v0.11.0

update aksk desc

print res query logs

Fix skills exec error with action type

Update Skills

Update Skills addr

Change uni-lab. to leap-lab.
Support unit in pylabrobot

Support async func.

change to leap-lab backend. Support feedback interval. Reduce cocurrent lags.

fix create_resource_with_slot

update unilabos_formulation & batch-submit-exp

scale multi exec thread up to 48

update handle creation api

fit cocurrent gap

add running status debounce

allow non @topic_config support

update skill

add placeholder keys

always free

提交实验技能

disable samples

correct sample demo ret value

新增试剂reagent

update registry

新增manual_confirm

add workstation creation skill

add virtual_sample_demo 样品追踪测试设备

add external devices param
fix registry upload missing type

fast registry load

minor fix on skill & registry

stripe ros2 schema desc
add create-device-skill

new registry system backwards to yaml

remove not exist resource

new registry sys
exp. support with add device

correct raise create resource error

ret info fix revert

ret info fix

fix prcxi check

add create_resource schema

re signal host ready event

add websocket connection timeout and improve reconnection logic

add open_timeout parameter to websocket connection
add TimeoutError and InvalidStatus exception handling
implement exponential backoff for reconnection attempts
simplify reconnection logic flow

.conda/base/recipe.yaml

@@ -3,7 +3,7 @@
 
 package:
   name: unilabos
-  version: 0.10.19
+  version: 0.11.0
 
 source:
   path: ../../unilabos
@@ -54,7 +54,7 @@ requirements:
   - pymodbus
   - matplotlib
   - pylibftdi
-  - uni-lab::unilabos-env ==0.10.19
+  - uni-lab::unilabos-env ==0.11.0
 
 about:
   repository: https://github.com/deepmodeling/Uni-Lab-OS

.conda/environment/recipe.yaml

@@ -2,7 +2,7 @@
 
 package:
   name: unilabos-env
-  version: 0.10.19
+  version: 0.11.0
 
 build:
   noarch: generic

.conda/full/recipe.yaml

@@ -3,7 +3,7 @@
 
 package:
   name: unilabos-full
-  version: 0.10.19
+  version: 0.11.0
 
 build:
   noarch: generic
@@ -11,7 +11,7 @@ build:
 requirements:
   run:
   # Base unilabos package (includes unilabos-env)
-  - uni-lab::unilabos ==0.10.19
+  - uni-lab::unilabos ==0.11.0
   # Documentation tools
   - sphinx
   - sphinx_rtd_theme

.cursor/skills/yibin-electrolyte-submit/SKILL.md

@@ -1,483 +0,0 @@
----
-name: yibin-electrolyte-submit
-description: >-
-  通过 Uni-Lab Notebook API 向宜宾电解液工站提交实验，覆盖配液分液（Bioyond LIMS）、
-  扣电组装（CoinCellAssembly）、扣电测试全流程。
-  包含 Excel 解析、formulation 构建、工作流节点参数填写、notebook 提交与状态轮询。
-  Use when the user wants to submit electrolyte experiments, assemble or test coin cells,
-  parse experiment Excel files, build notebook payloads, or mentions
-  宜宾/配液/分液/扣电/电解液实验/notebook提交/CoinCell/BioyondLIMS.
----
-
-# 宜宾电解液产线 API 操作指南
-
-本 skill 覆盖两个设备的完整操作流程：
-1. **配液分液工站** (`bioyond_cell_workstation`) — Bioyond LIMS 配液/分液/转运
-2. **扣电组装站** (`BatteryStation`) — Modbus PLC 扣电组装/数据采集
-
-## 设备信息
-
-| 属性 | 配液分液工站 | 扣电组装站 |
-|------|------------|-----------|
-| device_id | `bioyond_cell_workstation` | `BatteryStation` |
-| 显示名 | 配液分液工站 | 扣电工作站 |
-| 源码 | `unilabos/devices/workstation/bioyond_studio/bioyond_cell/bioyond_cell_workstation.py` | `unilabos/devices/workstation/coin_cell_assembly/coin_cell_assembly.py` |
-| 类名 | `BioyondCellWorkstation` | `CoinCellAssemblyWorkstation` |
-| 通讯 | HTTP REST (Bioyond LIMS API) | Modbus TCP (PLC 寄存器) |
-
-## 前置条件
-
-### 认证信息
-
-```
-AUTH="Authorization: Lab OTdlY2FkNmUtZmZmMi00YjhiLThhOWEtNWM5ODAyOTJmOTUxOmU0OGM2YWJkLTA4ZmEtNDFjMy04NzhhLTc4M2FiODlhZjYxMw=="
-BASE="https://uni-lab.test.bohrium.com"
-```
-
-来源：`--ak 97ecad6e-fff2-4b8b-8a9a-5c980292f951 --sk e48c6abd-08fa-41c3-878a-783ab89af613 --addr test`
-
-### 启动 unilab（云端模式）
-
-> **重要**：提交实验前必须确保 unilab 正在运行且已连接云端 WebSocket。
-
-```powershell
-$env:PYTHONIOENCODING="utf-8"
-conda activate newunilab2603
-cd D:\UniLabdev\Uni-Lab-OS\unilabos\devices\workstation
-unilab -g D:\UniLabdev\Uni-Lab-OS\yibin_electrolyte_config.json --ak 97ecad6e-fff2-4b8b-8a9a-5c980292f951 --sk e48c6abd-08fa-41c3-878a-783ab89af613 --upload_registry --addr test --disable_browser --skip_env_check
-```
-
-**启动要点**：
-1. 必须先激活虚拟环境 `newunilab2603`
-2. 工作目录切到 `unilabos/devices/workstation`（设备驱动所在目录）
-3. `--upload_registry` 将 64 个设备 + 142 个资源注册到云端
-4. `--skip_env_check` + `PYTHONIOENCODING=utf-8` 避免 Windows GBK 编码崩溃
-5. 启动后后台运行，等待日志出现 `Application startup complete` 和 `Host node ready signal published with 3 devices`
-
-**验证连接成功的标志**：
-- 日志出现 `[MessageProcessor] ... wss://uni-lab.test.bohrium.com/api/v1/ws/schedule`
-- 日志出现 `[WebSocketClient] Host node ready signal published with 3 devices`
-- 日志出现 `Resource tree add completed`（资源树同步完成）
-
-### 云端物料上架与入库（启动后必做）
-
-> **在提交实验之前，必须提醒用户完成以下云端操作，否则实验会因物料缺失而失败。**
-
-1. **拖拽上料**：在云端 UI（`$BASE/laboratory/<lab_uuid>`）的资源树视图中，将物料拖拽到对应的仓库/库位上。unilab 启动后资源树会自动同步到云端，但物料的**上架位置**需要用户在 UI 上手动确认或调整。
-
-2. **确认配液物料入库**：确保所有配液实验需要的试剂（如 LiPF6、EC、DMC、EMC 等）已在 LIMS 系统中完成入库。可通过以下方式验证：
-   - 云端 UI 资源树中对应仓库（如"粉末加样头堆栈"、"配液站内试剂仓库"）下有物料节点
-   - 或通过 API #8 获取资源树后检查物料节点是否存在
-
-3. **告知 AI 可以提交**：用户完成上述操作后，告知 AI "物料已上架，可以提交实验"，AI 再执行 notebook 提交流程。
-
-**提醒话术模板**（AI 应在启动成功后发送给用户）：
-```
-unilab 已成功启动并连接云端。提交实验前请完成以下操作：
-1. 在云端 UI 上确认资源树中的物料位置，必要时拖拽调整上料位
-2. 确保配液所需的试剂（粉末、液体）已在 LIMS 中完成入库
-3. 完成后告诉我，我将为您提交实验
-```
-
-### 生成 Action Schema（首次使用）
-
-启动 unilab 后，在 `unilabos_data/` 目录下会生成 `req_device_registry_upload.json`。运行以下命令提取两个设备的 action JSON：
-
-```bash
-python .cursor/skills/create-device-skill/scripts/extract_device_actions.py --registry unilabos_data/req_device_registry_upload.json bioyond_cell_workstation .cursor/skills/yibin-electrolyte-submit/actions/
-python .cursor/skills/create-device-skill/scripts/extract_device_actions.py --registry unilabos_data/req_device_registry_upload.json BatteryStation .cursor/skills/yibin-electrolyte-submit/actions/
-```
-
-## 请求约定
-
-- Windows 平台**必须用 `curl.exe`**（非 PowerShell 的 curl 别名）
-- 所有请求带 `$AUTH` 头
-- URL 格式：`$BASE/api/v1/<endpoint>`
-- POST/PATCH 请求体写入临时 JSON 文件后用 `-d '@tmp.json'` 传参（避免 PowerShell 转义问题）
-- 本地 API 基址：`http://127.0.0.1:8002/api/v1/`
-
-## Session State
-
-每次会话开始时，依次获取以下信息：
-
-```bash
-# 1. lab_uuid
-curl.exe -s -X GET "$BASE/api/v1/edge/lab/info" -H "$AUTH"
-# → data.uuid → $lab_uuid
-
-# 2. project_uuid
-curl.exe -s -X GET "$BASE/api/v1/lab/project/list?lab_uuid=$lab_uuid" -H "$AUTH"
-# → data.items[].uuid/name → 让用户选择或取唯一项 → $project_uuid
-```
-
-## 工作流模板（重要）
-
-> **必须向用户索要已有的工作流模板 UUID 或 URL，不要自行创建。**
->
-> 原因：通过 `edge/workflow/node` API 创建节点会报 `resource_node_template not found`——
-> 云端的工作流节点模板系统和设备注册表是独立的，需要用户在云端 UI 上预先配置好工作流模板。
-
-**获取方式**：
-- 用户提供工作流页面 URL，如 `$BASE/laboratory/<lab_uuid>/workflow/<workflow_uuid>`
-- 从 URL 中提取 `workflow_uuid`
-- 用 API 获取模板详情：
-
-```
-GET /api/v1/lab/workflow/template/detail/<workflow_uuid>
-```
-
-返回 `data.nodes[]`：每个节点的 uuid、name、param、device_name、handles、disabled。
-
-**示例**：
-```
-工作流 URL: https://uni-lab.test.bohrium.com/laboratory/e9ed9102-d709-4741-b7a0-d1e8578e2065/workflow/b49f80d9-58d6-4456-a521-56f4dd39cda0
-→ workflow_uuid = b49f80d9-58d6-4456-a521-56f4dd39cda0
-```
-
-从模板详情中提取**未 disabled** 的节点的 `uuid` 和 `name`，后续提交 notebook 时使用。
-
-## API Endpoints
-
-### #1 获取 lab_uuid
-
-```
-GET /api/v1/edge/lab/info
-```
-
-### #2 列出项目
-
-```
-GET /api/v1/lab/project/list?lab_uuid=$lab_uuid
-```
-
-返回 `data.items[]`，取 `uuid` 和 `name`。
-
-### #3 获取工作流模板详情
-
-```
-GET /api/v1/lab/workflow/template/detail/<workflow_uuid>
-```
-
-返回 `data.nodes[]`：每个节点的 uuid、name、param、device_name、handles。
-提取活跃节点（`disabled != true`）的 `uuid` 用于构建 notebook 请求。
-
-### #4 提交实验（创建 notebook）— 核心 API
-
-```
-POST /api/v1/lab/notebook
-Body: {
-  "lab_uuid": "<lab_uuid>",
-  "project_uuid": "<project_uuid>",
-  "workflow_uuid": "<workflow_uuid>",
-  "name": "<实验名称>",
-  "node_params": [
-    {
-      "sample_uuids": [],
-      "datas": [
-        {
-          "node_uuid": "<模板中的节点UUID>",
-          "param": { <参数键值对> },
-          "sample_params": []
-        }
-      ]
-    }
-  ]
-}
-```
-
-**关键注意事项**：
-- `node_params` 是数组，每个元素代表一轮实验
-- `datas` 中每个节点对应模板中的一个活跃节点
-- `param` 中的字段名**必须使用 Python 函数参数名**，不能用模板中存储的 LIMS 字段名（见下方映射表）
-
-### #5 查询 notebook 状态
-
-```
-GET /api/v1/lab/notebook/status?uuid=<notebook_uuid>
-```
-
-| status | 含义 |
-|--------|------|
-| `running` | 执行中 |
-| `success` | 成功 |
-| `fail` | 失败 |
-
-### #6 运行设备单动作（本地 API）
-
-```
-POST http://127.0.0.1:8002/api/v1/job/add
-Body: {
-  "device_id": "<device_id>",
-  "action": "<action_name>",
-  "action_args": { <参数键值对> },
-  "sample_material": {}
-}
-```
-
-本地 API 可自动解析 `action_type`，无需手动指定。适用于快速调试或云端未连接时。
-
-### #7 查询本地任务状态
-
-```
-GET http://127.0.0.1:8002/api/v1/job/<job_id>/status
-```
-
-| status | 含义 |
-|--------|------|
-| 0 | UNKNOWN |
-| 1 | ACCEPTED |
-| 2 | EXECUTING |
-| 4 | SUCCEEDED |
-| 5 | CANCELED |
-| 6 | ABORTED |
-
-### #8 获取资源树
-
-```
-GET /api/v1/lab/material/download/<lab_uuid>
-```
-
-返回所有节点（`id`, `name`, `uuid`, `type`, `parent`）。填写 Slot 字段时用此接口筛选节点。
-
-## Placeholder Slot 填写规则
-
-action JSON 中 `placeholder_keys` 标记了哪些字段需要填 Slot：
-
-| placeholder 值 | Slot 类型 | 填写格式 |
-|---------------|-----------|---------|
-| `unilabos_resources` | ResourceSlot | `{"id": "/path/name", "name": "name", "uuid": "xxx"}` |
-| `unilabos_devices` | DeviceSlot | `"/parent/device_name"` 路径字符串 |
-| `unilabos_nodes` | NodeSlot | `"/parent/node_name"` 路径字符串 |
-| `unilabos_class` | ClassSlot | `"class_name"` 字符串 |
-| `unilabos_formulation` | FormulationSlot | `[{well_name, liquids: [{name, volume}]}]` |
-
-### ResourceSlot 填写
-
-从 API #8 资源树中筛选**物料**节点：
-
-```json
-{"id": "/bioyond_cell_workstation/YB_Bioyond_Deck/自动堆栈-左", "name": "自动堆栈-左", "uuid": "3a19debc-..."}
-```
-
-数组字段：`[{id, name, uuid}, ...]`
-特例：`create_resource` 的 `res_id` 允许填不存在的路径。
-
-### DeviceSlot 填写
-
-从资源树筛选 `type=device` 的节点，填路径字符串：
-
-```
-"/BatteryStation"
-"/bioyond_cell_workstation"
-```
-
-### FormulationSlot 填写
-
-```json
-[
-  {
-    "sample_uuid": "",
-    "well_name": "YB_PrepBottle_15mL_Carrier_bottle_A1",
-    "liquids": [
-      { "name": "LiPF6", "mass": 12.5 },
-      { "name": "EC", "mass": 50.0 }
-    ]
-  }
-]
-```
-
-`well_name` 从资源树中取物料节点的 `name`。
-
-## 参数名映射（重要的坑）
-
-> 工作流模板中存储的参数名和 Python 函数实际接受的参数名**不一定相同**。
-> 提交 notebook 时必须使用 **Python 函数参数名**。
-
-### `create_orders_formulation` 参数映射
-
-| 模板中的 param 键 | 实际 Python 参数名 | 说明 |
-|-------------------|-------------------|------|
-| `pouch_cell_info` | `pouch_cell_volume` | 软包组装分液体积 (mL) |
-| `conductivity_info` | `conductivity_volume` | 电导测试分液体积 (mL) |
-| `load_shedding_info` | `coin_cell_volume` | 扣电组装分液体积 (mL) |
-| `formulation` | `formulation` | 配方数组（名称一致） |
-| `batch_id` | `batch_id` | 批次号（名称一致） |
-| `bottle_type` | `bottle_type` | 配液瓶类型（名称一致） |
-| `mix_time` | `mix_time` | 混匀时间(秒)（名称一致） |
-| `conductivity_bottle_count` | `conductivity_bottle_count` | 电导瓶数（名称一致） |
-
-当从模板中读到 `param` 包含 `pouch_cell_info` 等 LIMS 字段名时，提交 notebook 时要用右列的 Python 函数参数名。否则会报 `TypeError: got an unexpected keyword argument`。
-
-## 典型工作流
-
-### 方式一：通过 Notebook API 批量提交（推荐）
-
-**适用场景**：多组配方的批量实验，云端管理实验记录
-
-```
-1. 向用户索要工作流模板 URL（不要自行创建）
-2. 获取 lab_uuid（API #1）和 project_uuid（API #2）
-3. 获取工作流模板详情（API #3），提取活跃节点 UUID
-4. 解析用户提供的 Excel 文件，构建 formulation 数组
-5. 提交 notebook（API #4）
-6. 轮询 notebook 状态（API #5）直到完成
-```
-
-**Excel 解析规则**：
-- 全局参数在第一个数据行：`batch_id`、`bottle_type`、`mix_time`、`coin_cell_volume`、`pouch_cell_volume`、`conductivity_volume`、`conductivity_bottle_count`
-- 配方列从"试剂名1"开始，交替排列：试剂名列 + 质量列（以 `(g)` 结尾）
-- 每行一个配方，`order_name` = 配方ID列
-- formulation 中每个配方的 materials 数组只包含 `mass > 0` 的试剂
-
-**node_params 构建**：所有配方放入同一个 round 的同一个 datas 条目中，因为只有一个节点（`create_orders_formulation`）。
-
-### 方式二：设备单步操作（本地 API）
-
-**适用场景**：调试、快速测试
-
-```
-1. 确保 unilab 已在本地启动
-2. 通过 POST http://127.0.0.1:8002/api/v1/job/add 提交任务
-3. 通过 GET /api/v1/job/<job_id>/status 查询状态
-```
-
-### 设备操作流程：配液 → 转运 → 扣电
-
-```
-1. [配液站] scheduler_start_and_auto_feeding  → 启动调度 + 上料
-2. [配液站] create_orders_formulation          → 创建配液实验（配方输入）
-3. [配液站] transfer_3_to_2_to_1_auto         → 分液瓶板转运到扣电站
-4. [扣电站] func_pack_device_init_auto_start_combined → 初始化+自动+启动
-5. [扣电站] func_sendbottle_allpack_multi      → 发送瓶数+批量组装
-```
-
-## 云端使用心得
-
-### 环境准备
-- Windows 必须设置 `$env:PYTHONIOENCODING="utf-8"` 防止编码崩溃
-- 使用 `--skip_env_check` 跳过依赖检查，加快启动
-- 工作目录建议在 `unilabos/devices/workstation` 下启动
-
-### 连接与注册
-- `--upload_registry` 会自动将设备和资源注册到云端
-- WebSocket 连接建立后，本地和云端的资源树会自动同步
-- 注册成功后用户需在云端 UI 完成**物料拖放上架**操作
-- 如果 unilab 断开重连，资源树会重新同步
-
-### 工作流模板
-- **不要自行调用 API 创建工作流或节点**——云端工作流节点模板需要预配置
-- 始终向用户索要已有的工作流模板 URL
-- 从 URL 中提取 `workflow_uuid`，通过 API #3 获取详情
-- 模板中 `disabled: true` 的节点跳过，只处理活跃节点
-
-### Notebook 实验提交
-- Notebook 是云端管理实验的标准方式
-- 一个 notebook 可包含多轮（`node_params` 数组），每轮可包含多组参数
-- 提交后通过 API #5 轮询状态，LIMS 配液流程通常需要较长时间（8 个配方约 30-60 分钟）
-- 实验进度可在云端 UI 和本地 unilab 日志中同步查看
-
-### 常见错误
-| 错误 | 原因 | 解决 |
-|------|------|------|
-| `edge not started error` | unilab 未连接云端 WebSocket | 检查 unilab 是否在运行、重启 |
-| `resource_node_template not found` | 云端没有该设备的工作流模板 | 向用户索要已有模板，不要自行创建 |
-| `got an unexpected keyword argument` | 参数名用了模板字段名而非 Python 函数参数名 | 参照上方映射表转换 |
-| `UnicodeEncodeError: 'gbk'` | Windows 默认编码不支持特殊字符 | 设置 `PYTHONIOENCODING=utf-8` |
-| `parse parameter error` | 云端 API 字段名错误 | `device_id` (非 `device_name`)、`action` (非 `action_name`)、必须带 `action_type` |
-
-## 渐进加载策略
-
-1. 先读本文件了解 API 端点、参数映射和云端注意事项
-2. 需要具体 action 参数时，读 [action-index.md](action-index.md) 查找 action 名称和核心参数
-3. 需要完整 schema 时，读 `actions/<action_name>.json`（需先运行提取命令生成）
-4. 需要理解参数含义时，读设备源码
-
-## 完整 Notebook 提交 Checklist
-
-```
-- [ ] 确认 unilab 已在本地启动并连接云端 WebSocket
-- [ ] 提醒用户在云端 UI 拖拽上料、确认物料位置
-- [ ] 提醒用户确认配液所需试剂已在 LIMS 完成入库
-- [ ] 等待用户确认物料就绪后再继续
-- [ ] 向用户索要工作流模板 URL → 提取 workflow_uuid
-- [ ] 获取 lab_uuid（API #1）
-- [ ] 获取 project_uuid（API #2）
-- [ ] 获取工作流模板详情（API #3），提取活跃节点 UUID
-- [ ] 解析用户 Excel 文件 → 构建 formulation + 全局参数
-- [ ] 注意参数名映射（模板字段名 → Python 函数参数名）
-- [ ] 提交 notebook（API #4）
-- [ ] 轮询 notebook 状态（API #5）直到完成
-```
-
----
-
-## 真实场景：宜宾产线 Excel 提交提示词模板
-
-> 以下为已验证可用的标准提示词，适用于配液-分液-扣电全流程。
-
-### 场景说明
-
-- unilab 运行在本地 Windows 机器（miniforge 环境），连接云端 WebSocket
-- AI（Cursor / OpenClaw）在任意设备上，通过云端 API 操作，**不需要本地 127.0.0.1**
-- 工作流为 5 节点串联：`create_orders_formulation` → `transfer_3_to_2_to_1_auto` → `func_pack_device_init_auto_start_combined` → `func_sendbottle_allpack_multi` → `transfer_1_to_2`
-
-### 已知固定参数（宜宾产线）
-
-```
-BASE     = https://uni-lab.test.bohrium.com
-lab_uuid = e9ed9102-d709-4741-b7a0-d1e8578e2065
-project  = YiBinElectrolyte (bc5224b4-8120-4765-9961-9dfc1802a1f6)
-workflow = 配液分液formulation全流程 (2bc59938-db79-4415-ac2d-9897ef125f2f)
-```
-
-#### 工作流节点 UUID（固定，无需重新查询）
-
-| 顺序 | action | node_uuid |
-|------|--------|-----------|
-| Step1 | auto-create_orders_formulation | `ece6744a-81ac-4ae4-8cd1-1c8eeda1dab6` |
-| Step2 | auto-transfer_3_to_2_to_1_auto | `1c37a8dd-5ba0-413d-81db-94b9c936a171` |
-| Step3 | auto-func_pack_device_init_auto_start_combined | `97a676a2-d257-4479-9096-073b40300970` |
-| Step4 | auto-func_sendbottle_allpack_multi | `cf69017a-d29c-4aad-a63b-309d63dac2e9` |
-| Step5 | auto-transfer_1_to_2 | `80d1c1aa-dbc3-4601-86b7-5c22a992dd9e` |
-
-### 标准提示词
-
-```
-请使用 yibin-electrolyte-submit skill，提交以下实验：
-
-工作流模板 URL：https://uni-lab.test.bohrium.com/laboratory/e9ed9102-d709-4741-b7a0-d1e8578e2065/workflow/2bc59938-db79-4415-ac2d-9897ef125f2f
-Excel 文件路径：<粘贴或上传 xlsx 路径>
-
-注意事项：
-- lab_uuid、project_uuid、workflow节点UUID均已固定，无需重新查询
-- 直接解析 Excel → 构建 payload → 提交
-- mix_time 传标量整数即可（已兼容）
-- 试剂名以 Excel 为准，注意区分 LiDFOB / LiDOFB 等拼写
-- csv_export_path 取 Excel 中 csv_export_path 列的值
-- 提交后告知 notebook UUID，无需自动轮询（实验耗时较长）
-```
-
-### Excel 列结构说明（experment_template_0415sim-*.xlsx）
-
-| 列范围 | 内容 |
-|--------|------|
-| C | batch_id |
-| D | bottle_type |
-| E-H | coin_cell_volume / conductivity_bottle_count / conductivity_volume / csv_export_path |
-| I-T | 试剂名+质量 交替排列（最多6对）|
-| U | mix_time |
-| V | order_name（每行配方的订单号）|
-| W | pouch_cell_volume |
-| X-Y | target_device / target_location（Step2参数）|
-| AA | material_search_enable（Step3参数）|
-| AB-AS | 扣电站参数（Step4）|
-
-### CSV 导出说明
-
-每次 `create_orders_formulation` 完成后，在 `csv_export_path` 目录下生成：
-```
-electrolyte_orders_<YYYYMMDD_HHMMSS>.csv
-```
-列：`orderCode, orderName, 配液瓶类型, 配液瓶二维码, 分液瓶类型, 分液瓶二维码, 目标配液质量比, 真实配液质量比, 时间`
-
-> **注意**：barCode 为 `null` 或 `"nullBarCode123456"` 是正常现象，表示 LIMS 中该物料尚未扫码。配液瓶缺失通常是因为物料未放在手动传递窗（`locationId` 前缀 `3a19deae-2c7a-`）。

.cursor/skills/yibin-electrolyte-submit/action-index.md

@@ -1,295 +0,0 @@
-# Action 索引
-
-> Action JSON 文件需运行提取命令生成，详见 [SKILL.md](SKILL.md) 中「生成 Action Schema」。
-> 以下描述和参数信息基于源码分析。
-
----
-
-## 配液分液工站 (`bioyond_cell_workstation`)
-
-源码：`unilabos/devices/workstation/bioyond_studio/bioyond_cell/bioyond_cell_workstation.py`
-
-### 调度控制
-
-#### `scheduler_start`
-
-启动 Bioyond LIMS 调度系统
-
-- **核心参数**: 无（仅需 apiKey/requestTime，由设备内部处理）
-- **返回**: LIMS 响应 `{code, message, data}`
-
-#### `scheduler_stop`
-
-停止调度
-
-- **核心参数**: 无
-
-#### `scheduler_continue`
-
-继续调度（从暂停状态恢复）
-
-- **核心参数**: 无
-
-#### `scheduler_reset`
-
-复位调度
-
-- **核心参数**: 无
-
-#### `scheduler_start_and_auto_feeding`
-
-**组合操作**：启动调度 + 自动化上料（4号→3号手套箱）
-
-- **核心参数**: `xlsx_path`（Excel 物料模板路径，可选）
-- **可选参数**: WH4 加样头面 12 个点位（materialName + quantity）、WH4 原液瓶面 9 个点位（materialName + quantity + materialType + targetWH）、WH3 人工堆栈 15 个点位（materialType + materialId + quantity）
-- **流程**: 先 `scheduler_start()`，成功后执行 `auto_feeding4to3()`
-- **备注**: 支持 Excel 模式和手动参数模式，Excel 路径存在时优先使用 Excel
-
-### 物料上料/下料
-
-#### `auto_feeding4to3`
-
-自动化上料：从 4 号手套箱转运物料到 3 号手套箱
-
-- **核心参数**: `xlsx_path`（Excel 物料模板路径）
-- **可选参数**: 同 `scheduler_start_and_auto_feeding` 的 WH4/WH3 点位参数
-- **返回**: 等待上料任务完成后返回结果
-
-#### `auto_batch_outbound_from_xlsx`
-
-自动化下料（从 Excel 读取下料信息）
-
-- **核心参数**: `xlsx_path`（Excel 下料模板）
-- **Excel 列**: locationId, warehouseId, 数量, x, y, z
-
-### 物料管理
-
-#### `create_and_inbound_materials`
-
-批量创建固体物料并入库
-
-- **核心参数**: `material_names`（物料名称列表，默认 `["LiPF6", "LiDFOB", "DTD", "LiFSI", "LiPO2F2"]`）
-- **可选参数**: `type_id`（物料类型ID）, `warehouse_name`（目标仓库，默认 "粉末加样头堆栈"）
-- **流程**: 创建物料 → 批量入库 → 同步
-
-#### `create_material`
-
-创建单个物料并可选入库
-
-- **核心参数**: `material_name`, `type_id`, `warehouse_name`
-- **可选参数**: `location_name_or_id`（库位编号如 "A01" 或 UUID）
-
-#### `create_sample`
-
-创建配液板物料（含子瓶）并入库
-
-- **核心参数**: `name`, `board_type`（如 "5ml分液瓶板"）, `bottle_type`（如 "5ml分液瓶"）, `location_code`（如 "A01"）
-- **可选参数**: `warehouse_name`（默认 "手动堆栈"）
-- **备注**: 自动创建 2x4=8 个子瓶
-
-#### `storage_inbound`
-
-单个物料入库
-
-- **核心参数**: `material_id`, `location_id`
-
-#### `storage_batch_inbound`
-
-批量物料入库
-
-- **核心参数**: `items`（`[{materialId, locationId}, ...]`）
-
-### 配液实验
-
-#### `create_orders`
-
-从 Excel 文件创建配液实验订单
-
-- **核心参数**: `xlsx_path`（Excel 文件路径）
-- **Excel 列**: 配方ID, 创建日期, 配液瓶类型, 混匀时间(s), 扣电组装分液体积, 软包组装分液体积, 电导测试分液体积, 电导测试分液瓶数, 以及所有以 `(g)` 结尾的物料列
-- **流程**: 解析 Excel → 提交订单 → 等待全部完成 → 计算质量比 → 提取分液瓶板 → 创建资源树对象
-- **返回**: `{status, total_orders, bottle_count, reports, mass_ratios, vial_plates}`
-
-#### `create_orders_formulation`
-
-从配方列表创建配液实验订单（前端/API 输入版本）
-
-- **核心参数**: `formulation`（配方数组）
-- **可选参数**: `batch_id`, `bottle_type`（默认 "配液小瓶"）, `mix_time`（秒，列表）, `coin_cell_volume`, `pouch_cell_volume`, `conductivity_volume`, `conductivity_bottle_count`
-- **formulation 格式**:
-  ```json
-  [
-    {
-      "order_name": "配方A",
-      "materials": [
-        {"name": "LiPF6", "mass": 12.5},
-        {"name": "EC", "mass": 50.0},
-        {"name": "DMC", "mass": 37.5}
-      ]
-    }
-  ]
-  ```
-- **返回**: 同 `create_orders`
-
-### 物料转运
-
-#### `transfer_3_to_2_to_1_auto`
-
-**自动转运**：从 create_orders 结果中自动定位分液瓶板并转运到目标设备
-
-- **核心参数**: `vial_plates`（分液瓶板列表，来自 create_orders 返回的 `vial_plates`）
-- **可选参数**: `target_device`（默认 "BatteryStation"）, `target_location`（默认 "bottle_rack_6x2"）, `mass_ratios`（配方信息）
-- **流程**: 遍历瓶板 → 解析 locationId → 调用 LIMS 转运 API → 更新资源树
-- **返回**: `{total, success, failed, results}`
-
-#### `transfer_3_to_2_to_1`
-
-3→2→1 物料转运（手动指定坐标）
-
-- **核心参数**: `source_wh_id`, `source_x`, `source_y`, `source_z`
-
-#### `transfer_3_to_2`
-
-3→2 物料转运
-
-- **核心参数**: `source_wh_id`, `source_x`, `source_y`, `source_z`
-
-#### `transfer_1_to_2`
-
-1→2 物料转运
-
-- **核心参数**: 无
-
-### 查询
-
-#### `order_list_v2`
-
-批量查询实验报告
-
-- **可选参数**: `timeType`, `beginTime`, `endTime`, `status`（60=运行中, 80=完成, 90=失败）, `filter`, `skipCount`, `pageCount`, `sorting`
-
----
-
-## 扣电组装站 (`BatteryStation`)
-
-源码：`unilabos/devices/workstation/coin_cell_assembly/coin_cell_assembly.py`
-
-### 设备控制（组合操作）
-
-#### `func_pack_device_init_auto_start_combined`
-
-**组合操作**：设备初始化 → 物料搜寻确认 → 切换自动模式 → 启动
-
-- **核心参数**: `material_search_enable`（是否启用物料搜寻，默认 `False`）
-- **前置检查**: REG_UNILAB_INTERACT=False, COIL_GB_L_IGNORE_CMD=False, 所有握手寄存器无残留
-- **流程**: 手动模式 → 初始化命令 → 监测物料搜寻弹窗并自动处理 → 自动模式 → 启动
-- **返回**: `True`/`False`
-- **备注**: 第一次运行必须调用此函数；后续批次调用 `func_sendbottle_allpack_multi`
-
-### 批量组装
-
-#### `func_sendbottle_allpack_multi`
-
-**发送瓶数 + 批量组装**（适用于第二批次及后续批次）
-
-- **核心参数**: `elec_num`（电解液瓶数）, `elec_use_num`（每瓶组装电池数）, `elec_vol`（电解液吸液量 μL，默认 50）
-- **可选参数**:
-  - 双滴模式：`dual_drop_mode`(bool), `dual_drop_first_volume`(μL), `dual_drop_suction_timing`(bool), `dual_drop_start_timing`(bool)
-  - 组装参数：`assembly_type`(7=不用铝箔垫/8=用), `assembly_pressure`(N，默认 4200)
-  - 物料参数：`fujipian_panshu`, `fujipian_juzhendianwei`, `gemopanshu`, `gemo_juzhendianwei`, `qiangtou_juzhendianwei`
-  - 开关：`lvbodian`(铝箔垫片), `battery_pressure_mode`(压力模式), `battery_clean_ignore`(忽略清洁)
-  - 其他：`file_path`(CSV保存路径), `formulations`(配方信息，用于CSV追溯)
-- **流程**: 发送瓶数触发物料搬运 → 设置PLC参数 → 循环（等待PLC请求→下发参数→读取电池数据→写入CSV→更新资源树）→ 完成握手
-- **返回**: `{success, total_batteries, batteries, summary}`
-- **备注**: 设备已初始化后直接调用；`formulations` 来自 create_orders 的 `mass_ratios`
-
-#### `func_allpack_cmd`
-
-全套组装（基础版本，含断点续传）
-
-- **核心参数**: `elec_num`, `elec_use_num`, `elec_vol`, `assembly_type`, `assembly_pressure`, `file_path`
-- **返回**: `{success, total_batteries, batteries, summary}`
-
-#### `func_allpack_cmd_simp`
-
-增强版组装（含双滴模式 + 负极片/隔膜/枪头参数）
-
-- **核心参数**: 同 `func_sendbottle_allpack_multi`
-- **备注**: 被 `func_sendbottle_allpack_multi` 内部调用
-
-### 设备控制（单步操作）
-
-#### `func_pack_device_init`
-
-设备初始化（手动模式 → 初始化 → 复位标志）
-
-#### `func_pack_device_auto`
-
-切换自动模式
-
-#### `func_pack_device_start`
-
-启动设备
-
-#### `func_pack_device_stop`
-
-设备停止
-
-#### `func_pack_send_bottle_num`
-
-发送电解液瓶数（触发物料搬运）
-
-- **核心参数**: `bottle_num`（瓶数）
-
-### PLC 参数设置
-
-#### `qiming_coin_cell_code`
-
-设置组装物料参数
-
-- **核心参数**: `fujipian_panshu`（负极片盘数）
-- **可选参数**: `fujipian_juzhendianwei`, `gemopanshu`, `gemo_juzhendianwei`, `lvbodian`, `battery_pressure_mode`, `battery_pressure`, `battery_clean_ignore`
-
-### 数据采集
-
-#### `func_read_data_and_output`
-
-持续数据采集并导出 CSV（后台循环运行）
-
-- **核心参数**: `file_path`（CSV 保存目录）
-- **采集字段**: 开路电压, 极片质量, 组装时间, 压制力, 电解液加注量, 电池类型, 电解液二维码, 电池二维码
-
-#### `func_stop_read_data`
-
-停止 CSV 数据采集
-
-### 设备状态属性（只读）
-
-| 属性 | 类型 | 说明 |
-|------|------|------|
-| `sys_status` | str | 设备状态（启动中/停止中/复位中/初始化中） |
-| `sys_mode` | str | 设备模式（手动/自动） |
-| `data_assembly_coin_cell_num` | int | 已完成电池数量 |
-| `data_assembly_time` | float | 单颗电池组装时间(秒) |
-| `data_open_circuit_voltage` | float | 开路电压(V) |
-| `data_pole_weight` | float | 正极片称重(g) |
-| `data_glove_box_pressure` | float | 手套箱压力(mbar) |
-| `data_glove_box_o2_content` | float | 手套箱氧含量(ppm) |
-| `data_glove_box_water_content` | float | 手套箱水含量(ppm) |
-| `data_coin_cell_code` | str | 电池二维码 |
-| `data_electrolyte_code` | str | 电解液二维码 |
-
----
-
-## 配置参考
-
-设备图文件 `yibin_electrolyte_config.json` 中的仓库映射（`warehouse_mapping`）：
-
-| 仓库名称 | 说明 | 典型操作 |
-|---------|------|---------|
-| 粉末加样头堆栈 | 20 个点位 (A01-T01) | `create_and_inbound_materials` 入库目标 |
-| 配液站内试剂仓库 | 9 个点位 (A01-C03) | 试剂存储 |
-| 自动堆栈-左 | 4 个点位 | 分液瓶板存放，`transfer_3_to_2_to_1_auto` 的源位置 |
-| 自动堆栈-右 | 4 个点位 | 分液瓶板存放 |
-| 手动传递窗左/右 | 各 15 个点位 | 人工上料/下料 |
-| 4号手套箱内部堆栈 | 12 个点位 | `auto_feeding4to3` 的源位置 |

.gitignore

@@ -251,7 +251,4 @@ ros-humble-unilabos-msgs-0.9.13-h6403a04_5.tar.bz2
 *.bz2
 test_config.py
 
-# Local config files with secrets
-yibin_coin_cell_only_config.json
-yibin_electrolyte_config.json
-yibin_electrolyte_only_config.json
+

260415csv_export_walkthrough.md

@@ -1,72 +0,0 @@
-# CSV 导出功能变更概要
-
-## 修改的文件
-
-### 1. [bioyond_cell_workstation.py](file:///d:/UniLabdev/Uni-Lab-OS/unilabos/devices/workstation/bioyond_studio/bioyond_cell/bioyond_cell_workstation.py)
-
-#### 新增导入
-- `import csv` 和 `import os`（L14-15）
-
-#### 新增方法
-
-| 方法 | 功能 |
-|------|------|
-| `_extract_prep_bottle_from_report` | 从 order_finish 报文提取**配液瓶**信息（每订单最多1个） |
-| `_extract_vial_bottles_from_report` | 从 order_finish 报文提取**分液瓶**信息（每订单可多个，返回数组） |
-| `_export_order_csv` | 汇总所有信息写入 CSV 文件 |
-
-#### 配液瓶筛选逻辑 (`_extract_prep_bottle_from_report`)
-- `typemode="1"`, `realQuantity=1`, `usedQuantity=1`
-- `locationId` 以 `3a19deae-2c7a-` 开头（手动传递窗）
-- LIMS API 二次确认：`typeName` 含"配液瓶(小)"或"配液瓶(大)"
-
-#### 分液瓶筛选逻辑 (`_extract_vial_bottles_from_report`)
-- `typemode="1"`, `realQuantity=1`, `usedQuantity=1`
-- `locationId` 以 `3a19debc-84b5-` 或 `3a19debe-5200` 开头（自动堆栈-左/右）
-- LIMS API 二次确认：`typeName` 为"5ml分液瓶"或"20ml分液瓶"
-- **返回数组**，支持 1×5ml + n×20ml 的组合
-
-#### 修改的方法
-
-| 方法 | 变更 |
-|------|------|
-| `_submit_and_wait_orders` | 新增配液瓶+分液瓶提取步骤，将 `prep_bottles` 和 `vial_bottles` 存入 `final_result` |
-| `create_orders` | 添加 `csv_export_path` 参数，末尾调用 `_export_order_csv` |
-| `create_orders_formulation` | 添加 `csv_export_path` 参数，末尾调用 `_export_order_csv` |
-
-#### CSV 输出格式
-```
-orderCode, orderName, 配液瓶类型, 配液瓶二维码, 分液瓶类型, 分液瓶二维码, 目标配液质量比, 真实配液质量比, 时间
-```
-- 单个分液瓶时直接写值；多个分液瓶时类型和二维码用 JSON 数组表示
-- CSV 编码使用 `utf-8-sig`（兼容 Excel 打开）
-- `csv_export_path` 默认为空字符串，不传则不导出（向后兼容）
-
----
-
-### 2. [bioyond_cell.yaml](file:///d:/UniLabdev/Uni-Lab-OS/unilabos/registry/devices/bioyond_cell.yaml)
-
-为两个 action 注册了 `csv_export_path` 参数：
-
-- `auto-create_orders`: `goal_default` + `schema.properties.goal.properties` 中添加 `csv_export_path`
-- `auto-create_orders_formulation`: 同上
-
----
-
-### 3. [coin_cell_assembly.py](file:///d:/UniLabdev/Uni-Lab-OS/unilabos/devices/workstation/coin_cell_assembly/coin_cell_assembly.py) 的 CSV 改动与全流程追溯
-
-在 `bioyond_cell_workstation.py` 的 `_submit_and_wait_orders` 最后阶段，提取 `prep_bottles`（配液瓶）和 `vial_bottles`（分液瓶）的条码并随 `mass_ratios` 数组一起下发给各下游工站（例如扣电组装站），实现跨站的全流程配方追溯。
-
-并在扣电站生成的 `date_xxx.csv` 中，**替换并新增**了以下列：
-- 移除了原有的 `formulation_order_code` 与合并的 `formulation_ratio` 列。
-- 新增 `orderName` 导出
-- 新增 `prep_bottle_barcode`（奔曜传递的配液瓶二维码）
-- 新增 `vial_bottle_barcodes`（奔曜传递的分液瓶二维码，多瓶时存 JSON 数组）
-- 新增 `target_mass_ratio` 理论目标质量比
-- 新增 `real_mass_ratio` 实际称量真实质量比
-
-*注意：这与操作人员在手套箱内扫码传入扣电站的 `electrolyte_code` 是单独记录的，方便做数据核对。*
-
-## 向后兼容性
-- `csv_export_path` 默认值为 `""`（空字符串），现有调用不受影响
-- 新增的 `prep_bottles` 和 `vial_bottles` 字段为 `final_result` 和 `mass_ratios` 内部的新增附属字段，不破坏现有数据结构。

CHANGES_2026_03_24.md

@@ -1,168 +0,0 @@
-# 变更说明 2026-03-24
-
-## 问题背景
-
-`BioyondElectrolyteDeck`（原 `BIOYOND_YB_Deck`）迁移后，前端物料未能正常上传/同步。
-
----
-
-## 修复内容
-
-### 1. `unilabos/resources/bioyond/decks.py`
-
-- 补回 `setup: bool = False` 参数及 `if setup: self.setup()` 逻辑，与旧版 `BIOYOND_YB_Deck` 保持一致
-- 工厂函数 `bioyond_electrolyte_deck` 保留显式调用 `deck.setup()`，避免重复初始化
-
-```python
-# 修复前（缺少 setup 参数，无法通过 setup=True 触发初始化）
-def __init__(self, name, size_x, size_y, size_z, category):
-    super().__init__(...)
-
-# 修复后
-def __init__(self, name, size_x, size_y, size_z, category, setup: bool = False):
-    super().__init__(...)
-    if setup:
-        self.setup()
-```
-
----
-
-### 2. `unilabos/resources/graphio.py`
-
-- 修复 `resource_bioyond_to_plr` 中两处 `bottle.tracker.liquids` 直接赋值导致的崩溃
-- `ResourceHolder`（如枪头盒的 TipSpot 槽位）没有 `tracker` 属性，直接访问会抛出 `AttributeError`，阻断整个 Bioyond 同步流程
-
-```python
-# 修复前
-bottle.tracker.liquids = [...]
-
-# 修复后
-if hasattr(bottle, 'tracker') and bottle.tracker is not None:
-    bottle.tracker.liquids = [...]
-```
-
----
-
-### 3. `unilabos/app/main.py`
-
-- 保留 `file_path is not None` 条件不变（已还原），并补充注释说明原因
-- 该逻辑只在**本地文件模式**下有意义：本地 graph 文件只含设备结构，远端有已保存物料，merge 才能将两者合并
-- 远端模式（`file_path=None`）下，`resource_tree_set` 和 `request_startup_json` 来自同一份数据，merge 为空操作，条件是否加 `file_path is not None` 对结果没有影响
-
----
-
-### 4. `unilabos/devices/workstation/bioyond_studio/station.py` ⭐ 核心修复
-
-- 当 deck 通过反序列化创建时，不会自动调用 `setup()`，导致 `deck.children` 为空，`warehouses` 始终是 `{}`
-- 增加兜底逻辑：仓库扫描后仍为空，则主动调用 `deck.setup()` 初始化仓库
-- 这是导致所有物料放置失败（`warehouse '...' 在deck中不存在。可用warehouses: []`）的根本原因
-
-```python
-# 新增兜底
-if not self.deck.warehouses and hasattr(self.deck, "setup") and callable(self.deck.setup):
-    logger.info("Deck 无仓库子节点，调用 setup() 初始化仓库")
-    self.deck.setup()
-```
-
----
-
----
-
-## 补充修复 2026-03-25：依华扣电组装工站子物料未上传
-
-### 问题
-
-`CoinCellAssemblyWorkstation.post_init` 直接上传空 deck，未调用 `deck.setup()`，导致：
-- 前端子物料（成品弹夹、料盘、瓶架等）不显示
-- 运行时 `self.deck.get_resource("成品弹夹")` 抛出 `ResourceNotFoundError`
-
-### 修复文件
-
-**`unilabos/devices/workstation/coin_cell_assembly/YB_YH_materials.py`**
-- `YihuaCoinCellDeck.__init__` 补回 `setup: bool = False` 参数及 `if setup: self.setup()` 逻辑
-
-**`unilabos/devices/workstation/coin_cell_assembly/coin_cell_assembly.py`**
-- `post_init` 中增加与 Bioyond 工站相同的兜底逻辑：deck 无子节点时调用 `deck.setup()` 初始化
-
-```python
-# post_init 中新增
-if self.deck and not self.deck.children and hasattr(self.deck, "setup") and callable(self.deck.setup):
-    logger.info("YihuaCoinCellDeck 无子节点，调用 setup() 初始化")
-    self.deck.setup()
-```
-
-### 联动 Bug：`MaterialPlate.create_with_holes` 构造顺序错误
-
-**现象**：`deck.setup()` 被调用后，启动时抛出：
-```
-设备后初始化失败: Must specify either `ordered_items` or `ordering`.
-```
-
-**根因**：`create_with_holes` 原来的逻辑是先构造空的 `MaterialPlate` 实例，再 assign 洞位：
-```python
-# 旧（错误）：cls(...) 时 ordered_items=None → ItemizedResource.__init__ 立即报错
-plate = cls(name=name, ...)          # ← 这里就崩了
-holes = create_ordered_items_2d(...) # ← 根本没走到这里
-for hole_name, hole in holes.items():
-    plate.assign_child_resource(...)
-```
-pylabrobot 的 `ItemizedResource.__init__` 强制要求 `ordered_items` 和 `ordering` 必须有一个不为 `None`，空构造直接失败。
-
-**修复**：先建洞位，再作为 `ordered_items` 传给构造函数：
-```python
-# 新（正确）：先建洞位，再一次性传入构造函数
-holes = create_ordered_items_2d(klass=MaterialHole, num_items_x=4, ...)
-return cls(name=name, ..., ordered_items=holes)
-```
-
-> 此 bug 此前未被触发，是因为 `deck.setup()` 从未被调用到——正是上面 `post_init` 兜底修复引出的联动问题。
-
----
-
-## 补充修复 2026-03-25：3→2→1 转运资源同步失败
-
-### 问题
-
-配液工站（Bioyond）完成分液后，调用 `transfer_3_to_2_to_1_auto` 将分液瓶板转运到扣电工站（BatteryStation）。物理 LIMS 转运成功，但数字孪生资源树同步始终失败：
-```
-[资源同步] ❌ 失败: 目标设备 'BatteryStation' 中未找到资源 'bottle_rack_6x2'
-```
-
-### 根因
-
-`_get_resource_from_device` 方法负责跨设备查找资源对象，有两个问题：
-
-1. **原始路径完全失效**：尝试 `from unilabos.app.ros2_app import get_device_plr_resource_by_name`，但该模块不存在，`ImportError` 被 `except Exception: pass` 静默吞掉
-2. **降级路径搜错地方**：遍历 `self._plr_resources`（Bioyond 自己的资源），不可能找到 BatteryStation 的 `bottle_rack_6x2`
-
-### 修复文件
-
-**`unilabos/devices/workstation/bioyond_studio/bioyond_cell/bioyond_cell_workstation.py`**
-
-改用全局设备注册表 `registered_devices` 跨设备访问目标 deck：
-
-```python
-# 修复前（失效）
-from unilabos.app.ros2_app import get_device_plr_resource_by_name  # 模块不存在
-return get_device_plr_resource_by_name(device_id, resource_name)
-
-# 修复后
-from unilabos.ros.nodes.base_device_node import registered_devices
-device_info = registered_devices.get(device_id)
-if device_info is not None:
-    driver = device_info.get("driver_instance")  # TypedDict 是 dict，必须用 .get()
-    if driver is not None:
-        deck = getattr(driver, "deck", None)
-        if deck is not None:
-            res = deck.get_resource(resource_name)
-```
-
-关键细节：`DeviceInfoType` 是 `TypedDict`（即普通 `dict`），必须用 `device_info.get("driver_instance")` 而非 `getattr(device_info, "driver_instance", None)`——后者对字典永远返回 `None`。
-
----
-
-## 根本原因分析
-
-旧版以**本地文件模式**启动（有 `graph` 文件），deck 在启动前已通过 `merge_remote_resources` 获得仓库子节点，反序列化时能正确恢复 warehouses。
-
-新版以**远端模式**启动（`file_path=None`），deck 反序列化时没有仓库子节点，`station.py` 扫描为空，所有物料的 warehouse 匹配失败，Bioyond 同步的 16 个资源全部无法放置到对应仓库位，前端不显示。

recipes/msgs/recipe.yaml

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

recipes/unilabos/recipe.yaml

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

scripts/workflow.py

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

setup.py

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

unilabos/__init__.py

@@ -1 +1 @@
-__version__ = "0.10.19"
+__version__ = "0.11.0"

unilabos/app/main.py

@@ -621,8 +621,6 @@ def main():
             continue
 
     # 如果从远端获取了物料信息，则与本地物料进行同步
-    # 仅在本地文件模式下有意义：本地文件只含设备结构，远端有已保存的物料，需要 merge
-    # 远端模式下 resource_tree_set 与 request_startup_json 来自同一份数据，merge 为空操作
     if file_path is not None and request_startup_json and "nodes" in request_startup_json:
         print_status("开始同步远端物料到本地...", "info")
         remote_tree_set = ResourceTreeSet.from_raw_dict_list(request_startup_json["nodes"])

unilabos/devices/neware_battery_test_system/OSS_UPLOAD_README_CN.md

@@ -219,10 +219,10 @@ device = NewareBatteryTestSystem(
 
 #### 步骤 2：提交测试任务
 
-使用 `submit_from_csv_export_ndax` 提交测试任务：
+使用 `submit_from_csv` 提交测试任务：
 
 ```python
-result = device.submit_from_csv_export_ndax(
+result = device.submit_from_csv(
     csv_path="test_data.csv",
     output_dir="D:/neware_output"
 )
@@ -489,7 +489,7 @@ A: 重新获取新的 Token 并更新环境变量 `UNI_LAB_AUTH_TOKEN`。
 **Q: 可以自定义上传路径吗？**  
 A: 当前版本路径由统一 API 自动分配，`oss_prefix` 参数暂不使用（保留接口兼容性）。
 
-**Q: 为什么不在 `submit_from_csv_export_ndax` 中自动上传？**  
+**Q: 为什么不在 `submit_from_csv` 中自动上传？**  
 A: 因为备份文件在测试进行中逐步生成，方法返回时可能文件尚未完全生成，因此提供独立的上传方法更灵活。
 
 **Q: 上传后如何访问文件？**  

unilabos/devices/neware_battery_test_system/OSS_UPLOAD_README_EN.md

@@ -230,10 +230,10 @@ device = NewareBatteryTestSystem(
 
 #### Step 2: Submit Test Tasks
 
-Use `submit_from_csv_export_ndax` to submit test tasks:
+Use `submit_from_csv` to submit test tasks:
 
 ```python
-result = device.submit_from_csv_export_ndax(
+result = device.submit_from_csv(
     csv_path="test_data.csv",
     output_dir="D:/neware_output"
 )
@@ -500,7 +500,7 @@ A: Obtain a new API Key and update the `UNI_LAB_AUTH_TOKEN` environment variable
 **Q: Can I customize upload paths?**  
 A: Current version has paths automatically assigned by unified API. `oss_prefix` parameter is currently unused (retained for interface compatibility).
 
-**Q: Why not auto-upload in `submit_from_csv_export_ndax`?**  
+**Q: Why not auto-upload in `submit_from_csv`?**  
 A: Because backup files are generated progressively during testing, they may not be fully generated when the method returns. A separate upload method provides more flexibility.
 
 **Q: How to access files after upload?**  

unilabos/devices/neware_battery_test_system/device.json

@@ -14,7 +14,7 @@
             "config": {
                 "ip": "127.0.0.1",
                 "port": 502,
-                "machine_ids": [1, 2, 3, 4, 5, 6, 86],
+                "machine_id": 1,
                 "devtype": "27",
                 "timeout": 20,
                 "size_x": 500.0,
@@ -26,10 +26,10 @@
             "data": {
                 "功能说明": "新威电池测试系统，提供720通道监控和CSV批量提交功能",
                 "监控功能": "支持720个通道的实时状态监控、2盘电池物料管理、状态导出等",
-                "提交功能": "通过submit_from_csv action从CSV文件批量提交测试任务（NDA备份），或通过submit_from_csv_export_excel action提交并备份为Excel格式。CSV必须包含: Battery_Code, Pole_Weight, 集流体质量, 活性物质含量, 克容量mah/g, 电池体系, 设备号, 排号, 通道号"
+                "提交功能": "通过submit_from_csv action从CSV文件批量提交测试任务。CSV必须包含: Battery_Code, Pole_Weight, 集流体质量, 活性物质含量, 克容量mah/g, 电池体系, 设备号, 排号, 通道号"
             },
             "children": []
         }
     ],
     "links": []
-}
+}

unilabos/devices/neware_battery_test_system/neware_driver.py

@@ -1,56 +0,0 @@
-import socket
-END_MARKS = [b"\r\n#\r\n", b"</bts>"]  # 读到任一标志即可判定完整响应
-
-def build_start_command(devid, subdevid, chlid, CoinID,
-                        ip_in_xml="127.0.0.1",
-                        devtype:int=27,
-                        recipe_path:str=f"D:\\HHM_test\\A001.xml",
-                        backup_dir:str=f"D:\\HHM_test\\backup",
-                        filetype:int=1) -> str:
-    """
-    filetype: 备份文件类型。0=NDA（新威原生），1=Excel。默认 1。
-    """
-    lines = [
-        '<?xml version="1.0" encoding="UTF-8"?>',
-        '<bts version="1.0">',
-        '  <cmd>start</cmd>',
-        '  <list count="1">',
-        f'    <start ip="{ip_in_xml}" devtype="{devtype}" devid="{devid}" subdevid="{subdevid}" chlid="{chlid}" barcode="{CoinID}">{recipe_path}</start>',
-        f'    <backup backupdir="{backup_dir}" remotedir="" filenametype="1" customfilename="" createdirbydate="0" filetype="{int(filetype)}" backupontime="1" backupontimeinterval="1" backupfree="0" />',
-        '  </list>',
-        '</bts>',
-    ]
-    # TCP 模式：请求必须以 #\r\n 结束（协议要求）
-    return "\r\n".join(lines) + "\r\n#\r\n"
-
-def recv_until_marks(sock: socket.socket, timeout=60):
-    sock.settimeout(timeout)  # 上限给足，协议允许到 30s:contentReference[oaicite:2]{index=2}
-    buf = bytearray()
-    while True:
-        chunk = sock.recv(8192)
-        if not chunk:
-            break
-        buf += chunk
-        # 读到结束标志就停，避免等对端断开
-        for m in END_MARKS:
-            if m in buf:
-                return bytes(buf)
-        # 保险：读到完整 XML 结束标签也停
-        if b"</bts>" in buf:
-            return bytes(buf)
-    return bytes(buf)
-
-def start_test(ip="127.0.0.1", port=502, devid=3, subdevid=2, chlid=1, CoinID="A001", recipe_path=f"D:\\HHM_test\\A001.xml", backup_dir=f"D:\\HHM_test\\backup", filetype:int=1):
-    """
-    filetype: 备份文件类型，0=NDA，1=Excel。默认 1。
-    """
-    xml_cmd = build_start_command(devid=devid, subdevid=subdevid, chlid=chlid, CoinID=CoinID, recipe_path=recipe_path, backup_dir=backup_dir, filetype=filetype)
-    #print(xml_cmd)
-    with socket.create_connection((ip, port), timeout=60) as s:
-        s.sendall(xml_cmd.encode("utf-8"))
-        data = recv_until_marks(s, timeout=60)
-    return data.decode("utf-8", errors="replace")
-
-if __name__ == "__main__":
-    resp = start_test(ip="127.0.0.1", port=502, devid=4, subdevid=10, chlid=1, CoinID="A001", recipe_path=f"D:\\HHM_test\\A001.xml", backup_dir=f"D:\\HHM_test\\backup")
-    print(resp)

unilabos/devices/workstation/bioyond_studio/station.py

@@ -258,7 +258,7 @@ class BioyondResourceSynchronizer(ResourceSynchronizer):
                 logger.info(f"[同步→Bioyond] ➕ 物料不存在于 Bioyond，将创建新物料并入库")
 
             # 第1步：从配置中获取仓库配置
-            warehouse_mapping = self.workstation.bioyond_config.get("warehouse_mapping", {})
+            warehouse_mapping = self.bioyond_config.get("warehouse_mapping", {})
 
             # 确定目标仓库名称
             parent_name = None
@@ -760,9 +760,10 @@ class BioyondWorkstation(WorkstationBase):
                         except:
                             pass
 
-        # 创建通信模块；同步器将在 post_init 中初始化并执行首次同步
+        # 创建通信模块
         self._create_communication_module(bioyond_config)
-        self.resource_synchronizer = None
+        self.resource_synchronizer = BioyondResourceSynchronizer(self)
+        self.resource_synchronizer.sync_from_external()
 
         # TODO: self._ros_node里面拿属性
 
@@ -801,15 +802,6 @@ class BioyondWorkstation(WorkstationBase):
     def post_init(self, ros_node: ROS2WorkstationNode):
         self._ros_node = ros_node
 
-        # Deck 为空时（反序列化未恢复子节点），主动调用 setup() 初始化仓库
-        if self.deck and not self.deck.children and hasattr(self.deck, "setup") and callable(self.deck.setup):
-            logger.info("Deck 无仓库子节点，调用 setup() 初始化仓库")
-            self.deck.setup()
-
-        # 初始化同步器并执行首次同步（需在仓库初始化之后）
-        self.resource_synchronizer = BioyondResourceSynchronizer(self)
-        self.resource_synchronizer.sync_from_external()
-
         # 启动连接监控
         try:
             self.connection_monitor = ConnectionMonitor(self)

unilabos/devices/workstation/changelog_2026-03-12.md

@@ -1,219 +0,0 @@
-# 代码变更说明 — 2026-03-12
-
-> 本次变更基于 `implementation_plan_v2.md` 执行，目标：**物理几何结构初始化与物料内容物填充彻底解耦**，消除 PLR 反序列化时的 `Resource already assigned to deck` 错误，并修复若干运行时新增问题。
-
----
-
-## 一、物料系统标准化重构（主线任务）
-
-### 1. `unilabos/resources/battery/magazine.py`
-
-**改动**：`MagazineHolder_6_Cathode`、`MagazineHolder_6_Anode`、`MagazineHolder_4_Cathode` 三个工厂函数的 `klasses` 参数改为 `None`。
-
-**原因**：原来三个工厂函数在初始化时就向洞位填满极片对象（`ElectrodeSheet`），导致 PLR 反序列化时"几何结构已创建子节点 + DB 再次 assign"双重冲突。
-
-**原则**：物料余量改由寄存器直读（阶段 F），资源树不再追踪每个极片实体。`MagazineHolder_6_Battery` 原本就是 `klasses=None`，三者现在保持一致。
-
----
-
-### 2. `unilabos/resources/battery/magazine.py`（追加，响应重复 UUID 问题）
-
-**改动**：为 `Magazine`（洞位类）新增 `serialize` 和 `deserialize` 重写：
-- `serialize`：序列化时强制将 `children` 置空，不再把极片写回数据库。
-- `deserialize`：反序列化时强制忽略 `children` 字段，阻止数据库中旧极片记录被恢复。
-
-**原因**：数据库中遗留有旧的 `ElectrodeSheet` 记录（`A1_sheet100` 等），启动时被 PLR 反序列化进来，导致同一 UUID 出现在多个 Magazine 洞位中，触发 `发现重复的uuid` 错误。此修复从源头截断旧数据，经过一次完整的"启动 → 资源树写回"后，数据库旧极片记录也会被干净覆盖。
-
----
-
-### 3. `unilabos/resources/battery/bottle_carriers.py`
-
-**改动**：删除 `YIHUA_Electrolyte_12VialCarrier` 末尾的 12 瓶填充循环及对应 `import`。
-
-**原因**：`bottle_rack_6x2` 和 `bottle_rack_6x2_2` 应初始化为空载架，瓶子由 Bioyond 侧实际转运后再填入。原来初始化时直接塞满 `YB_pei_ye_xiao_Bottle`，反序列化时产生重复 assign。
-
----
-
-### 4. `unilabos/resources/bioyond/decks.py`
-
-**改动**：
-- 将 `BIOYOND_YB_Deck` 重命名为 `BioyondElectrolyteDeck`，保留 `BIOYOND_YB_Deck` 作为向后兼容别名。
-- 工厂函数 `YB_Deck()` 重命名为 `bioyond_electrolyte_deck()`，保留 `YB_Deck` 作为别名。
-- `BIOYOND_PolymerReactionStation_Deck`、`BIOYOND_PolymerPreparationStation_Deck`、`BioyondElectrolyteDeck` 三个 Deck 类：
-  - 移除 `__init__` 中的 `setup: bool = False` 参数及 `if setup: self.setup()` 调用。
-  - 删除临时 `deserialize` 补丁（该补丁是为了强制 `setup=False`，根本原因消除后不再需要）。
-
-**原因**：`setup` 参数导致 PLR 反序列化时先通过 `__init__` 创建所有子资源，再从 JSON `children` 字段再次 assign，产生 `already assigned to deck` 错误。正确模式：`__init__` 只初始化自身几何，`setup()` 由工厂函数调用，反序列化由 PLR 从 DB 数据重建子资源。
-
----
-
-### 5. `unilabos/devices/workstation/coin_cell_assembly/YB_YH_materials.py`
-
-**改动**：
-- `CoincellDeck` 重命名为 `YihuaCoinCellDeck`，保留 `CoincellDeck` 作为向后兼容别名。
-- 工厂函数 `YH_Deck()` 重命名为 `yihua_coin_cell_deck()`，保留 `YH_Deck` 作为别名。
-- 移除 `YihuaCoinCellDeck.__init__` 中的 `setup: bool = False` 参数及调用，删除 `deserialize` 补丁（原因同 decks.py）。
-- `MaterialPlate.__init__` 移除 `fill` 参数和 `fill=True` 分支，新增类方法 `MaterialPlate.create_with_holes()` 作为"带洞位"的工厂方法，`setup()` 改为调用该工厂方法。
-- `YihuaCoinCellDeck.setup()` 末尾新增 `electrolyte_buffer`（`ResourceStack`）接驳槽，用于接收来自 Bioyond 侧的分液瓶板，命名与 `bioyond_cell_workstation.py` 中 `sites=["electrolyte_buffer"]` 一致。
-
----
-
-### 6. `unilabos/resources/resource_tracker.py`
-
-**改动 1**：`to_plr_resources` 中，`load_all_state` 调用前预填 `Container` 类资源缺失的键：
-
-```python
-state.setdefault("liquid_history", [])
-state.setdefault("pending_liquids", {})
-```
-
-**原因**：新版 PLR 要求 `Container` 状态中必须包含这两个键，旧数据库记录缺失时 `load_all_state` 会抛出 `KeyError`。
-
-**改动 2**：`_validate_tree` 中，遇到重复 UUID 时改为自动重新分配新 UUID 并打 `WARNING`，不再直接抛异常崩溃。
-
-**原因**：旧数据库中存在多个同名同 UUID 的极片对象（历史脏数据），严格校验会导致节点无法启动。改为 WARNING + 自动修复，确保启动成功，下次资源树写回后脏数据自然清除。
-
----
-
-### 7. `unilabos/resources/itemized_carrier.py`
-
-**改动**：将原来的 `idx is None` 兜底补丁（静默调用 `super().assign_child_resource`，不更新槽位追踪）替换为两段式逻辑：
-
-1. **XY 近似匹配**（容差 2mm）：精确三维坐标匹配失败时，仅对比 XY 二维坐标，找到最近槽位后用槽位的正确坐标（含 Z）完成 assign，并打 `WARNING`。
-2. **XY 也失败才抛异常**：给出详细的槽位列表和传入坐标，便于问题排查。
-
-**原因**：数据库中存储的资源坐标 Z=0，而 `warehouse_factory` 定义的槽位 Z=dz（如 10mm）。精确匹配永远失败，原补丁静默兜底掩盖了这一问题。近似匹配修复了 Z 偏移，同时保留了真正异常时的报错能力。
-
----
-
-### 8. `unilabos/devices/workstation/bioyond_studio/bioyond_cell/bioyond_cell_workstation.py`
-
-**改动 1**：更新导入：`BIOYOND_YB_Deck` → `BioyondElectrolyteDeck, bioyond_electrolyte_deck`。
-
-**改动 2**：`__main__` 入口处改为调用 `bioyond_electrolyte_deck(name="YB_Deck")`。
-
-**改动 3**：新增 `_get_resource_from_device(device_id, resource_name)` 方法，用于从目标设备的资源树中动态查找 PLR 资源对象（带降级回退逻辑）。
-
-**改动 4**：跨站转运逻辑中，将原来"创建 `size=1,1,1` 的虚拟 `ResourcePLR` + 硬编码 UUID"的方式，改为通过 `_get_resource_from_device` 从目标设备获取真实的 `electrolyte_buffer` 资源对象。
-
-**原因**：原代码使用硬编码 UUID 的虚拟资源作为转运目标，该对象在 YihuaCoinCellDeck 的资源树中不存在，转移后资源树状态混乱。
-
----
-
-### 9. `unilabos/devices/workstation/coin_cell_assembly/coin_cell_assembly.py`
-
-**改动 1**：更新导入：`CoincellDeck` → `YihuaCoinCellDeck, yihua_coin_cell_deck`，`__main__` 入口改为调用 `yihua_coin_cell_deck()`。
-
-**改动 2**：新增 10 个 `@property`，实现对依华扣电工站 Modbus 寄存器的直读：
-
-| 属性名 | 寄存器地址 | 说明 |
-|---|---|---|
-| `data_10mm_positive_plate_remaining` | 520 | 10mm正极片余量 |
-| `data_12mm_positive_plate_remaining` | 522 | 12mm正极片余量 |
-| `data_16mm_positive_plate_remaining` | 524 | 16mm正极片余量 |
-| `data_aluminum_foil_remaining` | 526 | 铝箔余量 |
-| `data_positive_shell_remaining` | 528 | 正极壳余量 |
-| `data_flat_washer_remaining` | 530 | 平垫余量 |
-| `data_negative_shell_remaining` | 532 | 负极壳余量 |
-| `data_spring_washer_remaining` | 534 | 弹垫余量 |
-| `data_finished_battery_remaining_capacity` | 536 | 成品电池余量 |
-| `data_finished_battery_ng_remaining_capacity` | 538 | 成品电池NG槽余量 |
-
-**原因**：`coin_cell_workstation.yaml` 的 `status_types` 中定义了这 10 个属性，但代码中从未实现，导致每次前端轮询时均报 `AttributeError`。
-
----
-
-## 二、配置与注册表更新
-
-### 10. `yibin_electrolyte_config.json`
-- `BIOYOND_YB_Deck` → `BioyondElectrolyteDeck`（class、type、_resource_type 三处）
-- `CoincellDeck` → `YihuaCoinCellDeck`（class、type、_resource_type 三处）
-- 移除 `"setup": true` 字段
-
-### 11. `yibin_coin_cell_only_config.json`
-- `CoincellDeck` → `YihuaCoinCellDeck`
-- 移除 `"setup": true`
-
-### 12. `yibin_electrolyte_only_config.json`
-- `BIOYOND_YB_Deck` → `BioyondElectrolyteDeck`
-- 移除 `"setup": true`
-
-### 13. `unilabos/registry/resources/bioyond/deck.yaml`
-- `BIOYOND_YB_Deck` → `BioyondElectrolyteDeck`，工厂函数路径更新为 `bioyond_electrolyte_deck`
-- `CoincellDeck` → `YihuaCoinCellDeck`，工厂函数路径更新为 `yihua_coin_cell_deck`
-
----
-
-## 三、独立 Bug 修复
-
-### 14. `unilabos/devices/workstation/coin_cell_assembly/coin_cell_assembly_b.csv`
-
-**改动**：10 条余量寄存器记录的 `DataType` 列从 `REAL` 改为 `FLOAT32`。
-
-**原因**：`REAL` 是 IEC 61131-3 PLC 工程师惯用名称，但 pymodbus 的 `DATATYPE` 枚举只有 `FLOAT32`，`DataType['REAL']` 查表时抛 `KeyError: 'REAL'`，导致 `CoinCellAssemblyWorkstation` 节点启动失败。
-
----
-
-## 四、运行期新增 Bug 修复（第二轮，2026-03-12 18:12 日志）
-
-### 15. `unilabos/devices/workstation/bioyond_studio/station.py`
-
-**改动**：第 261 行 `self.bioyond_config` → `self.workstation.bioyond_config`。
-
-**原因**：`BioyondResourceSynchronizer.sync_to_external` 内部误用了 `self.bioyond_config`，而该类从未设置此属性（应通过 `self.workstation.bioyond_config` 访问）。触发场景：用户在前端将任意物料拖入仓库时，同步到 Bioyond 必定抛出 `AttributeError: 'BioyondResourceSynchronizer' object has no attribute 'bioyond_config'`。
-
----
-
-### 16. `unilabos/devices/workstation/bioyond_studio/bioyond_cell/bioyond_cell_workstation.py`
-
-**改动**：`_get_type_id_by_name` 方法新增"直接英文 key 命中"分支：
-
-- **原逻辑**：仅按 `value[0]`（中文名，如 `"5ml分液瓶板"`）遍历比较。
-- **新逻辑**：先以 `type_name` 直接查找 `material_type_mappings` 字典 key（英文 model 名，如 `"YB_Vial_5mL_Carrier"`），命中则立即返回 UUID；否则再按中文名兜底遍历。
-
-**原因**：`resource_tree_transfer` 将 `plr_resource.model`（英文 key）作为 `board_type` / `bottle_type` 传给 `create_sample`，后者再调用 `_get_type_id_by_name`。旧版函数只按中文名查，导致英文 key 永远匹配不到 → `ValueError: 未找到板类型 'YB_Vial_5mL_Carrier' 的配置`。新函数兼容两种查找方式，同时保持向后兼容。
-
----
-
-## 五、运行期新增 Bug 修复（第三轮，2026-03-12 20:30 日志）
-
-### 17. `unilabos/resources/resource_tracker.py`（追加）
-
-**改动**：在 `to_plr_resources` 中，`sub_cls.deserialize` 调用前新增 `_deduplicate_plr_dict(plr_dict)` 预处理函数。
-
-**函数逻辑**：递归遍历整个 `plr_dict` 树，在**全树范围**对 `children` 列表按 `name` 去重——保留首次出现的同名节点，跳过重复项并打 `WARNING`。
-
-**根本原因**：
-1. 用户通过前端将 `YB_Vial_5mL_Carrier` 拖入仓库 E01，carrier 及其子 vial（`YB_Vial_5mL_Carrier_vial_A1` 等）被写入数据库。
-2. 随后 `sync_from_external`（Bioyond 定期同步）以**新 UUID** 重新创建同名 carrier 并赋给同一槽位，PLR 内存树中的旧 carrier 被替换，但**数据库旧记录未被清除**。
-3. 下次重启时，数据库同一 `WareHouse` 下存在两条同名 `BottleCarrier`（不同 UUID），`node_to_plr_dict` 将二者都放入 `children` 列表，PLR 反序列化第二个 carrier 时子 vial 命名冲突，抛出 `ValueError: Resource with name 'YB_Vial_5mL_Carrier_vial_A1' already exists in the tree.`，整个 deck 无法加载，系统启动失败。
-
-**连锁错误（随根因修复自动消除）**：
-- `TypeError: Deck.__init__() got an unexpected keyword argument 'data'` — deck 加载失败后 `driver_creator.py` 触发降级路径，参数类型错误
-- `AttributeError: 'ResourceDictInstance' object has no attribute 'copy'` — 另一条降级路径失败
-- `ValueError: Deck 配置不能为空` — 所有 deck 创建路径失败，`deck=None` 传入工作站
-
----
-
-> **验证状态**：2026-03-12 20:56 日志确认系统正常运行，无新增 ERROR 级错误。
-
----
-
-## 六、变更文件汇总（最终）
-
-| 文件 | 变更类型 | 轮次 |
-|---|---|---|
-| `resources/battery/magazine.py` | 重构 + Bug 修复（极片子节点解耦 + 旧数据清理） | 第一轮 |
-| `resources/battery/bottle_carriers.py` | 重构（移除初始化时自动填瓶） | 第一轮 |
-| `resources/bioyond/decks.py` | 重构 + 重命名（BioyondElectrolyteDeck） | 第一轮 |
-| `devices/workstation/coin_cell_assembly/YB_YH_materials.py` | 重构 + 重命名（YihuaCoinCellDeck）+ 新增 electrolyte_buffer 槽位 | 第一轮 |
-| `resources/resource_tracker.py` | Bug 修复 × 3（Container 状态键预填 + 重复 UUID 自动修复 + 树级名称去重） | 第一/三轮 |
-| `resources/itemized_carrier.py` | Bug 修复（XY 近似坐标匹配，修复 Z 偏移） | 第一轮 |
-| `devices/workstation/bioyond_studio/bioyond_cell/bioyond_cell_workstation.py` | 重构 + Bug 修复（跨站转运 + 类型映射双模式查找） | 第一/二轮 |
-| `devices/workstation/bioyond_studio/station.py` | Bug 修复（sync_to_external 属性访问路径） | 第二轮 |
-| `devices/workstation/coin_cell_assembly/coin_cell_assembly.py` | 新增 10 个 Modbus 余量属性 + 更新导入 | 第一轮 |
-| `yibin_electrolyte_config.json` | 配置更新（类名 + 移除 setup） | 第一轮 |
-| `yibin_coin_cell_only_config.json` | 配置更新（类名 + 移除 setup） | 第一轮 |
-| `yibin_electrolyte_only_config.json` | 配置更新（类名 + 移除 setup） | 第一轮 |
-| `registry/resources/bioyond/deck.yaml` | 注册表更新（类名 + 工厂函数路径） | 第一轮 |
-| `devices/workstation/coin_cell_assembly/coin_cell_assembly_b.csv` | Bug 修复（REAL → FLOAT32） | 第一轮 |

unilabos/devices/workstation/coin_cell_assembly/YB_YH_materials.py

@@ -130,14 +130,20 @@ class MaterialPlate(ItemizedResource[MaterialHole]):
         ordering: Optional[OrderedDict[str, str]] = None,
         category: str = "material_plate",
         model: Optional[str] = None,
+        fill: bool = False
     ):
-        """初始化料板（不主动填充洞位，由工厂方法或反序列化恢复）
+        """初始化料板
 
         Args:
             name: 料板名称
             size_x: 长度 (mm)
             size_y: 宽度 (mm)
             size_z: 高度 (mm)
+            hole_diameter: 洞直径 (mm)
+            hole_depth: 洞深度 (mm)
+            hole_spacing_x: X方向洞位间距 (mm)
+            hole_spacing_y: Y方向洞位间距 (mm)
+            number: 编号
             category: 类别
             model: 型号
         """
@@ -147,50 +153,42 @@ class MaterialPlate(ItemizedResource[MaterialHole]):
             hole_diameter=20.0,
             info="",
         )
-        super().__init__(
-            name=name,
-            size_x=size_x,
-            size_y=size_y,
-            size_z=size_z,
-            ordered_items=ordered_items,
-            ordering=ordering,
-            category=category,
-            model=model,
-        )
-
-    @classmethod
-    def create_with_holes(
-        cls,
-        name: str,
-        size_x: float,
-        size_y: float,
-        size_z: float,
-        category: str = "material_plate",
-        model: Optional[str] = None,
-    ) -> "MaterialPlate":
-        """工厂方法：创建带 4x4 洞位的料板（仅用于初始 setup，不在反序列化路径调用）"""
-        # 默认洞位间距（与 _unilabos_state 默认值保持一致）
-        hole_spacing_x = 24.0
-        hole_spacing_y = 24.0
-        # 先建洞位，再作为 ordered_items 传入构造函数
-        # （ItemizedResource.__init__ 要求 ordered_items 或 ordering 二选一必须有值）
+        # 创建4x4的洞位
+        # TODO: 这里要改，对应不同形状
         holes = create_ordered_items_2d(
             klass=MaterialHole,
             num_items_x=4,
             num_items_y=4,
-            dx=(size_x - 4 * hole_spacing_x) / 2,
-            dy=(size_y - 4 * hole_spacing_y) / 2,
+            dx=(size_x - 4 * self._unilabos_state["hole_spacing_x"]) / 2,  # 居中
+            dy=(size_y - 4 * self._unilabos_state["hole_spacing_y"]) / 2,  # 居中
             dz=size_z,
-            item_dx=hole_spacing_x,
-            item_dy=hole_spacing_y,
-            size_x=16,
-            size_y=16,
-            size_z=16,
-        )
-        return cls(
-            name=name, size_x=size_x, size_y=size_y, size_z=size_z,
-            ordered_items=holes, category=category, model=model,
+            item_dx=self._unilabos_state["hole_spacing_x"],
+            item_dy=self._unilabos_state["hole_spacing_y"],
+            size_x = 16,
+            size_y = 16,
+            size_z = 16,
         )
+        if fill:
+            super().__init__(
+                name=name,
+                size_x=size_x,
+                size_y=size_y,
+                size_z=size_z,
+                ordered_items=holes,
+                category=category,
+                model=model,
+            )
+        else:
+            super().__init__(
+                name=name,
+                size_x=size_x,
+                size_y=size_y,
+                size_z=size_z,
+                ordered_items=ordered_items,
+                ordering=ordering,
+                category=category,
+                model=model,
+            )
 
     def update_locations(self):
         # TODO:调多次相加
@@ -536,19 +534,30 @@ class WasteTipBox(Trash):
         return data
 
 
-class YihuaCoinCellDeck(Deck):
-    """依华纽扣电池组装工作站台面类"""
+class CoincellDeck(Deck):
+    """纽扣电池组装工作站台面类"""
 
     def __init__(
         self,
         name: str = "coin_cell_deck",
-        size_x: float = 1450.0,
-        size_y: float = 1450.0,
-        size_z: float = 100.0,
+        size_x: float = 1450.0,  # 1m
+        size_y: float = 1450.0,  # 1m
+        size_z: float = 100.0,   # 0.9m
         origin: Coordinate = Coordinate(-2200, 0, 0),
         category: str = "coin_cell_deck",
-        setup: bool = False,
+        setup: bool = False,  # 是否自动执行 setup
     ):
+        """初始化纽扣电池组装工作站台面
+
+        Args:
+            name: 台面名称
+            size_x: 长度 (mm) - 1m
+            size_y: 宽度 (mm) - 1m
+            size_z: 高度 (mm) - 0.9m
+            origin: 原点坐标
+            category: 类别
+            setup: 是否自动执行 setup 配置标准布局
+        """
         super().__init__(
             name=name,
             size_x=1450.0,
@@ -582,11 +591,14 @@ class YihuaCoinCellDeck(Deck):
         # ====================================== 物料板 ============================================
         # 创建物料板（料盘carrier）- 4x4布局
         # 负极料盘
-        fujiliaopan = MaterialPlate.create_with_holes(name="负极料盘", size_x=120, size_y=100, size_z=10.0)
+        fujiliaopan = MaterialPlate(name="负极料盘", size_x=120, size_y=100, size_z=10.0, fill=True)
         self.assign_child_resource(fujiliaopan, Coordinate(x=708.0, y=794.0, z=0))
+        # for i in range(16):
+        #     fujipian = ElectrodeSheet(name=f"{fujiliaopan.name}_jipian_{i}", size_x=12, size_y=12, size_z=0.1)
+        #     fujiliaopan.children[i].assign_child_resource(fujipian, location=None)
 
         # 隔膜料盘
-        gemoliaopan = MaterialPlate.create_with_holes(name="隔膜料盘", size_x=120, size_y=100, size_z=10.0)
+        gemoliaopan = MaterialPlate(name="隔膜料盘", size_x=120, size_y=100, size_z=10.0, fill=True)
         self.assign_child_resource(gemoliaopan, Coordinate(x=718.0, y=918.0, z=0))
         # for i in range(16):
         #     gemopian = ElectrodeSheet(name=f"{gemoliaopan.name}_jipian_{i}", size_x=12, size_y=12, size_z=0.1)
@@ -621,27 +633,11 @@ class YihuaCoinCellDeck(Deck):
         waste_tip_box = WasteTipBox(name="waste_tip_box")
         self.assign_child_resource(waste_tip_box, Coordinate(x=778.0, y=622.0, z=0))
 
-        # 分液瓶板接驳区 - 接收来自 BioyondElectrolyte 侧的完整 Vial Carrier 板
-        # 命名 electrolyte_buffer 与 bioyond_cell_workstation.py 中 sites=["electrolyte_buffer"] 对应
-        electrolyte_buffer = ResourceStack(
-            name="electrolyte_buffer",
-            direction="z",
-            resources=[],
-        )
-        self.assign_child_resource(electrolyte_buffer, Coordinate(x=1050.0, y=700.0, z=0))
 
-
-def yihua_coin_cell_deck(name: str = "coin_cell_deck") -> YihuaCoinCellDeck:
-    deck = YihuaCoinCellDeck(name=name)
-    deck.setup()
-    return deck
-
-
-# 向后兼容别名，日后废弃
-CoincellDeck = YihuaCoinCellDeck
-
-def YH_Deck(name: str = "") -> YihuaCoinCellDeck:
-    return yihua_coin_cell_deck(name=name or "coin_cell_deck")
+def YH_Deck(name=""):
+    cd = CoincellDeck(name=name)
+    cd.setup()
+    return cd
 
 
 if __name__ == "__main__":

unilabos/devices/workstation/coin_cell_assembly/coin_cell_assembly.py

@@ -6,7 +6,7 @@ import threading
 import time
 import types
 from datetime import datetime
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, Optional
 from functools import wraps
 from pylabrobot.resources import Deck, Resource as PLRResource
 from unilabos_msgs.msg import Resource
@@ -17,7 +17,7 @@ from unilabos.device_comms.modbus_plc.modbus import DeviceType, Base as ModbusNo
 from unilabos.devices.workstation.coin_cell_assembly.YB_YH_materials import *
 from unilabos.ros.nodes.base_device_node import ROS2DeviceNode, BaseROS2DeviceNode
 from unilabos.ros.nodes.presets.workstation import ROS2WorkstationNode
-from unilabos.devices.workstation.coin_cell_assembly.YB_YH_materials import YihuaCoinCellDeck, yihua_coin_cell_deck
+from unilabos.devices.workstation.coin_cell_assembly.YB_YH_materials import CoincellDeck
 from unilabos.resources.graphio import convert_resources_to_type
 from unilabos.utils.log import logger
 import struct
@@ -161,9 +161,7 @@ class CoinCellAssemblyWorkstation(WorkstationBase):
             logger.info("没有传入依华deck，检查启动json文件")
         super().__init__(deck=deck, *args, **kwargs,)
         self.debug_mode = debug_mode
-        self._modbus_address = address
-        self._modbus_port = port
-
+ 
         """ 连接初始化 """
         modbus_client = TCPClient(addr=address, port=port)
         logger.debug(f"创建 Modbus 客户端: {modbus_client}")
@@ -180,11 +178,9 @@ class CoinCellAssemblyWorkstation(WorkstationBase):
                 raise ValueError('modbus tcp connection failed')
             self.nodes = BaseClient.load_csv(os.path.join(os.path.dirname(__file__), 'coin_cell_assembly_b.csv'))                            
             self.client = modbus_client.register_node_list(self.nodes)
-            self._modbus_client_raw = modbus_client
         else:
             print("测试模式，跳过连接")
             self.nodes, self.client = None, None
-            self._modbus_client_raw = None
 
         """ 工站的配置 """
 
@@ -195,40 +191,9 @@ class CoinCellAssemblyWorkstation(WorkstationBase):
         self.csv_export_file = None
         self.coin_num_N = 0  #已组装电池数量
 
-    def _ensure_modbus_connected(self) -> None:
-        """检查 Modbus TCP 连接是否存活，若已断开则自动重连（防止长时间空闲后连接超时）"""
-        if self.debug_mode or self._modbus_client_raw is None:
-            return
-        raw_client = self._modbus_client_raw.client
-        if raw_client.is_socket_open():
-            return
-        logger.warning("[Modbus] 检测到连接已断开，尝试重连...")
-        try:
-            raw_client.close()
-        except Exception:
-            pass
-        count = 10
-        while count > 0:
-            count -= 1
-            try:
-                raw_client.connect()
-            except Exception:
-                pass
-            if raw_client.is_socket_open():
-                break
-            time.sleep(2)
-        if not raw_client.is_socket_open():
-            raise RuntimeError(f"Modbus TCP 重连失败（{self._modbus_address}:{self._modbus_port}），请检查设备连接")
-        logger.info("[Modbus] 重连成功")
-
     def post_init(self, ros_node: ROS2WorkstationNode):
         self._ros_node = ros_node
-
-        # Deck 为空时（反序列化未恢复子节点），主动调用 setup() 初始化子物料
-        if self.deck and not self.deck.children and hasattr(self.deck, "setup") and callable(self.deck.setup):
-            logger.info("YihuaCoinCellDeck 无子节点，调用 setup() 初始化")
-            self.deck.setup()
-
+        #self.deck = create_a_coin_cell_deck()
         ROS2DeviceNode.run_async_func(self._ros_node.update_resource, True, **{
             "resources": [self.deck]
         })
@@ -658,28 +623,12 @@ class CoinCellAssemblyWorkstation(WorkstationBase):
         return vol
 
     @property
-    def data_coin_type(self) -> int:
-        """电池类型 - 7种或8种组装物料 (INT16)"""
-        if self.debug_mode:
-            return 7
-        coin_type, read_err = self.client.use_node('REG_DATA_COIN_TYPE').read(1)
-        return coin_type
-    
-    @property
-    def data_current_assembling_count(self) -> int:
-        """当前进行组装的电池数量 - Current assembling battery count (INT16)"""
+    def data_coin_num(self) -> int:
+        """当前电池数量 (INT16)"""
         if self.debug_mode:
             return 0
-        count, read_err = self.client.use_node('REG_DATA_CURRENT_ASSEMBLING_COUNT').read(1)
-        return count
-    
-    @property
-    def data_current_completed_count(self) -> int:
-        """当前完成组装的电池数量 - Current completed battery count (INT16)"""
-        if self.debug_mode:
-            return 0
-        count, read_err = self.client.use_node('REG_DATA_CURRENT_COMPLETED_COUNT').read(1)
-        return count
+        num, read_err = self.client.use_node('REG_DATA_COIN_NUM').read(1)
+        return num
 
     @property
     def data_coin_cell_code(self) -> str:
@@ -777,116 +726,6 @@ class CoinCellAssemblyWorkstation(WorkstationBase):
             return 0.0
         return _decode_float32_correct(result.registers)
 
-    @property
-    def data_10mm_positive_plate_remaining(self) -> float:
-        """10mm正极片剩余物料数量 (FLOAT32)"""
-        if self.debug_mode:
-            return 0.0
-        result = self.client.client.read_holding_registers(address=self.client.use_node('REG_DATA_10MM_POSITIVE_PLATE_REMAINING_COUNT').address, count=2)
-        if result.isError():
-            logger.error("读取10mm正极片余量失败")
-            return 0.0
-        return _decode_float32_correct(result.registers)
-
-    @property
-    def data_12mm_positive_plate_remaining(self) -> float:
-        """12mm正极片剩余物料数量 (FLOAT32)"""
-        if self.debug_mode:
-            return 0.0
-        result = self.client.client.read_holding_registers(address=self.client.use_node('REG_DATA_12MM_POSITIVE_PLATE_REMAINING_COUNT').address, count=2)
-        if result.isError():
-            logger.error("读取12mm正极片余量失败")
-            return 0.0
-        return _decode_float32_correct(result.registers)
-
-    @property
-    def data_16mm_positive_plate_remaining(self) -> float:
-        """16mm正极片剩余物料数量 (FLOAT32)"""
-        if self.debug_mode:
-            return 0.0
-        result = self.client.client.read_holding_registers(address=self.client.use_node('REG_DATA_16MM_POSITIVE_PLATE_REMAINING_COUNT').address, count=2)
-        if result.isError():
-            logger.error("读取16mm正极片余量失败")
-            return 0.0
-        return _decode_float32_correct(result.registers)
-
-    @property
-    def data_aluminum_foil_remaining(self) -> float:
-        """铝箔剩余物料数量 (FLOAT32)"""
-        if self.debug_mode:
-            return 0.0
-        result = self.client.client.read_holding_registers(address=self.client.use_node('REG_DATA_ALUMINUM_FOIL_REMAINING_COUNT').address, count=2)
-        if result.isError():
-            logger.error("读取铝箔余量失败")
-            return 0.0
-        return _decode_float32_correct(result.registers)
-
-    @property
-    def data_positive_shell_remaining(self) -> float:
-        """正极壳剩余物料数量 (FLOAT32)"""
-        if self.debug_mode:
-            return 0.0
-        result = self.client.client.read_holding_registers(address=self.client.use_node('REG_DATA_POSITIVE_SHELL_REMAINING_COUNT').address, count=2)
-        if result.isError():
-            logger.error("读取正极壳余量失败")
-            return 0.0
-        return _decode_float32_correct(result.registers)
-
-    @property
-    def data_flat_washer_remaining(self) -> float:
-        """平垫剩余物料数量 (FLOAT32)"""
-        if self.debug_mode:
-            return 0.0
-        result = self.client.client.read_holding_registers(address=self.client.use_node('REG_DATA_FLAT_WASHER_REMAINING_COUNT').address, count=2)
-        if result.isError():
-            logger.error("读取平垫余量失败")
-            return 0.0
-        return _decode_float32_correct(result.registers)
-
-    @property
-    def data_negative_shell_remaining(self) -> float:
-        """负极壳剩余物料数量 (FLOAT32)"""
-        if self.debug_mode:
-            return 0.0
-        result = self.client.client.read_holding_registers(address=self.client.use_node('REG_DATA_NEGATIVE_SHELL_REMAINING_COUNT').address, count=2)
-        if result.isError():
-            logger.error("读取负极壳余量失败")
-            return 0.0
-        return _decode_float32_correct(result.registers)
-
-    @property
-    def data_spring_washer_remaining(self) -> float:
-        """弹垫剩余物料数量 (FLOAT32)"""
-        if self.debug_mode:
-            return 0.0
-        result = self.client.client.read_holding_registers(address=self.client.use_node('REG_DATA_SPRING_WASHER_REMAINING_COUNT').address, count=2)
-        if result.isError():
-            logger.error("读取弹垫余量失败")
-            return 0.0
-        return _decode_float32_correct(result.registers)
-
-    @property
-    def data_finished_battery_remaining_capacity(self) -> float:
-        """成品电池剩余可容纳数量 (FLOAT32)"""
-        if self.debug_mode:
-            return 0.0
-        result = self.client.client.read_holding_registers(address=self.client.use_node('REG_DATA_FINISHED_BATTERY_REMAINING_CAPACITY').address, count=2)
-        if result.isError():
-            logger.error("读取成品电池余量失败")
-            return 0.0
-        return _decode_float32_correct(result.registers)
-
-    @property
-    def data_finished_battery_ng_remaining_capacity(self) -> float:
-        """成品电池NG槽剩余可容纳数量 (FLOAT32)"""
-        if self.debug_mode:
-            return 0.0
-        result = self.client.client.read_holding_registers(address=self.client.use_node('REG_DATA_FINISHED_BATTERY_NG_REMAINING_CAPACITY').address, count=2)
-        if result.isError():
-            logger.error("读取成品电池NG槽余量失败")
-            return 0.0
-        return _decode_float32_correct(result.registers)
-
 #    @property
 #    def data_stack_vision_code(self) -> int:
 #        """物料堆叠复检图片编码 (INT16)"""
@@ -1086,7 +925,6 @@ class CoinCellAssemblyWorkstation(WorkstationBase):
         
         # 步骤0: 前置条件检查
         logger.info("\n【步骤 0/4】前置条件检查...")
-        self._ensure_modbus_connected()
         try:
             # 检查 REG_UNILAB_INTERACT (应该为False，表示使用Unilab交互)
             unilab_interact_node = self.client.use_node('REG_UNILAB_INTERACT')
@@ -1147,42 +985,6 @@ class CoinCellAssemblyWorkstation(WorkstationBase):
                 raise RuntimeError(error_msg)
             
             logger.info("  ✓ COIL_GB_L_IGNORE_CMD 检查通过 (值为False，使用左手套箱)")
-            
-            # 检查握手寄存器残留（正常初始状态均应为False）
-            # 若上次运行意外断网，这些Unilab侧COIL可能被遗留为True，导致PLC逻辑卡死
-            handshake_checks = [
-                ("COIL_UNILAB_SEND_MSG_SUCC_CMD",       "Unilab→PLC 配方发送完毕",     "上次配方握手未正常复位，PLC可能处于等待配方的卡死状态"),
-                ("COIL_UNILAB_REC_MSG_SUCC_CMD",        "Unilab→PLC 数据接收完毕",     "上次数据接收握手未正常复位"),
-                ("UNILAB_SEND_ELECTROLYTE_BOTTLE_NUM",  "Unilab→PLC 瓶数发送完毕",     "上次瓶数握手未正常复位"),
-                ("UNILAB_SEND_FINISHED_CMD",            "Unilab→PLC 一组完成确认",     "上次完成握手未正常复位"),
-                ("COIL_REQUEST_REC_MSG_STATUS",         "PLC→Unilab 请求接收配方",     "PLC正处于等待配方状态，设备流程已卡死，需重启PLC或手动复位握手"),
-                ("COIL_REQUEST_SEND_MSG_STATUS",        "PLC→Unilab 请求发送测试数据", "PLC正处于等待发送数据状态，设备流程已卡死"),
-            ]
-            for coil_name, coil_desc, stuck_reason in handshake_checks:
-                try:
-                    hs_node = self.client.use_node(coil_name)
-                    hs_value, hs_err = hs_node.read(1)
-                    if hs_err:
-                        logger.warning(f"  ⚠ 无法读取 {coil_name}，跳过此项检查")
-                        continue
-                    hs_actual = hs_value[0] if isinstance(hs_value, (list, tuple)) else hs_value
-                    logger.info(f"  {coil_name} 当前值: {hs_actual}")
-                    if hs_actual:
-                        error_msg = (
-                            "❌ 前置握手寄存器检查失败！\n"
-                            f"  {coil_name} = True (期望值: False)\n"
-                            f"  含义: {coil_desc}\n"
-                            f"  原因: {stuck_reason}\n"
-                            "  建议: 检查上次运行是否意外中断，手动将该寄存器置为False后重试"
-                        )
-                        logger.error(error_msg)
-                        raise RuntimeError(error_msg)
-                    logger.info(f"  ✓ {coil_name} 检查通过 (值为False)")
-                except RuntimeError:
-                    raise
-                except Exception as hs_e:
-                    logger.warning(f"  ⚠ 检查 {coil_name} 时发生异常: {hs_e}，跳过此项")
-            
             logger.info("✓ 所有前置条件检查通过！")
             
         except ValueError as e:
@@ -1356,8 +1158,7 @@ class CoinCellAssemblyWorkstation(WorkstationBase):
         lvbodian: bool = True,
         battery_pressure_mode: bool = True,
         battery_clean_ignore: bool = False,
-        file_path: str = "/Users/sml/work",
-        formulations: List[Dict] = None
+        file_path: str = "/Users/sml/work"
     ) -> Dict[str, Any]:
         """
         发送瓶数+简化组装函数（适用于第二批次及后续批次）
@@ -1384,77 +1185,17 @@ class CoinCellAssemblyWorkstation(WorkstationBase):
             battery_pressure_mode: 是否启用压力模式
             battery_clean_ignore: 是否忽略电池清洁
             file_path: 实验记录保存路径
-            formulations: 配方信息列表（从 create_orders.mass_ratios 获取）
-                         包含 orderCode, target_mass_ratio, real_mass_ratio 等
-                         用于CSV数据追溯，可选参数
             
         Returns:
             dict: 包含组装结果的字典
             
-        注意:
+        注意：
             - 第一次启动需先调用 func_pack_device_init_auto_start_combined()
             - 后续批次直接调用此函数即可
         """
         logger.info("=" * 60)
         logger.info("开始发送瓶数+简化组装流程...")
         logger.info(f"电解液瓶数: {elec_num}, 每瓶电池数: {elec_use_num}")
-        
-        # 存储配方信息到设备状态（供 CSV 写入使用）
-        if formulations:
-            logger.info(f"接收到配方信息: {len(formulations)} 条")
-            # 将配方信息按 orderCode 索引，方便后续查找
-            self._formulations_map = {
-                f["orderCode"]: f for f in formulations
-            } if formulations else {}
-            # ✅ 新增：存储配方列表（按接收顺序），用于索引访问（兜底用）
-            self._formulations_list = formulations
-            # ✅ 新增：按分液瓶条码（vial_bottle_barcodes）反向索引配方
-            # 配液站夹爪取放顺序与扣电站夹取顺序可能不同，所以不能再依赖位置序号，
-            # 必须用扣电站扫码得到的 data_electrolyte_code 去对齐配液站登记的瓶条码。
-            # vial_bottle_barcodes 字段可能形如 "LG100114"（单瓶）或 '["LG100114","LG100115"]'（多瓶）。
-            self._formulations_by_vial_barcode: Dict[str, Dict] = {}
-            for f in formulations:
-                raw_barcodes = f.get("vial_bottle_barcodes", "")
-                if not raw_barcodes:
-                    continue
-                barcodes: List[str] = []
-                if isinstance(raw_barcodes, list):
-                    barcodes = [str(b).strip() for b in raw_barcodes if b]
-                else:
-                    s = str(raw_barcodes).strip()
-                    if s.startswith("[") and s.endswith("]"):
-                        try:
-                            parsed = json.loads(s)
-                            if isinstance(parsed, list):
-                                barcodes = [str(b).strip() for b in parsed if b]
-                            else:
-                                barcodes = [str(parsed).strip()]
-                        except Exception:
-                            barcodes = [s]
-                    else:
-                        barcodes = [s]
-                for bc in barcodes:
-                    if bc and bc not in self._formulations_by_vial_barcode:
-                        self._formulations_by_vial_barcode[bc] = f
-            logger.info(
-                f"已建立分液瓶条码 → 配方索引: {len(self._formulations_by_vial_barcode)} 条 "
-                f"(条码: {list(self._formulations_by_vial_barcode.keys())})"
-            )
-        else:
-            logger.warning("未接收到配方信息，CSV将不包含配方字段")
-            self._formulations_map = {}
-            self._formulations_list = []
-            self._formulations_by_vial_barcode = {}
-        
-        # ✅ 新增：存储每瓶电池数，用于计算当前使用的瓶号
-        # ⚠️ 确保转换为整数（前端可能传递字符串）
-        self._elec_use_num = int(elec_use_num) if elec_use_num else 0
-        logger.info(f"已存储参数: 每瓶电池数={self._elec_use_num}, 配方数={len(self._formulations_list)}")
-        
-        # ✅ 新增：软件层电池计数器（防止硬件计数器不准确）
-        self._software_battery_counter = 0  # 从0开始，每写入一次CSV递增
-        logger.info("软件层电池计数器已初始化")
-        
         logger.info("=" * 60)
         
         # 步骤1: 发送电解液瓶数（触发物料搬运）
@@ -1590,8 +1331,7 @@ class CoinCellAssemblyWorkstation(WorkstationBase):
         data_assembly_time = self.data_assembly_time
         data_assembly_pressure = self.data_assembly_pressure
         data_electrolyte_volume = self.data_electrolyte_volume
-        data_coin_type = self.data_coin_type  # 电池类型（7或8种物料）
-        data_battery_number = self.data_current_assembling_count  # ✅ 真正的电池编号
+        data_coin_num = self.data_coin_num
         
         # 处理电解液二维码 - 确保是字符串类型
         try:
@@ -1621,32 +1361,28 @@ class CoinCellAssemblyWorkstation(WorkstationBase):
         logger.debug(f"data_assembly_time: {data_assembly_time}")
         logger.debug(f"data_assembly_pressure: {data_assembly_pressure}")
         logger.debug(f"data_electrolyte_volume: {data_electrolyte_volume}")
-        logger.debug(f"data_coin_type: {data_coin_type}")  # 电池类型
-        logger.debug(f"data_battery_number: {data_battery_number}")  # ✅ 电池编号
+        logger.debug(f"data_coin_num: {data_coin_num}")
         logger.debug(f"data_electrolyte_code: {data_electrolyte_code}")
         logger.debug(f"data_coin_cell_code: {data_coin_cell_code}")
         #接收完信息后，读取完毕标志位置True
-        finished_battery_magazine = self.deck.get_resource("成品弹夹")        
-        
-        # 计算电池应该放在哪个洞，以及洞内的堆叠位置
-        # 成品弹夹有6个洞，每个洞可堆叠20颗电池
-        # 前5个洞（索引0-4）放正常电池，第6个洞（索引5）放NG电池
-        BATTERIES_PER_HOLE = 20
-        MAX_NORMAL_BATTERIES = 100  # 5个洞 × 20颗/洞
-        
-        hole_index = self.coin_num_N // BATTERIES_PER_HOLE  # 第几个洞（0-4为正常电池）
-        in_hole_position = self.coin_num_N % BATTERIES_PER_HOLE  # 洞内的堆叠序号
-        
-        if hole_index >= 5:
-            logger.error(f"电池数量超出正常容量范围: {self.coin_num_N + 1} > {MAX_NORMAL_BATTERIES}")
-            raise ValueError(f"成品弹夹正常洞位已满（最多{MAX_NORMAL_BATTERIES}颗），当前尝试放置第{self.coin_num_N + 1}颗")
-        
-        target_hole = finished_battery_magazine.children[hole_index]  # 获取目标洞
+        liaopan3 = self.deck.get_resource("成品弹夹")        
         
         # 生成唯一的电池名称（使用时间戳确保唯一性）
         timestamp_suffix = datetime.now().strftime("%Y%m%d_%H%M%S_%f")
         battery_name = f"battery_{self.coin_num_N}_{timestamp_suffix}"
         
+        # 检查目标位置是否已有资源，如果有则先卸载
+        target_slot = liaopan3.children[self.coin_num_N]
+        if target_slot.children:
+            logger.warning(f"位置 {self.coin_num_N} 已有资源，将先卸载旧资源")
+            try:
+                # 卸载所有现有子资源
+                for child in list(target_slot.children):
+                    target_slot.unassign_child_resource(child)
+                    logger.info(f"已卸载旧资源: {child.name}")
+            except Exception as e:
+                logger.error(f"卸载旧资源时出错: {e}")
+        
         # 创建新的电池资源
         battery = ElectrodeSheet(name=battery_name, size_x=14, size_y=14, size_z=2)
         battery._unilabos_state = {
@@ -1657,12 +1393,13 @@ class CoinCellAssemblyWorkstation(WorkstationBase):
                             "electrolyte_volume": data_electrolyte_volume
                             }
         
-        # 将电池堆叠到目标洞中
+        # 分配新资源到目标位置
         try:
-            target_hole.assign_child_resource(battery, location=None)
-            logger.info(f"成功放置电池 {battery_name} 到弹夹洞{hole_index}的第{in_hole_position + 1}层 (总计第{self.coin_num_N + 1}颗)")
+            target_slot.assign_child_resource(battery, location=None)
+            logger.info(f"成功分配电池 {battery_name} 到位置 {self.coin_num_N}")
         except Exception as e:
-            logger.error(f"放置电池资源失败: {e}")
+            logger.error(f"分配电池资源失败: {e}")
+            # 如果分配失败，尝试使用更简单的方法
             raise
         
         #print(jipian2.parent)
@@ -1683,7 +1420,6 @@ class CoinCellAssemblyWorkstation(WorkstationBase):
         time_date = datetime.now().strftime("%Y%m%d")
             #秒级时间戳用于标记每一行电池数据
         timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        self._last_assembly_timestamp = timestamp
             #生成输出文件的变量
         self.csv_export_file = os.path.join(file_path, f"date_{time_date}.csv")   
         #将数据存入csv文件
@@ -1694,107 +1430,17 @@ class CoinCellAssemblyWorkstation(WorkstationBase):
                 writer.writerow([
                     'Time', 'open_circuit_voltage', 'pole_weight', 
                     'assembly_time', 'assembly_pressure', 'electrolyte_volume', 
-                    'data_coin_type', 'electrolyte_code', 'coin_cell_code',
-                    'orderName', 'prep_bottle_barcode', 'vial_bottle_barcodes',
-                    'target_mass_ratio', 'real_mass_ratio'
+                    'coin_num', 'electrolyte_code', 'coin_cell_code'
                 ])
                 #立刻写入磁盘
                 csvfile.flush()
         #开始追加电池信息
         with open(self.csv_export_file, 'a', newline='', encoding='utf-8') as csvfile:
             writer = csv.writer(csvfile)
-            
-            # ========== 提取配方信息 ==========
-            formulation_order_name = ""
-            prep_bottle_barcode = ""
-            vial_bottle_barcodes = ""
-            target_ratio_str = ""
-            real_ratio_str = ""
-            
-            # 从 self._formulations_list 获取配方信息
-            if hasattr(self, '_formulations_list') and self._formulations_list:
-                # ============================================================
-                # ✅ 主方案：用扣电站扫码得到的电解液瓶条码 (data_electrolyte_code)
-                #   反查配液站登记的 vial_bottle_barcodes，避免依赖夹爪取放顺序。
-                # 配液站和扣电站的瓶子顺序往往不一致（不同自动化设备的取放策略不同），
-                # 按位置序号匹配会错位；但每个瓶子的条码是唯一的，按条码匹配最可靠。
-                # ============================================================
-                formulation = None
-                match_method = ""
-
-                barcode_map = getattr(self, "_formulations_by_vial_barcode", {}) or {}
-                scan_code = (data_electrolyte_code or "").strip()
-                if scan_code and scan_code != "N/A" and barcode_map:
-                    formulation = barcode_map.get(scan_code)
-                    if formulation is not None:
-                        match_method = f"按条码({scan_code})精确匹配"
-                    else:
-                        logger.warning(
-                            f"[CSV写入] 电池 {data_battery_number}: 扫码条码 {scan_code} "
-                            f"在配方索引中找不到 (已登记条码: {list(barcode_map.keys())})"
-                        )
-
-                # ============================================================
-                # 🔁 降级方案：扫码失败 / 条码缺失时按瓶号位置兜底
-                #   保留原有"每瓶电池数"或"二维码尾号"的位置推断逻辑，
-                #   确保在异常路径下仍能落盘（位置推断的结果可能不准，仅供回溯）。
-                # ============================================================
-                if formulation is None:
-                    if hasattr(self, '_elec_use_num') and self._elec_use_num:
-                        elec_use_num_int = int(self._elec_use_num) if self._elec_use_num else 1
-                        if elec_use_num_int > 0:
-                            current_bottle_index = (data_battery_number - 1) // elec_use_num_int
-                        else:
-                            current_bottle_index = 0
-
-                        logger.debug(
-                            f"[CSV写入] 电池 {data_battery_number}: 降级按瓶号索引={current_bottle_index} "
-                            f"(每瓶{self._elec_use_num}颗电池)"
-                        )
-                    else:
-                        current_bottle_index = (
-                            int(data_electrolyte_code.split('-')[-1])
-                            if '-' in str(data_electrolyte_code)
-                            else 0
-                        )
-                        logger.debug(
-                            f"[CSV写入] 电池 {data_battery_number}: 降级按二维码尾号瓶号索引={current_bottle_index}"
-                        )
-
-                    if 0 <= current_bottle_index < len(self._formulations_list):
-                        formulation = self._formulations_list[current_bottle_index]
-                        match_method = f"按位置兜底匹配[{current_bottle_index}]"
-                    else:
-                        logger.warning(
-                            f"[CSV写入] 电池 {data_battery_number}: 瓶号索引 {current_bottle_index} "
-                            f"超出配方列表范围 (共{len(self._formulations_list)}个配方)"
-                        )
-
-                if formulation is not None:
-                    formulation_order_name = formulation.get("orderName", "")
-                    prep_bottle_barcode = formulation.get("prep_bottle_barcode", "")
-                    vial_bottle_barcodes = formulation.get("vial_bottle_barcodes", "")
-
-                    real_ratio = formulation.get("real_mass_ratio", {})
-                    target_ratio = formulation.get("target_mass_ratio", {})
-
-                    target_ratio_str = json.dumps(target_ratio, ensure_ascii=False) if target_ratio else ""
-                    real_ratio_str = json.dumps(real_ratio, ensure_ascii=False) if real_ratio else ""
-
-                    logger.info(
-                        f"[CSV写入] 电池 {data_battery_number} ({match_method}): "
-                        f"orderName={formulation_order_name}, 配液瓶={prep_bottle_barcode}, "
-                        f"分液瓶={vial_bottle_barcodes}"
-                    )
-            else:
-                logger.debug(f"[CSV写入] 电池 {data_battery_number}: 未找到配方信息数据")
-            
             writer.writerow([
                 timestamp, data_open_circuit_voltage, data_pole_weight,
                 data_assembly_time, data_assembly_pressure, data_electrolyte_volume,
-                data_coin_type, data_electrolyte_code, data_coin_cell_code,
-                formulation_order_name, prep_bottle_barcode, vial_bottle_barcodes,
-                target_ratio_str, real_ratio_str
+                data_coin_num, data_electrolyte_code, data_coin_cell_code
             ])
             #立刻写入磁盘
             csvfile.flush()
@@ -1939,18 +1585,17 @@ class CoinCellAssemblyWorkstation(WorkstationBase):
                     pole_weight = 0.0
                 
                 battery_info = {
-                    "Time": getattr(self, "_last_assembly_timestamp", datetime.now().strftime("%Y%m%d_%H%M%S")),
+                    "battery_index": coin_num_N + 1,
+                    "battery_barcode": battery_qr_code,
+                    "electrolyte_barcode": electrolyte_qr_code,
                     "open_circuit_voltage": open_circuit_voltage,
                     "pole_weight": pole_weight,
                     "assembly_time": self.data_assembly_time,
                     "assembly_pressure": self.data_assembly_pressure,
-                    "electrolyte_volume": self.data_electrolyte_volume,
-                    "data_coin_type": getattr(self, "data_coin_type", 0),
-                    "electrolyte_code": electrolyte_qr_code,
-                    "coin_cell_code": battery_qr_code,
+                    "electrolyte_volume": self.data_electrolyte_volume
                 }
                 battery_data_list.append(battery_info)
-                print(f"已收集第 {coin_num_N + 1} 个电池数据: 电池码={battery_info['coin_cell_code']}, 电解液码={battery_info['electrolyte_code']}")
+                print(f"已收集第 {coin_num_N + 1} 个电池数据: 电池码={battery_info['battery_barcode']}, 电解液码={battery_info['electrolyte_barcode']}")
                 
                 time.sleep(1)
                 # TODO:读完再将电池数加一还是进入循环就将电池数加一需要考虑
@@ -1979,7 +1624,6 @@ class CoinCellAssemblyWorkstation(WorkstationBase):
             "success": True,
             "total_batteries": len(battery_data_list),
             "batteries": battery_data_list,
-            "assembly_data": battery_data_list,
             "summary": {
                 "electrolyte_bottles_used": elec_num,
                 "batteries_per_bottle": elec_use_num,
@@ -2023,7 +1667,8 @@ class CoinCellAssemblyWorkstation(WorkstationBase):
         file_path: str = "/Users/sml/work"
     ) -> Dict[str, Any]:
         """
-    
+        简化版电池组装函数，整合了原 qiming_coin_cell_code 的参数设置和双滴模式
+        
         此函数是 func_allpack_cmd 的增强版本，自动处理以下配置：
         - 负极片和隔膜的盘数及矩阵点位
         - 枪头盒矩阵点位
@@ -2194,18 +1839,17 @@ class CoinCellAssemblyWorkstation(WorkstationBase):
                     pole_weight = 0.0
                 
                 battery_info = {
-                    "Time": getattr(self, "_last_assembly_timestamp", datetime.now().strftime("%Y%m%d_%H%M%S")),
+                    "battery_index": coin_num_N + 1,
+                    "battery_barcode": battery_qr_code,
+                    "electrolyte_barcode": electrolyte_qr_code,
                     "open_circuit_voltage": open_circuit_voltage,
                     "pole_weight": pole_weight,
                     "assembly_time": self.data_assembly_time,
                     "assembly_pressure": self.data_assembly_pressure,
-                    "electrolyte_volume": self.data_electrolyte_volume,
-                    "data_coin_type": getattr(self, "data_coin_type", 0),
-                    "electrolyte_code": electrolyte_qr_code,
-                    "coin_cell_code": battery_qr_code,
+                    "electrolyte_volume": self.data_electrolyte_volume
                 }
                 battery_data_list.append(battery_info)
-                print(f"已收集第 {coin_num_N + 1} 个电池数据: 电池码={battery_info['coin_cell_code']}, 电解液码={battery_info['electrolyte_code']}")
+                print(f"已收集第 {coin_num_N + 1} 个电池数据: 电池码={battery_info['battery_barcode']}, 电解液码={battery_info['electrolyte_barcode']}")
                 
                 time.sleep(1)
 
@@ -2232,7 +1876,6 @@ class CoinCellAssemblyWorkstation(WorkstationBase):
             "success": True,
             "total_batteries": len(battery_data_list),
             "batteries": battery_data_list,
-            "assembly_data": battery_data_list,
             "summary": {
                 "electrolyte_bottles_used": elec_num,
                 "batteries_per_bottle": elec_use_num,
@@ -2279,7 +1922,7 @@ class CoinCellAssemblyWorkstation(WorkstationBase):
     
     def fun_wuliao_test(self) -> bool: 
         #找到data_init中构建的2个物料盘
-        test_battery_plate = self.deck.get_resource("\u7535\u6c60\u6599\u76d8")
+        liaopan3 = self.deck.get_resource("\u7535\u6c60\u6599\u76d8")
         for i in range(16):            
             battery = ElectrodeSheet(name=f"battery_{i}", size_x=16, size_y=16, size_z=2)
             battery._unilabos_state = {
@@ -2289,7 +1932,7 @@ class CoinCellAssemblyWorkstation(WorkstationBase):
                                 "electrolyte_volume": 20.0,
                                 "electrolyte_name": f"DP{i}"
                                 }
-            test_battery_plate.children[i].assign_child_resource(battery, location=None)
+            liaopan3.children[i].assign_child_resource(battery, location=None)
             
             ROS2DeviceNode.run_async_func(self._ros_node.update_resource, True, **{
                 "resources": [self.deck]
@@ -2332,7 +1975,7 @@ class CoinCellAssemblyWorkstation(WorkstationBase):
             data_assembly_time = self.data_assembly_time
             data_assembly_pressure = self.data_assembly_pressure
             data_electrolyte_volume = self.data_electrolyte_volume
-            data_coin_type = self.data_coin_type  # 电池类型（7或8种物料）
+            data_coin_num = self.data_coin_num
             data_electrolyte_code = self.data_electrolyte_code
             data_coin_cell_code = self.data_coin_cell_code
             # 电解液瓶位置
@@ -2446,7 +2089,7 @@ class CoinCellAssemblyWorkstation(WorkstationBase):
                 writer.writerow([
                     timestamp, data_open_circuit_voltage, data_pole_weight,
                     data_assembly_time, data_assembly_pressure, data_electrolyte_volume,
-                    data_coin_type, data_electrolyte_code, data_coin_cell_code  # ✅ 已修正
+                    data_coin_num, data_electrolyte_code, data_coin_cell_code
                 ])
                 #立刻写入磁盘
                 csvfile.flush()
@@ -2497,7 +2140,7 @@ class CoinCellAssemblyWorkstation(WorkstationBase):
 
 if __name__ == "__main__":
     # 简单测试
-    workstation = CoinCellAssemblyWorkstation(deck=yihua_coin_cell_deck(name="coin_cell_deck"))
+    workstation = CoinCellAssemblyWorkstation(deck=CoincellDeck(setup=True, name="coin_cell_deck"))
     # workstation.qiming_coin_cell_code(fujipian_panshu=1, fujipian_juzhendianwei=2, gemopanshu=3, gemo_juzhendianwei=4, lvbodian=False, battery_pressure_mode=False, battery_pressure=4200, battery_clean_ignore=False)
     # print(f"工作站创建成功: {workstation.deck.name}")
     # print(f"料盘数量: {len(workstation.deck.children)}")

unilabos/devices/workstation/coin_cell_assembly/coin_cell_assembly_b.csv

@@ -0,0 +1,133 @@
+Name,DataType,InitValue,Comment,Attribute,DeviceType,Address,
+COIL_SYS_START_CMD,BOOL,,,,coil,8010,
+COIL_SYS_STOP_CMD,BOOL,,,,coil,8020,
+COIL_SYS_RESET_CMD,BOOL,,,,coil,8030,
+COIL_SYS_HAND_CMD,BOOL,,,,coil,8040,
+COIL_SYS_AUTO_CMD,BOOL,,,,coil,8050,
+COIL_SYS_INIT_CMD,BOOL,,,,coil,8060,
+COIL_UNILAB_SEND_MSG_SUCC_CMD,BOOL,,,,coil,8700,
+COIL_UNILAB_REC_MSG_SUCC_CMD,BOOL,,,,coil,8710,unilab_rec_msg_succ_cmd
+COIL_SYS_START_STATUS,BOOL,,,,coil,8210,
+COIL_SYS_STOP_STATUS,BOOL,,,,coil,8220,
+COIL_SYS_RESET_STATUS,BOOL,,,,coil,8230,
+COIL_SYS_HAND_STATUS,BOOL,,,,coil,8240,
+COIL_SYS_AUTO_STATUS,BOOL,,,,coil,8250,
+COIL_SYS_INIT_STATUS,BOOL,,,,coil,8260,
+COIL_REQUEST_REC_MSG_STATUS,BOOL,,,,coil,8500,
+COIL_REQUEST_SEND_MSG_STATUS,BOOL,,,,coil,8510,request_send_msg_status
+REG_MSG_ELECTROLYTE_USE_NUM,INT16,,,,hold_register,11000,
+REG_MSG_ELECTROLYTE_NUM,INT16,,,,hold_register,11002,unilab_send_msg_electrolyte_num
+REG_MSG_ELECTROLYTE_VOLUME,INT16,,,,hold_register,11004,unilab_send_msg_electrolyte_vol
+REG_MSG_ASSEMBLY_TYPE,INT16,,,,hold_register,11006,unilab_send_msg_assembly_type
+REG_MSG_ASSEMBLY_PRESSURE,INT16,,,,hold_register,11008,unilab_send_msg_assembly_pressure
+REG_DATA_ASSEMBLY_COIN_CELL_NUM,INT16,,,,hold_register,10000,data_assembly_coin_cell_num
+REG_DATA_OPEN_CIRCUIT_VOLTAGE,FLOAT32,,,,hold_register,10002,data_open_circuit_voltage
+REG_DATA_AXIS_X_POS,FLOAT32,,,,hold_register,10004,
+REG_DATA_AXIS_Y_POS,FLOAT32,,,,hold_register,10006,
+REG_DATA_AXIS_Z_POS,FLOAT32,,,,hold_register,10008,
+REG_DATA_POLE_WEIGHT,FLOAT32,,,,hold_register,10010,data_pole_weight
+REG_DATA_ASSEMBLY_PER_TIME,FLOAT32,,,,hold_register,10012,data_assembly_time
+REG_DATA_ASSEMBLY_PRESSURE,INT16,,,,hold_register,10014,data_assembly_pressure
+REG_DATA_ELECTROLYTE_VOLUME,INT16,,,,hold_register,10016,data_electrolyte_volume
+REG_DATA_COIN_NUM,INT16,,,,hold_register,10018,data_coin_num
+REG_DATA_ELECTROLYTE_CODE,STRING,,,,hold_register,10020,data_electrolyte_code()
+REG_DATA_COIN_CELL_CODE,STRING,,,,hold_register,10030,data_coin_cell_code()
+REG_DATA_STACK_VISON_CODE,STRING,,,,hold_register,12004,data_stack_vision_code()
+REG_DATA_GLOVE_BOX_PRESSURE,FLOAT32,,,,hold_register,10050,data_glove_box_pressure
+REG_DATA_GLOVE_BOX_WATER_CONTENT,FLOAT32,,,,hold_register,10052,data_glove_box_water_content
+REG_DATA_GLOVE_BOX_O2_CONTENT,FLOAT32,,,,hold_register,10054,data_glove_box_o2_content
+UNILAB_SEND_ELECTROLYTE_BOTTLE_NUM,BOOL,,,,coil,8720,
+UNILAB_RECE_ELECTROLYTE_BOTTLE_NUM,BOOL,,,,coil,8520,
+REG_MSG_ELECTROLYTE_NUM_USED,INT16,,,,hold_register,496,
+REG_DATA_ELECTROLYTE_USE_NUM,INT16,,,,hold_register,10000,
+UNILAB_SEND_FINISHED_CMD,BOOL,,,,coil,8730,
+UNILAB_RECE_FINISHED_CMD,BOOL,,,,coil,8530,
+REG_DATA_ASSEMBLY_TYPE,INT16,,,,hold_register,10018,ASSEMBLY_TYPE7or8
+REG_UNILAB_INTERACT,BOOL,,,,coil,8450,
+,,,,,coil,8320,
+COIL_ALUMINUM_FOIL,BOOL,,,,coil,8340,
+REG_MSG_NE_PLATE_MATRIX,INT16,,,,hold_register,440,
+REG_MSG_SEPARATOR_PLATE_MATRIX,INT16,,,,hold_register,450,
+REG_MSG_TIP_BOX_MATRIX,INT16,,,,hold_register,480,
+REG_MSG_NE_PLATE_NUM,INT16,,,,hold_register,443,
+REG_MSG_SEPARATOR_PLATE_NUM,INT16,,,,hold_register,453,
+REG_MSG_PRESS_MODE,BOOL,,,,coil,8360,
+,BOOL,,,,coil,8300,
+,BOOL,,,,coil,8310,
+COIL_GB_L_IGNORE_CMD,BOOL,,,,coil,8320,
+COIL_GB_R_IGNORE_CMD,BOOL,,,,coil,8420,
+,BOOL,,,,coil,8350,
+COIL_ELECTROLYTE_DUAL_DROP_MODE,BOOL,,,,coil,8370,
+,BOOL,,,,coil,8380,
+,BOOL,,,,coil,8390,
+,BOOL,,,,coil,8400,
+,BOOL,,,,coil,8410,
+REG_MSG_DUAL_DROP_FIRST_VOLUME,INT16,,,,hold_register,4001,
+COIL_DUAL_DROP_SUCTION_TIMING,BOOL,,,,coil,8430,
+COIL_DUAL_DROP_START_TIMING,BOOL,,,,coil,8470,
+REG_MSG_BATTERY_CLEAN_IGNORE,BOOL,,,,coil,8460,
+COIL_MATERIAL_SEARCH_DIALOG_APPEAR,BOOL,,,,coil,6470,
+COIL_MATERIAL_SEARCH_CONFIRM_YES,BOOL,,,,coil,6480,
+COIL_MATERIAL_SEARCH_CONFIRM_NO,BOOL,,,,coil,6490,
+COIL_ALARM_100_SYSTEM_ERROR,BOOL,,,,coil,1000,异常100-系统异常
+COIL_ALARM_101_EMERGENCY_STOP,BOOL,,,,coil,1010,异常101-急停
+COIL_ALARM_111_GLOVEBOX_EMERGENCY_STOP,BOOL,,,,coil,1110,异常111-手套箱急停
+COIL_ALARM_112_GLOVEBOX_GRATING_BLOCKED,BOOL,,,,coil,1120,异常112-手套箱内光栅遮挡
+COIL_ALARM_160_PIPETTE_TIP_SHORTAGE,BOOL,,,,coil,1600,异常160-移液枪头缺料
+COIL_ALARM_161_POSITIVE_SHELL_SHORTAGE,BOOL,,,,coil,1610,异常161-正极壳缺料
+COIL_ALARM_162_ALUMINUM_FOIL_SHORTAGE,BOOL,,,,coil,1620,异常162-铝箔垫缺料
+COIL_ALARM_163_POSITIVE_PLATE_SHORTAGE,BOOL,,,,coil,1630,异常163-正极片缺料
+COIL_ALARM_164_SEPARATOR_SHORTAGE,BOOL,,,,coil,1640,异常164-隔膜缺料
+COIL_ALARM_165_NEGATIVE_PLATE_SHORTAGE,BOOL,,,,coil,1650,异常165-负极片缺料
+COIL_ALARM_166_FLAT_WASHER_SHORTAGE,BOOL,,,,coil,1660,异常166-平垫缺料
+COIL_ALARM_167_SPRING_WASHER_SHORTAGE,BOOL,,,,coil,1670,异常167-弹垫缺料
+COIL_ALARM_168_NEGATIVE_SHELL_SHORTAGE,BOOL,,,,coil,1680,异常168-负极壳缺料
+COIL_ALARM_169_FINISHED_BATTERY_FULL,BOOL,,,,coil,1690,异常169-成品电池满料
+COIL_ALARM_201_SERVO_AXIS_01_ERROR,BOOL,,,,coil,2010,异常201-伺服轴01异常
+COIL_ALARM_202_SERVO_AXIS_02_ERROR,BOOL,,,,coil,2020,异常202-伺服轴02异常
+COIL_ALARM_203_SERVO_AXIS_03_ERROR,BOOL,,,,coil,2030,异常203-伺服轴03异常
+COIL_ALARM_204_SERVO_AXIS_04_ERROR,BOOL,,,,coil,2040,异常204-伺服轴04异常
+COIL_ALARM_205_SERVO_AXIS_05_ERROR,BOOL,,,,coil,2050,异常205-伺服轴05异常
+COIL_ALARM_206_SERVO_AXIS_06_ERROR,BOOL,,,,coil,2060,异常206-伺服轴06异常
+COIL_ALARM_207_SERVO_AXIS_07_ERROR,BOOL,,,,coil,2070,异常207-伺服轴07异常
+COIL_ALARM_208_SERVO_AXIS_08_ERROR,BOOL,,,,coil,2080,异常208-伺服轴08异常
+COIL_ALARM_209_SERVO_AXIS_09_ERROR,BOOL,,,,coil,2090,异常209-伺服轴09异常
+COIL_ALARM_210_SERVO_AXIS_10_ERROR,BOOL,,,,coil,2100,异常210-伺服轴10异常
+COIL_ALARM_211_SERVO_AXIS_11_ERROR,BOOL,,,,coil,2110,异常211-伺服轴11异常
+COIL_ALARM_212_SERVO_AXIS_12_ERROR,BOOL,,,,coil,2120,异常212-伺服轴12异常
+COIL_ALARM_213_SERVO_AXIS_13_ERROR,BOOL,,,,coil,2130,异常213-伺服轴13异常
+COIL_ALARM_214_SERVO_AXIS_14_ERROR,BOOL,,,,coil,2140,异常214-伺服轴14异常
+COIL_ALARM_250_OTHER_COMPONENT_ERROR,BOOL,,,,coil,2500,异常250-其他元件异常
+COIL_ALARM_251_PIPETTE_COMM_ERROR,BOOL,,,,coil,2510,异常251-移液枪通讯异常
+COIL_ALARM_252_PIPETTE_ALARM,BOOL,,,,coil,2520,异常252-移液枪报警
+COIL_ALARM_256_ELECTRIC_GRIPPER_ERROR,BOOL,,,,coil,2560,异常256-电爪异常
+COIL_ALARM_262_RB_UNKNOWN_POSITION_ERROR,BOOL,,,,coil,2620,异常262-RB报警：未知点位错误
+COIL_ALARM_263_RB_XYZ_PARAM_LIMIT_ERROR,BOOL,,,,coil,2630,异常263-RB报警：X、Y、Z参数超限制
+COIL_ALARM_264_RB_VISION_PARAM_ERROR,BOOL,,,,coil,2640,异常264-RB报警：视觉参数误差过大
+COIL_ALARM_265_RB_NOZZLE_1_PICK_FAIL,BOOL,,,,coil,2650,异常265-RB报警：1#吸嘴取料失败
+COIL_ALARM_266_RB_NOZZLE_2_PICK_FAIL,BOOL,,,,coil,2660,异常266-RB报警：2#吸嘴取料失败
+COIL_ALARM_267_RB_NOZZLE_3_PICK_FAIL,BOOL,,,,coil,2670,异常267-RB报警：3#吸嘴取料失败
+COIL_ALARM_268_RB_NOZZLE_4_PICK_FAIL,BOOL,,,,coil,2680,异常268-RB报警：4#吸嘴取料失败
+COIL_ALARM_269_RB_TRAY_PICK_FAIL,BOOL,,,,coil,2690,异常269-RB报警：取物料盘失败
+COIL_ALARM_280_RB_COLLISION_ERROR,BOOL,,,,coil,2800,异常280-RB碰撞异常
+COIL_ALARM_290_VISION_SYSTEM_COMM_ERROR,BOOL,,,,coil,2900,异常290-视觉系统通讯异常
+COIL_ALARM_291_VISION_ALIGNMENT_NG,BOOL,,,,coil,2910,异常291-视觉对位NG异常
+COIL_ALARM_292_BARCODE_SCANNER_COMM_ERROR,BOOL,,,,coil,2920,异常292-扫码枪通讯异常
+COIL_ALARM_310_OCV_TRANSFER_NOZZLE_SUCTION_ERROR,BOOL,,,,coil,3100,异常310-开电移载吸嘴吸真空异常
+COIL_ALARM_311_OCV_TRANSFER_NOZZLE_BREAK_ERROR,BOOL,,,,coil,3110,异常311-开电移载吸嘴破真空异常
+COIL_ALARM_312_WEIGHT_TRANSFER_NOZZLE_SUCTION_ERROR,BOOL,,,,coil,3120,异常312-称重移载吸嘴吸真空异常
+COIL_ALARM_313_WEIGHT_TRANSFER_NOZZLE_BREAK_ERROR,BOOL,,,,coil,3130,异常313-称重移载吸嘴破真空异常
+COIL_ALARM_340_OCV_NOZZLE_TRANSFER_CYLINDER_ERROR,BOOL,,,,coil,3400,异常340-开路电压吸嘴移载气缸异常
+COIL_ALARM_342_OCV_NOZZLE_LIFT_CYLINDER_ERROR,BOOL,,,,coil,3420,异常342-开路电压吸嘴升降气缸异常
+COIL_ALARM_344_OCV_CRIMPING_CYLINDER_ERROR,BOOL,,,,coil,3440,异常344-开路电压旋压气缸异常
+COIL_ALARM_350_WEIGHT_NOZZLE_TRANSFER_CYLINDER_ERROR,BOOL,,,,coil,3500,异常350-称重吸嘴移载气缸异常
+COIL_ALARM_352_WEIGHT_NOZZLE_LIFT_CYLINDER_ERROR,BOOL,,,,coil,3520,异常352-称重吸嘴升降气缸异常
+COIL_ALARM_354_CLEANING_CLOTH_TRANSFER_CYLINDER_ERROR,BOOL,,,,coil,3540,异常354-清洗无尘布移载气缸异常
+COIL_ALARM_356_CLEANING_CLOTH_PRESS_CYLINDER_ERROR,BOOL,,,,coil,3560,异常356-清洗无尘布压紧气缸异常
+COIL_ALARM_360_ELECTROLYTE_BOTTLE_POSITION_CYLINDER_ERROR,BOOL,,,,coil,3600,异常360-电解液瓶定位气缸异常
+COIL_ALARM_362_PIPETTE_TIP_BOX_POSITION_CYLINDER_ERROR,BOOL,,,,coil,3620,异常362-移液枪头盒定位气缸异常
+COIL_ALARM_364_REAGENT_BOTTLE_GRIPPER_LIFT_CYLINDER_ERROR,BOOL,,,,coil,3640,异常364-试剂瓶夹爪升降气缸异常
+COIL_ALARM_366_REAGENT_BOTTLE_GRIPPER_CYLINDER_ERROR,BOOL,,,,coil,3660,异常366-试剂瓶夹爪气缸异常
+COIL_ALARM_370_PRESS_MODULE_BLOW_CYLINDER_ERROR,BOOL,,,,coil,3700,异常370-压制模块吹气气缸异常
+COIL_ALARM_151_ELECTROLYTE_BOTTLE_POSITION_ERROR,BOOL,,,,coil,1510,异常151-电解液瓶定位在籍异常
+COIL_ALARM_152_ELECTROLYTE_BOTTLE_CAP_ERROR,BOOL,,,,coil,1520,异常152-电解液瓶盖在籍异常

unilabos/devices/workstation/implementation_plan.md

@@ -1,88 +0,0 @@
-# 物料系统标准化重构方案
-
-根据开发者的反馈，本方案旨在遵循“标准化而非绕过”的原则，对资源类（Deck、Carrier、Magazine）进行重构。核心目标是将物理结构的初始化与物料/极片的初始填充逻辑解耦，彻底解决反序列化过程中的初始化冲突。
-
-## 拟议变更
-
-### [参考] PRCXI9300 标准化模式
-#### [参考文件] [prcxi.py](file:///d:/UniLabdev/Uni-Lab-OS/unilabos/devices/liquid_handling/prcxi/prcxi.py)
-*   **PRCXI9300Deck**: 演示了如何在 `serialize` 中导出 `sites` 元数据，以及如何在 `assign_child_resource` 中实现稳健的槽位匹配（支持按名称、坐标或索引匹配）。
-*   **PRCXI9300Container**: 演示了标准的 `load_state` 和 `serialize_state` 模式，确保业务状态（如 `Material` UUID）能正确往返序列化。
-
-### [组件] 台面 (Decks)
-#### [修改] [decks.py](file:///d:/UniLabdev/Uni-Lab-OS/unilabos/resources/bioyond/decks.py)
-*   将 `BIOYOND_YB_Deck` 重命名为 **`BioyondElectrolyteDeck`**，对应工厂函数 `YB_Deck()` 重命名为 **`bioyond_electrolyte_deck()`**。
-*   `BIOYOND_PolymerReactionStation_Deck` 和 `BIOYOND_PolymerPreparationStation_Deck` **保持不变**。
-*   以上三个 Deck 的 `__init__` 中均移除 `setup` 参数和 `setup()` 调用，删除临时的 `deserialize` 重写。
-
-#### [修改 + 重命名] [YB_YH_materials.py](file:///d:/UniLabdev/Uni-Lab-OS/unilabos/devices/workstation/coin_cell_assembly/YB_YH_materials.py) → `yihua_coin_cell_materials.py`
-*   将 `CoincellDeck` 重命名为 **`YihuaCoinCellDeck`**，对应工厂函数 `YH_Deck()` 重命名为 **`yihua_coin_cell_deck()`**。
-*   从 `YihuaCoinCellDeck.__init__` 中移除 `setup` 参数和 `setup()` 调用，删除临时的 `deserialize` 重写。
-
-### [组件] 容器类与弹夹 (Itemized Carriers & Magazines)
-#### [修改] [magazine.py](file:///d:/UniLabdev/Uni-Lab-OS/unilabos/resources/battery/magazine.py)
-*   重构 `magazine_factory`：将创建 `MagazineHolder` 几何结构（空槽位）的过程与填充 `ElectrodeSheet` 物料的过程分离。
-*   确保 `MagazineHolder` 和 `Magazine` 的 `__init__` 过程中不主动创建任何内容物。
-
-#### [修改] [warehouse.py](file:///d:/UniLabdev/Uni-Lab-OS/unilabos/resources/warehouse.py)
-*   确保 `WareHouse` 类和 `warehouse_factory` 遵循相同模式：先初始化几何结构，内容物另行处理。
-
-#### [修改] [itemized_carrier.py](file:///d:/UniLabdev/Uni-Lab-OS/unilabos/resources/itemized_carrier.py)
-*   移除之前添加的 `idx is None` 兜底补丁。
-*   修复命名规范，确保 `assign_child_resource` 在反序列化时能准确匹配资源。
-
-### [组件] 状态兼容性 (State Compatibility)
-#### [修改] [resource_tracker.py](file:///d:/UniLabdev/Uni-Lab-OS/unilabos/resources/resource_tracker.py)
-*   在 `to_plr_resources` 方法中调用 `load_all_state` 之前，预处理 `all_states` 字典。
-*   对于 `Container` 类型的资源，如果其状态中缺少 `liquid_history` 或 `pending_liquids` 等 PLR 新版本要求的键，则填充默认值（如空列表/字典），防止反序列化中断。
-
-### [组件] 料盘 (Material Plates)
-#### [修改] [YB_YH_materials.py](file:///d:/UniLabdev/Uni-Lab-OS/unilabos/devices/workstation/coin_cell_assembly/YB_YH_materials.py)
-*   重构 `MaterialPlate`：不在 `__init__` 中直接调用 `create_ordered_items_2d`。
-*   重构 `YIHUA_Electrolyte_12VialCarrier`：将其修改为标准的基类定义或在工厂方法中彻底剥离内部 12 个 `YB_pei_ye_xiao_Bottle` 的强制初始化，以防反序列化冲突。
-
-### [组件] 跨站转运与分液瓶板 (Vial Plate Transfer)
-#### [修改] [bioyond_cell_workstation.py] & [YB_YH_materials.py]
-*   **分析**：目前的 `bioyond_cell_workstation.py` 在执行转移时，是用 `sites=["electrolyte_buffer"]` 试图把整块 `YB_Vial_5mL_Carrier` 板转移给目标。但由于实际工艺中，配液站将分液瓶板传往扣电工站后，是由扣电工站的机械臂**逐瓶抓取**并放入内部的 `bottle_rack_6x2`（电解液缓存位），用完后再放入 `bottle_rack_6x2_2`（废液位），因此配液站的这一次“跨工位资源树转移”在逻辑上存在偏差：目标槽位不应该是装单瓶的载体 `bottle_rack`。
-*   **修复方案**：
-    1.  **目标端 (Yihua 侧)**：
-        *   在 `YB_YH_materials.py` 中为从配液站传过来的“分液瓶板”本身设置一个接驳专用的 `PlateSlot`（或者单纯直接移到 Deck 指定坐标）。这个位置负责真正在资源树层级上合法接收配液站传过来的完整 Board。
-        *   重构 `YIHUA_Electrolyte_12VialCarrier`：为了防止初始化反序列化冲突，取消内部在 `__init__` 中自动填充满 12 个 `YB_pei_ye_xiao_Bottle` 实例的逻辑。`bottle_rack_6x2` 和 `bottle_rack_6x2_2` 初始化时均应为空。
-    2.  **转运端 (Bioyond 侧)**：
-        *   修改 `bioyond_cell_workstation.py` 的资源树数字转运代码，将其转移目标对应到 Yihua 侧新设立的“分液瓶板接驳区域”资源，或者干脆只更新资源树坐标位置（使其脱离 Bioyond Deck 加入 Yihua Deck），而不再强行挂载到一个无法容纳 Carrier 的 `bottle_rack_6x2` 内部。
-
-### [组件] 依华扣电组装工站物料余量监控 (Material Monitoring)
-#### [修改] 寄存器直读与前端集成
-*   **物理对象保留但虚化追踪**：原有的实体台面对象（如 `MaterialPlate`、`MagazineHolder` 各类型及其对应的洞位坐标）**仍然保留并使用**。保留它们是为了给机器臂提供基础的物理空间取放标定，以及作为前端页面的可视和可交互区块。
-*   **内部物料免追踪**：既然余量完全由寄存器接管，**我们将不再在这些弹夹或洞位内部显式生成、塞入和追踪每一个具体的极片或外壳对象 (如 `ElectrodeSheet` 等)**。这恰好与我们的重构主旨（不主动在 `__init__` 建子物料以避开反序列化冲突）完美结合，进一步极大地减轻了后台资源树对象的复杂度。
-*   **监控方式变更**：放弃现有的物料余量方式，直接读取依华扣电组装工站开放的寄存器地址以获取准确余量。
-*   **前端界面集成**：在前端界面点击负极壳、弹垫片等弹夹的 data view 时，直接读取并显示寄存器中的各自余量。
-*   **新增寄存器映射** (参考 `coin_cell_assembly_b.csv`)：
-    *   `10mm正极片剩余物料数量（R）`：`read hold_register 520` (REAL)
-    *   `12mm正极片剩余物料数量（R）`：`read hold_register 522` (REAL)
-    *   `16mm正极片剩余物料数量（R）`：`read hold_register 524` (REAL)
-    *   `铝箔剩余物料数量（R）`：`read hold_register 526` (REAL)
-    *   `正极壳剩余物料数量（R）`：`read hold_register 528` (REAL)
-    *   `平垫剩余物料数量（R）`：`read hold_register 530` (REAL)
-    *   `负极壳剩余物料数量（R）`：`read hold_register 532` (REAL)
-    *   `弹垫剩余物料数量（R）`：`read hold_register 534` (REAL)
-    *   `成品电池剩余可容纳数量（R）`：`read hold_register 536` (REAL)
-    *   `成品电池NG槽剩余可容纳数量（R）`：`read hold_register 538` (REAL)
-
-### [配置] JSON 配置文件 (Configuration Files)
-#### [修改] 资源类型名称更新
-*   更新以下配置文件，将其中的 `BIOYOND_YB_Deck` 替换为新的类名 **`BioyondElectrolyteDeck`**，以及将 `coin_cell_deck` 替换为 **`YihuaCoinCellDeck`**：
-    *   `yibin_electrolyte_config.json`
-    *   `yibin_coin_cell_only_config.json`
-    *   `yibin_electrolyte_only_config.json`
-
-## 验证计划
-
-### 自动化测试
-*   对重构后的类运行 `pylabrobot` 序列化/反序列化测试，确保状态能够完美恢复。
-*   检查各工作站节点启动时是否仍存在 `ValueError: Resource '...' already assigned to deck` 报错。
-*   检查 `resource_tracker` 中是否仍存在重复 UUID 报错。
-
-### 手动验证
-*   重启各工作站节点，验证资源树是否能根据数据库数据正确还还原。
-*   验证“自动”与“手动”传输窗资源在台面上的分配是否正确。

unilabos/devices/workstation/implementation_plan_v2.md

@@ -1,388 +0,0 @@
-# 物料系统标准化重构方案 v2（增强版）
-
-> **基于原始方案 (`implementation_plan.md`) 的补充与细化**。
-> 本文档在原方案基础上：①增加当前代码现状核查结果；②明确各任务的执行顺序与文件级改动；③新增注意事项与回归测试命令。
-
----
-
-## 0. 核心原则（保持不变）
-
-"**物理几何结构初始化（Deck / Carrier / Magazine 的 `__init__`）与物料内容物填充（`setup()` / `klasses` 参数）必须彻底解耦**"，以消除 PLR 反序列化时的 `Resource already assigned to deck` 错误。
-
----
-
-## 1. 当前代码现状核查（2026-03-12）
-
-| 文件 | 计划要求 | 当前状态 | 是否完成 |
-|---|---|---|---|
-| `resources/bioyond/decks.py` | 重命名类；移除 `setup` 参数和 `deserialize` 补丁 | 仍是 `BIOYOND_YB_Deck`；`setup` 参数和 `deserialize` 均存在 | ❌ |
-| `coin_cell_assembly/YB_YH_materials.py` | 重命名类；文件迁移；移除补丁 | 仍是 `CoincellDeck`；`setup` 参数和 `deserialize` 均存在 | ❌ |
-| `resources/battery/magazine.py` | `magazine_factory` 不主动填充物料 | `MagazineHolder_6_Cathode` / `_6_Anode` / `_4_Cathode` 仍传 `klasses`，初始化时填满极片 | ❌ |
-| `resources/battery/bottle_carriers.py` | `YIHUA_Electrolyte_12VialCarrier` 初始化时不填充瓶子 | 第 54-55 行仍循环填充 12 个 `YB_pei_ye_xiao_Bottle` | ❌ |
-| `resources/itemized_carrier.py` | 移除 `idx is None` 兜底补丁 | 第 182-190 行仍保留该兜底逻辑 | ❌（待前置任务完成后移除） |
-| `resources/resource_tracker.py` | `load_all_state` 前预填 `Container` 缺失键 | 第 616 行直接调用，无预处理 | ❌ |
-| `bioyond_cell_workstation.py` | 修正跨站转运目标为合法接驳槽 | 第 1563 行仍 `sites=["electrolyte_buffer"]`，目标 UUID 为硬编码虚拟资源 | ❌ |
-| `yibin_*.json` 配置文件 | 更新类名 | 仍使用 `BIOYOND_YB_Deck` / `CoincellDeck` | ❌ |
-| `registry/resources/bioyond/deck.yaml` | 更新类名（原计划未提及） | 仍使用 `BIOYOND_YB_Deck` / `CoincellDeck` | ❌（**新增**） |
-
----
-
-## 2. 执行顺序（含依赖关系）
-
-```
-阶段 A（底层资源类）
-  A1. magazine.py — 移除 klasses 填充
-  A2. bottle_carriers.py — 移除瓶子填充
-  
-阶段 B（Deck 层）
-  B1. decks.py — 移除 setup 参数和 deserialize 补丁；重命名
-  B2. YB_YH_materials.py → 重命名；移除 CoincellDeck 的 setup 参数和 deserialize 补丁
-  
-阶段 C（状态兼容）
-  C1. resource_tracker.py — 预填 Container 缺失键
-  C2. itemized_carrier.py — 移除 idx is None 兜底补丁（B 阶段完成后）
-  
-阶段 D（跨站转运修复）
-  D1. YB_YH_materials.py 新增 vial_plate_dock（接驳专用槽）
-  D2. bioyond_cell_workstation.py 修正 transfer 目标
-  
-阶段 E（配置与注册表）
-  E1. yibin_*.json 更新类名
-  E2. registry/resources/bioyond/deck.yaml 更新类名
-  E3. coin_cell_assembly.py 更新导入路径（若文件重命名）
-```
-
----
-
-## 3. 分阶段详细说明
-
----
-
-### 阶段 A — 底层资源类
-
-#### A1. `unilabos/resources/battery/magazine.py`
-
-**问题**：`MagazineHolder_6_Cathode`、`MagazineHolder_6_Anode`、`MagazineHolder_4_Cathode` 在调用 `magazine_factory` 时传入 `klasses`，导致每次 `__init__` 就填满极片，反序列化时重复添加。
-
-**修改**：
-
-- 将三个函数中的 `klasses=[...]` 改为 `klasses=None`（与 `MagazineHolder_6_Battery` 保持一致）。
-- **理由**：物料余量已由寄存器管理（见阶段 F），不需要在资源树中追踪每一个极片。
-
-```python
-# 修改前（MagazineHolder_6_Cathode 举例）
-klasses=[FlatWasher, PositiveCan, PositiveCan, FlatWasher, PositiveCan, PositiveCan],
-
-# 修改后
-klasses=None,
-```
-
-> **注意**：`magazine_factory` 中 `klasses` 参数及循环体代码保留（仍可按需在非序列化场景使用），只是各具体工厂函数不再传入。
-
----
-
-#### A2. `unilabos/resources/battery/bottle_carriers.py`
-
-**问题**：`YIHUA_Electrolyte_12VialCarrier` 第 54-55 行在工厂函数末尾循环填充 12 个瓶子。
-
-**修改**：删除以下两行：
-
-```python
-# 删除
-for i in range(12):
-    carrier[i] = YB_pei_ye_xiao_Bottle(f"{name}_vial_{i+1}")
-```
-
-**理由**：`bottle_rack_6x2` 和 `bottle_rack_6x2_2` 均应初始化为空，瓶子由 Bioyond 侧实际转运后再填入。
-
----
-
-### 阶段 B — Deck 层重构
-
-#### B1. `unilabos/resources/bioyond/decks.py`
-
-**改动列表**：
-
-1. **重命名** `BIOYOND_YB_Deck` → `BioyondElectrolyteDeck`
-2. **重命名** `YB_Deck()` 工厂函数 → `bioyond_electrolyte_deck()`
-3. **移除** `__init__` 中的 `setup: bool = False` 参数及 `if setup: self.setup()` 调用
-4. **删除** `deserialize` 方法重写（该临时补丁在 `setup` 参数移除后自然失效，继续保留反而掩盖问题）
-5. `BIOYOND_PolymerReactionStation_Deck` 和 `BIOYOND_PolymerPreparationStation_Deck` 同步执行第 3、4 步
-
-**重构后初始化模式**：
-
-```python
-class BioyondElectrolyteDeck(Deck):
-    def __init__(self, name: str = "YB_Deck", ...):
-        super().__init__(name=name, ...)
-        # ❌ 不调用 self.setup()
-        # PLR 反序列化时只会调用 __init__，然后从 children JSON 重建子资源
-
-    def setup(self) -> None:
-        # 完整的子资源初始化逻辑保留在这里，只由工厂函数调用
-        ...
-
-def bioyond_electrolyte_deck(name: str) -> BioyondElectrolyteDeck:
-    deck = BioyondElectrolyteDeck(name=name)
-    deck.setup()   # ✅ 工厂函数负责填充
-    return deck
-```
-
-**同步修改**：
-- `bioyond_cell_workstation.py` 第 20 行：
-  ```python
-  # 修改前
-  from unilabos.resources.bioyond.decks import BIOYOND_YB_Deck
-  # 修改后
-  from unilabos.resources.bioyond.decks import BioyondElectrolyteDeck
-  ```
-- 同文件第 2440 行：`BIOYOND_YB_Deck(setup=True)` → `bioyond_electrolyte_deck(name="YB_Deck")`
-
----
-
-#### B2. `unilabos/devices/workstation/coin_cell_assembly/YB_YH_materials.py`
-
-**改动列表**：
-
-1. **重命名** `CoincellDeck` → `YihuaCoinCellDeck`
-2. **重命名** `YH_Deck()` → `yihua_coin_cell_deck()`（可保留 `YH_Deck` 作为兼容别名，日后废弃）
-3. **移除** `CoincellDeck.__init__` 中 `setup: bool = False` 参数及调用
-4. **删除** `CoincellDeck.deserialize` 重写方法
-5. `MaterialPlate.__init__` 中移除 `fill` 参数，始终不主动调用 `create_ordered_items_2d`（当前 `fill=False` 路径已正确，只需删除 `fill=True` 分支）
-
-```python
-# 修改前（MaterialPlate.__init__ 片段）
-if fill:
-    super().__init__(..., ordered_items=holes, ...)
-else:
-    super().__init__(..., ordered_items=ordered_items, ...)
-
-# 修改后（始终走 "不填充" 路径）
-super().__init__(..., ordered_items=ordered_items, ...)
-# holes 的创建代码整体移入独立工厂方法
-```
-
-**同步修改**：
-- `coin_cell_assembly.py` 第 20 行导入：
-  ```python
-  # 修改前
-  from unilabos.devices.workstation.coin_cell_assembly.YB_YH_materials import CoincellDeck
-  # 修改后
-  from unilabos.devices.workstation.coin_cell_assembly.YB_YH_materials import YihuaCoinCellDeck
-  ```
-- 同文件第 2245 行：`CoincellDeck(setup=True, name="coin_cell_deck")` → `yihua_coin_cell_deck(name="coin_cell_deck")`
-- 文件重命名（可选）：`YB_YH_materials.py` → `yihua_coin_cell_materials.py`（若重命名，所有 import 路径需全局替换）
-
----
-
-### 阶段 C — 状态兼容
-
-#### C1. `unilabos/resources/resource_tracker.py`
-
-**问题**：第 616 行直接调用 `plr_resource.load_all_state(all_states)`，若 `Container` 类资源的 `data` 字段缺少 `liquid_history` 或 `pending_liquids`，PLR 新版本会抛出 `KeyError`。
-
-**修改**：在第 616 行前插入预处理：
-
-```python
-# 在 load_all_state 调用前预填缺失键
-from pylabrobot.resources.container import Container as PLRContainer
-for res_name, state in all_states.items():
-    if state and isinstance(state, dict):
-        # Container 类型要求这两个键存在
-        state.setdefault("liquid_history", [])
-        state.setdefault("pending_liquids", {})
-
-plr_resource.load_all_state(all_states)
-```
-
----
-
-#### C2. `unilabos/resources/itemized_carrier.py`
-
-**前提**：B1、B2 阶段完成，Deck 类名与资源命名规范已对齐后再执行此步。
-
-**修改**：删除第 182-190 行的兜底补丁：
-
-```python
-# 删除以下整个 if 块
-if idx is None:
-    fallback_location = location if location is not None else Coordinate.zero()
-    super().assign_child_resource(resource, location=fallback_location, reassign=reassign)
-    return
-```
-
-**替代**：改为抛出带诊断信息的异常，便于后续问题排查：
-
-```python
-if idx is None:
-    raise ValueError(
-        f"[ItemizedCarrier] 无法为资源 '{resource.name}' 找到匹配的槽位。"
-        f"已知槽位：{list(self.child_locations.keys())}，"
-        f"传入坐标：{location}"
-    )
-```
-
----
-
-### 阶段 D — 跨站转运修复
-
-#### D1. `YB_YH_materials.py` — 新增分液瓶板接驳槽
-
-在 `YihuaCoinCellDeck.setup()` 中，新增一个专用于接收 Bioyond 侧传来的完整分液瓶板的 `ResourceStack`（或 `PlateSlot`）：
-
-```python
-# 在 setup() 末尾追加
-from pylabrobot.resources.resource_stack import ResourceStack
-
-vial_plate_dock = ResourceStack(
-    name="electrolyte_buffer",   # 保持与 bioyond_cell_workstation.py 的 sites 键一致
-    direction="z",
-    resources=[],
-)
-self.assign_child_resource(vial_plate_dock, Coordinate(x=1050.0, y=700.0, z=0))
-```
-
-> **说明**：槽位命名 `electrolyte_buffer` 与 `bioyond_cell_workstation.py` 现有的 `sites=["electrolyte_buffer"]` 对应，减少改动量。如改名，D2 需同步。
-
----
-
-#### D2. `bioyond_cell_workstation.py` — 修正 transfer 目标
-
-**问题**：第 1545-1552 行创建了一个 `size=1,1,1` 的虚拟 `ResourcePLR` 并硬编码 UUID，这个对象在 YihuaCoinCellDeck 的资源树中不存在，导致转移后资源树状态混乱。
-
-**修改**：
-
-```python
-# 修改前：创建虚拟目标资源
-target_resource_obj = ResourcePLR(name=target_location, size_x=1.0, ...)
-target_resource_obj.unilabos_uuid = "550e8400-e29b-41d4-a716-446655440001"  # 硬编码
-
-# 修改后：通过 ROS2/设备注册表查询真实资源
-# （需要从 target_device 的资源树中取出 electrolyte_buffer 的真实对象）
-target_resource_obj = self._get_resource_from_device(
-    device_id=target_device,
-    resource_name=target_location
-)
-if target_resource_obj is None:
-    raise RuntimeError(
-        f"目标设备 {target_device} 中未找到资源 '{target_location}'，"
-        f"请确认 YihuaCoinCellDeck.setup() 中已添加 electrolyte_buffer 槽位"
-    )
-```
-
-> **说明**：`_get_resource_from_device` 需根据现有 ROS2 资源同步机制实现，或复用已有的 `get_plr_resource_by_name` 类似方法。
-
----
-
-### 阶段 E — 配置与注册表
-
-#### E1. `yibin_electrolyte_config.json` / `yibin_coin_cell_only_config.json` / `yibin_electrolyte_only_config.json`
-
-全局替换以下字符串：
-
-| 旧值 | 新值 |
-|---|---|
-| `BIOYOND_YB_Deck` | `BioyondElectrolyteDeck` |
-| `unilabos.resources.bioyond.decks:BIOYOND_YB_Deck` | `unilabos.resources.bioyond.decks:BioyondElectrolyteDeck` |
-| `CoincellDeck` | `YihuaCoinCellDeck` |
-| `unilabos.devices.workstation.coin_cell_assembly.YB_YH_materials:CoincellDeck` | 若文件已重命名：`unilabos.devices.workstation.coin_cell_assembly.yihua_coin_cell_materials:YihuaCoinCellDeck` |
-
----
-
-#### E2. `unilabos/registry/resources/bioyond/deck.yaml`（**原计划未覆盖，新增**）
-
-当前第 25 行和第 37 行仍使用旧类名，需同步更新：
-
-```yaml
-# 修改前
-BIOYOND_YB_Deck:
-  ...
-CoincellDeck:
-  ...
-
-# 修改后
-BioyondElectrolyteDeck:
-  ...
-YihuaCoinCellDeck:
-  ...
-```
-
----
-
-### 阶段 F — 物料余量监控集成（原计划第5节细化）
-
-**目标**：弃用资源树内极片对象计数，改为直读依华扣电工站寄存器。
-
-#### F1. `coin_cell_assembly/coin_cell_assembly.py` — 新增寄存器读取方法
-
-参考 `coin_cell_assembly_b.csv` 中的地址，封装读取工具方法：
-
-```python
-MATERIAL_REGISTER_MAP = {
-    "10mm正极片":   (520, "REAL"),
-    "12mm正极片":   (522, "REAL"),
-    "16mm正极片":   (524, "REAL"),
-    "铝箔":         (526, "REAL"),
-    "正极壳":       (528, "REAL"),
-    "平垫":         (530, "REAL"),
-    "负极壳":       (532, "REAL"),
-    "弹垫":         (534, "REAL"),
-    "成品容量":     (536, "REAL"),
-    "成品NG容量":   (538, "REAL"),
-}
-
-def get_material_remaining(self, material_name: str) -> float:
-    """通过寄存器直读指定物料的剩余数量"""
-    if material_name not in MATERIAL_REGISTER_MAP:
-        raise KeyError(f"未知物料名称: {material_name}")
-    address, dtype = MATERIAL_REGISTER_MAP[material_name]
-    return self.read_hold_register(address, dtype)  # 复用现有 Modbus 读取方法
-```
-
-#### F2. 前端 data view 集成
-
-- 前端点击 `MagazineHolder` 类资源的 data view 时，调用后端 `get_material_remaining` 接口（而非读取 `children` 长度）。
-- 具体接口路径和前端调用代码需与前端开发同步，本文档不作具体实现约定。
-
----
-
-## 4. 验证计划（细化）
-
-### 4.1 单元测试（自动化）
-
-```bash
-# 序列化/反序列化往返测试
-python -m pytest unilabos/test/ -k "serial" -v
-
-# 特别检查以下错误消失：
-# - ValueError: Resource '...' already assigned to deck
-# - KeyError: 'liquid_history' 
-# - 重复 UUID 报错
-```
-
-### 4.2 集成测试（手动）
-
-按以下顺序逐步验证，确保每步正常后再进行下一步：
-
-1. **单独启动 `BatteryStation` 节点**，检查 `CoincellDeck`（现 `YihuaCoinCellDeck`）能否从数据库状态正确还原，无 `already assigned` 报错。
-2. **单独启动 `BioyondElectrolyte` 节点**，检查 `BioyondElectrolyteDeck` 反序列化正常。
-3. **同时启动两个节点**，模拟执行一次分液→扣电的完整跨站转运，确认：
-   - `electrolyte_buffer` 槽位正确接收分液瓶板。
-   - `bottle_rack_6x2` 初始为空，不出现虚拟瓶子。
-4. **重启两个节点**（模拟断电恢复），确认资源树从数据库还原后，`electrolyte_buffer` 中仍持有正确的分液瓶板对象。
-5. **寄存器余量读取**：手动触发 `get_material_remaining("负极壳")`，确认返回值与设备显示一致。
-
----
-
-## 5. 与原计划的差异对照
-
-| 维度 | 原计划 | 本文档新增/修订 |
-|---|---|---|
-| 执行顺序 | 未排序 | 明确 A→B→C→D→E→F 的依赖顺序 |
-| `itemized_carrier.py` | 移除兜底补丁 | 补充：替换为带诊断信息的异常，便于排查 |
-| `bottle_carriers.py` | 提及 `YIHUA_Electrolyte_12VialCarrier` 需修改 | 明确：删除第 54-55 行的瓶子填充循环 |
-| `MaterialPlate` | 提及移除 `fill` 参数 | 说明保留 `fill=False` 路径；整体删除 `fill=True` 分支 |
-| `deck.yaml` | 未提及 | **新增**：该注册文件也需要同步更新类名 |
-| `resource_tracker.py` | 简略描述 | 提供具体的 `setdefault` 预处理代码示例 |
-| 跨站转运 | 描述了问题和方向 | 细化：新增 `electrolyte_buffer` 槽位的具体名称和坐标；修正 `transfer` 目标查找方式 |
-| 验证计划 | 简述目标 | 提供具体测试命令和逐步手动验证流程 |

unilabos/registry/devices/coin_cell_workstation.yaml

@@ -64,12 +64,59 @@ coincellassemblyworkstation_device:
               properties: {}
               required: []
               type: object
-            result: {}
+            result:
+              type: boolean
           required:
           - goal
           title: fun_wuliao_test参数
           type: object
         type: UniLabJsonCommand
+      auto-func_allpack_cmd:
+        feedback: {}
+        goal: {}
+        goal_default:
+          assembly_pressure: 4200
+          assembly_type: 7
+          elec_num: null
+          elec_use_num: null
+          elec_vol: 50
+          file_path: /Users/sml/work
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                assembly_pressure:
+                  default: 4200
+                  type: integer
+                assembly_type:
+                  default: 7
+                  type: integer
+                elec_num:
+                  type: string
+                elec_use_num:
+                  type: string
+                elec_vol:
+                  default: 50
+                  type: integer
+                file_path:
+                  default: /Users/sml/work
+                  type: string
+              required:
+              - elec_num
+              - elec_use_num
+              type: object
+            result:
+              type: object
+          required:
+          - goal
+          title: func_allpack_cmd参数
+          type: object
+        type: UniLabJsonCommand
       auto-func_allpack_cmd_simp:
         feedback: {}
         goal: {}
@@ -102,7 +149,7 @@ coincellassemblyworkstation_device:
             goal:
               properties:
                 assembly_pressure:
-                  default: 3200
+                  default: 4200
                   description: 电池压制力(N)
                   type: integer
                 assembly_type:
@@ -118,7 +165,7 @@ coincellassemblyworkstation_device:
                   description: 是否启用压力模式
                   type: boolean
                 dual_drop_first_volume:
-                  default: 0
+                  default: 25
                   description: 二次滴液第一次排液体积(μL)
                   type: integer
                 dual_drop_mode:
@@ -137,7 +184,6 @@ coincellassemblyworkstation_device:
                   description: 电解液瓶数
                   type: string
                 elec_use_num:
-                  default: 5
                   description: 每瓶电解液组装电池数
                   type: string
                 elec_vol:
@@ -145,7 +191,7 @@ coincellassemblyworkstation_device:
                   description: 电解液吸液量(μL)
                   type: integer
                 file_path:
-                  default: D:\UniLabdev\Uni-Lab-OS\unilabos\devices\workstation\coin_cell_assembly
+                  default: /Users/sml/work
                   description: 实验记录保存路径
                   type: string
                 fujipian_juzhendianwei:
@@ -176,7 +222,8 @@ coincellassemblyworkstation_device:
               - elec_num
               - elec_use_num
               type: object
-            result: {}
+            result:
+              type: object
           required:
           - goal
           title: func_allpack_cmd_simp参数
@@ -265,7 +312,8 @@ coincellassemblyworkstation_device:
                   type: boolean
               required: []
               type: object
-            result: {}
+            result:
+              type: boolean
           required:
           - goal
           title: func_pack_device_init_auto_start_combined参数
@@ -307,7 +355,8 @@ coincellassemblyworkstation_device:
               properties: {}
               required: []
               type: object
-            result: {}
+            result:
+              type: boolean
           required:
           - goal
           title: func_pack_device_stop参数
@@ -332,7 +381,8 @@ coincellassemblyworkstation_device:
                   type: string
               required: []
               type: object
-            result: {}
+            result:
+              type: boolean
           required:
           - goal
           title: func_pack_get_msg_cmd参数
@@ -346,10 +396,12 @@ coincellassemblyworkstation_device:
         handles:
           input:
           - data_key: bottle_num
-            data_source: handle
+            data_source: workflow
             data_type: integer
             handler_key: bottle_count
+            io_type: source
             label: 配液瓶数
+            required: true
         placeholder_keys: {}
         result: {}
         schema:
@@ -384,7 +436,8 @@ coincellassemblyworkstation_device:
               properties: {}
               required: []
               type: object
-            result: {}
+            result:
+              type: boolean
           required:
           - goal
           title: func_pack_send_finished_cmd参数
@@ -421,7 +474,8 @@ coincellassemblyworkstation_device:
               - assembly_type
               - assembly_pressure
               type: object
-            result: {}
+            result:
+              type: boolean
           required:
           - goal
           title: func_pack_send_msg_cmd参数
@@ -477,21 +531,12 @@ coincellassemblyworkstation_device:
         handles:
           input:
           - data_key: elec_num
-            data_source: handle
+            data_source: workflow
             data_type: integer
             handler_key: bottle_count
+            io_type: source
             label: 配液瓶数
-          - data_key: formulations
-            data_source: handle
-            data_type: array
-            handler_key: formulations_input
-            label: 配方信息列表
-          output:
-          - data_key: assembly_data
-            data_source: executor
-            data_type: array
-            handler_key: assembly_data_output
-            label: 扣电组装数据列表
+            required: true
         placeholder_keys: {}
         result: {}
         schema:
@@ -574,7 +619,8 @@ coincellassemblyworkstation_device:
               - elec_num
               - elec_use_num
               type: object
-            result: {}
+            result:
+              type: object
           required:
           - goal
           title: func_sendbottle_allpack_multi参数
@@ -626,31 +672,6 @@ coincellassemblyworkstation_device:
           title: modify_deck_name参数
           type: object
         type: UniLabJsonCommand
-      auto-post_init:
-        feedback: {}
-        goal: {}
-        goal_default:
-          ros_node: null
-        handles: {}
-        placeholder_keys: {}
-        result: {}
-        schema:
-          description: ''
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                ros_node:
-                  type: object
-              required:
-              - ros_node
-              type: object
-            result: {}
-          required:
-          - goal
-          title: post_init参数
-          type: object
-        type: UniLabJsonCommand
       auto-qiming_coin_cell_code:
         feedback: {}
         goal: {}
@@ -698,7 +719,8 @@ coincellassemblyworkstation_device:
               required:
               - fujipian_panshu
               type: object
-            result: {}
+            result:
+              type: boolean
           required:
           - goal
           title: qiming_coin_cell_code参数
@@ -706,10 +728,6 @@ coincellassemblyworkstation_device:
         type: UniLabJsonCommand
     module: unilabos.devices.workstation.coin_cell_assembly.coin_cell_assembly:CoinCellAssemblyWorkstation
     status_types:
-      data_10mm_positive_plate_remaining: float
-      data_12mm_positive_plate_remaining: float
-      data_16mm_positive_plate_remaining: float
-      data_aluminum_foil_remaining: float
       data_assembly_coin_cell_num: int
       data_assembly_pressure: int
       data_assembly_time: float
@@ -717,22 +735,14 @@ coincellassemblyworkstation_device:
       data_axis_y_pos: float
       data_axis_z_pos: float
       data_coin_cell_code: str
-      data_coin_type: int
-      data_current_assembling_count: int
-      data_current_completed_count: int
+      data_coin_num: int
       data_electrolyte_code: str
       data_electrolyte_volume: int
-      data_finished_battery_ng_remaining_capacity: float
-      data_finished_battery_remaining_capacity: float
-      data_flat_washer_remaining: float
       data_glove_box_o2_content: float
       data_glove_box_pressure: float
       data_glove_box_water_content: float
-      data_negative_shell_remaining: float
       data_open_circuit_voltage: float
       data_pole_weight: float
-      data_positive_shell_remaining: float
-      data_spring_washer_remaining: float
       request_rec_msg_status: bool
       request_send_msg_status: bool
       sys_mode: str
@@ -762,14 +772,6 @@ coincellassemblyworkstation_device:
       type: object
     data:
       properties:
-        data_10mm_positive_plate_remaining:
-          type: number
-        data_12mm_positive_plate_remaining:
-          type: number
-        data_16mm_positive_plate_remaining:
-          type: number
-        data_aluminum_foil_remaining:
-          type: number
         data_assembly_coin_cell_num:
           type: integer
         data_assembly_pressure:
@@ -784,38 +786,22 @@ coincellassemblyworkstation_device:
           type: number
         data_coin_cell_code:
           type: string
-        data_coin_type:
-          type: integer
-        data_current_assembling_count:
-          type: integer
-        data_current_completed_count:
+        data_coin_num:
           type: integer
         data_electrolyte_code:
           type: string
         data_electrolyte_volume:
           type: integer
-        data_finished_battery_ng_remaining_capacity:
-          type: number
-        data_finished_battery_remaining_capacity:
-          type: number
-        data_flat_washer_remaining:
-          type: number
         data_glove_box_o2_content:
           type: number
         data_glove_box_pressure:
           type: number
         data_glove_box_water_content:
           type: number
-        data_negative_shell_remaining:
-          type: number
         data_open_circuit_voltage:
           type: number
         data_pole_weight:
           type: number
-        data_positive_shell_remaining:
-          type: number
-        data_spring_washer_remaining:
-          type: number
         request_rec_msg_status:
           type: boolean
         request_send_msg_status:
@@ -825,36 +811,24 @@ coincellassemblyworkstation_device:
         sys_status:
           type: string
       required:
-      - sys_status
-      - sys_mode
-      - request_rec_msg_status
-      - request_send_msg_status
       - data_assembly_coin_cell_num
-      - data_open_circuit_voltage
+      - data_assembly_pressure
+      - data_assembly_time
       - data_axis_x_pos
       - data_axis_y_pos
       - data_axis_z_pos
-      - data_pole_weight
-      - data_assembly_pressure
-      - data_electrolyte_volume
-      - data_coin_type
-      - data_current_assembling_count
-      - data_current_completed_count
       - data_coin_cell_code
+      - data_coin_num
       - data_electrolyte_code
-      - data_glove_box_pressure
+      - data_electrolyte_volume
       - data_glove_box_o2_content
+      - data_glove_box_pressure
       - data_glove_box_water_content
-      - data_10mm_positive_plate_remaining
-      - data_12mm_positive_plate_remaining
-      - data_16mm_positive_plate_remaining
-      - data_aluminum_foil_remaining
-      - data_positive_shell_remaining
-      - data_flat_washer_remaining
-      - data_negative_shell_remaining
-      - data_spring_washer_remaining
-      - data_finished_battery_remaining_capacity
-      - data_finished_battery_ng_remaining_capacity
+      - data_open_circuit_voltage
+      - data_pole_weight
+      - request_rec_msg_status
+      - request_send_msg_status
+      - sys_mode
+      - sys_status
       type: object
-  registry_type: device
   version: 1.0.0

unilabos/registry/resources/battery/bottle_carriers.yaml

@@ -1,12 +0,0 @@
-YIHUA_Electrolyte_12VialCarrier:
-  category:
-  - battery_bottle_carriers
-  class:
-    module: unilabos.resources.battery.bottle_carriers:YIHUA_Electrolyte_12VialCarrier
-    type: pylabrobot
-  description: YIHUA 12-vial electrolyte carrier for coin cell assembly workstation
-  handles: []
-  icon: ''
-  init_param_schema: {}
-  registry_type: resource
-  version: 1.0.0

unilabos/registry/resources/bioyond/YB_bottle.yaml

@@ -1,140 +1,84 @@
-YB_Vial_20mL:
+YB_20ml_fenyeping:
   category:
+  - yb3
   - YB_bottle
   class:
-    module: unilabos.resources.bioyond.YB_bottles:YB_Vial_20mL
+    module: unilabos.resources.bioyond.YB_bottles:YB_20ml_fenyeping
     type: pylabrobot
-  description: YB_Vial_20mL
+  description: YB_20ml_fenyeping
   handles: []
   icon: ''
   init_param_schema: {}
   version: 1.0.0
-YB_Vial_5mL:
+YB_5ml_fenyeping:
   category:
+  - yb3
   - YB_bottle
   class:
-    module: unilabos.resources.bioyond.YB_bottles:YB_Vial_5mL
+    module: unilabos.resources.bioyond.YB_bottles:YB_5ml_fenyeping
     type: pylabrobot
-  description: YB_Vial_5mL
+  description: YB_5ml_fenyeping
   handles: []
   icon: ''
   init_param_schema: {}
   version: 1.0.0
-YB_DosingHead_L:
+YB_jia_yang_tou_da:
   category:
+  - yb3
   - YB_bottle
   class:
-    module: unilabos.resources.bioyond.YB_bottles:YB_DosingHead_L
+    module: unilabos.resources.bioyond.YB_bottles:YB_jia_yang_tou_da
     type: pylabrobot
-  description: YB_DosingHead_L
+  description: YB_jia_yang_tou_da
   handles: []
   icon: ''
   init_param_schema: {}
   version: 1.0.0
-YB_PrepBottle_60mL:
+YB_pei_ye_da_Bottle:
   category:
+  - yb3
   - YB_bottle
   class:
-    module: unilabos.resources.bioyond.YB_bottles:YB_PrepBottle_60mL
+    module: unilabos.resources.bioyond.YB_bottles:YB_pei_ye_da_Bottle
     type: pylabrobot
-  description: YB_PrepBottle_60mL
+  description: YB_pei_ye_da_Bottle
   handles: []
   icon: ''
   init_param_schema: {}
   version: 1.0.0
-YB_PrepBottle_15mL:
+YB_pei_ye_xiao_Bottle:
   category:
+  - yb3
   - YB_bottle
   class:
-    module: unilabos.resources.bioyond.YB_bottles:YB_PrepBottle_15mL
+    module: unilabos.resources.bioyond.YB_bottles:YB_pei_ye_xiao_Bottle
     type: pylabrobot
-  description: YB_PrepBottle_15mL
+  description: YB_pei_ye_xiao_Bottle
   handles: []
   icon: ''
   init_param_schema: {}
   version: 1.0.0
-YB_Tip_5000uL:
+YB_qiang_tou:
   category:
+  - yb3
   - YB_bottle
   class:
-    module: unilabos.resources.bioyond.YB_bottles:YB_Tip_5000uL
+    module: unilabos.resources.bioyond.YB_bottles:YB_qiang_tou
     type: pylabrobot
-  description: YB_Tip_5000uL
+  description: YB_qiang_tou
   handles: []
   icon: ''
   init_param_schema: {}
   version: 1.0.0
-YB_Tip_1000uL:
-  category:
-  - YB_bottle
-  class:
-    module: unilabos.resources.bioyond.YB_bottles:YB_Tip_1000uL
-    type: pylabrobot
-  description: YB_Tip_1000uL
-  handles: []
-  icon: ''
-  init_param_schema: {}
-  registry_type: resource
-  version: 1.0.0
-YB_Tip_50uL:
-  category:
-  - YB_bottle
-  class:
-    module: unilabos.resources.bioyond.YB_bottles:YB_Tip_50uL
-    type: pylabrobot
-  description: YB_Tip_50uL
-  handles: []
-  icon: ''
-  init_param_schema: {}
-  registry_type: resource
-  version: 1.0.0
-YB_NormalLiq_250mL_Bottle:
+YB_ye_Bottle:
   category:
+  - yb3
   - YB_bottle_carriers
   - YB_bottle
   class:
-    module: unilabos.resources.bioyond.YB_bottles:YB_NormalLiq_250mL_Bottle
+    module: unilabos.resources.bioyond.YB_bottles:YB_ye_Bottle
     type: pylabrobot
-  description: YB_NormalLiq_250mL_Bottle
-  handles: []
-  icon: ''
-  init_param_schema: {}
-  registry_type: resource
-  version: 1.0.0
-YB_NormalLiq_100mL_Bottle:
-  category:
-  - YB_bottle_carriers
-  - YB_bottle
-  class:
-    module: unilabos.resources.bioyond.YB_bottles:YB_NormalLiq_100mL_Bottle
-    type: pylabrobot
-  description: YB_NormalLiq_100mL_Bottle
-  handles: []
-  icon: ''
-  init_param_schema: {}
-  registry_type: resource
-  version: 1.0.0
-YB_HighVis_250mL_Bottle:
-  category:
-  - YB_bottle_carriers
-  - YB_bottle
-  class:
-    module: unilabos.resources.bioyond.YB_bottles:YB_HighVis_250mL_Bottle
-    type: pylabrobot
-  description: YB_HighVis_250mL_Bottle
-  handles: []
-  icon: ''
-  init_param_schema: {}
-  registry_type: resource
-  version: 1.0.0
-YB_HighVis_100mL_Bottle:
-  category:
-  - YB_bottle_carriers
-  - YB_bottle
-  class:
-    module: unilabos.resources.bioyond.YB_bottles:YB_HighVis_100mL_Bottle
-    type: pylabrobot
-  description: YB_HighVis_100mL_Bottle
+  description: YB_ye_Bottle
   handles: []
   icon: ''
   init_param_schema: {}

unilabos/registry/resources/bioyond/YB_bottle_carriers.yaml

@@ -1,29 +1,42 @@
-YB_Vial_20mL_Carrier:
+YB_100ml_yeti:
   category:
+  - yb3
   - YB_bottle_carriers
   class:
-    module: unilabos.resources.bioyond.YB_bottle_carriers:YB_Vial_20mL_Carrier
+    module: unilabos.resources.bioyond.YB_bottle_carriers:YB_100ml_yeti
     type: pylabrobot
-  description: YB_Vial_20mL_Carrier
+  description: YB_100ml_yeti
   handles: []
   icon: ''
   init_param_schema: {}
-  registry_type: resource
   version: 1.0.0
-YB_Vial_5mL_Carrier:
+YB_20ml_fenyepingban:
   category:
+  - yb3
   - YB_bottle_carriers
   class:
-    module: unilabos.resources.bioyond.YB_bottle_carriers:YB_Vial_5mL_Carrier
+    module: unilabos.resources.bioyond.YB_bottle_carriers:YB_20ml_fenyepingban
     type: pylabrobot
-  description: YB_Vial_5mL_Carrier
+  description: YB_20ml_fenyepingban
+  handles: []
+  icon: ''
+  init_param_schema: {}
+  version: 1.0.0
+YB_5ml_fenyepingban:
+  category:
+  - yb3
+  - YB_bottle_carriers
+  class:
+    module: unilabos.resources.bioyond.YB_bottle_carriers:YB_5ml_fenyepingban
+    type: pylabrobot
+  description: YB_5ml_fenyepingban
   handles: []
   icon: ''
   init_param_schema: {}
-  registry_type: resource
   version: 1.0.0
 YB_6StockCarrier:
   category:
+  - yb3
   - YB_bottle_carriers
   class:
     module: unilabos.resources.bioyond.YB_bottle_carriers:YB_6StockCarrier
@@ -32,10 +45,10 @@ YB_6StockCarrier:
   handles: []
   icon: ''
   init_param_schema: {}
-  registry_type: resource
   version: 1.0.0
 YB_6VialCarrier:
   category:
+  - yb3
   - YB_bottle_carriers
   class:
     module: unilabos.resources.bioyond.YB_bottle_carriers:YB_6VialCarrier
@@ -44,137 +57,112 @@ YB_6VialCarrier:
   handles: []
   icon: ''
   init_param_schema: {}
-  registry_type: resource
   version: 1.0.0
-YB_DosingHead_L_Carrier:
+YB_gao_nian_ye_Bottle:
   category:
+  - yb3
   - YB_bottle_carriers
   class:
-    module: unilabos.resources.bioyond.YB_bottle_carriers:YB_DosingHead_L_Carrier
+    module: unilabos.resources.bioyond.YB_bottles:YB_gao_nian_ye_Bottle
     type: pylabrobot
-  description: YB_DosingHead_L_Carrier
+  description: YB_gao_nian_ye_Bottle
   handles: []
   icon: ''
   init_param_schema: {}
-  registry_type: resource
   version: 1.0.0
-YB_PrepBottle_60mL_Carrier:
+YB_gaonianye:
   category:
+  - yb3
   - YB_bottle_carriers
   class:
-    module: unilabos.resources.bioyond.YB_bottle_carriers:YB_PrepBottle_60mL_Carrier
+    module: unilabos.resources.bioyond.YB_bottle_carriers:YB_gaonianye
     type: pylabrobot
-  description: YB_PrepBottle_60mL_Carrier
+  description: YB_gaonianye
   handles: []
   icon: ''
   init_param_schema: {}
-  registry_type: resource
   version: 1.0.0
-YB_PrepBottle_15mL_Carrier:
+YB_jia_yang_tou_da_Carrier:
   category:
+  - yb3
   - YB_bottle_carriers
   class:
-    module: unilabos.resources.bioyond.YB_bottle_carriers:YB_PrepBottle_15mL_Carrier
+    module: unilabos.resources.bioyond.YB_bottle_carriers:YB_jia_yang_tou_da_Carrier
     type: pylabrobot
-  description: YB_PrepBottle_15mL_Carrier
+  description: YB_jia_yang_tou_da_Carrier
   handles: []
   icon: ''
   init_param_schema: {}
-  registry_type: resource
   version: 1.0.0
-YB_TipRack_Mixed:
+YB_peiyepingdaban:
   category:
+  - yb3
   - YB_bottle_carriers
   class:
-    module: unilabos.resources.bioyond.YB_bottle_carriers:YB_TipRack_Mixed
+    module: unilabos.resources.bioyond.YB_bottle_carriers:YB_peiyepingdaban
     type: pylabrobot
-  description: YB_TipRack_Mixed
+  description: YB_peiyepingdaban
   handles: []
   icon: ''
   init_param_schema: {}
-  registry_type: resource
   version: 1.0.0
-YB_TipRack_5000uL:
+YB_peiyepingxiaoban:
   category:
+  - yb3
   - YB_bottle_carriers
   class:
-    module: unilabos.resources.bioyond.YB_bottle_carriers:YB_TipRack_5000uL
+    module: unilabos.resources.bioyond.YB_bottle_carriers:YB_peiyepingxiaoban
     type: pylabrobot
-  description: YB_TipRack_5000uL
+  description: YB_peiyepingxiaoban
   handles: []
   icon: ''
   init_param_schema: {}
-  registry_type: resource
   version: 1.0.0
-YB_TipRack_50uL:
+YB_qiang_tou_he:
   category:
+  - yb3
   - YB_bottle_carriers
   class:
-    module: unilabos.resources.bioyond.YB_bottle_carriers:YB_TipRack_50uL
+    module: unilabos.resources.bioyond.YB_bottle_carriers:YB_qiang_tou_he
     type: pylabrobot
-  description: YB_TipRack_50uL
+  description: YB_qiang_tou_he
   handles: []
   icon: ''
   init_param_schema: {}
-  registry_type: resource
   version: 1.0.0
-YB_Adapter_60mL:
+YB_shi_pei_qi_kuai:
   category:
+  - yb3
   - YB_bottle_carriers
   class:
-    module: unilabos.resources.bioyond.YB_bottle_carriers:YB_Adapter_60mL
+    module: unilabos.resources.bioyond.YB_bottle_carriers:YB_shi_pei_qi_kuai
     type: pylabrobot
-  description: YB_Adapter_60mL
+  description: YB_shi_pei_qi_kuai
   handles: []
   icon: ''
   init_param_schema: {}
-  registry_type: resource
   version: 1.0.0
-YB_NormalLiq_250mL_Carrier:
+YB_ye:
   category:
+  - yb3
   - YB_bottle_carriers
   class:
-    module: unilabos.resources.bioyond.YB_bottle_carriers:YB_NormalLiq_250mL_Carrier
+    module: unilabos.resources.bioyond.YB_bottle_carriers:YB_ye
     type: pylabrobot
-  description: YB_NormalLiq_250mL_Carrier
+  description: YB_ye_Bottle_Carrier
   handles: []
   icon: ''
   init_param_schema: {}
-  registry_type: resource
   version: 1.0.0
-YB_NormalLiq_100mL_Carrier:
+YB_ye_100ml_Bottle:
   category:
+  - yb3
   - YB_bottle_carriers
   class:
-    module: unilabos.resources.bioyond.YB_bottle_carriers:YB_NormalLiq_100mL_Carrier
+    module: unilabos.resources.bioyond.YB_bottles:YB_ye_100ml_Bottle
     type: pylabrobot
-  description: YB_NormalLiq_100mL_Carrier
+  description: YB_ye_100ml_Bottle
   handles: []
   icon: ''
   init_param_schema: {}
-  registry_type: resource
   version: 1.0.0
-YB_HighVis_250mL_Carrier:
-  category:
-  - YB_bottle_carriers
-  class:
-    module: unilabos.resources.bioyond.YB_bottle_carriers:YB_HighVis_250mL_Carrier
-    type: pylabrobot
-  description: YB_HighVis_250mL_Carrier
-  handles: []
-  icon: ''
-  init_param_schema: {}
-  registry_type: resource
-  version: 1.0.0
-YB_HighVis_100mL_Carrier:
-  category:
-  - YB_bottle_carriers
-  class:
-    module: unilabos.resources.bioyond.YB_bottle_carriers:YB_HighVis_100mL_Carrier
-    type: pylabrobot
-  description: YB_HighVis_100mL_Carrier
-  handles: []
-  icon: ''
-  init_param_schema: {}
-  registry_type: resource
-  version: 1.0.0

unilabos/registry/resources/bioyond/deck.yaml

@@ -20,22 +20,22 @@ BIOYOND_PolymerReactionStation_Deck:
   icon: 反应站.webp
   init_param_schema: {}
   version: 1.0.0
-BioyondElectrolyteDeck:
+BIOYOND_YB_Deck:
   category:
   - deck
   class:
-    module: unilabos.resources.bioyond.decks:bioyond_electrolyte_deck
+    module: unilabos.resources.bioyond.decks:YB_Deck
     type: pylabrobot
   description: BIOYOND ElectrolyteFormulationStation Deck
   handles: []
   icon: 配液站.webp
   init_param_schema: {}
   version: 1.0.0
-YihuaCoinCellDeck:
+CoincellDeck:
   category:
   - deck
   class:
-    module: unilabos.devices.workstation.coin_cell_assembly.YB_YH_materials:yihua_coin_cell_deck
+    module: unilabos.devices.workstation.coin_cell_assembly.YB_YH_materials:YH_Deck
     type: pylabrobot
   description: YIHUA CoinCellAssembly Deck
   handles: []

unilabos/resources/battery/bottle_carriers.py

@@ -1,6 +1,9 @@
 from pylabrobot.resources import create_homogeneous_resources, Coordinate, ResourceHolder, create_ordered_items_2d
 
 from unilabos.resources.itemized_carrier import Bottle, BottleCarrier
+from unilabos.resources.bioyond.YB_bottles import (
+    YB_pei_ye_xiao_Bottle,
+)
 # 命名约定：试剂瓶-Bottle，烧杯-Beaker，烧瓶-Flask，小瓶-Vial
 
 
@@ -48,5 +51,6 @@ def YIHUA_Electrolyte_12VialCarrier(name: str) -> BottleCarrier:
     carrier.num_items_x = 2
     carrier.num_items_y = 6
     carrier.num_items_z = 1
-    # 载架初始化为空，瓶子由实际转运操作填入，避免反序列化时重复 assign
+    for i in range(12):
+        carrier[i] = YB_pei_ye_xiao_Bottle(f"{name}_vial_{i+1}")
     return carrier

unilabos/resources/battery/electrode_sheet.py

@@ -135,7 +135,6 @@ class BatteryState(TypedDict):
     open_circuit_voltage: float
     assembly_pressure: float
     electrolyte_volume: float
-    pole_weight: float  # 极片称重 (mg)
 
     info: Optional[str]  # 附加信息
 
@@ -180,7 +179,6 @@ class Battery(Container):
             open_circuit_voltage=0.0,
             assembly_pressure=0.0,
             electrolyte_volume=0.0,
-            pole_weight=0.0,
             info=None
         )
 

unilabos/resources/battery/magazine.py

@@ -53,28 +53,13 @@ class Magazine(ResourceStack):
         return self.get_size_z()
 
     def serialize(self) -> dict:
-        data = super().serialize()
-        # 物料余量由寄存器接管，不再持久化极片子节点，
-        # 防止旧数据写回数据库后下次启动时再次引发重复 UUID。
-        data["children"] = []
-        data.update({
+        return {
+            **super().serialize(),
             "size_x": self.size_x or 10.0,
             "size_y": self.size_y or 10.0,
             "size_z": self.size_z or 10.0,
             "max_sheets": self.max_sheets,
-        })
-        return data
-
-    @classmethod
-    def deserialize(cls, data: dict, allow_marshal: bool = False):
-        """反序列化时丢弃极片子节点（ElectrodeSheet 等）。
-
-        物料余量已由寄存器接管，不再在资源树中追踪每个极片实体。
-        清空 children 可防止数据库中的旧极片记录被重新加载，避免重复 UUID 报错。
-        """
-        data = dict(data)
-        data["children"] = []
-        return super().deserialize(data, allow_marshal=allow_marshal)
+        }
 
 
 class MagazineHolder(ItemizedResource):
@@ -235,7 +220,7 @@ def MagazineHolder_6_Cathode(
         size_y=size_y,
         size_z=size_z,
         locations=locations,
-        klasses=None,
+        klasses=[FlatWasher, PositiveCan, PositiveCan, FlatWasher, PositiveCan, PositiveCan],
         hole_diameter=hole_diameter,
         hole_depth=hole_depth,
         max_sheets_per_hole=max_sheets_per_hole,
@@ -273,7 +258,7 @@ def MagazineHolder_6_Anode(
         size_y=size_y,
         size_z=size_z,
         locations=locations,
-        klasses=None,
+        klasses=[SpringWasher, NegativeCan, NegativeCan, SpringWasher, NegativeCan, NegativeCan],
         hole_diameter=hole_diameter,
         hole_depth=hole_depth,
         max_sheets_per_hole=max_sheets_per_hole,
@@ -350,7 +335,7 @@ def MagazineHolder_4_Cathode(
         size_y=size_y,
         size_z=size_z,
         locations=locations,
-        klasses=None,
+        klasses=[AluminumFoil, PositiveElectrode, PositiveElectrode, PositiveElectrode],
         hole_diameter=hole_diameter,
         hole_depth=hole_depth,
         max_sheets_per_hole=max_sheets_per_hole,

unilabos/resources/bioyond/YB_bottle_carriers.py

@@ -2,18 +2,15 @@ from pylabrobot.resources import create_homogeneous_resources, Coordinate, Resou
 
 from unilabos.resources.itemized_carrier import Bottle, BottleCarrier
 from unilabos.resources.bioyond.YB_bottles import (
-    YB_DosingHead_L,
-    YB_NormalLiq_250mL_Bottle,
-    YB_NormalLiq_100mL_Bottle,
-    YB_HighVis_250mL_Bottle,
-    YB_HighVis_100mL_Bottle,
-    YB_Vial_5mL,
-    YB_Vial_20mL,
-    YB_PrepBottle_15mL,
-    YB_PrepBottle_60mL,
-    YB_Tip_5000uL,
-    YB_Tip_1000uL,
-    YB_Tip_50uL,
+    YB_jia_yang_tou_da,
+    YB_ye_Bottle,
+    YB_ye_100ml_Bottle,
+    YB_gao_nian_ye_Bottle,
+    YB_5ml_fenyeping,
+    YB_20ml_fenyeping,
+    YB_pei_ye_xiao_Bottle,
+    YB_pei_ye_da_Bottle,
+    YB_qiang_tou,
 )
 # 命名约定：试剂瓶-Bottle，烧杯-Beaker，烧瓶-Flask，小瓶-Vial
 
@@ -209,7 +206,7 @@ def YB_6VialCarrier(name: str) -> BottleCarrier:
     return carrier
 
 # 1瓶载架 - 单个中央位置
-def YB_NormalLiq_250mL_Carrier(name: str) -> BottleCarrier:
+def YB_ye(name: str) -> BottleCarrier:
     
     # 载架尺寸 (mm)
     carrier_size_x = 127.8
@@ -236,17 +233,17 @@ def YB_NormalLiq_250mL_Carrier(name: str) -> BottleCarrier:
             resource_size_y=beaker_diameter,
             name_prefix=name,
         ),
-        model="YB_NormalLiq_250mL_Carrier",
+        model="YB_ye",
     )
     carrier.num_items_x = 1
     carrier.num_items_y = 1
     carrier.num_items_z = 1
-    carrier[0] = YB_NormalLiq_250mL_Bottle(f"{name}_flask_1")
+    carrier[0] = YB_ye_Bottle(f"{name}_flask_1")
     return carrier
 
 
 # 高粘液瓶载架 - 单个中央位置
-def YB_HighVis_250mL_Carrier(name: str) -> BottleCarrier:
+def YB_gaonianye(name: str) -> BottleCarrier:
     
     # 载架尺寸 (mm)
     carrier_size_x = 127.8
@@ -273,17 +270,17 @@ def YB_HighVis_250mL_Carrier(name: str) -> BottleCarrier:
             resource_size_y=beaker_diameter,
             name_prefix=name,
         ),
-        model="YB_HighVis_250mL_Carrier",
+        model="YB_gaonianye",
     )
     carrier.num_items_x = 1
     carrier.num_items_y = 1
     carrier.num_items_z = 1
-    carrier[0] = YB_HighVis_250mL_Bottle(f"{name}_flask_1")
+    carrier[0] = YB_gao_nian_ye_Bottle(f"{name}_flask_1")
     return carrier
 
 
-# 100mL普通液瓶载架 - 单个中央位置
-def YB_NormalLiq_100mL_Carrier(name: str) -> BottleCarrier:
+# 100ml液体瓶载架 - 单个中央位置
+def YB_100ml_yeti(name: str) -> BottleCarrier:
     
     # 载架尺寸 (mm)
     carrier_size_x = 127.8
@@ -310,52 +307,16 @@ def YB_NormalLiq_100mL_Carrier(name: str) -> BottleCarrier:
             resource_size_y=beaker_diameter,
             name_prefix=name,
         ),
-        model="YB_NormalLiq_100mL_Carrier",
+        model="YB_100ml_yeti",
     )
     carrier.num_items_x = 1
     carrier.num_items_y = 1
     carrier.num_items_z = 1
-    carrier[0] = YB_NormalLiq_100mL_Bottle(f"{name}_flask_1")
+    carrier[0] = YB_ye_100ml_Bottle(f"{name}_flask_1")
     return carrier
 
-# 100mL高粘液瓶载架 - 单个中央位置
-def YB_HighVis_100mL_Carrier(name: str) -> BottleCarrier:
-    
-    # 载架尺寸 (mm)
-    carrier_size_x = 127.8
-    carrier_size_y = 85.5
-    carrier_size_z = 20.0
-
-    # 烧杯尺寸
-    beaker_diameter = 60.0
-
-    # 计算中央位置
-    center_x = (carrier_size_x - beaker_diameter) / 2
-    center_y = (carrier_size_y - beaker_diameter) / 2
-    center_z = 5.0
-
-    carrier = BottleCarrier(
-        name=name,
-        size_x=carrier_size_x,
-        size_y=carrier_size_y,
-        size_z=carrier_size_z,
-        sites=create_homogeneous_resources(
-            klass=ResourceHolder,
-            locations=[Coordinate(center_x, center_y, center_z)],
-            resource_size_x=beaker_diameter,
-            resource_size_y=beaker_diameter,
-            name_prefix=name,
-        ),
-        model="YB_HighVis_100mL_Carrier",
-    )
-    carrier.num_items_x = 1
-    carrier.num_items_y = 1
-    carrier.num_items_z = 1
-    carrier[0] = YB_HighVis_100mL_Bottle(f"{name}_flask_1")
-    return carrier
-
-# 5mL分液瓶板 - 4x2布局，8个位置
-def YB_Vial_5mL_Carrier(name: str) -> BottleCarrier:
+# 5ml分液瓶板 - 4x2布局，8个位置
+def YB_5ml_fenyepingban(name: str) -> BottleCarrier:
     
 
     # 载架尺寸 (mm)
@@ -394,18 +355,18 @@ def YB_Vial_5mL_Carrier(name: str) -> BottleCarrier:
         size_y=carrier_size_y,
         size_z=carrier_size_z,
         sites=sites,
-        model="YB_Vial_5mL_Carrier",
+        model="YB_5ml_fenyepingban",
     )
     carrier.num_items_x = 4
     carrier.num_items_y = 2
     carrier.num_items_z = 1
     ordering = ["A1", "A2", "A3", "A4", "B1", "B2", "B3", "B4"]
     for i in range(8):
-        carrier[i] = YB_Vial_5mL(f"{name}_vial_{ordering[i]}")
+        carrier[i] = YB_5ml_fenyeping(f"{name}_vial_{ordering[i]}")
     return carrier
 
-# 20mL分液瓶板 - 4x2布局，8个位置
-def YB_Vial_20mL_Carrier(name: str) -> BottleCarrier:
+# 20ml分液瓶板 - 4x2布局，8个位置
+def YB_20ml_fenyepingban(name: str) -> BottleCarrier:
 
 
     # 载架尺寸 (mm)
@@ -444,18 +405,18 @@ def YB_Vial_20mL_Carrier(name: str) -> BottleCarrier:
         size_y=carrier_size_y,
         size_z=carrier_size_z,
         sites=sites,
-        model="YB_Vial_20mL_Carrier",
+        model="YB_20ml_fenyepingban",
     )
     carrier.num_items_x = 4
     carrier.num_items_y = 2
     carrier.num_items_z = 1
     ordering = ["A1", "A2", "A3", "A4", "B1", "B2", "B3", "B4"]
     for i in range(8):
-        carrier[i] = YB_Vial_20mL(f"{name}_vial_{ordering[i]}")
+        carrier[i] = YB_20ml_fenyeping(f"{name}_vial_{ordering[i]}")
     return carrier
 
 # 配液瓶(小)板 - 4x2布局，8个位置
-def YB_PrepBottle_15mL_Carrier(name: str) -> BottleCarrier:
+def YB_peiyepingxiaoban(name: str) -> BottleCarrier:
     
 
     # 载架尺寸 (mm)
@@ -494,19 +455,19 @@ def YB_PrepBottle_15mL_Carrier(name: str) -> BottleCarrier:
         size_y=carrier_size_y,
         size_z=carrier_size_z,
         sites=sites,
-        model="YB_PrepBottle_15mL_Carrier",
+        model="YB_peiyepingxiaoban",
     )
     carrier.num_items_x = 4
     carrier.num_items_y = 2
     carrier.num_items_z = 1
     ordering = ["A1", "A2", "A3", "A4", "B1", "B2", "B3", "B4"]
     for i in range(8):
-        carrier[i] = YB_PrepBottle_15mL(f"{name}_bottle_{ordering[i]}")
+        carrier[i] = YB_pei_ye_xiao_Bottle(f"{name}_bottle_{ordering[i]}")
     return carrier
 
 
 # 配液瓶(大)板 - 2x2布局，4个位置
-def YB_PrepBottle_60mL_Carrier(name: str) -> BottleCarrier:
+def YB_peiyepingdaban(name: str) -> BottleCarrier:
 
     # 载架尺寸 (mm)
     carrier_size_x = 127.8
@@ -544,18 +505,18 @@ def YB_PrepBottle_60mL_Carrier(name: str) -> BottleCarrier:
         size_y=carrier_size_y,
         size_z=carrier_size_z,
         sites=sites,
-        model="YB_PrepBottle_60mL_Carrier",
+        model="YB_peiyepingdaban",
     )
     carrier.num_items_x = 2
     carrier.num_items_y = 2
     carrier.num_items_z = 1
     ordering = ["A1", "A2", "B1", "B2"]
     for i in range(4):
-        carrier[i] = YB_PrepBottle_60mL(f"{name}_bottle_{ordering[i]}")
+        carrier[i] = YB_pei_ye_da_Bottle(f"{name}_bottle_{ordering[i]}")
     return carrier
 
 # 加样头(大)板 - 1x1布局，1个位置
-def YB_DosingHead_L_Carrier(name: str) -> BottleCarrier:
+def YB_jia_yang_tou_da_Carrier(name: str) -> BottleCarrier:
     
     # 载架尺寸 (mm)
     carrier_size_x = 127.8
@@ -593,16 +554,16 @@ def YB_DosingHead_L_Carrier(name: str) -> BottleCarrier:
         size_y=carrier_size_y,
         size_z=carrier_size_z,
         sites=sites,
-        model="YB_DosingHead_L_Carrier",
+        model="YB_jia_yang_tou_da_Carrier",
     )
     carrier.num_items_x = 1
     carrier.num_items_y = 1
     carrier.num_items_z = 1
-    carrier[0] = YB_DosingHead_L(f"{name}_head_1")
+    carrier[0] = YB_jia_yang_tou_da(f"{name}_head_1")
     return carrier
 
 
-def YB_Adapter_60mL(name: str) -> BottleCarrier:
+def YB_shi_pei_qi_kuai(name: str) -> BottleCarrier:
     """适配器块 - 单个中央位置"""
 
     # 载架尺寸 (mm)
@@ -630,7 +591,7 @@ def YB_Adapter_60mL(name: str) -> BottleCarrier:
             resource_size_y=adapter_diameter,
             name_prefix=name,
         ),
-        model="YB_Adapter_60mL",
+        model="YB_shi_pei_qi_kuai",
     )
     carrier.num_items_x = 1
     carrier.num_items_y = 1
@@ -639,7 +600,7 @@ def YB_Adapter_60mL(name: str) -> BottleCarrier:
     return carrier
 
 
-def YB_TipRack_50uL(name: str) -> BottleCarrier:
+def YB_qiang_tou_he(name: str) -> BottleCarrier:
     """枪头盒 - 8x12布局，96个位置"""
 
     # 载架尺寸 (mm)
@@ -648,9 +609,9 @@ def YB_TipRack_50uL(name: str) -> BottleCarrier:
     carrier_size_z = 55.0
 
     # 枪头尺寸
-    tip_diameter = 7.0
-    tip_spacing_x = 7.5  # X方向间距
-    tip_spacing_y = 7.5  # Y方向间距
+    tip_diameter = 10.0
+    tip_spacing_x = 9.0  # X方向间距
+    tip_spacing_y = 9.0  # Y方向间距
 
     # 计算起始位置 (居中排列)
     start_x = (carrier_size_x - (12 - 1) * tip_spacing_x - tip_diameter) / 2
@@ -678,7 +639,7 @@ def YB_TipRack_50uL(name: str) -> BottleCarrier:
         size_y=carrier_size_y,
         size_z=carrier_size_z,
         sites=sites,
-        model="YB_TipRack_50uL",
+        model="YB_qiang_tou_he",
     )
     carrier.num_items_x = 12
     carrier.num_items_y = 8
@@ -687,182 +648,6 @@ def YB_TipRack_50uL(name: str) -> BottleCarrier:
     for i in range(96):
         row = chr(65 + i // 12)  # A-H
         col = (i % 12) + 1  # 1-12
-        carrier[i] = YB_Tip_50uL(f"{name}_tip_{row}{col}")
-    return carrier
-
-
-def YB_TipRack_5000uL(name: str) -> BottleCarrier:
-    """枪头盒 - 4x6布局，24个位置"""
-
-    # 载架尺寸 (mm)
-    carrier_size_x = 127.8
-    carrier_size_y = 85.5
-    carrier_size_z = 95.0
-
-    # 枪头尺寸
-    tip_diameter = 16.0
-    tip_spacing_x = 16.5  # X方向间距
-    tip_spacing_y = 16.5  # Y方向间距
-
-    # 计算起始位置 (居中排列)
-    start_x = (carrier_size_x - (6 - 1) * tip_spacing_x - tip_diameter) / 2
-    start_y = (carrier_size_y - (4 - 1) * tip_spacing_y - tip_diameter) / 2
-
-    sites = create_ordered_items_2d(
-        klass=ResourceHolder,
-        num_items_x=6,
-        num_items_y=4,
-        dx=start_x,
-        dy=start_y,
-        dz=5.0,
-        item_dx=tip_spacing_x,
-        item_dy=tip_spacing_y,
-        size_x=tip_diameter,
-        size_y=tip_diameter,
-        size_z=carrier_size_z,
-    )
-    for k, v in sites.items():
-        v.name = f"{name}_{v.name}"
-
-    carrier = BottleCarrier(
-        name=name,
-        size_x=carrier_size_x,
-        size_y=carrier_size_y,
-        size_z=carrier_size_z,
-        sites=sites,
-        model="YB_TipRack_5000uL",
-    )
-    carrier.num_items_x = 6
-    carrier.num_items_y = 4
-    carrier.num_items_z = 1
-    # 创建24个枪头
-    for i in range(24):
-        row = chr(65 + i // 6)  # A-D
-        col = (i % 6) + 1  # 1-6
-        carrier[i] = YB_Tip_5000uL(f"{name}_tip_{row}{col}")
-    return carrier
-
-
-
-def YB_TipRack_Mixed(name: str) -> BottleCarrier:
-    """混合枪头盒 - 复杂布局
-    上层: 2x8空位（原50uL枪头位置，现空余）
-    中层: 4x4布局，放5000uL枪头
-    下层: 2x8布局，放1000uL枪头
-    """
-
-    # 载架尺寸 (mm)
-    carrier_size_x = 127.8
-    carrier_size_y = 85.5
-    carrier_size_z = 95.0
-
-    # 各类枪头的尺寸参数
-    tip_5000_diameter = 16.0
-    tip_5000_spacing_x = 16.5
-    tip_5000_spacing_y = 16.5
-    
-    tip_1000_diameter = 7.0
-    tip_1000_spacing_x = 7.5
-    tip_1000_spacing_y = 7.5
-
-    # 空位尺寸（上层2x8，原50uL位置）
-    empty_diameter = 7.0
-    empty_spacing_x = 7.5
-    empty_spacing_y = 7.5
-
-    # 计算各层的起始位置
-    # 上层空位 (2x8)
-    empty_top_start_x = (carrier_size_x - (8 - 1) * empty_spacing_x - empty_diameter) / 2
-    empty_top_start_y = 5.0
-    
-    # 中层5000uL (4x4)
-    tip_5000_start_x = (carrier_size_x - (4 - 1) * tip_5000_spacing_x - tip_5000_diameter) / 2
-    tip_5000_start_y = empty_top_start_y + 2 * empty_spacing_y + 5.0
-    
-    # 下层1000uL (2x8)
-    tip_1000_start_x = (carrier_size_x - (8 - 1) * tip_1000_spacing_x - tip_1000_diameter) / 2
-    tip_1000_start_y = tip_5000_start_y + 4 * tip_5000_spacing_y + 5.0
-
-    sites = {}
-    
-    # 创建上层空位 (2x8) - 不创建实际的枪头对象
-    empty_top_sites = create_ordered_items_2d(
-        klass=ResourceHolder,
-        num_items_x=8,
-        num_items_y=2,
-        dx=empty_top_start_x,
-        dy=empty_top_start_y,
-        dz=5.0,
-        item_dx=empty_spacing_x,
-        item_dy=empty_spacing_y,
-        size_x=empty_diameter,
-        size_y=empty_diameter,
-        size_z=carrier_size_z,
-    )
-    # 添加空位，索引 0-15
-    for k, v in empty_top_sites.items():
-        v.name = f"{name}_empty_top_{v.name}"
-        sites[k] = v
-    
-    # 创建中层5000uL枪头位 (4x4)，索引 16-31
-    tip_5000_sites = create_ordered_items_2d(
-        klass=ResourceHolder,
-        num_items_x=4,
-        num_items_y=4,
-        dx=tip_5000_start_x,
-        dy=tip_5000_start_y,
-        dz=15.0,
-        item_dx=tip_5000_spacing_x,
-        item_dy=tip_5000_spacing_y,
-        size_x=tip_5000_diameter,
-        size_y=tip_5000_diameter,
-        size_z=carrier_size_z,
-    )
-    for i, (k, v) in enumerate(tip_5000_sites.items()):
-        v.name = f"{name}_5000_{v.name}"
-        sites[16 + i] = v
-    
-    # 创建下层1000uL枪头位 (2x8)，索引 32-47
-    tip_1000_sites = create_ordered_items_2d(
-        klass=ResourceHolder,
-        num_items_x=8,
-        num_items_y=2,
-        dx=tip_1000_start_x,
-        dy=tip_1000_start_y,
-        dz=25.0,
-        item_dx=tip_1000_spacing_x,
-        item_dy=tip_1000_spacing_y,
-        size_x=tip_1000_diameter,
-        size_y=tip_1000_diameter,
-        size_z=carrier_size_z,
-    )
-    for i, (k, v) in enumerate(tip_1000_sites.items()):
-        v.name = f"{name}_1000_{v.name}"
-        sites[32 + i] = v
-
-    carrier = BottleCarrier(
-        name=name,
-        size_x=carrier_size_x,
-        size_y=carrier_size_y,
-        size_z=carrier_size_z,
-        sites=sites,
-        model="YB_TipRack_Mixed",
-    )
-    carrier.num_items_x = 8  # 最大宽度
-    carrier.num_items_y = 8  # 总行数 (2+4+2)
-    carrier.num_items_z = 1
-    
-    # 为5000uL枪头创建实例 (16个)，对应索引 16-31
-    for i in range(16):
-        row = chr(65 + i // 4)  # A-D
-        col = (i % 4) + 1  # 1-4
-        carrier[16 + i] = YB_Tip_5000uL(f"{name}_tip5000_{row}{col}")
-    
-    # 为1000uL枪头创建实例 (16个)，对应索引 32-47
-    for i in range(16):
-        row = chr(65 + i // 8)  # A-B
-        col = (i % 8) + 1  # 1-8
-        carrier[32 + i] = YB_Tip_1000uL(f"{name}_tip1000_{row}{col}")
-    
+        carrier[i] = YB_qiang_tou(f"{name}_tip_{row}{col}")
     return carrier
 

unilabos/resources/bioyond/YB_bottles.py

@@ -1,7 +1,7 @@
 from unilabos.resources.itemized_carrier import Bottle, BottleCarrier
 # 工厂函数
 """加样头（大）"""
-def YB_DosingHead_L(
+def YB_jia_yang_tou_da(
     name: str,
     diameter: float = 20.0,
     height: float = 100.0,
@@ -15,11 +15,11 @@ def YB_DosingHead_L(
         height=height,
         max_volume=max_volume,
         barcode=barcode,
-        model="YB_DosingHead_L",
+        model="YB_jia_yang_tou_da",
     )
 
-"""250mL普通液"""
-def YB_NormalLiq_250mL_Bottle(
+"""液1x1"""
+def YB_ye_Bottle(
     name: str,
     diameter: float = 40.0,
     height: float = 70.0,
@@ -33,105 +33,87 @@ def YB_NormalLiq_250mL_Bottle(
         height=height,
         max_volume=max_volume,
         barcode=barcode,
-        model="YB_NormalLiq_250mL_Bottle",
+        model="YB_ye_Bottle",
     )
 
-"""100mL普通液"""
-def YB_NormalLiq_100mL_Bottle(
+"""100ml液体"""
+def YB_ye_100ml_Bottle(
     name: str,
     diameter: float = 50.0,
     height: float = 90.0,
     max_volume: float = 100000.0,  # 100mL
     barcode: str = None,
 ) -> Bottle:
-    """创建100mL普通液瓶"""
+    """创建100ml液体瓶"""
     return Bottle(
         name=name,
         diameter=diameter,
         height=height,
         max_volume=max_volume,
         barcode=barcode,
-        model="YB_NormalLiq_100mL_Bottle",
+        model="YB_100ml_yeti",
     )
 
-"""100mL高粘液"""
-def YB_HighVis_100mL_Bottle(
-    name: str,
-    diameter: float = 50.0,
-    height: float = 90.0,
-    max_volume: float = 100000.0,  # 100mL
-    barcode: str = None,
-) -> Bottle:
-    """创建100mL高粘液瓶"""
-    return Bottle(
-        name=name,
-        diameter=diameter,
-        height=height,
-        max_volume=max_volume,
-        barcode=barcode,
-        model="YB_HighVis_100mL_Bottle",
-    )
-
-"""250mL高粘液"""
-def YB_HighVis_250mL_Bottle(
+"""高粘液"""
+def YB_gao_nian_ye_Bottle(
     name: str,
     diameter: float = 40.0,
     height: float = 70.0,
     max_volume: float = 50000.0,  # 50mL
     barcode: str = None,
 ) -> Bottle:
-    """创建250mL高粘液瓶"""
+    """创建高粘液瓶"""
     return Bottle(
         name=name,
         diameter=diameter,
         height=height,
         max_volume=max_volume,
         barcode=barcode,
-        model="YB_HighVis_250mL_Bottle",
+        model="High_Viscosity_Liquid",
     )
 
-"""5mL分液瓶"""
-def YB_Vial_5mL(
+"""5ml分液瓶"""
+def YB_5ml_fenyeping(
     name: str,
     diameter: float = 20.0,
     height: float = 50.0,
     max_volume: float = 5000.0,  # 5mL
     barcode: str = None,
 ) -> Bottle:
-    """创建5mL分液瓶"""
+    """创建5ml分液瓶"""
     return Bottle(
         name=name,
         diameter=diameter,
         height=height,
         max_volume=max_volume,
         barcode=barcode,
-        model="YB_Vial_5mL",
+        model="YB_5ml_fenyeping",
     )
 
-"""20mL分液瓶"""
-def YB_Vial_20mL(
+"""20ml分液瓶"""
+def YB_20ml_fenyeping(
     name: str,
     diameter: float = 30.0,
     height: float = 65.0,
     max_volume: float = 20000.0,  # 20mL
     barcode: str = None,
 ) -> Bottle:
-    """创建20mL分液瓶"""
+    """创建20ml分液瓶"""
     return Bottle(
         name=name,
         diameter=diameter,
         height=height,
         max_volume=max_volume,
         barcode=barcode,
-        model="YB_Vial_20mL",
+        model="YB_20ml_fenyeping",
     )
 
 """配液瓶(小)"""
-def YB_PrepBottle_15mL(
+def YB_pei_ye_xiao_Bottle(
     name: str,
     diameter: float = 35.0,
     height: float = 60.0,
-    max_volume: float = 15000.0,  # 15mL
+    max_volume: float = 30000.0,  # 30mL
     barcode: str = None,
 ) -> Bottle:
     """创建配液瓶(小)"""
@@ -141,15 +123,15 @@ def YB_PrepBottle_15mL(
         height=height,
         max_volume=max_volume,
         barcode=barcode,
-        model="YB_PrepBottle_15mL",
+        model="YB_pei_ye_xiao_Bottle",
     )
 
 """配液瓶(大)"""
-def YB_PrepBottle_60mL(
+def YB_pei_ye_da_Bottle(
     name: str,
     diameter: float = 55.0,
     height: float = 100.0,
-    max_volume: float = 60000.0,  # 60mL
+    max_volume: float = 150000.0,  # 150mL
     barcode: str = None,
 ) -> Bottle:
     """创建配液瓶(大)"""
@@ -159,29 +141,11 @@ def YB_PrepBottle_60mL(
         height=height,
         max_volume=max_volume,
         barcode=barcode,
-        model="YB_PrepBottle_60mL",
+        model="YB_pei_ye_da_Bottle",
     )
 
-"""5000uL枪头"""
-def YB_Tip_5000uL(
-    name: str,
-    diameter: float = 10.0,
-    height: float = 50.0,
-    max_volume: float = 5000.0,  # 5mL
-    barcode: str = None,
-) -> Bottle:
-    """创建枪头"""
-    return Bottle(
-        name=name,
-        diameter=diameter,
-        height=height,
-        max_volume=max_volume,
-        barcode=barcode,
-        model="YB_Tip_5000uL",
-    ) 
-
-"""1000uL枪头"""
-def YB_Tip_1000uL(
+"""枪头"""
+def YB_qiang_tou(
     name: str,
     diameter: float = 10.0,
     height: float = 50.0,
@@ -195,23 +159,5 @@ def YB_Tip_1000uL(
         height=height,
         max_volume=max_volume,
         barcode=barcode,
-        model="YB_Tip_1000uL",
+        model="YB_qiang_tou",
     )    
-
-"""50uL枪头"""
-def YB_Tip_50uL(
-    name: str,
-    diameter: float = 10.0,
-    height: float = 50.0,
-    max_volume: float = 50.0,  # 50uL
-    barcode: str = None,
-) -> Bottle:
-    """创建枪头"""
-    return Bottle(
-        name=name,
-        diameter=diameter,
-        height=height,
-        max_volume=max_volume,
-        barcode=barcode,
-        model="YB_Tip_50uL",
-    ) 

unilabos/resources/bioyond/decks.py

@@ -1,3 +1,4 @@
+from os import name
 from pylabrobot.resources import Deck, Coordinate, Rotation
 
 from unilabos.resources.bioyond.YB_warehouses import (
@@ -33,8 +34,11 @@ class BIOYOND_PolymerReactionStation_Deck(Deck):
         size_y: float = 1080.0,
         size_z: float = 1500.0,
         category: str = "deck",
+        setup: bool = False
     ) -> None:
         super().__init__(name=name, size_x=2700.0, size_y=1080.0, size_z=1500.0)
+        if setup:
+            self.setup()
 
     def setup(self) -> None:
         # 添加仓库
@@ -62,7 +66,6 @@ class BIOYOND_PolymerReactionStation_Deck(Deck):
         for warehouse_name, warehouse in self.warehouses.items():
             self.assign_child_resource(warehouse, location=self.warehouse_locations[warehouse_name])
 
-
 class BIOYOND_PolymerPreparationStation_Deck(Deck):
     def __init__(
         self,
@@ -71,8 +74,11 @@ class BIOYOND_PolymerPreparationStation_Deck(Deck):
         size_y: float = 1080.0,
         size_z: float = 1500.0,
         category: str = "deck",
+        setup: bool = False
     ) -> None:
         super().__init__(name=name, size_x=2700.0, size_y=1080.0, size_z=1500.0)
+        if setup:
+            self.setup()
 
     def setup(self) -> None:
         # 添加仓库 - 配液站的3个堆栈，使用Bioyond系统中的实际名称
@@ -95,8 +101,7 @@ class BIOYOND_PolymerPreparationStation_Deck(Deck):
         for warehouse_name, warehouse in self.warehouses.items():
             self.assign_child_resource(warehouse, location=self.warehouse_locations[warehouse_name])
 
-
-class BioyondElectrolyteDeck(Deck):
+class BIOYOND_YB_Deck(Deck):
     def __init__(
         self,
         name: str = "YB_Deck",
@@ -104,7 +109,7 @@ class BioyondElectrolyteDeck(Deck):
         size_y: float = 1400.0,
         size_z: float = 2670.0,
         category: str = "deck",
-        setup: bool = False,
+        setup: bool = False
     ) -> None:
         super().__init__(name=name, size_x=4150.0, size_y=1400.0, size_z=2670.0)
         if setup:
@@ -113,8 +118,8 @@ class BioyondElectrolyteDeck(Deck):
     def setup(self) -> None:
         # 添加仓库
         self.warehouses = {
-            "自动堆栈-左": bioyond_warehouse_2x2x1("自动堆栈-左"),  # 2行×2列
-            "自动堆栈-右": bioyond_warehouse_2x2x1("自动堆栈-右"),  # 2行×2列
+            "321窗口": bioyond_warehouse_2x2x1("321窗口"),  # 2行×2列
+            "43窗口": bioyond_warehouse_2x2x1("43窗口"),  # 2行×2列
             "手动传递窗右": bioyond_warehouse_5x3x1("手动传递窗右", row_offset=0),  # A01-E03
             "手动传递窗左": bioyond_warehouse_5x3x1("手动传递窗左", row_offset=5),  # F01-J03
             "加样头堆栈左": bioyond_warehouse_10x1x1("加样头堆栈左"),
@@ -128,34 +133,29 @@ class BioyondElectrolyteDeck(Deck):
         }
         # warehouse 的位置
         self.warehouse_locations = {
-            "自动堆栈-左": Coordinate(-150.0, 1142.0, 0.0),
-            "自动堆栈-右": Coordinate(4160.0, 1142.0, 0.0),
-            "手动传递窗左": Coordinate(-150.0, 423.0, 0.0),
-            "手动传递窗右": Coordinate(4160.0, 423.0, 0.0),
-            "加样头堆栈左": Coordinate(385.0, 0, 0.0),
-            "加样头堆栈右": Coordinate(2187.0, 0, 0.0),
+            "321窗口": Coordinate(-150.0, 158.0, 0.0),
+            "43窗口": Coordinate(4160.0, 158.0, 0.0),
+            "手动传递窗左": Coordinate(-150.0, 877.0, 0.0),
+            "手动传递窗右": Coordinate(4160.0, 877.0, 0.0),
+            "加样头堆栈左": Coordinate(385.0, 1300.0, 0.0),
+            "加样头堆栈右": Coordinate(2187.0, 1300.0, 0.0),
 
-            "15ml配液堆栈左": Coordinate(749.0, 945.0, 0.0),
-            "母液加样右": Coordinate(2152.0, 967.0, 0.0),
-            "大瓶母液堆栈左": Coordinate(1164.0, 624.0, 0.0),
-            "大瓶母液堆栈右": Coordinate(2717.0, 624.0, 0.0),
-            "2号手套箱内部堆栈": Coordinate(-800, 800.0, 0.0),  # 新增：位置需根据实际硬件调整
+            "15ml配液堆栈左": Coordinate(749.0, 355.0, 0.0),
+            "母液加样右": Coordinate(2152.0, 333.0, 0.0),
+            "大瓶母液堆栈左": Coordinate(1164.0, 676.0, 0.0),
+            "大瓶母液堆栈右": Coordinate(2717.0, 676.0, 0.0),
+            "2号手套箱内部堆栈": Coordinate(-800, -500.0, 0.0),  # 新增：位置需根据实际硬件调整
         }
 
         for warehouse_name, warehouse in self.warehouses.items():
             self.assign_child_resource(warehouse, location=self.warehouse_locations[warehouse_name])
 
-
-# 向后兼容别名，日后废弃
-BIOYOND_YB_Deck = BioyondElectrolyteDeck
+def YB_Deck(name: str) -> Deck:
+    by=BIOYOND_YB_Deck(name=name)
+    by.setup()
+    return by
+
 
 
-def bioyond_electrolyte_deck(name: str) -> BioyondElectrolyteDeck:
-    deck = BioyondElectrolyteDeck(name=name)
-    deck.setup()
-    return deck
 
 
-# 向后兼容别名，日后废弃
-def YB_Deck(name: str) -> BioyondElectrolyteDeck:
-    return bioyond_electrolyte_deck(name)

unilabos/resources/graphio.py

@@ -42,7 +42,7 @@ def canonicalize_nodes_data(
     Returns:
         ResourceTreeSet: 标准化后的资源树集合
     """
-    print_status(f"{len(nodes)} Resources loaded", "info")
+    print_status(f"{len(nodes)} Resources loaded:", "info")
 
     # 第一步：基本预处理（处理graphml的label字段）
     outer_host_node_id = None
@@ -797,10 +797,9 @@ def resource_bioyond_to_plr(bioyond_materials: list[dict], type_mapping: Dict[st
                     bottle = plr_material[number] = initialize_resource(
                         {"name": f'{detail["name"]}_{number}', "class": reverse_type_mapping[typeName][0]}, resource_type=ResourcePLR
                     )
-                    if hasattr(bottle, 'tracker') and bottle.tracker is not None:
-                        bottle.tracker.liquids = [
-                            (detail["name"], float(detail.get("quantity", 0)) if detail.get("quantity") else 0)
-                        ]
+                    bottle.tracker.liquids = [
+                        (detail["name"], float(detail.get("quantity", 0)) if detail.get("quantity") else 0)
+                    ]
                     bottle.code = detail.get("code", "")
                     logger.debug(f"  └─ [子物料] {detail['name']} → {plr_material.name}[{number}] (类型:{typeName})")
                 else:
@@ -809,10 +808,9 @@ def resource_bioyond_to_plr(bioyond_materials: list[dict], type_mapping: Dict[st
             # 只对有 capacity 属性的容器（液体容器）处理液体追踪
             if hasattr(plr_material, 'capacity'):
                 bottle = plr_material[0] if plr_material.capacity > 0 else plr_material
-                if hasattr(bottle, 'tracker') and bottle.tracker is not None:
-                    bottle.tracker.liquids = [
-                        (material["name"], float(material.get("quantity", 0)) if material.get("quantity") else 0)
-                    ]
+                bottle.tracker.liquids = [
+                    (material["name"], float(material.get("quantity", 0)) if material.get("quantity") else 0)
+                ]
 
         plr_materials.append(plr_material)
 

unilabos/resources/itemized_carrier.py

@@ -179,35 +179,6 @@ class ItemizedCarrier(ResourcePLR):
           idx = i
           break
 
-    if idx is None and location is not None:
-      # 精确坐标匹配失败（常见原因：DB 存储的 z=0，而槽位定义 z=dz>0）。
-      # 降级为仅按 XY 坐标进行近似匹配，找到后使用槽位自身的正确坐标写回，
-      # 避免因 Z 偏移导致反序列化中断。
-      _XY_TOLERANCE = 2.0  # mm，覆盖浮点误差和 z 偏移
-      min_dist = float("inf")
-      nearest_idx = None
-      for _i, _loc in enumerate(self.child_locations.values()):
-        _d = (((_loc.x - location.x) ** 2) + ((_loc.y - location.y) ** 2)) ** 0.5
-        if _d < min_dist:
-          min_dist = _d
-          nearest_idx = _i
-      if nearest_idx is not None and min_dist <= _XY_TOLERANCE:
-        from unilabos.utils.log import logger as _logger
-        _slot_label = list(self.child_locations.keys())[nearest_idx]
-        _logger.warning(
-          f"[ItemizedCarrier '{self.name}'] 资源 '{resource.name}' 坐标 {location} 与槽位 "
-          f"'{_slot_label}' {list(self.child_locations.values())[nearest_idx]} 的 XY 吻合"
-          f"（XY 偏差={min_dist:.2f}mm），按 XY 近似匹配成功，z 偏移已被修正。"
-        )
-        idx = nearest_idx
-
-    if idx is None:
-      raise ValueError(
-        f"[ItemizedCarrier '{self.name}'] 无法为资源 '{resource.name}' 找到匹配的槽位。\n"
-        f"  已知槽位: {list(self.child_locations.keys())}\n"
-        f"  传入坐标: {location}\n"
-        f"  提示: XY 近似匹配也失败，请检查资源坐标或 Carrier 槽位定义是否正确。"
-      )
     if not reassign and self.sites[idx] is not None:
       raise ValueError(f"a site with index {idx} already exists")
     location = list(self.child_locations.values())[idx]

unilabos/resources/resource_tracker.py

@@ -612,31 +612,6 @@ class ResourceTreeSet(object):
                 d["model"] = res.config.get("model", None)
             return d
 
-        def _deduplicate_plr_dict(d: dict, _seen: set = None) -> dict:
-            """递归去除 children 中同名重复节点（全树范围、保留首次出现）。
-
-            根本原因：同一槽位被 sync_from_external（Bioyond 同步）重复写入，
-            导致数据库中同一 WareHouse 下存在多条同名 BottleCarrier 记录（不同 UUID）。
-            PLR 的 _check_naming_conflicts 在全树范围检查名称唯一性，
-            重复名称会在 deserialize 时抛出 ValueError，导致节点启动失败。
-            此函数在 sub_cls.deserialize 前预先清理，保证名称唯一。
-            """
-            if _seen is None:
-                _seen = set()
-            children = d.get("children", [])
-            deduped = []
-            for child in children:
-                child = _deduplicate_plr_dict(child, _seen)
-                cname = child.get("name")
-                if cname not in _seen:
-                    _seen.add(cname)
-                    deduped.append(child)
-                else:
-                    logger.warning(
-                        f"[资源树去重] 发现重复资源名称 '{cname}'，跳过重复项（历史脏数据）"
-                    )
-            return {**d, "children": deduped}
-
         plr_resources = []
         tracker = DeviceNodeResourceTracker()
 
@@ -647,8 +622,6 @@ class ResourceTreeSet(object):
             collect_node_data(tree.root_node, name_to_uuid, all_states, name_to_extra)
             has_model = tree.root_node.res_content.type != "deck"
             plr_dict = node_to_plr_dict(tree.root_node, has_model)
-            plr_dict = _deduplicate_plr_dict(plr_dict)
-
             try:
                 sub_cls = find_subclass(plr_dict["type"], PLRResource)
                 if skip_devices and plr_dict["type"] == "device":
@@ -667,14 +640,6 @@ class ResourceTreeSet(object):
 
                 location = cast(Coordinate, deserialize(plr_dict["location"]))
                 plr_resource.location = location
-
-                # 预填 Container 类型资源在新版 PLR 中要求必须存在的键，
-                # 防止旧数据库状态缺失这些键时 load_all_state 抛出 KeyError。
-                for state in all_states.values():
-                    if isinstance(state, dict):
-                        state.setdefault("liquid_history", [])
-                        state.setdefault("pending_liquids", {})
-
                 plr_resource.load_all_state(all_states)
                 # 使用 DeviceNodeResourceTracker 设置 UUID 和 Extra
                 tracker.loop_set_uuid(plr_resource, name_to_uuid)

unilabos/resources/warehouse.py

@@ -41,9 +41,8 @@ def warehouse_factory(
 
                 # 根据 layout 决定 y 坐标计算
                 if layout == "row-major":
-                    # 行优先：row=0(A行) 应该显示在上方
-                    # 前端现在 y 越大越靠上，所以 row=0 对应最大的 y
-                    y = dy + (num_items_y - row - 1) * item_dy
+                    # 行优先：row=0(A行) 应该显示在上方，需要较小的 y 值
+                    y = dy + row * item_dy
                 elif layout == "vertical-col-major":
                     # 竖向warehouse: row=0 对应顶部（y小），row=n-1 对应底部（y大）
                     # 但标签 01 应该在底部，所以使用反向映射

unilabos/ros/nodes/base_device_node.py

@@ -1971,15 +1971,10 @@ class BaseROS2DeviceNode(Node, Generic[T]):
 
         mapped_plr_resources = []
         for uuid in uuids_list:
-            found = None
             for plr_resource in figured_resources:
                 r = self.resource_tracker.loop_find_with_uuid(plr_resource, uuid)
-                if r is not None:
-                    found = r
-                    break
-            if found is None:
-                raise Exception(f"未能在已解析的资源树中找到 uuid={uuid} 对应的资源")
-            mapped_plr_resources.append(found)
+                mapped_plr_resources.append(r)
+                break
 
         return mapped_plr_resources
 
@@ -2340,4 +2335,4 @@ class DeviceInfoType(TypedDict):
     status_publishers: Dict[str, PropertyPublisher]
     actions: Dict[str, ActionServer]
     hardware_interface: Dict[str, Any]
-    base_node_instance: BaseROS2DeviceNode
+    base_node_instance: BaseROS2DeviceNode

unilabos/test/experiments/yibin_electrolyte_config_example.json

@@ -13,7 +13,7 @@
                 "deck": {
                     "data": {
                         "_resource_child_name": "YB_Bioyond_Deck",
-                        "_resource_type": "unilabos.resources.bioyond.decks:BioyondElectrolyteDeck"
+                        "_resource_type": "unilabos.resources.bioyond.decks:BIOYOND_YB_Deck"
                     }
                 },
                 "protocol_type": [],
@@ -103,14 +103,15 @@
             "children": [],
             "parent": "bioyond_cell_workstation",
             "type": "deck",
-            "class": "BioyondElectrolyteDeck",
+            "class": "BIOYOND_YB_Deck",
             "position": {
                 "x": 0,
                 "y": 0,
                 "z": 0
             },
             "config": {
-                "type": "BioyondElectrolyteDeck",
+                "type": "BIOYOND_YB_Deck",
+                "setup": true,
                 "rotation": {
                     "x": 0,
                     "y": 0,

unilabos/utils/log-origin.py

@@ -1,385 +0,0 @@
-import logging
-import os
-import platform
-from datetime import datetime
-import ctypes
-import atexit
-import inspect
-from typing import Tuple, cast
-
-# 添加TRACE级别到logging模块
-TRACE_LEVEL = 5
-logging.addLevelName(TRACE_LEVEL, "TRACE")
-
-
-class CustomRecord:
-    custom_stack_info: Tuple[str, int, str, str]
-
-
-# Windows颜色支持
-if platform.system() == "Windows":
-    # 尝试启用Windows终端的ANSI支持
-    kernel32 = ctypes.windll.kernel32
-    # 获取STD_OUTPUT_HANDLE
-    STD_OUTPUT_HANDLE = -11
-    # 启用ENABLE_VIRTUAL_TERMINAL_PROCESSING
-    ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x0004
-    # 获取当前控制台模式
-    handle = kernel32.GetStdHandle(STD_OUTPUT_HANDLE)
-    mode = ctypes.c_ulong()
-    kernel32.GetConsoleMode(handle, ctypes.byref(mode))
-    # 启用ANSI处理
-    kernel32.SetConsoleMode(handle, mode.value | ENABLE_VIRTUAL_TERMINAL_PROCESSING)
-
-    # 程序退出时恢复控制台设置
-    @atexit.register
-    def reset_console():
-        kernel32.SetConsoleMode(handle, mode.value)
-
-
-# 定义不同日志级别的颜色
-class ColoredFormatter(logging.Formatter):
-    """自定义日志格式化器，支持颜色输出"""
-
-    # ANSI 颜色代码
-    COLORS = {
-        "RESET": "\033[0m",  # 重置
-        "BOLD": "\033[1m",  # 加粗
-        "GRAY": "\033[37m",  # 灰色
-        "WHITE": "\033[97m",  # 白色
-        "BLACK": "\033[30m",  # 黑色
-        "TRACE_LEVEL": "\033[1;90m",  # 加粗深灰色
-        "DEBUG_LEVEL": "\033[1;36m",  # 加粗青色
-        "INFO_LEVEL": "\033[1;32m",  # 加粗绿色
-        "WARNING_LEVEL": "\033[1;33m",  # 加粗黄色
-        "ERROR_LEVEL": "\033[1;31m",  # 加粗红色
-        "CRITICAL_LEVEL": "\033[1;35m",  # 加粗紫色
-        "TRACE_TEXT": "\033[90m",  # 深灰色
-        "DEBUG_TEXT": "\033[37m",  # 灰色
-        "INFO_TEXT": "\033[97m",  # 白色
-        "WARNING_TEXT": "\033[33m",  # 黄色
-        "ERROR_TEXT": "\033[31m",  # 红色
-        "CRITICAL_TEXT": "\033[35m",  # 紫色
-        "DATE": "\033[37m",  # 日期始终使用灰色
-    }
-
-    def __init__(self, use_colors=True):
-        super().__init__()
-        # 强制启用颜色
-        self.use_colors = use_colors
-
-    def format(self, record):
-        # 检查是否有自定义堆栈信息
-        if hasattr(record, "custom_stack_info") and record.custom_stack_info:  # type: ignore
-            r = cast(CustomRecord, record)
-            frame_info = r.custom_stack_info
-            record.filename = frame_info[0]
-            record.lineno = frame_info[1]
-            record.funcName = frame_info[2]
-            if len(frame_info) > 3:
-                record.name = frame_info[3]
-        if not self.use_colors:
-            return self._format_basic(record)
-
-        level_color = self.COLORS.get(f"{record.levelname}_LEVEL", self.COLORS["WHITE"])
-        text_color = self.COLORS.get(f"{record.levelname}_TEXT", self.COLORS["WHITE"])
-        date_color = self.COLORS["DATE"]
-        reset = self.COLORS["RESET"]
-
-        # 日期格式
-        datetime_str = datetime.fromtimestamp(record.created).strftime("%y-%m-%d [%H:%M:%S,%f")[:-3] + "]"
-
-        # 模块和函数信息
-        filename = record.filename.replace(".py", "").split("\\")[-1]  # 提取文件名（不含路径和扩展名）
-        if "/" in filename:
-            filename = filename.split("/")[-1]
-        module_path = f"{record.name}.{filename}"
-        func_line = f"{record.funcName}:{record.lineno}"
-        right_info = f" [{func_line}] [{module_path}]"
-
-        # 主要消息
-        main_msg = record.getMessage()
-
-        # 构建基本消息格式
-        formatted_message = (
-            f"{date_color}{datetime_str}{reset} "
-            f"{level_color}[{record.levelname}]{reset} "
-            f"{text_color}{main_msg}"
-            f"{date_color}{right_info}{reset}"
-        )
-
-        # 处理异常信息
-        if record.exc_info:
-            exc_text = self.formatException(record.exc_info)
-            if formatted_message[-1:] != "\n":
-                formatted_message = formatted_message + "\n"
-            formatted_message = formatted_message + text_color + exc_text + reset
-        elif record.stack_info:
-            if formatted_message[-1:] != "\n":
-                formatted_message = formatted_message + "\n"
-            formatted_message = formatted_message + text_color + self.formatStack(record.stack_info) + reset
-
-        return formatted_message
-
-    def _format_basic(self, record):
-        """基本格式化，不包含颜色"""
-        datetime_str = datetime.fromtimestamp(record.created).strftime("%y-%m-%d [%H:%M:%S,%f")[:-3] + "]"
-        filename = record.filename.replace(".py", "").split("\\")[-1]  # 提取文件名（不含路径和扩展名）
-        if "/" in filename:
-            filename = filename.split("/")[-1]
-        module_path = f"{record.name}.{filename}"
-        func_line = f"{record.funcName}:{record.lineno}"
-        right_info = f" [{func_line}] [{module_path}]"
-
-        formatted_message = f"{datetime_str} [{record.levelname}] {record.getMessage()}{right_info}"
-
-        if record.exc_info:
-            exc_text = self.formatException(record.exc_info)
-            if formatted_message[-1:] != "\n":
-                formatted_message = formatted_message + "\n"
-            formatted_message = formatted_message + exc_text
-        elif record.stack_info:
-            if formatted_message[-1:] != "\n":
-                formatted_message = formatted_message + "\n"
-            formatted_message = formatted_message + self.formatStack(record.stack_info)
-
-        return formatted_message
-
-    def formatException(self, exc_info):
-        """重写异常格式化，确保异常信息保持正确的格式和颜色"""
-        # 获取标准的异常格式化文本
-        formatted_exc = super().formatException(exc_info)
-        return formatted_exc
-
-
-# 配置日志处理器
-def configure_logger(loglevel=None, working_dir=None):
-    """配置日志记录器
-
-    Args:
-        loglevel: 日志级别，可以是字符串（'TRACE', 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'）
-                 或logging模块的常量（如logging.DEBUG）或TRACE_LEVEL
-    """
-    # 获取根日志记录器
-    root_logger = logging.getLogger()
-    root_logger.setLevel(TRACE_LEVEL)
-    # 设置日志级别
-    numeric_level = logging.DEBUG
-    if loglevel is not None:
-        if isinstance(loglevel, str):
-            # 将字符串转换为logging级别
-            if loglevel.upper() == "TRACE":
-                numeric_level = TRACE_LEVEL
-            else:
-                numeric_level = getattr(logging, loglevel.upper(), None)
-                if not isinstance(numeric_level, int):
-                    print(f"警告: 无效的日志级别 '{loglevel}'，使用默认级别 DEBUG")
-        else:
-            numeric_level = loglevel
-
-    # 移除已存在的处理器
-    for handler in root_logger.handlers[:]:
-        root_logger.removeHandler(handler)
-
-    # 创建控制台处理器
-    console_handler = logging.StreamHandler()
-    console_handler.setLevel(numeric_level)  # 使用与根记录器相同的级别
-
-    # 使用自定义的颜色格式化器
-    color_formatter = ColoredFormatter()
-    console_handler.setFormatter(color_formatter)
-
-    # 添加处理器到根日志记录器
-    root_logger.addHandler(console_handler)
-
-    # 如果指定了工作目录，添加文件处理器
-    if working_dir is not None:
-        logs_dir = os.path.join(working_dir, "logs")
-        os.makedirs(logs_dir, exist_ok=True)
-
-        # 生成日志文件名：日期 时间.log
-        log_filename = datetime.now().strftime("%Y-%m-%d %H-%M-%S") + ".log"
-        log_filepath = os.path.join(logs_dir, log_filename)
-
-        # 创建文件处理器
-        file_handler = logging.FileHandler(log_filepath, encoding="utf-8")
-        file_handler.setLevel(TRACE_LEVEL)
-
-        # 使用不带颜色的格式化器
-        file_formatter = ColoredFormatter(use_colors=False)
-        file_handler.setFormatter(file_formatter)
-
-        root_logger.addHandler(file_handler)
-
-    logging.getLogger("asyncio").setLevel(logging.INFO)
-    logging.getLogger("urllib3").setLevel(logging.INFO)
-
-
-
-# 配置日志系统
-configure_logger()
-
-# 获取日志记录器
-logger = logging.getLogger(__name__)
-
-
-# 获取调用栈信息的工具函数
-def _get_caller_info(stack_level=0) -> Tuple[str, int, str, str]:
-    """
-    获取调用者的信息
-
-    Args:
-        stack_level: 堆栈回溯的级别，0表示当前函数，1表示调用者，依此类推
-
-    Returns:
-        (filename, line_number, function_name, module_name) 元组
-    """
-    # 堆栈级别需要加3:
-    # +1 因为这个函数本身占一层
-    # +1 因为日志函数(debug, info等)占一层
-    # +1 因为下面调用 inspect.stack() 也占一层
-    frame = inspect.currentframe()
-    try:
-        # 跳过适当的堆栈帧
-        for _ in range(stack_level + 3):
-            if frame and frame.f_back:
-                frame = frame.f_back
-            else:
-                break
-
-        if frame:
-            filename = frame.f_code.co_filename if frame.f_code else "unknown"
-            line_number = frame.f_lineno if hasattr(frame, "f_lineno") else 0
-            function_name = frame.f_code.co_name if frame.f_code else "unknown"
-
-            # 获取模块名称
-            module_name = "unknown"
-            if frame.f_globals and "__name__" in frame.f_globals:
-                module_name = frame.f_globals["__name__"].rsplit(".", 1)[0]
-
-            return (filename, line_number, function_name, module_name)
-        return ("unknown", 0, "unknown", "unknown")
-    finally:
-        del frame  # 避免循环引用
-
-
-# 便捷日志记录函数
-def debug(msg, *args, stack_level=0, **kwargs):
-    """
-    记录DEBUG级别日志
-
-    Args:
-        msg: 日志消息
-        stack_level: 堆栈回溯级别，用于定位日志的实际调用位置
-        *args, **kwargs: 传递给logger.debug的其他参数
-    """
-    # 获取调用者信息
-    if stack_level > 0:
-        caller_info = _get_caller_info(stack_level)
-        extra = kwargs.get("extra", {})
-        extra["custom_stack_info"] = caller_info
-        kwargs["extra"] = extra
-    logger.debug(msg, *args, **kwargs)
-
-
-def info(msg, *args, stack_level=0, **kwargs):
-    """
-    记录INFO级别日志
-
-    Args:
-        msg: 日志消息
-        stack_level: 堆栈回溯级别，用于定位日志的实际调用位置
-        *args, **kwargs: 传递给logger.info的其他参数
-    """
-    if stack_level > 0:
-        caller_info = _get_caller_info(stack_level)
-        extra = kwargs.get("extra", {})
-        extra["custom_stack_info"] = caller_info
-        kwargs["extra"] = extra
-    logger.info(msg, *args, **kwargs)
-
-
-def warning(msg, *args, stack_level=0, **kwargs):
-    """
-    记录WARNING级别日志
-
-    Args:
-        msg: 日志消息
-        stack_level: 堆栈回溯级别，用于定位日志的实际调用位置
-        *args, **kwargs: 传递给logger.warning的其他参数
-    """
-    if stack_level > 0:
-        caller_info = _get_caller_info(stack_level)
-        extra = kwargs.get("extra", {})
-        extra["custom_stack_info"] = caller_info
-        kwargs["extra"] = extra
-    logger.warning(msg, *args, **kwargs)
-
-
-def error(msg, *args, stack_level=0, **kwargs):
-    """
-    记录ERROR级别日志
-
-    Args:
-        msg: 日志消息
-        stack_level: 堆栈回溯级别，用于定位日志的实际调用位置
-        *args, **kwargs: 传递给logger.error的其他参数
-    """
-    if stack_level > 0:
-        caller_info = _get_caller_info(stack_level)
-        extra = kwargs.get("extra", {})
-        extra["custom_stack_info"] = caller_info
-        kwargs["extra"] = extra
-    logger.error(msg, *args, **kwargs)
-
-
-def critical(msg, *args, stack_level=0, **kwargs):
-    """
-    记录CRITICAL级别日志
-
-    Args:
-        msg: 日志消息
-        stack_level: 堆栈回溯级别，用于定位日志的实际调用位置
-        *args, **kwargs: 传递给logger.critical的其他参数
-    """
-    if stack_level > 0:
-        caller_info = _get_caller_info(stack_level)
-        extra = kwargs.get("extra", {})
-        extra["custom_stack_info"] = caller_info
-        kwargs["extra"] = extra
-    logger.critical(msg, *args, **kwargs)
-
-
-def trace(msg, *args, stack_level=0, **kwargs):
-    """
-    记录TRACE级别日志（比DEBUG级别更低）
-
-    Args:
-        msg: 日志消息
-        stack_level: 堆栈回溯级别，用于定位日志的实际调用位置
-        *args, **kwargs: 传递给logger.log的其他参数
-    """
-    if stack_level > 0:
-        caller_info = _get_caller_info(stack_level)
-        extra = kwargs.get("extra", {})
-        extra["custom_stack_info"] = caller_info
-        kwargs["extra"] = extra
-    logger.log(TRACE_LEVEL, msg, *args, **kwargs)
-
-
-logger.trace = trace
-
-# 测试日志输出（如果直接运行此文件）
-if __name__ == "__main__":
-    print("测试不同日志级别的颜色输出:")
-    trace("这是一条跟踪日志 (TRACE级别显示为深灰色，其他文本也为深灰色)")
-    debug("这是一条调试日志 (DEBUG级别显示为蓝色，其他文本为灰色)")
-    info("这是一条信息日志 (INFO级别显示为绿色，其他文本为白色)")
-    warning("这是一条警告日志 (WARNING级别显示为黄色，其他文本也为黄色)")
-    error("这是一条错误日志 (ERROR级别显示为红色，其他文本也为红色)")
-    critical("这是一条严重错误日志 (CRITICAL级别显示为紫色，其他文本也为紫色)")
-    # 测试异常输出
-    try:
-        1 / 0
-    except Exception as e:
-        error(f"发生错误: {e}", exc_info=True)

unilabos/utils/log.py

@@ -191,23 +191,9 @@ def configure_logger(loglevel=None, working_dir=None):
 
     # 添加处理器到根日志记录器
     root_logger.addHandler(console_handler)
-    
-    # 降低第三方库的日志级别，避免过多输出
-    # pymodbus 库的日志太详细，设置为 WARNING
-    logging.getLogger('pymodbus').setLevel(logging.WARNING)
-    logging.getLogger('pymodbus.logging').setLevel(logging.WARNING)
-    logging.getLogger('pymodbus.logging.base').setLevel(logging.WARNING)
-    logging.getLogger('pymodbus.logging.decoders').setLevel(logging.WARNING)
-    
-    # websockets 库的日志输出较多，设置为 WARNING
-    logging.getLogger('websockets').setLevel(logging.WARNING)
-    logging.getLogger('websockets.client').setLevel(logging.WARNING)
-    logging.getLogger('websockets.server').setLevel(logging.WARNING)
-    
-    # ROS 节点的状态更新日志过于频繁，设置为 INFO
-    logging.getLogger('unilabos.ros.nodes.presets.host_node').setLevel(logging.INFO)
 
     # 如果指定了工作目录，添加文件处理器
+    log_filepath = None
     if working_dir is not None:
         logs_dir = os.path.join(working_dir, "logs")
         os.makedirs(logs_dir, exist_ok=True)
@@ -228,6 +214,7 @@ def configure_logger(loglevel=None, working_dir=None):
 
     logging.getLogger("asyncio").setLevel(logging.INFO)
     logging.getLogger("urllib3").setLevel(logging.INFO)
+    return log_filepath
 
 
 # 配置日志系统

unilabos/workflow/from_python_script.py

@@ -1,241 +0,0 @@
-import ast
-import json
-from typing import Dict, List, Any, Tuple, Optional
-
-from .common import WorkflowGraph, RegistryAdapter
-
-Json = Dict[str, Any]
-
-# ---------------- Converter ----------------
-
-class DeviceMethodConverter:
-    """
-    - 字段统一：resource_name（原 device_class）、template_name（原 action_key）
-    - params 单层；inputs 使用 'params.' 前缀
-    - SimpleGraph.add_workflow_node 负责变量连线与边
-    """
-    def __init__(self, device_registry: Optional[Dict[str, Any]] = None):
-        self.graph = WorkflowGraph()
-        self.variable_sources: Dict[str, Dict[str, Any]] = {}        # var -> {node_id, output_name}
-        self.instance_to_resource: Dict[str, Optional[str]] = {}     # 实例名 -> resource_name
-        self.node_id_counter: int = 0
-        self.registry = RegistryAdapter(device_registry or {})
-
-    # ---- helpers ----
-    def _new_node_id(self) -> int:
-        nid = self.node_id_counter
-        self.node_id_counter += 1
-        return nid
-
-    def _assign_targets(self, targets) -> List[str]:
-        names: List[str] = []
-        import ast
-        if isinstance(targets, ast.Tuple):
-            for elt in targets.elts:
-                if isinstance(elt, ast.Name):
-                    names.append(elt.id)
-        elif isinstance(targets, ast.Name):
-            names.append(targets.id)
-        return names
-
-    def _extract_device_instantiation(self, node) -> Optional[Tuple[str, str]]:
-        import ast
-        if not isinstance(node.value, ast.Call):
-            return None
-        callee = node.value.func
-        if isinstance(callee, ast.Name):
-            class_name = callee.id
-        elif isinstance(callee, ast.Attribute) and isinstance(callee.value, ast.Name):
-            class_name = callee.attr
-        else:
-            return None
-        if isinstance(node.targets[0], ast.Name):
-            instance = node.targets[0].id
-            return instance, class_name
-        return None
-
-    def _extract_call(self, call) -> Tuple[str, str, Dict[str, Any], str]:
-        import ast
-        owner_name, method_name, call_kind = "", "", "func"
-        if isinstance(call.func, ast.Attribute):
-            method_name = call.func.attr
-            if isinstance(call.func.value, ast.Name):
-                owner_name = call.func.value.id
-                call_kind = "instance" if owner_name in self.instance_to_resource else "class_or_module"
-            elif isinstance(call.func.value, ast.Attribute) and isinstance(call.func.value.value, ast.Name):
-                owner_name = call.func.value.attr
-                call_kind = "class_or_module"
-        elif isinstance(call.func, ast.Name):
-            method_name = call.func.id
-            call_kind = "func"
-
-        def pack(node):
-            if isinstance(node, ast.Name):
-                return {"type": "variable", "value": node.id}
-            if isinstance(node, ast.Constant):
-                return {"type": "constant", "value": node.value}
-            if isinstance(node, ast.Dict):
-                return {"type": "dict", "value": self._parse_dict(node)}
-            if isinstance(node, ast.List):
-                return {"type": "list", "value": self._parse_list(node)}
-            return {"type": "raw", "value": ast.unparse(node) if hasattr(ast, "unparse") else str(node)}
-
-        args: Dict[str, Any] = {}
-        pos: List[Any] = []
-        for a in call.args:
-            pos.append(pack(a))
-        for kw in call.keywords:
-            args[kw.arg] = pack(kw.value)
-        if pos:
-            args["_positional"] = pos
-        return owner_name, method_name, args, call_kind
-
-    def _parse_dict(self, node) -> Dict[str, Any]:
-        import ast
-        out: Dict[str, Any] = {}
-        for k, v in zip(node.keys, node.values):
-            if isinstance(k, ast.Constant):
-                key = str(k.value)
-                if isinstance(v, ast.Name):
-                    out[key] = f"var:{v.id}"
-                elif isinstance(v, ast.Constant):
-                    out[key] = v.value
-                elif isinstance(v, ast.Dict):
-                    out[key] = self._parse_dict(v)
-                elif isinstance(v, ast.List):
-                    out[key] = self._parse_list(v)
-        return out
-
-    def _parse_list(self, node) -> List[Any]:
-        import ast
-        out: List[Any] = []
-        for elt in node.elts:
-            if isinstance(elt, ast.Name):
-                out.append(f"var:{elt.id}")
-            elif isinstance(elt, ast.Constant):
-                out.append(elt.value)
-            elif isinstance(elt, ast.Dict):
-                out.append(self._parse_dict(elt))
-            elif isinstance(elt, ast.List):
-                out.append(self._parse_list(elt))
-        return out
-
-    def _normalize_var_tokens(self, x: Any) -> Any:
-        if isinstance(x, str) and x.startswith("var:"):
-            return {"__var__": x[4:]}
-        if isinstance(x, list):
-            return [self._normalize_var_tokens(i) for i in x]
-        if isinstance(x, dict):
-            return {k: self._normalize_var_tokens(v) for k, v in x.items()}
-        return x
-
-    def _make_params_payload(self, resource_name: Optional[str], template_name: str, call_args: Dict[str, Any]) -> Dict[str, Any]:
-        input_keys = self.registry.get_action_input_keys(resource_name, template_name) if resource_name else []
-        defaults = self.registry.get_action_goal_default(resource_name, template_name) if resource_name else {}
-        params: Dict[str, Any] = dict(defaults)
-
-        def unpack(p):
-            t, v = p.get("type"), p.get("value")
-            if t == "variable":
-                return {"__var__": v}
-            if t == "dict":
-                return self._normalize_var_tokens(v)
-            if t == "list":
-                return self._normalize_var_tokens(v)
-            return v
-
-        for k, p in call_args.items():
-            if k == "_positional":
-                continue
-            params[k] = unpack(p)
-
-        pos = call_args.get("_positional", [])
-        if pos:
-            if input_keys:
-                for i, p in enumerate(pos):
-                    if i >= len(input_keys):
-                        break
-                    name = input_keys[i]
-                    if name in params:
-                        continue
-                    params[name] = unpack(p)
-            else:
-                for i, p in enumerate(pos):
-                    params[f"arg_{i}"] = unpack(p)
-        return params
-
-    # ---- handlers ----
-    def _on_assign(self, stmt):
-        import ast
-        inst = self._extract_device_instantiation(stmt)
-        if inst:
-            instance, code_class = inst
-            resource_name = self.registry.resolve_resource_by_classname(code_class)
-            self.instance_to_resource[instance] = resource_name
-            return
-
-        if isinstance(stmt.value, ast.Call):
-            owner, method, call_args, kind = self._extract_call(stmt.value)
-            if kind == "instance":
-                device_key = owner
-                resource_name = self.instance_to_resource.get(owner)
-            else:
-                device_key = owner
-                resource_name = self.registry.resolve_resource_by_classname(owner)
-
-            module = self.registry.get_device_module(resource_name)
-            params = self._make_params_payload(resource_name, method, call_args)
-
-            nid = self._new_node_id()
-            self.graph.add_workflow_node(
-                nid,
-                device_key=device_key,
-                resource_name=resource_name,      # ✅
-                module=module,
-                template_name=method,             # ✅
-                params=params,
-                variable_sources=self.variable_sources,
-                add_ready_if_no_vars=True,
-                prev_node_id=(nid - 1) if nid > 0 else None,
-            )
-
-            out_vars = self._assign_targets(stmt.targets[0])
-            for var in out_vars:
-                self.variable_sources[var] = {"node_id": nid, "output_name": "result"}
-
-    def _on_expr(self, stmt):
-        import ast
-        if not isinstance(stmt.value, ast.Call):
-            return
-        owner, method, call_args, kind = self._extract_call(stmt.value)
-        if kind == "instance":
-            device_key = owner
-            resource_name = self.instance_to_resource.get(owner)
-        else:
-            device_key = owner
-            resource_name = self.registry.resolve_resource_by_classname(owner)
-
-        module = self.registry.get_device_module(resource_name)
-        params = self._make_params_payload(resource_name, method, call_args)
-
-        nid = self._new_node_id()
-        self.graph.add_workflow_node(
-            nid,
-            device_key=device_key,
-            resource_name=resource_name,      # ✅
-            module=module,
-            template_name=method,             # ✅
-            params=params,
-            variable_sources=self.variable_sources,
-            add_ready_if_no_vars=True,
-            prev_node_id=(nid - 1) if nid > 0 else None,
-        )
-
-    def convert(self, python_code: str):
-        tree = ast.parse(python_code)
-        for stmt in tree.body:
-            if isinstance(stmt, ast.Assign):
-                self._on_assign(stmt)
-            elif isinstance(stmt, ast.Expr):
-                self._on_expr(stmt)
-        return self

unilabos/workflow/from_xdl.py

@@ -1,131 +0,0 @@
-from typing import List, Any, Dict
-import xml.etree.ElementTree as ET
-
-
-def convert_to_type(val: str) -> Any:
-    """将字符串值转换为适当的数据类型"""
-    if val == "True":
-        return True
-    if val == "False":
-        return False
-    if val == "?":
-        return None
-    if val.endswith(" g"):
-        return float(val.split(" ")[0])
-    if val.endswith("mg"):
-        return float(val.split("mg")[0])
-    elif val.endswith("mmol"):
-        return float(val.split("mmol")[0]) / 1000
-    elif val.endswith("mol"):
-        return float(val.split("mol")[0])
-    elif val.endswith("ml"):
-        return float(val.split("ml")[0])
-    elif val.endswith("RPM"):
-        return float(val.split("RPM")[0])
-    elif val.endswith(" °C"):
-        return float(val.split(" ")[0])
-    elif val.endswith(" %"):
-        return float(val.split(" ")[0])
-    return val
-
-
-def flatten_xdl_procedure(procedure_elem: ET.Element) -> List[ET.Element]:
-    """展平嵌套的XDL程序结构"""
-    flattened_operations = []
-    TEMP_UNSUPPORTED_PROTOCOL = ["Purge", "Wait", "Stir", "ResetHandling"]
-
-    def extract_operations(element: ET.Element):
-        if element.tag not in ["Prep", "Reaction", "Workup", "Purification", "Procedure"]:
-            if element.tag not in TEMP_UNSUPPORTED_PROTOCOL:
-                flattened_operations.append(element)
-
-        for child in element:
-            extract_operations(child)
-
-    for child in procedure_elem:
-        extract_operations(child)
-
-    return flattened_operations
-
-
-def parse_xdl_content(xdl_content: str) -> tuple:
-    """解析XDL内容"""
-    try:
-        xdl_content_cleaned = "".join(c for c in xdl_content if c.isprintable())
-        root = ET.fromstring(xdl_content_cleaned)
-
-        synthesis_elem = root.find("Synthesis")
-        if synthesis_elem is None:
-            return None, None, None
-
-        # 解析硬件组件
-        hardware_elem = synthesis_elem.find("Hardware")
-        hardware = []
-        if hardware_elem is not None:
-            hardware = [{"id": c.get("id"), "type": c.get("type")} for c in hardware_elem.findall("Component")]
-
-        # 解析试剂
-        reagents_elem = synthesis_elem.find("Reagents")
-        reagents = []
-        if reagents_elem is not None:
-            reagents = [{"name": r.get("name"), "role": r.get("role", "")} for r in reagents_elem.findall("Reagent")]
-
-        # 解析程序
-        procedure_elem = synthesis_elem.find("Procedure")
-        if procedure_elem is None:
-            return None, None, None
-
-        flattened_operations = flatten_xdl_procedure(procedure_elem)
-        return hardware, reagents, flattened_operations
-
-    except ET.ParseError as e:
-        raise ValueError(f"Invalid XDL format: {e}")
-
-
-def convert_xdl_to_dict(xdl_content: str) -> Dict[str, Any]:
-    """
-    将XDL XML格式转换为标准的字典格式
-
-    Args:
-        xdl_content: XDL XML内容
-
-    Returns:
-        转换结果，包含步骤和器材信息
-    """
-    try:
-        hardware, reagents, flattened_operations = parse_xdl_content(xdl_content)
-        if hardware is None:
-            return {"error": "Failed to parse XDL content", "success": False}
-
-        # 将XDL元素转换为字典格式
-        steps_data = []
-        for elem in flattened_operations:
-            # 转换参数类型
-            parameters = {}
-            for key, val in elem.attrib.items():
-                converted_val = convert_to_type(val)
-                if converted_val is not None:
-                    parameters[key] = converted_val
-
-            step_dict = {
-                "operation": elem.tag,
-                "parameters": parameters,
-                "description": elem.get("purpose", f"Operation: {elem.tag}"),
-            }
-            steps_data.append(step_dict)
-
-        # 合并硬件和试剂为统一的labware_info格式
-        labware_data = []
-        labware_data.extend({"id": hw["id"], "type": "hardware", **hw} for hw in hardware)
-        labware_data.extend({"name": reagent["name"], "type": "reagent", **reagent} for reagent in reagents)
-
-        return {
-            "success": True,
-            "steps": steps_data,
-            "labware": labware_data,
-            "message": f"Successfully converted XDL to dict format. Found {len(steps_data)} steps and {len(labware_data)} labware items.",
-        }
-
-    except Exception as e:
-        error_msg = f"XDL conversion failed: {str(e)}"
-        return {"error": error_msg, "success": False}

unilabos_msgs/package.xml

@@ -2,7 +2,7 @@
 <?xml-model href="http://download.ros.org/schema/package_format3.xsd" schematypens="http://www.w3.org/2001/XMLSchema"?>
 <package format="3">
   <name>unilabos_msgs</name>
-  <version>0.10.19</version>
+  <version>0.11.0</version>
   <description>ROS2 Messages package for unilabos devices</description>
   <maintainer email="changjh@pku.edu.cn">Junhan Chang</maintainer>
   <maintainer email="18435084+Xuwznln@users.noreply.github.com">Xuwznln</maintainer>