From 78729ef86c58c2ffd103c095457ee2d2134f8bfc Mon Sep 17 00:00:00 2001 From: Andy6M Date: Wed, 14 Jan 2026 09:55:25 +0800 Subject: [PATCH] feat(workstation): update bioyond config migration and coin cell material search logic MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Migrate bioyond_cell config to JSON structure and remove global variable dependencies - Implement material search confirmation dialog auto-handling - Add documentation: 20260113_物料搜寻确认弹窗自动处理功能.md and 20260113_配置迁移修改总结.md --- .../bioyond_cell/20251229_多订单返回说明.md | 113 + .../bioyond_cell/20260108_multi_batch1.xlsx | Bin 0 -> 10380 bytes .../bioyond_cell/20260108_multi_batch2.xlsx | Bin 0 -> 10367 bytes .../bioyond_cell/202601091.xlsx | Bin 0 -> 10149 bytes .../bioyond_cell/20260113_JSON配置迁移经验.md | 204 + .../bioyond_cell/20260113_配置迁移修改总结.md | 312 + .../bioyond_cell/bioyond_cell_workstation.py | 2112 +++ .../bioyond_cell/material_template.xlsx | Bin 0 -> 10674 bytes .../bioyond_cell/smiles&molweight.py | 12 + .../bioyond_cell/solid_materials.csv | 7 + .../workstation/bioyond_studio/bioyond_rpc.py | 5 +- .../workstation/bioyond_studio/config.py | 142 - .../workstation/bioyond_studio/station.py | 33 +- .../20251230_Modbus_CSV_Mapping_Guide.md | 84 + .../20260113_物料搜寻确认弹窗自动处理功能.md | 352 + .../coin_cell_assembly/YB_YH_materials.py | 645 + .../button_battery_station.py | 1289 -- .../coin_cell_assembly/coin_cell_assembly.py | 1350 +- .../coin_cell_assembly_20260112.xlsx | Bin 0 -> 18578 bytes .../coin_cell_assembly_b.csv | 133 + .../coin_cell_assembly/new_cellconfig4.json | 14472 ---------------- unilabos/registry/devices/bioyond_cell.yaml | 847 + .../devices/coin_cell_workstation.yaml | 850 + .../bioyond/README_RESOURCE_ARCHITECTURE.md | 170 + .../registry/resources/bioyond/YB_bottle.yaml | 92 + .../resources/bioyond/YB_bottle_carriers.yaml | 182 + unilabos/registry/resources/bioyond/deck.yaml | 16 +- unilabos/resources/battery/__init__.py | 0 unilabos/resources/battery/bottle_carriers.py | 56 + unilabos/resources/battery/electrode_sheet.py | 195 + unilabos/resources/battery/magazine.py | 344 + .../resources/bioyond/README_WAREHOUSE.md | 548 + .../resources/bioyond/YB_bottle_carriers.py | 653 + unilabos/resources/bioyond/YB_bottles.py | 163 + unilabos/resources/bioyond/YB_warehouses.py | 384 + unilabos/resources/bioyond/decks.py | 14 +- unilabos/resources/itemized_carrier.py | 3 +- unilabos/resources/warehouse.py | 5 +- unilabos/ros/nodes/presets/host_node.py | 2 +- unilabos/utils/README_LOGGING.md | 187 + unilabos/utils/log.py | 16 + yibin_electrolyte_config_example.json | 126 + 42 files changed, 10013 insertions(+), 16105 deletions(-) create mode 100644 unilabos/devices/workstation/bioyond_studio/bioyond_cell/20251229_多订单返回说明.md create mode 100644 unilabos/devices/workstation/bioyond_studio/bioyond_cell/20260108_multi_batch1.xlsx create mode 100644 unilabos/devices/workstation/bioyond_studio/bioyond_cell/20260108_multi_batch2.xlsx create mode 100644 unilabos/devices/workstation/bioyond_studio/bioyond_cell/202601091.xlsx create mode 100644 unilabos/devices/workstation/bioyond_studio/bioyond_cell/20260113_JSON配置迁移经验.md create mode 100644 unilabos/devices/workstation/bioyond_studio/bioyond_cell/20260113_配置迁移修改总结.md create mode 100644 unilabos/devices/workstation/bioyond_studio/bioyond_cell/bioyond_cell_workstation.py create mode 100644 unilabos/devices/workstation/bioyond_studio/bioyond_cell/material_template.xlsx create mode 100644 unilabos/devices/workstation/bioyond_studio/bioyond_cell/smiles&molweight.py create mode 100644 unilabos/devices/workstation/bioyond_studio/bioyond_cell/solid_materials.csv delete mode 100644 unilabos/devices/workstation/bioyond_studio/config.py create mode 100644 unilabos/devices/workstation/coin_cell_assembly/20251230_Modbus_CSV_Mapping_Guide.md create mode 100644 unilabos/devices/workstation/coin_cell_assembly/20260113_物料搜寻确认弹窗自动处理功能.md create mode 100644 unilabos/devices/workstation/coin_cell_assembly/YB_YH_materials.py delete mode 100644 unilabos/devices/workstation/coin_cell_assembly/button_battery_station.py create mode 100644 unilabos/devices/workstation/coin_cell_assembly/coin_cell_assembly_20260112.xlsx create mode 100644 unilabos/devices/workstation/coin_cell_assembly/coin_cell_assembly_b.csv delete mode 100644 unilabos/devices/workstation/coin_cell_assembly/new_cellconfig4.json create mode 100644 unilabos/registry/devices/bioyond_cell.yaml create mode 100644 unilabos/registry/devices/coin_cell_workstation.yaml create mode 100644 unilabos/registry/resources/bioyond/README_RESOURCE_ARCHITECTURE.md create mode 100644 unilabos/registry/resources/bioyond/YB_bottle.yaml create mode 100644 unilabos/registry/resources/bioyond/YB_bottle_carriers.yaml create mode 100644 unilabos/resources/battery/__init__.py create mode 100644 unilabos/resources/battery/bottle_carriers.py create mode 100644 unilabos/resources/battery/electrode_sheet.py create mode 100644 unilabos/resources/battery/magazine.py create mode 100644 unilabos/resources/bioyond/README_WAREHOUSE.md create mode 100644 unilabos/resources/bioyond/YB_bottle_carriers.py create mode 100644 unilabos/resources/bioyond/YB_bottles.py create mode 100644 unilabos/resources/bioyond/YB_warehouses.py create mode 100644 unilabos/utils/README_LOGGING.md create mode 100644 yibin_electrolyte_config_example.json diff --git a/unilabos/devices/workstation/bioyond_studio/bioyond_cell/20251229_多订单返回说明.md b/unilabos/devices/workstation/bioyond_studio/bioyond_cell/20251229_多订单返回说明.md new file mode 100644 index 0000000..baecac9 --- /dev/null +++ b/unilabos/devices/workstation/bioyond_studio/bioyond_cell/20251229_多订单返回说明.md @@ -0,0 +1,113 @@ +# Bioyond Cell 工作站 - 多订单返回示例 + +本文档说明了 `create_orders` 函数如何收集并返回所有订单的完成报文。 + +## 问题描述 + +之前的实现只会等待并返回第一个订单的完成报文，如果有多个订单（例如从 Excel 解析出 3 个订单），只能得到第一个订单的推送信息。 + +## 解决方案 + +修改后的 `create_orders` 函数现在会： + +1. **提取所有 orderCode**：从 LIMS 接口返回的 `data` 列表中提取所有订单编号 +2. **逐个等待完成**：遍历所有 orderCode，调用 `wait_for_order_finish` 等待每个订单完成 +3. **收集所有报文**：将每个订单的完成报文存入 `all_reports` 列表 +4. **统一返回**：返回包含所有订单报文的 JSON 格式数据 + +## 返回格式 + +```json +{ + "status": "all_completed", + "total_orders": 3, + "reports": [ + { + "token": "", + "request_time": "2025-12-24T15:32:09.2148671+08:00", + "data": { + "orderId": "3a1e614d-a082-c44a-60be-68647a35e6f1", + "orderCode": "BSO2025122400024", + "orderName": "DP20251224001", + "status": "30", + "workflowStatus": "completed", + "usedMaterials": [...] + } + }, + { + "token": "", + "request_time": "2025-12-24T15:32:09.9999039+08:00", + "data": { + "orderId": "3a1e614d-a0a2-f7a9-9360-610021c9479d", + "orderCode": "BSO2025122400025", + "orderName": "DP20251224002", + "status": "30", + "workflowStatus": "completed", + "usedMaterials": [...] + } + }, + { + "token": "", + "request_time": "2025-12-24T15:34:00.4139986+08:00", + "data": { + "orderId": "3a1e614d-a0cd-81ca-9f7f-2f4e93af01cd", + "orderCode": "BSO2025122400026", + "orderName": "DP20251224003", + "status": "30", + "workflowStatus": "completed", + "usedMaterials": [...] + } + } + ], + "original_response": {...} +} +``` + +## 使用示例 + +```python +# 调用 create_orders +result = workstation.create_orders("20251224.xlsx") + +# 访问返回数据 +print(f"总订单数: {result['total_orders']}") +print(f"状态: {result['status']}") + +# 遍历所有订单的报文 +for i, report in enumerate(result['reports'], 1): + order_data = report.get('data', {}) + print(f"\n订单 {i}:") + print(f" orderCode: {order_data.get('orderCode')}") + print(f" orderName: {order_data.get('orderName')}") + print(f" status: {order_data.get('status')}") + print(f" 使用物料数: {len(order_data.get('usedMaterials', []))}") +``` + +## 控制台输出示例 + +``` +[create_orders] 即将提交订单数量: 3 +[create_orders] 接口返回: {...} +[create_orders] 等待 3 个订单完成: ['BSO2025122400024', 'BSO2025122400025', 'BSO2025122400026'] +[create_orders] 正在等待第 1/3 个订单: BSO2025122400024 +[create_orders] ✓ 订单 BSO2025122400024 完成 +[create_orders] 正在等待第 2/3 个订单: BSO2025122400025 +[create_orders] ✓ 订单 BSO2025122400025 完成 +[create_orders] 正在等待第 3/3 个订单: BSO2025122400026 +[create_orders] ✓ 订单 BSO2025122400026 完成 +[create_orders] 所有订单已完成，共收集 3 个报文 +实验记录本========================create_orders======================== +返回报文数量: 3 +报文 1: orderCode=BSO2025122400024, status=30 +报文 2: orderCode=BSO2025122400025, status=30 +报文 3: orderCode=BSO2025122400026, status=30 +======================== +``` + +## 关键改进 + +1. ✅ **等待所有订单**：不再只等待第一个订单，而是遍历所有 orderCode +2. ✅ **收集完整报文**：每个订单的完整推送报文都被保存在 `reports` 数组中 +3. ✅ **详细日志**：清晰显示正在等待哪个订单，以及完成情况 +4. ✅ **错误处理**：即使某个订单失败，也会记录其状态信息 +5. ✅ **统一格式**：返回的 JSON 格式便于后续处理和分析 diff --git a/unilabos/devices/workstation/bioyond_studio/bioyond_cell/20260108_multi_batch1.xlsx b/unilabos/devices/workstation/bioyond_studio/bioyond_cell/20260108_multi_batch1.xlsx new file mode 100644 index 0000000000000000000000000000000000000000..3bd3439954b0fd2a9f47bff32832ab6f4c081d5d GIT binary patch literal 10380 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 Mg2u)=n%{o?KY37~>Hq)$ literal 0 HcmV?d00001 diff --git a/unilabos/devices/workstation/bioyond_studio/bioyond_cell/20260108_multi_batch2.xlsx b/unilabos/devices/workstation/bioyond_studio/bioyond_cell/20260108_multi_batch2.xlsx new file mode 100644 index 0000000000000000000000000000000000000000..9ed74ec2a5cedd89b0be49d6b51f41bbe3e647ab GIT binary patch literal 10367 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 literal 0 HcmV?d00001 diff --git a/unilabos/devices/workstation/bioyond_studio/bioyond_cell/202601091.xlsx b/unilabos/devices/workstation/bioyond_studio/bioyond_cell/202601091.xlsx new file mode 100644 index 0000000000000000000000000000000000000000..9088a16ae42e97f3319e4a0b83882ba690962975 GIT binary patch literal 10149 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 Ur^jz+doTbUaBUo+`|aKT07o<`HUIzs literal 0 HcmV?d00001 diff --git a/unilabos/devices/workstation/bioyond_studio/bioyond_cell/20260113_JSON配置迁移经验.md b/unilabos/devices/workstation/bioyond_studio/bioyond_cell/20260113_JSON配置迁移经验.md new file mode 100644 index 0000000..c48cd43 --- /dev/null +++ b/unilabos/devices/workstation/bioyond_studio/bioyond_cell/20260113_JSON配置迁移经验.md @@ -0,0 +1,204 @@ +# BioyondCellWorkstation JSON 配置迁移经验总结 + +**日期**: 2026-01-13 +**目的**: 从 `config.py` 迁移到 JSON 配置文件 + +--- + +## 问题背景 + +原系统通过 `config.py` 管理配置，导致： +1. HTTP 服务重复启动（父类 `BioyondWorkstation` 和子类都启动） +2. 配置分散在代码中，不便于管理 +3. 无法通过 JSON 统一配置所有参数 + +--- + +## 解决方案：嵌套配置结构 + +### JSON 结构设计 + +**正确示例** (嵌套在 `config` 中): +```json +{ + "nodes": [{ + "id": "bioyond_cell_workstation", + "config": { + "deck": {...}, + "protocol_type": [], + "bioyond_config": { + "api_host": "http://172.16.11.219:44388", + "api_key": "8A819E5C", + "timeout": 30, + "HTTP_host": "172.16.11.206", + "HTTP_port": 8080, + "debug_mode": false, + "material_type_mappings": {...}, + "warehouse_mapping": {...}, + "solid_liquid_mappings": {...} + } + }, + "data": {} + }] +} +``` + +**关键点**： +- ✅ `bioyond_config` 放在 `config` 中（会传递到 `__init__`） +- ❌ **不要**放在 `data` 中（`data` 是运行时状态，不会传递） + +--- + +## Python 代码适配 + +### 1. 修改 `BioyondCellWorkstation.__init__` 签名 + +**文件**: `bioyond_cell_workstation.py` + +```python +def __init__(self, bioyond_config: dict = None, deck=None, protocol_type=None, **kwargs): + """ + Args: + bioyond_config: 从 JSON 加载的配置字典 + deck: Deck 配置 + protocol_type: 协议类型 + """ + # 验证配置 + if bioyond_config is None: + raise ValueError("需要 bioyond_config 参数") + + # 保存配置 + self.bioyond_config = bioyond_config + + # 设置 HTTP 服务去重标志 + self.bioyond_config["_disable_auto_http_service"] = True + + # 调用父类 + super().__init__(bioyond_config=self.bioyond_config, deck=deck, **kwargs) +``` + +### 2. 替换全局变量引用 + +**修改前**（使用全局变量）: +```python +from config import MATERIAL_TYPE_MAPPINGS, WAREHOUSE_MAPPING + +def create_sample(self, board_type, ...): + carrier_type_id = MATERIAL_TYPE_MAPPINGS[board_type][1] + location_id = WAREHOUSE_MAPPING[warehouse_name]["site_uuids"][location_code] +``` + +**修改后**（从配置读取）: +```python +def create_sample(self, board_type, ...): + carrier_type_id = self.bioyond_config['material_type_mappings'][board_type][1] + location_id = self.bioyond_config['warehouse_mapping'][warehouse_name]["site_uuids"][location_code] +``` + +### 3. 修复父类配置访问 + +在 `station.py` 中安全访问配置默认值： + +```python +# 修改前（会 KeyError） +self._http_service_config = { + "host": bioyond_config.get("http_service_host", HTTP_SERVICE_CONFIG["http_service_host"]) +} + +# 修改后（安全访问） +self._http_service_config = { + "host": bioyond_config.get("http_service_host", HTTP_SERVICE_CONFIG.get("http_service_host", "")) +} +``` + +--- + +## 常见陷阱 + +### ❌ 错误1：将配置放在 `data` 字段 +```json +"config": {"deck": {...}}, +"data": {"bioyond_config": {...}} // ❌ 不会传递到 __init__ +``` + +### ❌ 错误2：扁平化配置（已废弃方案） +虽然扁平化也能工作，但不推荐： +```json +"config": { + "deck": {...}, + "api_host": "...", // ❌ 不够清晰 + "api_key": "...", + "HTTP_host": "..." +} +``` + +### ❌ 错误3：忘记替换全局变量引用 +代码中直接使用 `MATERIAL_TYPE_MAPPINGS` 等全局变量会导致 `NameError`。 + +--- + +## 云端同步注意事项 + +使用 `--upload_registry` 时，云端配置可能覆盖本地配置： +- 首次上传时确保 JSON 完整 +- 或使用新的 `ak/sk` 避免旧配置干扰 +- 调试时可暂时移除 `--upload_registry` 参数 + +--- + +## 验证清单 + +启动成功后应看到： +``` +✅ 从 JSON 配置加载 bioyond_config 成功 + API Host: http://... + HTTP Service: ... +✅ BioyondCellWorkstation 初始化完成 +Loaded ResourceTreeSet with ... nodes +``` + +运行时不应出现： +- ❌ `NameError: name 'MATERIAL_TYPE_MAPPINGS' is not defined` +- ❌ `KeyError: 'http_service_host'` +- ❌ `bioyond_config 缺少必需参数` + +--- + +## 调试经验 + +1. **添加调试日志**查看参数传递链路： + - `graphio.py`: JSON 加载后的 config 内容 + - `initialize_device.py`: `device_config.res_content.config` 的键 + - `bioyond_cell_workstation.py`: `__init__` 接收到的参数 + +2. **config vs data 区别**： + - `config`: 初始化参数，传递给 `__init__` + - `data`: 运行时状态，不传递给 `__init__` + +3. **参数名必须匹配**： + - JSON 中的键名必须与 `__init__` 参数名完全一致 + +4. **调试代码清理**：完成后记得删除调试日志（🔍 DEBUG 标记） + +--- + +## 修改文件清单 + +| 文件 | 修改内容 | +|------|----------| +| `yibin_electrolyte_config.json` | 创建嵌套 `config.bioyond_config` 结构 | +| `bioyond_cell_workstation.py` | 修改 `__init__` 接收 `bioyond_config`，替换所有全局变量引用 | +| `station.py` | 安全访问 `HTTP_SERVICE_CONFIG` 默认值 | + +--- + +## 参考代码位置 + +- JSON 配置示例: `yibin_electrolyte_config.json` L12-L353 +- `__init__` 实现: `bioyond_cell_workstation.py` L39-L94 +- 全局变量替换示例: `bioyond_cell_workstation.py` L2005, L1863, L1966 +- HTTP 服务配置: `station.py` L629-L634 + +--- + +**总结**: 使用嵌套结构将所有配置放在 `config.bioyond_config` 中，修改 `__init__` 直接接收该参数，并替换所有全局变量引用为 `self.bioyond_config` 访问。 diff --git a/unilabos/devices/workstation/bioyond_studio/bioyond_cell/20260113_配置迁移修改总结.md b/unilabos/devices/workstation/bioyond_studio/bioyond_cell/20260113_配置迁移修改总结.md new file mode 100644 index 0000000..1113549 --- /dev/null +++ b/unilabos/devices/workstation/bioyond_studio/bioyond_cell/20260113_配置迁移修改总结.md @@ -0,0 +1,312 @@ +# BioyondCell 配置迁移修改总结 + +**日期**: 2026-01-13 +**目标**: 从 `config.py` 完全迁移到 JSON 配置，消除所有全局变量依赖 + +--- + +## 📋 修改概览 + +本次修改完成了 BioyondCell 模块从 Python 配置文件到 JSON 配置的完整迁移，并清理了所有对 `config.py` 全局变量的依赖。 + +### 核心成果 + +- ✅ 完全移除对 `config.py` 的导入依赖 +- ✅ 使用嵌套 JSON 结构 `config.bioyond_config` +- ✅ 修复 7 处 `bioyond_cell_workstation.py` 中的全局变量引用 +- ✅ 修复 3 处其他文件中的全局变量引用 +- ✅ HTTP 服务去重机制完善 +- ✅ 系统成功启动并正常运行 + +--- + +## 🔧 修改文件清单 + +### 1. JSON 配置文件 + +**文件**: `yibin_electrolyte_config.json` + +**修改**: +- 采用嵌套结构将所有配置放在 `config.bioyond_config` 中 +- 包含：`api_host`, `api_key`, `HTTP_host`, `HTTP_port`, `material_type_mappings`, `warehouse_mapping`, `solid_liquid_mappings` 等 + +**示例结构**: +```json +{ + "nodes": [{ + "id": "bioyond_cell_workstation", + "config": { + "deck": {...}, + "protocol_type": [], + "bioyond_config": { + "api_host": "http://172.16.11.219:44388", + "api_key": "8A819E5C", + "HTTP_host": "172.16.11.206", + "HTTP_port": 8080, + "material_type_mappings": {...}, + "warehouse_mapping": {...}, + "solid_liquid_mappings": {...} + } + } + }] +} +``` + +--- + +### 2. bioyond_cell_workstation.py + +**位置**: `unilabos/devices/workstation/bioyond_studio/bioyond_cell/bioyond_cell_workstation.py` + +#### 修改 A: `__init__` 方法签名 (L39-99) + +**修改前**: +```python +def __init__(self, deck=None, protocol_type=None, **kwargs): + # 从 kwargs 收集配置字段 + self.bioyond_config = {} + for field in bioyond_field_names: + if field in kwargs: + self.bioyond_config[field] = kwargs.pop(field) +``` + +**修改后**: +```python +def __init__(self, bioyond_config: dict = None, deck=None, protocol_type=None, **kwargs): + """直接接收 bioyond_config 参数""" + if bioyond_config is None: + raise ValueError("需要 bioyond_config 参数") + + self.bioyond_config = bioyond_config + + # 设置 HTTP 服务去重标志 + self.bioyond_config["_disable_auto_http_service"] = True + + super().__init__(bioyond_config=self.bioyond_config, deck=deck, **kwargs) +``` + +#### 修改 B: 替换全局变量引用 (7 处) + +| 位置 | 原代码 | 修改后 | +|------|--------|--------| +| L2005 | `MATERIAL_TYPE_MAPPINGS[board_type][1]` | `self.bioyond_config['material_type_mappings'][board_type][1]` | +| L2006 | `MATERIAL_TYPE_MAPPINGS[bottle_type][1]` | `self.bioyond_config['material_type_mappings'][bottle_type][1]` | +| L2009 | `WAREHOUSE_MAPPING` | `self.bioyond_config['warehouse_mapping']` | +| L2013 | `WAREHOUSE_MAPPING[warehouse_name]` | `self.bioyond_config['warehouse_mapping'][warehouse_name]` | +| L2017 | `WAREHOUSE_MAPPING[warehouse_name]["site_uuids"]` | `self.bioyond_config['warehouse_mapping'][warehouse_name]["site_uuids"]` | +| L1863 | `SOLID_LIQUID_MAPPINGS.get(material_name)` | `self.bioyond_config.get('solid_liquid_mappings', {}).get(material_name)` | +| L1966, L1976 | `MATERIAL_TYPE_MAPPINGS.items()` | `self.bioyond_config['material_type_mappings'].items()` | + +--- + +### 3. station.py + +**位置**: `unilabos/devices/workstation/bioyond_studio/station.py` + +#### 修改 A: 删除 config 导入 (L26-28) + +**修改前**: +```python +from unilabos.devices.workstation.bioyond_studio.config import ( + API_CONFIG, WORKFLOW_MAPPINGS, MATERIAL_TYPE_MAPPINGS, WAREHOUSE_MAPPING, HTTP_SERVICE_CONFIG +) +``` + +**修改后**: +```python +# 已删除此导入 +``` + +#### 修改 B: `_create_communication_module` 方法 (L691-702) + +**修改前**: +```python +def _create_communication_module(self, config: Optional[Dict[str, Any]] = None) -> None: + default_config = { + **API_CONFIG, + "workflow_mappings": WORKFLOW_MAPPINGS, + "material_type_mappings": MATERIAL_TYPE_MAPPINGS, + "warehouse_mapping": WAREHOUSE_MAPPING + } + if config: + self.bioyond_config = {**default_config, **config} + else: + self.bioyond_config = default_config +``` + +**修改后**: +```python +def _create_communication_module(self, config: Optional[Dict[str, Any]] = None) -> None: + """创建Bioyond通信模块""" + # 使用传入的 config 参数（来自 bioyond_config） + # 不再依赖全局变量 API_CONFIG 等 + if config: + self.bioyond_config = config + else: + # 如果没有传入配置，创建空配置（用于测试或兼容性） + self.bioyond_config = {} + + self.hardware_interface = BioyondV1RPC(self.bioyond_config) +``` + +#### 修改 C: HTTP 服务配置 (L627-632) + +**修改前**: +```python +self._http_service_config = { + "host": bioyond_config.get("http_service_host", HTTP_SERVICE_CONFIG.get("http_service_host", "")), + "port": bioyond_config.get("http_service_port", HTTP_SERVICE_CONFIG.get("http_service_port", 0)) +} +``` + +**修改后**: +```python +self._http_service_config = { + "host": bioyond_config.get("http_service_host", bioyond_config.get("HTTP_host", "")), + "port": bioyond_config.get("http_service_port", bioyond_config.get("HTTP_port", 0)) +} +``` + +--- + +### 4. bioyond_rpc.py + +**位置**: `unilabos/devices/workstation/bioyond_studio/bioyond_rpc.py` + +#### 修改 A: 删除 config 导入 (L12) + +**修改前**: +```python +from unilabos.devices.workstation.bioyond_studio.config import LOCATION_MAPPING +``` + +**修改后**: +```python +# 已删除此导入 +``` + +#### 修改 B: `material_outbound` 方法 (L278-280) + +**修改前**: +```python +def material_outbound(self, material_id: str, location_name: str, quantity: int) -> dict: + """指定库位出库物料（通过库位名称）""" + location_id = LOCATION_MAPPING.get(location_name, location_name) +``` + +**修改后**: +```python +def material_outbound(self, material_id: str, location_name: str, quantity: int) -> dict: + """指定库位出库物料（通过库位名称）""" + # location_name 参数实际上应该直接是 location_id (UUID) + location_id = location_name +``` + +**说明**: `LOCATION_MAPPING` 在 `config-0113.py` 中本来就是空字典 `{}`，所以直接使用 `location_name` 逻辑等价。 + +--- + +## 🎯 关键设计决策 + +### 1. 嵌套 vs 扁平配置 + +**选择**: 嵌套结构 `config.bioyond_config` + +**理由**: +- ✅ 语义清晰，配置分组明确 +- ✅ 参数传递直观，直接对应 `__init__` 参数 +- ✅ 易于维护，不需要硬编码字段列表 +- ✅ 符合 UniLab 设计模式 + +### 2. HTTP 服务去重 + +**实现**: 子类设置 `_disable_auto_http_service` 标志 + +```python +# bioyond_cell_workstation.py +self.bioyond_config["_disable_auto_http_service"] = True + +# station.py (post_init) +if self.bioyond_config.get("_disable_auto_http_service"): + logger.info("子类已自行管理HTTP服务，跳过自动启动") + return +``` + +### 3. 全局变量替换策略 + +**原则**: 所有配置从 `self.bioyond_config` 获取 + +**模式**: +```python +# 修改前 +from config import MATERIAL_TYPE_MAPPINGS +carrier_type_id = MATERIAL_TYPE_MAPPINGS[board_type][1] + +# 修改后 +carrier_type_id = self.bioyond_config['material_type_mappings'][board_type][1] +``` + +--- + +## ✅ 验证结果 + +### 启动成功日志 +``` +✅ 从 JSON 配置加载 bioyond_config 成功 + API Host: http://172.16.11.219:44388 + HTTP Service: 172.16.11.206:8080 +🔧 已设置 _disable_auto_http_service 标志，防止 HTTP 服务重复启动 +✅ BioyondCellWorkstation 初始化完成 +Loaded ResourceTreeSet with 1 trees, 1785 total nodes +``` + +### 功能验证 +- ✅ 订单创建 (`create_orders_v2`) +- ✅ 质量比计算 +- ✅ 物料转移 (`transfer_3_to_2_to_1`) +- ✅ HTTP 报送接收 (step_finish, sample_finish, order_finish) +- ✅ 等待机制 (`wait_for_order_finish`) +- ✅ 仓库 UUID 映射 +- ✅ 物料类型映射 + +--- + +## 📚 相关文档 + +- **配置迁移经验**: `2026-01-13_JSON配置迁移经验.md` +- **任务清单**: `C:\Users\AndyXie\.gemini\antigravity\brain\...\task.md` +- **实施计划**: `C:\Users\AndyXie\.gemini\antigravity\brain\...\implementation_plan.md` + +--- + +## ⚠️ 注意事项 + +### 其他工作站模块 + +以下文件仍在使用 `config.py` 全局变量（未包含在本次修改中）: +- `reaction_station.py` - 使用 `API_CONFIG` +- `experiment.py` - 使用 `API_CONFIG`, `WORKFLOW_MAPPINGS`, `MATERIAL_TYPE_MAPPINGS` +- `dispensing_station.py` - 使用 `API_CONFIG`, `WAREHOUSE_MAPPING` +- `station.py` L176, L177, L529, L530 - 动态导入 `WAREHOUSE_MAPPING` + +**建议**: 后续可以统一迁移这些模块到 JSON 配置。 + +### config.py 文件 + +`config.py` 文件已恢复但**不再被 bioyond_cell 使用**。可以： +- 保留作为其他模块的参考 +- 或者完全删除（如果其他模块也迁移完成） + +--- + +## 🚀 下一步建议 + +1. **清理调试代码** ✅ (已完成) +2. **提交代码到 Git** +3. **迁移其他工作站模块** (可选) +4. **更新文档和启动脚本** + +--- + +**修改完成日期**: 2026-01-13 +**系统状态**: ✅ 稳定运行 diff --git a/unilabos/devices/workstation/bioyond_studio/bioyond_cell/bioyond_cell_workstation.py b/unilabos/devices/workstation/bioyond_studio/bioyond_cell/bioyond_cell_workstation.py new file mode 100644 index 0000000..333b7b2 --- /dev/null +++ b/unilabos/devices/workstation/bioyond_studio/bioyond_cell/bioyond_cell_workstation.py @@ -0,0 +1,2112 @@ +# -*- coding: utf-8 -*- +from cgi import print_arguments +from doctest import debug +from typing import Dict, Any, List, Optional +import requests +from pylabrobot.resources.resource import Resource as ResourcePLR +from pathlib import Path +import pandas as pd +import time +from datetime import datetime, timedelta +import re +import threading +import json +from copy import deepcopy +from urllib3 import response +from unilabos.devices.workstation.bioyond_studio.station import BioyondWorkstation, BioyondResourceSynchronizer +# ⚠️ config.py 已废弃 - 所有配置现在从 JSON 文件加载 +# from unilabos.devices.workstation.bioyond_studio.config import API_CONFIG, ... +from unilabos.devices.workstation.workstation_http_service import WorkstationHTTPService +from unilabos.resources.bioyond.decks import BIOYOND_YB_Deck +from unilabos.utils.log import logger +from unilabos.registry.registry import lab_registry + +def _iso_local_now_ms() -> str: + # 文档要求：到毫秒 + Z，例如 2025-08-15T05:43:22.814Z + dt = datetime.now() + # print(dt) + return dt.strftime("%Y-%m-%dT%H:%M:%S.") + f"{int(dt.microsecond/1000):03d}Z" + + +class BioyondCellWorkstation(BioyondWorkstation): + """ + 集成 Bioyond LIMS 的工作站示例， + 覆盖：入库(2.17/2.18) → 新建实验(2.14) → 启动调度(2.7) → + 运行中推送：物料变更(2.24)、步骤完成(2.21)、订单完成(2.23) → + 查询实验(2.5/2.6) → 3-2-1 转运(2.32) → 样品/废料取出(2.28) + """ + + def __init__(self, bioyond_config: dict = None, deck=None, protocol_type=None, **kwargs): + """ + 初始化 BioyondCellWorkstation + + Args: + bioyond_config: 从 JSON 文件加载的 bioyond 配置字典 + 包含 api_host, api_key, HTTP_host, HTTP_port 等配置 + deck: Deck 配置（可选，会从 JSON 中自动处理） + protocol_type: 协议类型（可选） + **kwargs: 其他参数（如 children 等） + """ + + # ⚠️ 配置验证：确保传入了必需的配置 + if bioyond_config is None: + raise ValueError( + "BioyondCellWorkstation 需要 bioyond_config 参数！\n" + "请在 JSON 配置文件的 config 中添加 bioyond_config 字段，例如：\n" + "\"config\": {\n" + " \"bioyond_config\": {\n" + " \"api_host\": \"http://...\",\n" + " \"api_key\": \"...\",\n" + " ...\n" + " }\n" + "}" + ) + + # 验证 bioyond_config 的类型 + if not isinstance(bioyond_config, dict): + raise ValueError( + f"bioyond_config 必须是字典类型，实际类型: {type(bioyond_config).__name__}" + ) + + # 保存配置 + self.bioyond_config = bioyond_config + + # 验证必需的配置参数 + required_keys = ['api_host', 'api_key', 'HTTP_host', 'HTTP_port', + 'material_type_mappings', 'warehouse_mapping'] + missing_keys = [key for key in required_keys if key not in self.bioyond_config] + if missing_keys: + raise ValueError( + f"bioyond_config 缺少必需参数: {', '.join(missing_keys)}\n" + f"请检查 JSON 配置文件中的 bioyond_config 字段" + ) + + logger.info("✅ 从 JSON 配置加载 bioyond_config 成功") + logger.info(f" API Host: {self.bioyond_config.get('api_host')}") + logger.info(f" HTTP Service: {self.bioyond_config.get('HTTP_host')}:{self.bioyond_config.get('HTTP_port')}") + + # 设置调试模式 + self.debug_mode = self.bioyond_config.get("debug_mode", False) + self.http_service_started = self.debug_mode + self._device_id = "bioyond_cell_workstation" # 默认值，后续会从_ros_node获取 + + # ⚠️ 关键：设置标志位，告诉父类不要在 post_init 中启动 HTTP 服务 + # 因为子类会在这里自己启动 HTTP 服务 + self.bioyond_config["_disable_auto_http_service"] = True + logger.info("🔧 已设置 _disable_auto_http_service 标志，防止 HTTP 服务重复启动") + + # 调用父类初始化（传入完整的 bioyond_config） + super().__init__(bioyond_config=self.bioyond_config, deck=deck, **kwargs) + + # 更新奔耀端的报送 IP 地址 + self.update_push_ip() + logger.info("已更新奔耀端推送 IP 地址") + + # 启动 HTTP 服务线程（子类自己管理） + t = threading.Thread(target=self._start_http_service, daemon=True, name="unilab_http") + t.start() + logger.info("HTTP 服务线程已启动") + + # 初始化订单报送事件 + self.order_finish_event = threading.Event() + self.last_order_status = None + self.last_order_code = None + + logger.info(f"✅ BioyondCellWorkstation 初始化完成 (debug_mode={self.debug_mode})") + + @property + def device_id(self): + """获取设备ID，优先从_ros_node获取，否则返回默认值""" + if hasattr(self, '_ros_node') and self._ros_node is not None: + return getattr(self._ros_node, 'device_id', self._device_id) + return self._device_id + + def _start_http_service(self): + """启动 HTTP 服务""" + host = self.bioyond_config.get("HTTP_host", "") + port = self.bioyond_config.get("HTTP_port", None) + try: + self.service = WorkstationHTTPService(self, host=host, port=port) + self.service.start() + self.http_service_started = True + logger.info(f"WorkstationHTTPService 成功启动: {host}:{port}") + while True: + time.sleep(1) #一直挂着，直到进程退出 + except Exception as e: + self.http_service_started = False + logger.error(f"启动 WorkstationHTTPService 失败: {e}", exc_info=True) + + + # http报送服务，返回数据部分 + def process_step_finish_report(self, report_request): + stepId = report_request.data.get("stepId") + logger.info(f"步骤完成: stepId: {stepId}, stepName:{report_request.data.get('stepName')}") + return report_request.data.get('executionStatus') + + def process_sample_finish_report(self, report_request): + logger.info(f"通量完成: {report_request.data.get('sampleId')}") + return {"status": "received"} + + def process_order_finish_report(self, report_request, used_materials=None): + order_code = report_request.data.get("orderCode") + status = report_request.data.get("status") + + # 🔍 详细调试日志 + logger.info(f"[DEBUG] ========== 收到 order_finish 报送 ==========") + logger.info(f"[DEBUG] 报送的 orderCode: '{order_code}' (type: {type(order_code).__name__})") + logger.info(f"[DEBUG] 当前等待的 last_order_code: '{self.last_order_code}' (type: {type(self.last_order_code).__name__})") + logger.info(f"[DEBUG] 报送状态: {status}") + logger.info(f"[DEBUG] orderCode 是否匹配: {self.last_order_code == order_code}") + logger.info(f"[DEBUG] Event 当前状态 (触发前): is_set={self.order_finish_event.is_set()}") + logger.info(f"report_request: {report_request}") + logger.info(f"任务完成: {order_code}, status={status}") + + # 保存完整报文 + self.last_order_report = report_request.data + + # 如果是当前等待的订单，触发事件 + if self.last_order_code == order_code: + logger.info(f"[DEBUG] ✅ orderCode 匹配！触发 order_finish_event") + self.order_finish_event.set() + logger.info(f"[DEBUG] Event 状态 (触发后): is_set={self.order_finish_event.is_set()}") + else: + logger.warning(f"[DEBUG] ❌ orderCode 不匹配，不触发 event") + logger.warning(f"[DEBUG] 期望: '{self.last_order_code}'") + logger.warning(f"[DEBUG] 实际: '{order_code}'") + + logger.info(f"[DEBUG] ========================================") + return {"status": "received"} + + def wait_for_order_finish(self, order_code: str, timeout: int = 36000) -> Dict[str, Any]: + """ + 等待指定 orderCode 的 /report/order_finish 报送。 + Args: + order_code: 任务编号 + timeout: 超时时间（秒） + Returns: + 完整的报送数据 + 状态判断结果 + """ + if not order_code: + logger.error("wait_for_order_finish() 被调用，但 order_code 为空！") + return {"status": "error", "message": "empty order_code"} + + self.last_order_code = order_code + self.last_order_report = None + self.order_finish_event.clear() + + logger.info(f"等待任务完成报送: orderCode={order_code} (timeout={timeout}s)") + + if not self.order_finish_event.wait(timeout=timeout): + logger.error(f"等待任务超时: orderCode={order_code}") + return {"status": "timeout", "orderCode": order_code} + + # 报送数据匹配验证 + report = self.last_order_report or {} + report_code = report.get("orderCode") + status = str(report.get("status", "")) + + if report_code != order_code: + logger.warning(f"收到的报送 orderCode 不匹配: {report_code} ≠ {order_code}") + return {"status": "mismatch", "report": report} + + if status == "30": + logger.info(f"任务成功完成 (orderCode={order_code})") + return {"status": "success", "report": report} + elif status == "-11": + logger.error(f"任务异常停止 (orderCode={order_code})") + return {"status": "abnormal_stop", "report": report} + elif status == "-12": + logger.warning(f"任务人工停止 (orderCode={order_code})") + return {" status": "manual_stop", "report": report} + else: + logger.warning(f"任务未知状态 ({status}) (orderCode={order_code})") + return {"status": f"unknown_{status}", "report": report} + + def wait_for_order_finish_polling(self, order_code: str, timeout: int = 36000, poll_interval: float = 0.5) -> Dict[str, Any]: + """ + 等待指定 orderCode 的 /report/order_finish 报送（非阻塞轮询版本）。 + + 与 wait_for_order_finish 的区别： + - 使用轮询而非阻塞等待，每隔 poll_interval 秒检查一次 + - 允许 ROS2 在等待期间处理 feedback 消息 + - 适用于长时间运行的 ROS2 Action + + Args: + order_code: 任务编号 + timeout: 超时时间（秒） + poll_interval: 轮询间隔（秒），默认 0.5 秒 + Returns: + 完整的报送数据 + 状态判断结果 + """ + if not order_code: + logger.error("wait_for_order_finish_polling() 被调用，但 order_code 为空！") + return {"status": "error", "message": "empty order_code"} + + self.last_order_code = order_code + self.last_order_report = None + self.order_finish_event.clear() + + logger.info(f"[轮询模式] 等待任务完成报送: orderCode={order_code} (timeout={timeout}s, poll_interval={poll_interval}s)") + logger.info(f"[轮询模式] [DEBUG] last_order_code 已设置为: '{self.last_order_code}'") + logger.info(f"[轮询模式] [DEBUG] Event 初始状态: is_set={self.order_finish_event.is_set()}") + + start_time = time.time() + poll_count = 0 + while not self.order_finish_event.is_set(): + poll_count += 1 + elapsed = time.time() - start_time + + # 每 10 次轮询（约 5 秒）输出一次状态 + if poll_count % 10 == 0: + logger.info(f"[轮询模式] [DEBUG] 轮询中... 已等待 {elapsed:.1f}s (第{poll_count}次检查)") + logger.info(f"[轮询模式] [DEBUG] Event.is_set() = {self.order_finish_event.is_set()}") + + # 检查是否超时 + if elapsed > timeout: + logger.error(f"[轮询模式] 等待任务超时: orderCode={order_code}") + logger.error(f"[轮询模式] [DEBUG] 总共轮询了 {poll_count} 次，耗时 {elapsed:.1f}s") + return {"status": "timeout", "orderCode": order_code} + + # 短暂 sleep，让出控制权给 ROS2 处理 feedback + time.sleep(poll_interval) + + # 事件已触发，获取报送数据 + logger.info(f"[轮询模式] [DEBUG] ✅ Event 已触发！共轮询 {poll_count} 次") + report = self.last_order_report or {} + report_code = report.get("orderCode") + status = str(report.get("status", "")) + + logger.info(f"[轮询模式] [DEBUG] 报送数据: orderCode='{report_code}', status={status}") + + # 报送数据匹配验证 + if report_code != order_code: + logger.warning(f"[轮询模式] 收到的报送 orderCode 不匹配: {report_code} ≠ {order_code}") + return {"status": "mismatch", "report": report} + + # 状态判断 + if status == "30": + logger.info(f"[轮询模式] 任务成功完成 (orderCode={order_code})") + return {"status": "success", "report": report} + elif status == "-11": + logger.error(f"[轮询模式] 任务异常停止 (orderCode={order_code})") + return {"status": "abnormal_stop", "report": report} + elif status == "-12": + logger.warning(f"[轮询模式] 任务人工停止 (orderCode={order_code})") + return {"status": "manual_stop", "report": report} + else: + logger.warning(f"[轮询模式] 任务未知状态 ({status}) (orderCode={order_code})") + return {"status": f"unknown_{status}", "report": report} + + + def get_material_info(self, material_id: str) -> Dict[str, Any]: + """查询物料详细信息（物料详情接口） + + Args: + material_id: 物料 ID (GUID) + + Returns: + 物料详情，包含 name, typeName, locations 等 + """ + result = self._post_lims("/api/lims/storage/material-info", material_id) + return result.get("data", {}) + + def _process_order_reagents(self, report: Dict[str, Any]) -> Dict[str, Any]: + """处理订单完成报文中的试剂数据，计算质量比 + + Args: + report: 订单完成推送的 report 数据 + + Returns: + { + "real_mass_ratio": {"试剂A": 0.6, "试剂B": 0.4}, + "target_mass_ratio": {"试剂A": 0.6, "试剂B": 0.4}, + "reagent_details": [...] # 详细数据 + } + """ + used_materials = report.get("usedMaterials", []) + + # 1. 筛选试剂（typemode="2"，注意是小写且是字符串） + reagents = [m for m in used_materials if str(m.get("typemode")) == "2"] + + if not reagents: + logger.warning("订单完成报文中没有试剂（typeMode=2）") + return { + "real_mass_ratio": {}, + "target_mass_ratio": {}, + "reagent_details": [] + } + + # 2. 查询试剂名称 + reagent_data = [] + for reagent in reagents: + material_id = reagent.get("materialId") + if not material_id: + continue + + try: + info = self.get_material_info(material_id) + name = info.get("name", f"Unknown_{material_id[:8]}") + real_qty = float(reagent.get("realQuantity", 0.0)) + used_qty = float(reagent.get("usedQuantity", 0.0)) + + reagent_data.append({ + "name": name, + "material_id": material_id, + "real_quantity": real_qty, + "used_quantity": used_qty + }) + logger.info(f"试剂: {name}, 目标={used_qty}g, 实际={real_qty}g") + except Exception as e: + logger.error(f"查询物料信息失败: {material_id}, {e}") + continue + + if not reagent_data: + return { + "real_mass_ratio": {}, + "target_mass_ratio": {}, + "reagent_details": [] + } + + # 3. 计算质量比 + def calculate_mass_ratio(items: List[Dict], key: str) -> Dict[str, float]: + total = sum(item[key] for item in items) + if total == 0: + logger.warning(f"总质量为0，无法计算{key}质量比") + return {item["name"]: 0.0 for item in items} + return {item["name"]: round(item[key] / total, 4) for item in items} + + real_mass_ratio = calculate_mass_ratio(reagent_data, "real_quantity") + target_mass_ratio = calculate_mass_ratio(reagent_data, "used_quantity") + + logger.info(f"真实质量比: {real_mass_ratio}") + logger.info(f"目标质量比: {target_mass_ratio}") + + return { + "real_mass_ratio": real_mass_ratio, + "target_mass_ratio": target_mass_ratio, + "reagent_details": reagent_data + } + + + # -------------------- 基础HTTP封装 -------------------- + def _url(self, path: str) -> str: + return f"{self.bioyond_config['api_host'].rstrip('/')}/{path.lstrip('/')}" + + def _post_lims(self, path: str, data: Optional[Any] = None) -> Dict[str, Any]: + """LIMS API：大多数接口用 {apiKey/requestTime,data} 包装""" + payload = { + "apiKey": self.bioyond_config["api_key"], + "requestTime": _iso_local_now_ms() + } + if data is not None: + payload["data"] = data + + if self.debug_mode: + # 模拟返回，不发真实请求 + logger.info(f"[DEBUG] POST {path} with payload={payload}") + + return {"debug": True, "url": self._url(path), "payload": payload, "status": "ok"} + + try: + logger.info(json.dumps(payload, ensure_ascii=False)) + response = requests.post( + self._url(path), + json=payload, + timeout=self.bioyond_config.get("timeout", 30), + headers={"Content-Type": "application/json"} + ) # 拼接网址+post bioyond接口 + response.raise_for_status() + return response.json() + except Exception as e: + logger.info(f"{self.bioyond_config['api_host'].rstrip('/')}/{path.lstrip('/')}") + logger.error(f"POST {path} 失败: {e}") + return {"error": str(e)} + + def _put_lims(self, path: str, data: Optional[Any] = None) -> Dict[str, Any]: + """LIMS API：PUT {apiKey/requestTime,data} 包装""" + payload = { + "apiKey": self.bioyond_config["api_key"], + "requestTime": _iso_local_now_ms() + } + if data is not None: + payload["data"] = data + + if self.debug_mode: + logger.info(f"[DEBUG] PUT {path} with payload={payload}") + return {"debug_mode": True, "url": self._url(path), "payload": payload, "status": "ok"} + + try: + response = requests.put( + self._url(path), + json=payload, + timeout=self.bioyond_config.get("timeout", 30), + headers={"Content-Type": "application/json"} + ) + response.raise_for_status() + return response.json() + except Exception as e: + logger.info(f"{self.bioyond_config['api_host'].rstrip('/')}/{path.lstrip('/')}") + logger.error(f"PUT {path} 失败: {e}") + return {"error": str(e)} + + # -------------------- 3.36 更新推送 IP 地址 -------------------- + def update_push_ip(self, ip: Optional[str] = None, port: Optional[int] = None) -> Dict[str, Any]: + """ + 3.36 更新推送 IP 地址接口（PUT） + URL: /api/lims/order/ip-config + 请求体：{ apiKey, requestTime, data: { ip, port } } + """ + target_ip = ip or self.bioyond_config.get("HTTP_host", "") + target_port = int(port or self.bioyond_config.get("HTTP_port", 0)) + data = {"ip": target_ip, "port": target_port} + + # 固定接口路径，不做其他路径兼容 + path = "/api/lims/order/ip-config" + return self._put_lims(path, data) + + # -------------------- 单点接口封装 -------------------- + # 2.17 入库物料（单个） + def storage_inbound(self, material_id: str, location_id: str) -> Dict[str, Any]: + return self._post_lims("/api/lims/storage/inbound", { + "materialId": material_id, + "locationId": location_id + }) + + # 2.18 批量入库（多个） + def storage_batch_inbound(self, items: List[Dict[str, str]]) -> Dict[str, Any]: + """ + items = [{"materialId": "...", "locationId": "..."}, ...] + """ + return self._post_lims("/api/lims/storage/batch-inbound", items) + + + def auto_feeding4to3( + self, + # ★ 修改点：默认模板路径 + xlsx_path: Optional[str] = "D:\\UniLab\\Uni-Lab-OS\\unilabos\\devices\\workstation\\bioyond_studio\\bioyond_cell\\material_template.xlsx", + # ---------------- WH4 - 加样头面 (Z=1, 12个点位) ---------------- + WH4_x1_y1_z1_1_materialName: str = "", WH4_x1_y1_z1_1_quantity: float = 0.0, + WH4_x2_y1_z1_2_materialName: str = "", WH4_x2_y1_z1_2_quantity: float = 0.0, + WH4_x3_y1_z1_3_materialName: str = "", WH4_x3_y1_z1_3_quantity: float = 0.0, + WH4_x4_y1_z1_4_materialName: str = "", WH4_x4_y1_z1_4_quantity: float = 0.0, + WH4_x5_y1_z1_5_materialName: str = "", WH4_x5_y1_z1_5_quantity: float = 0.0, + WH4_x1_y2_z1_6_materialName: str = "", WH4_x1_y2_z1_6_quantity: float = 0.0, + WH4_x2_y2_z1_7_materialName: str = "", WH4_x2_y2_z1_7_quantity: float = 0.0, + WH4_x3_y2_z1_8_materialName: str = "", WH4_x3_y2_z1_8_quantity: float = 0.0, + WH4_x4_y2_z1_9_materialName: str = "", WH4_x4_y2_z1_9_quantity: float = 0.0, + WH4_x5_y2_z1_10_materialName: str = "", WH4_x5_y2_z1_10_quantity: float = 0.0, + WH4_x1_y3_z1_11_materialName: str = "", WH4_x1_y3_z1_11_quantity: float = 0.0, + WH4_x2_y3_z1_12_materialName: str = "", WH4_x2_y3_z1_12_quantity: float = 0.0, + + # ---------------- WH4 - 原液瓶面 (Z=2, 9个点位) ---------------- + WH4_x1_y1_z2_1_materialName: str = "", WH4_x1_y1_z2_1_quantity: float = 0.0, WH4_x1_y1_z2_1_materialType: str = "", WH4_x1_y1_z2_1_targetWH: str = "", + WH4_x2_y1_z2_2_materialName: str = "", WH4_x2_y1_z2_2_quantity: float = 0.0, WH4_x2_y1_z2_2_materialType: str = "", WH4_x2_y1_z2_2_targetWH: str = "", + WH4_x3_y1_z2_3_materialName: str = "", WH4_x3_y1_z2_3_quantity: float = 0.0, WH4_x3_y1_z2_3_materialType: str = "", WH4_x3_y1_z2_3_targetWH: str = "", + WH4_x1_y2_z2_4_materialName: str = "", WH4_x1_y2_z2_4_quantity: float = 0.0, WH4_x1_y2_z2_4_materialType: str = "", WH4_x1_y2_z2_4_targetWH: str = "", + WH4_x2_y2_z2_5_materialName: str = "", WH4_x2_y2_z2_5_quantity: float = 0.0, WH4_x2_y2_z2_5_materialType: str = "", WH4_x2_y2_z2_5_targetWH: str = "", + WH4_x3_y2_z2_6_materialName: str = "", WH4_x3_y2_z2_6_quantity: float = 0.0, WH4_x3_y2_z2_6_materialType: str = "", WH4_x3_y2_z2_6_targetWH: str = "", + WH4_x1_y3_z2_7_materialName: str = "", WH4_x1_y3_z2_7_quantity: float = 0.0, WH4_x1_y3_z2_7_materialType: str = "", WH4_x1_y3_z2_7_targetWH: str = "", + WH4_x2_y3_z2_8_materialName: str = "", WH4_x2_y3_z2_8_quantity: float = 0.0, WH4_x2_y3_z2_8_materialType: str = "", WH4_x2_y3_z2_8_targetWH: str = "", + WH4_x3_y3_z2_9_materialName: str = "", WH4_x3_y3_z2_9_quantity: float = 0.0, WH4_x3_y3_z2_9_materialType: str = "", WH4_x3_y3_z2_9_targetWH: str = "", + + # ---------------- WH3 - 人工堆栈 (Z=3, 15个点位) ---------------- + WH3_x1_y1_z3_1_materialType: str = "", WH3_x1_y1_z3_1_materialId: str = "", WH3_x1_y1_z3_1_quantity: float = 0, + WH3_x2_y1_z3_2_materialType: str = "", WH3_x2_y1_z3_2_materialId: str = "", WH3_x2_y1_z3_2_quantity: float = 0, + WH3_x3_y1_z3_3_materialType: str = "", WH3_x3_y1_z3_3_materialId: str = "", WH3_x3_y1_z3_3_quantity: float = 0, + WH3_x1_y2_z3_4_materialType: str = "", WH3_x1_y2_z3_4_materialId: str = "", WH3_x1_y2_z3_4_quantity: float = 0, + WH3_x2_y2_z3_5_materialType: str = "", WH3_x2_y2_z3_5_materialId: str = "", WH3_x2_y2_z3_5_quantity: float = 0, + WH3_x3_y2_z3_6_materialType: str = "", WH3_x3_y2_z3_6_materialId: str = "", WH3_x3_y2_z3_6_quantity: float = 0, + WH3_x1_y3_z3_7_materialType: str = "", WH3_x1_y3_z3_7_materialId: str = "", WH3_x1_y3_z3_7_quantity: float = 0, + WH3_x2_y3_z3_8_materialType: str = "", WH3_x2_y3_z3_8_materialId: str = "", WH3_x2_y3_z3_8_quantity: float = 0, + WH3_x3_y3_z3_9_materialType: str = "", WH3_x3_y3_z3_9_materialId: str = "", WH3_x3_y3_z3_9_quantity: float = 0, + WH3_x1_y4_z3_10_materialType: str = "", WH3_x1_y4_z3_10_materialId: str = "", WH3_x1_y4_z3_10_quantity: float = 0, + WH3_x2_y4_z3_11_materialType: str = "", WH3_x2_y4_z3_11_materialId: str = "", WH3_x2_y4_z3_11_quantity: float = 0, + WH3_x3_y4_z3_12_materialType: str = "", WH3_x3_y4_z3_12_materialId: str = "", WH3_x3_y4_z3_12_quantity: float = 0, + WH3_x1_y5_z3_13_materialType: str = "", WH3_x1_y5_z3_13_materialId: str = "", WH3_x1_y5_z3_13_quantity: float = 0, + WH3_x2_y5_z3_14_materialType: str = "", WH3_x2_y5_z3_14_materialId: str = "", WH3_x2_y5_z3_14_quantity: float = 0, + WH3_x3_y5_z3_15_materialType: str = "", WH3_x3_y5_z3_15_materialId: str = "", WH3_x3_y5_z3_15_quantity: float = 0, + ): + """ + 自动化上料（支持两种模式） + - Excel 路径存在 → 从 Excel 模板解析 + - Excel 路径不存在 → 使用手动参数 + """ + items: List[Dict[str, Any]] = [] + + # ---------- 模式 1: Excel 导入 ---------- + if xlsx_path: + path = Path(__file__).parent / Path(xlsx_path) + if path.exists(): # ★ 修改点：路径存在才加载 + try: + df = pd.read_excel(path, sheet_name=0, header=None, engine="openpyxl") + except Exception as e: + raise RuntimeError(f"读取 Excel 失败：{e}") + + # 四号手套箱加样头面 + for _, row in df.iloc[1:13, 2:7].iterrows(): + if pd.notna(row[5]): + items.append({ + "sourceWHName": "四号手套箱堆栈", + "posX": int(row[2]), "posY": int(row[3]), "posZ": int(row[4]), + "materialName": str(row[5]).strip(), + "quantity": float(row[6]) if pd.notna(row[6]) else 0.0, + }) + # 四号手套箱原液瓶面 + for _, row in df.iloc[14:23, 2:9].iterrows(): + if pd.notna(row[5]): + items.append({ + "sourceWHName": "四号手套箱堆栈", + "posX": int(row[2]), "posY": int(row[3]), "posZ": int(row[4]), + "materialName": str(row[5]).strip(), + "quantity": float(row[6]) if pd.notna(row[6]) else 0.0, + "materialType": str(row[7]).strip() if pd.notna(row[7]) else "", + "targetWH": str(row[8]).strip() if pd.notna(row[8]) else "", + }) + # 三号手套箱人工堆栈 + for _, row in df.iloc[25:40, 2:7].iterrows(): + if pd.notna(row[5]) or pd.notna(row[6]): + items.append({ + "sourceWHName": "三号手套箱人工堆栈", + "posX": int(row[2]), "posY": int(row[3]), "posZ": int(row[4]), + "materialType": str(row[5]).strip() if pd.notna(row[5]) else "", + "materialId": str(row[6]).strip() if pd.notna(row[6]) else "", + "quantity": 1 + }) + else: + logger.warning(f"未找到 Excel 文件 {xlsx_path}，自动切换到手动参数模式。") + + # ---------- 模式 2: 手动填写 ---------- + if not items: + params = locals() + for name, value in params.items(): + if name.startswith("四号手套箱堆栈") and "materialName" in name and value: + idx = name.split("_") + items.append({ + "sourceWHName": "四号手套箱堆栈", + "posX": int(idx[1][1:]), "posY": int(idx[2][1:]), "posZ": int(idx[3][1:]), + "materialName": value, + "quantity": float(params.get(name.replace("materialName", "quantity"), 0.0)) + }) + elif name.startswith("四号手套箱堆栈") and "materialType" in name and (value or params.get(name.replace("materialType", "materialName"), "")): + idx = name.split("_") + items.append({ + "sourceWHName": "四号手套箱堆栈", + "posX": int(idx[1][1:]), "posY": int(idx[2][1:]), "posZ": int(idx[3][1:]), + "materialName": params.get(name.replace("materialType", "materialName"), ""), + "quantity": float(params.get(name.replace("materialType", "quantity"), 0.0)), + "materialType": value, + "targetWH": params.get(name.replace("materialType", "targetWH"), ""), + }) + elif name.startswith("三号手套箱人工堆栈") and "materialType" in name and (value or params.get(name.replace("materialType", "materialId"), "")): + idx = name.split("_") + items.append({ + "sourceWHName": "三号手套箱人工堆栈", + "posX": int(idx[1][1:]), "posY": int(idx[2][1:]), "posZ": int(idx[3][1:]), + "materialType": value, + "materialId": params.get(name.replace("materialType", "materialId"), ""), + "quantity": int(params.get(name.replace("materialType", "quantity"), 1)), + }) + + if not items: + logger.warning("没有有效的上料条目，已跳过提交。") + return {"code": 0, "message": "no valid items", "data": []} + logger.info(items) + response = self._post_lims("/api/lims/order/auto-feeding4to3", items) + + # 等待任务报送成功 + order_code = response.get("data", {}).get("orderCode") + if not order_code: + logger.error("上料任务未返回有效 orderCode！") + return response + # 等待完成报送 + result = self.wait_for_order_finish(order_code) + print("\n" + "="*60) + print("实验记录本结果auto_feeding4to3") + print("="*60) + print(json.dumps(result, indent=2, ensure_ascii=False)) + print("="*60 + "\n") + return result + + def auto_batch_outbound_from_xlsx(self, xlsx_path: str) -> Dict[str, Any]: + """ + 3.31 自动化下料（Excel -> JSON -> POST /api/lims/storage/auto-batch-out-bound） + """ + path = Path(xlsx_path) + if not path.exists(): + raise FileNotFoundError(f"未找到 Excel 文件：{path}") + + try: + df = pd.read_excel(path, sheet_name=0, engine="openpyxl") + except Exception as e: + raise RuntimeError(f"读取 Excel 失败：{e}") + + def pick(names: List[str]) -> Optional[str]: + for n in names: + if n in df.columns: + return n + return None + + c_loc = pick(["locationId", "库位ID", "库位Id", "库位id"]) + c_wh = pick(["warehouseId", "仓库ID", "仓库Id", "仓库id"]) + c_qty = pick(["数量", "quantity"]) + c_x = pick(["x", "X", "posX", "坐标X"]) + c_y = pick(["y", "Y", "posY", "坐标Y"]) + c_z = pick(["z", "Z", "posZ", "坐标Z"]) + + required = [c_loc, c_wh, c_qty, c_x, c_y, c_z] + if any(c is None for c in required): + raise KeyError("Excel 缺少必要列：locationId/warehouseId/数量/x/y/z（支持多别名，至少要能匹配到）。") + + def as_int(v, d=0): + try: + if pd.isna(v): return d + return int(v) + except Exception: + try: + return int(float(v)) + except Exception: + return d + + def as_float(v, d=0.0): + try: + if pd.isna(v): return d + return float(v) + except Exception: + return d + + def as_str(v, d=""): + if v is None or (isinstance(v, float) and pd.isna(v)): return d + s = str(v).strip() + return s if s else d + + items: List[Dict[str, Any]] = [] + for _, row in df.iterrows(): + items.append({ + "locationId": as_str(row[c_loc]), + "warehouseId": as_str(row[c_wh]), + "quantity": as_float(row[c_qty]), + "x": as_int(row[c_x]), + "y": as_int(row[c_y]), + "z": as_int(row[c_z]), + }) + + response = self._post_lims("/api/lims/storage/auto-batch-out-bound", items) + self.wait_for_response_orders(response, "auto_batch_outbound_from_xlsx") + return response + + # 2.14 新建实验 + def create_orders(self, xlsx_path: str) -> Dict[str, Any]: + """ + 从 Excel 解析并创建实验（2.14） + 约定： + - batchId = Excel 文件名（不含扩展名） + - 物料列：所有以 "(g)" 结尾（不再读取“总质量(g)”列） + - totalMass 自动计算为所有物料质量之和 + - createTime 缺失或为空时自动填充为当前日期（YYYY/M/D） + """ + default_path = Path("D:\\UniLab\\Uni-Lab-OS\\unilabos\\devices\\workstation\\bioyond_studio\\bioyond_cell\\2025122301.xlsx") + path = Path(xlsx_path) if xlsx_path else default_path + print(f"[create_orders] 使用 Excel 路径: {path}") + if path != default_path: + print("[create_orders] 来源: 调用方传入自定义路径") + else: + print("[create_orders] 来源: 使用默认模板路径") + + if not path.exists(): + print(f"[create_orders] ⚠️ Excel 文件不存在: {path}") + raise FileNotFoundError(f"未找到 Excel 文件：{path}") + + try: + df = pd.read_excel(path, sheet_name=0, engine="openpyxl") + except Exception as e: + raise RuntimeError(f"读取 Excel 失败：{e}") + print(f"[create_orders] Excel 读取成功，行数: {len(df)}, 列: {list(df.columns)}") + + # 列名容错：返回可选列名，找不到则返回 None + def _pick(col_names: List[str]) -> Optional[str]: + for c in col_names: + if c in df.columns: + return c + return None + + col_order_name = _pick(["配方ID", "orderName", "订单编号"]) + col_create_time = _pick(["创建日期", "createTime"]) + col_bottle_type = _pick(["配液瓶类型", "bottleType"]) + col_mix_time = _pick(["混匀时间(s)", "mixTime"]) + col_load = _pick(["扣电组装分液体积", "loadSheddingInfo"]) + col_pouch = _pick(["软包组装分液体积", "pouchCellInfo"]) + col_cond = _pick(["电导测试分液体积", "conductivityInfo"]) + col_cond_cnt = _pick(["电导测试分液瓶数", "conductivityBottleCount"]) + print("[create_orders] 列匹配结果:", { + "order_name": col_order_name, + "create_time": col_create_time, + "bottle_type": col_bottle_type, + "mix_time": col_mix_time, + "load": col_load, + "pouch": col_pouch, + "conductivity": col_cond, + "conductivity_bottle_count": col_cond_cnt, + }) + + # 物料列：所有以 (g) 结尾 + material_cols = [c for c in df.columns if isinstance(c, str) and c.endswith("(g)")] + print(f"[create_orders] 识别到的物料列: {material_cols}") + if not material_cols: + raise KeyError("未发现任何以“(g)”结尾的物料列，请检查表头。") + + batch_id = path.stem + + def _to_ymd_slash(v) -> str: + # 统一为 "YYYY/M/D"；为空或解析失败则用当前日期 + if v is None or (isinstance(v, float) and pd.isna(v)) or str(v).strip() == "": + ts = datetime.now() + else: + try: + ts = pd.to_datetime(v) + except Exception: + ts = datetime.now() + return f"{ts.year}/{ts.month}/{ts.day}" + + def _as_int(val, default=0) -> int: + try: + if pd.isna(val): + return default + return int(val) + except Exception: + return default + + def _as_float(val, default=0.0) -> float: + try: + if pd.isna(val): + return default + return float(val) + except Exception: + return default + + def _as_str(val, default="") -> str: + if val is None or (isinstance(val, float) and pd.isna(val)): + return default + s = str(val).strip() + return s if s else default + + orders: List[Dict[str, Any]] = [] + + for idx, row in df.iterrows(): + mats: List[Dict[str, Any]] = [] + total_mass = 0.0 + + for mcol in material_cols: + val = row.get(mcol, None) + if val is None or (isinstance(val, float) and pd.isna(val)): + continue + try: + mass = float(val) + except Exception: + continue + if mass > 0: + mats.append({"name": mcol.replace("(g)", ""), "mass": mass}) + total_mass += mass + else: + if mass < 0: + print(f"[create_orders] 第 {idx+1} 行物料 {mcol} 数值为负数: {mass}") + + order_data = { + "batchId": batch_id, + "orderName": _as_str(row[col_order_name], default=f"{batch_id}_order_{idx+1}") if col_order_name else f"{batch_id}_order_{idx+1}", + "createTime": _to_ymd_slash(row[col_create_time]) if col_create_time else _to_ymd_slash(None), + "bottleType": _as_str(row[col_bottle_type], default="配液小瓶") if col_bottle_type else "配液小瓶", + "mixTime": _as_int(row[col_mix_time]) if col_mix_time else 0, + "loadSheddingInfo": _as_float(row[col_load]) if col_load else 0.0, + "pouchCellInfo": _as_float(row[col_pouch]) if col_pouch else 0, + "conductivityInfo": _as_float(row[col_cond]) if col_cond else 0, + "conductivityBottleCount": _as_int(row[col_cond_cnt]) if col_cond_cnt else 0, + "materialInfos": mats, + "totalMass": round(total_mass, 4) # 自动汇总 + } + print(f"[create_orders] 第 {idx+1} 行解析结果: orderName={order_data['orderName']}, " + f"loadShedding={order_data['loadSheddingInfo']}, pouchCell={order_data['pouchCellInfo']}, " + f"conductivity={order_data['conductivityInfo']}, totalMass={order_data['totalMass']}, " + f"material_count={len(mats)}") + + if order_data["totalMass"] <= 0: + print(f"[create_orders] ⚠️ 第 {idx+1} 行总质量 <= 0，可能导致 LIMS 校验失败") + if not mats: + print(f"[create_orders] ⚠️ 第 {idx+1} 行未找到有效物料") + + orders.append(order_data) + print("================================================") + print("orders:", orders) + + print(f"[create_orders] 即将提交订单数量: {len(orders)}") + response = self._post_lims("/api/lims/order/orders", orders) + print(f"[create_orders] 接口返回: {response}") + + # 提取所有返回的 orderCode + data_list = response.get("data", []) + if not data_list: + logger.error("创建订单未返回有效数据！") + return response + + # 收集所有 orderCode + order_codes = [] + for order_item in data_list: + code = order_item.get("orderCode") + if code: + order_codes.append(code) + + if not order_codes: + logger.error("未找到任何有效的 orderCode！") + return response + + print(f"[create_orders] 等待 {len(order_codes)} 个订单完成: {order_codes}") + + # 等待所有订单完成并收集报文 + all_reports = [] + for idx, order_code in enumerate(order_codes, 1): + print(f"[create_orders] 正在等待第 {idx}/{len(order_codes)} 个订单: {order_code}") + result = self.wait_for_order_finish(order_code) + + # 提取报文数据 + if result.get("status") == "success": + report = result.get("report", {}) + + # [新增] 处理试剂数据，计算质量比 + try: + mass_ratios = self._process_order_reagents(report) + report["mass_ratios"] = mass_ratios # 添加到报文中 + logger.info(f"已计算订单 {order_code} 的试剂质量比") + except Exception as e: + logger.error(f"计算试剂质量比失败: {e}") + report["mass_ratios"] = { + "real_mass_ratio": {}, + "target_mass_ratio": {}, + "reagent_details": [], + "error": str(e) + } + + all_reports.append(report) + print(f"[create_orders] ✓ 订单 {order_code} 完成") + else: + logger.warning(f"订单 {order_code} 状态异常: {result.get('status')}") + # 即使订单失败，也记录下这个结果 + all_reports.append({ + "orderCode": order_code, + "status": result.get("status"), + "error": result.get("message", "未知错误") + }) + + print(f"[create_orders] 所有订单已完成，共收集 {len(all_reports)} 个报文") + print("实验记录本========================create_orders========================") + + # 返回所有订单的完成报文 + final_result = { + "status": "all_completed", + "total_orders": len(order_codes), + "reports": all_reports, + "original_response": response + } + + print(f"返回报文数量: {len(all_reports)}") + for i, report in enumerate(all_reports, 1): + print(f"报文 {i}: orderCode={report.get('orderCode', 'N/A')}, status={report.get('status', 'N/A')}") + print("========================") + + return final_result + + def create_orders_v2(self, xlsx_path: str) -> Dict[str, Any]: + """ + 从 Excel 解析并创建实验（2.14）- V2版本 + 约定： + - batchId = Excel 文件名（不含扩展名） + - 物料列：所有以 "(g)" 结尾（不再读取"总质量(g)"列） + - totalMass 自动计算为所有物料质量之和 + - createTime 缺失或为空时自动填充为当前日期（YYYY/M/D） + """ + default_path = Path("D:\\UniLab\\Uni-Lab-OS\\unilabos\\devices\\workstation\\bioyond_studio\\bioyond_cell\\2025122301.xlsx") + path = Path(xlsx_path) if xlsx_path else default_path + print(f"[create_orders_v2] 使用 Excel 路径: {path}") + if path != default_path: + print("[create_orders_v2] 来源: 调用方传入自定义路径") + else: + print("[create_orders_v2] 来源: 使用默认模板路径") + + if not path.exists(): + print(f"[create_orders_v2] ⚠️ Excel 文件不存在: {path}") + raise FileNotFoundError(f"未找到 Excel 文件：{path}") + + try: + df = pd.read_excel(path, sheet_name=0, engine="openpyxl") + except Exception as e: + raise RuntimeError(f"读取 Excel 失败：{e}") + print(f"[create_orders_v2] Excel 读取成功，行数: {len(df)}, 列: {list(df.columns)}") + + # 列名容错：返回可选列名，找不到则返回 None + def _pick(col_names: List[str]) -> Optional[str]: + for c in col_names: + if c in df.columns: + return c + return None + + col_order_name = _pick(["配方ID", "orderName", "订单编号"]) + col_create_time = _pick(["创建日期", "createTime"]) + col_bottle_type = _pick(["配液瓶类型", "bottleType"]) + col_mix_time = _pick(["混匀时间(s)", "mixTime"]) + col_load = _pick(["扣电组装分液体积", "loadSheddingInfo"]) + col_pouch = _pick(["软包组装分液体积", "pouchCellInfo"]) + col_cond = _pick(["电导测试分液体积", "conductivityInfo"]) + col_cond_cnt = _pick(["电导测试分液瓶数", "conductivityBottleCount"]) + print("[create_orders_v2] 列匹配结果:", { + "order_name": col_order_name, + "create_time": col_create_time, + "bottle_type": col_bottle_type, + "mix_time": col_mix_time, + "load": col_load, + "pouch": col_pouch, + "conductivity": col_cond, + "conductivity_bottle_count": col_cond_cnt, + }) + + # 物料列：所有以 (g) 结尾 + material_cols = [c for c in df.columns if isinstance(c, str) and c.endswith("(g)")] + print(f"[create_orders_v2] 识别到的物料列: {material_cols}") + if not material_cols: + raise KeyError("未发现任何以“(g)”结尾的物料列，请检查表头。") + + batch_id = path.stem + + def _to_ymd_slash(v) -> str: + # 统一为 "YYYY/M/D"；为空或解析失败则用当前日期 + if v is None or (isinstance(v, float) and pd.isna(v)) or str(v).strip() == "": + ts = datetime.now() + else: + try: + ts = pd.to_datetime(v) + except Exception: + ts = datetime.now() + return f"{ts.year}/{ts.month}/{ts.day}" + + def _as_int(val, default=0) -> int: + try: + if pd.isna(val): + return default + return int(val) + except Exception: + return default + + def _as_float(val, default=0.0) -> float: + try: + if pd.isna(val): + return default + return float(val) + except Exception: + return default + + def _as_str(val, default="") -> str: + if val is None or (isinstance(val, float) and pd.isna(val)): + return default + s = str(val).strip() + return s if s else default + + orders: List[Dict[str, Any]] = [] + + for idx, row in df.iterrows(): + mats: List[Dict[str, Any]] = [] + total_mass = 0.0 + + for mcol in material_cols: + val = row.get(mcol, None) + if val is None or (isinstance(val, float) and pd.isna(val)): + continue + try: + mass = float(val) + except Exception: + continue + if mass > 0: + mats.append({"name": mcol.replace("(g)", ""), "mass": mass}) + total_mass += mass + else: + if mass < 0: + print(f"[create_orders_v2] 第 {idx+1} 行物料 {mcol} 数值为负数: {mass}") + + order_data = { + "batchId": batch_id, + "orderName": _as_str(row[col_order_name], default=f"{batch_id}_order_{idx+1}") if col_order_name else f"{batch_id}_order_{idx+1}", + "createTime": _to_ymd_slash(row[col_create_time]) if col_create_time else _to_ymd_slash(None), + "bottleType": _as_str(row[col_bottle_type], default="配液小瓶") if col_bottle_type else "配液小瓶", + "mixTime": _as_int(row[col_mix_time]) if col_mix_time else 0, + "loadSheddingInfo": _as_float(row[col_load]) if col_load else 0.0, + "pouchCellInfo": _as_float(row[col_pouch]) if col_pouch else 0, + "conductivityInfo": _as_float(row[col_cond]) if col_cond else 0, + "conductivityBottleCount": _as_int(row[col_cond_cnt]) if col_cond_cnt else 0, + "materialInfos": mats, + "totalMass": round(total_mass, 4) # 自动汇总 + } + print(f"[create_orders_v2] 第 {idx+1} 行解析结果: orderName={order_data['orderName']}, " + f"loadShedding={order_data['loadSheddingInfo']}, pouchCell={order_data['pouchCellInfo']}, " + f"conductivity={order_data['conductivityInfo']}, totalMass={order_data['totalMass']}, " + f"material_count={len(mats)}") + + if order_data["totalMass"] <= 0: + print(f"[create_orders_v2] ⚠️ 第 {idx+1} 行总质量 <= 0，可能导致 LIMS 校验失败") + if not mats: + print(f"[create_orders_v2] ⚠️ 第 {idx+1} 行未找到有效物料") + + orders.append(order_data) + print("================================================") + print("orders:", orders) + + print(f"[create_orders_v2] 即将提交订单数量: {len(orders)}") + response = self._post_lims("/api/lims/order/orders", orders) + print(f"[create_orders_v2] 接口返回: {response}") + + # 提取所有返回的 orderCode + data_list = response.get("data", []) + if not data_list: + logger.error("创建订单未返回有效数据！") + return response + + # 收集所有 orderCode + order_codes = [] + for order_item in data_list: + code = order_item.get("orderCode") + if code: + order_codes.append(code) + + if not order_codes: + logger.error("未找到任何有效的 orderCode！") + return response + + print(f"[create_orders_v2] 等待 {len(order_codes)} 个订单完成: {order_codes}") + + # ========== 步骤1: 等待所有订单完成并收集报文（不计算质量比）========== + all_reports = [] + for idx, order_code in enumerate(order_codes, 1): + print(f"[create_orders_v2] 正在等待第 {idx}/{len(order_codes)} 个订单: {order_code}") + result = self.wait_for_order_finish(order_code) + + # 提取报文数据 + if result.get("status") == "success": + report = result.get("report", {}) + all_reports.append(report) + print(f"[create_orders_v2] ✓ 订单 {order_code} 完成") + else: + logger.warning(f"订单 {order_code} 状态异常: {result.get('status')}") + # 即使订单失败，也记录下这个结果 + all_reports.append({ + "orderCode": order_code, + "status": result.get("status"), + "error": result.get("message", "未知错误") + }) + + print(f"[create_orders_v2] 所有订单已完成，共收集 {len(all_reports)} 个报文") + + # ========== 步骤2: 统一计算所有订单的质量比 ========== + print(f"[create_orders_v2] 开始统一计算 {len(all_reports)} 个订单的质量比...") + all_mass_ratios = [] # 存储所有订单的质量比，与reports顺序一致 + + for idx, report in enumerate(all_reports, 1): + order_code = report.get("orderCode", "N/A") + print(f"[create_orders_v2] 计算第 {idx}/{len(all_reports)} 个订单 {order_code} 的质量比...") + + # 只为成功完成的订单计算质量比 + if "error" not in report: + try: + mass_ratios = self._process_order_reagents(report) + # 精简输出，只保留核心质量比信息 + all_mass_ratios.append({ + "orderCode": order_code, + "orderName": report.get("orderName", "N/A"), + "real_mass_ratio": mass_ratios.get("real_mass_ratio", {}), + "target_mass_ratio": mass_ratios.get("target_mass_ratio", {}) + }) + logger.info(f"✓ 已计算订单 {order_code} 的试剂质量比") + except Exception as e: + logger.error(f"计算订单 {order_code} 质量比失败: {e}") + all_mass_ratios.append({ + "orderCode": order_code, + "orderName": report.get("orderName", "N/A"), + "real_mass_ratio": {}, + "target_mass_ratio": {}, + "error": str(e) + }) + else: + # 失败的订单不计算质量比 + all_mass_ratios.append({ + "orderCode": order_code, + "orderName": report.get("orderName", "N/A"), + "real_mass_ratio": {}, + "target_mass_ratio": {}, + "error": "订单未成功完成" + }) + + print(f"[create_orders_v2] 质量比计算完成") + print("实验记录本========================create_orders_v2========================") + + # 返回所有订单的完成报文 + final_result = { + "status": "all_completed", + "total_orders": len(order_codes), + "bottle_count": len(order_codes), # 明确标注瓶数，用于下游check + "reports": all_reports, # 原始订单报文（不含质量比） + "mass_ratios": all_mass_ratios, # 所有质量比统一放在这里 + "original_response": response + } + + print(f"返回报文数量: {len(all_reports)}") + for i, report in enumerate(all_reports, 1): + print(f"报文 {i}: orderCode={report.get('orderCode', 'N/A')}, status={report.get('status', 'N/A')}") + print("========================") + + return final_result + + # 2.7 启动调度 + def scheduler_start(self) -> Dict[str, Any]: + return self._post_lims("/api/lims/scheduler/start") + # 3.10 停止调度 + def scheduler_stop(self) -> Dict[str, Any]: + + """ + 停止调度 (3.10) + 请求体只包含 apiKey 和 requestTime + """ + return self._post_lims("/api/lims/scheduler/stop") + + # 2.9 继续调度 + def scheduler_continue(self) -> Dict[str, Any]: + """ + 继续调度 (2.9) + 请求体只包含 apiKey 和 requestTime + """ + return self._post_lims("/api/lims/scheduler/continue") + def scheduler_reset(self) -> Dict[str, Any]: + """ + 复位调度 (2.11) + 请求体只包含 apiKey 和 requestTime + """ + return self._post_lims("/api/lims/scheduler/reset") + + def scheduler_start_and_auto_feeding( + self, + # ★ Excel路径参数 + xlsx_path: Optional[str] = "D:\\UniLab\\Uni-Lab-OS\\unilabos\\devices\\workstation\\bioyond_studio\\bioyond_cell\\material_template.xlsx", + # ---------------- WH4 - 加样头面 (Z=1, 12个点位) ---------------- + WH4_x1_y1_z1_1_materialName: str = "", WH4_x1_y1_z1_1_quantity: float = 0.0, + WH4_x2_y1_z1_2_materialName: str = "", WH4_x2_y1_z1_2_quantity: float = 0.0, + WH4_x3_y1_z1_3_materialName: str = "", WH4_x3_y1_z1_3_quantity: float = 0.0, + WH4_x4_y1_z1_4_materialName: str = "", WH4_x4_y1_z1_4_quantity: float = 0.0, + WH4_x5_y1_z1_5_materialName: str = "", WH4_x5_y1_z1_5_quantity: float = 0.0, + WH4_x1_y2_z1_6_materialName: str = "", WH4_x1_y2_z1_6_quantity: float = 0.0, + WH4_x2_y2_z1_7_materialName: str = "", WH4_x2_y2_z1_7_quantity: float = 0.0, + WH4_x3_y2_z1_8_materialName: str = "", WH4_x3_y2_z1_8_quantity: float = 0.0, + WH4_x4_y2_z1_9_materialName: str = "", WH4_x4_y2_z1_9_quantity: float = 0.0, + WH4_x5_y2_z1_10_materialName: str = "", WH4_x5_y2_z1_10_quantity: float = 0.0, + WH4_x1_y3_z1_11_materialName: str = "", WH4_x1_y3_z1_11_quantity: float = 0.0, + WH4_x2_y3_z1_12_materialName: str = "", WH4_x2_y3_z1_12_quantity: float = 0.0, + + # ---------------- WH4 - 原液瓶面 (Z=2, 9个点位) ---------------- + WH4_x1_y1_z2_1_materialName: str = "", WH4_x1_y1_z2_1_quantity: float = 0.0, WH4_x1_y1_z2_1_materialType: str = "", WH4_x1_y1_z2_1_targetWH: str = "", + WH4_x2_y1_z2_2_materialName: str = "", WH4_x2_y1_z2_2_quantity: float = 0.0, WH4_x2_y1_z2_2_materialType: str = "", WH4_x2_y1_z2_2_targetWH: str = "", + WH4_x3_y1_z2_3_materialName: str = "", WH4_x3_y1_z2_3_quantity: float = 0.0, WH4_x3_y1_z2_3_materialType: str = "", WH4_x3_y1_z2_3_targetWH: str = "", + WH4_x1_y2_z2_4_materialName: str = "", WH4_x1_y2_z2_4_quantity: float = 0.0, WH4_x1_y2_z2_4_materialType: str = "", WH4_x1_y2_z2_4_targetWH: str = "", + WH4_x2_y2_z2_5_materialName: str = "", WH4_x2_y2_z2_5_quantity: float = 0.0, WH4_x2_y2_z2_5_materialType: str = "", WH4_x2_y2_z2_5_targetWH: str = "", + WH4_x3_y2_z2_6_materialName: str = "", WH4_x3_y2_z2_6_quantity: float = 0.0, WH4_x3_y2_z2_6_materialType: str = "", WH4_x3_y2_z2_6_targetWH: str = "", + WH4_x1_y3_z2_7_materialName: str = "", WH4_x1_y3_z2_7_quantity: float = 0.0, WH4_x1_y3_z2_7_materialType: str = "", WH4_x1_y3_z2_7_targetWH: str = "", + WH4_x2_y3_z2_8_materialName: str = "", WH4_x2_y3_z2_8_quantity: float = 0.0, WH4_x2_y3_z2_8_materialType: str = "", WH4_x2_y3_z2_8_targetWH: str = "", + WH4_x3_y3_z2_9_materialName: str = "", WH4_x3_y3_z2_9_quantity: float = 0.0, WH4_x3_y3_z2_9_materialType: str = "", WH4_x3_y3_z2_9_targetWH: str = "", + + # ---------------- WH3 - 人工堆栈 (Z=3, 15个点位) ---------------- + WH3_x1_y1_z3_1_materialType: str = "", WH3_x1_y1_z3_1_materialId: str = "", WH3_x1_y1_z3_1_quantity: float = 0, + WH3_x2_y1_z3_2_materialType: str = "", WH3_x2_y1_z3_2_materialId: str = "", WH3_x2_y1_z3_2_quantity: float = 0, + WH3_x3_y1_z3_3_materialType: str = "", WH3_x3_y1_z3_3_materialId: str = "", WH3_x3_y1_z3_3_quantity: float = 0, + WH3_x1_y2_z3_4_materialType: str = "", WH3_x1_y2_z3_4_materialId: str = "", WH3_x1_y2_z3_4_quantity: float = 0, + WH3_x2_y2_z3_5_materialType: str = "", WH3_x2_y2_z3_5_materialId: str = "", WH3_x2_y2_z3_5_quantity: float = 0, + WH3_x3_y2_z3_6_materialType: str = "", WH3_x3_y2_z3_6_materialId: str = "", WH3_x3_y2_z3_6_quantity: float = 0, + WH3_x1_y3_z3_7_materialType: str = "", WH3_x1_y3_z3_7_materialId: str = "", WH3_x1_y3_z3_7_quantity: float = 0, + WH3_x2_y3_z3_8_materialType: str = "", WH3_x2_y3_z3_8_materialId: str = "", WH3_x2_y3_z3_8_quantity: float = 0, + WH3_x3_y3_z3_9_materialType: str = "", WH3_x3_y3_z3_9_materialId: str = "", WH3_x3_y3_z3_9_quantity: float = 0, + WH3_x1_y4_z3_10_materialType: str = "", WH3_x1_y4_z3_10_materialId: str = "", WH3_x1_y4_z3_10_quantity: float = 0, + WH3_x2_y4_z3_11_materialType: str = "", WH3_x2_y4_z3_11_materialId: str = "", WH3_x2_y4_z3_11_quantity: float = 0, + WH3_x3_y4_z3_12_materialType: str = "", WH3_x3_y4_z3_12_materialId: str = "", WH3_x3_y4_z3_12_quantity: float = 0, + WH3_x1_y5_z3_13_materialType: str = "", WH3_x1_y5_z3_13_materialId: str = "", WH3_x1_y5_z3_13_quantity: float = 0, + WH3_x2_y5_z3_14_materialType: str = "", WH3_x2_y5_z3_14_materialId: str = "", WH3_x2_y5_z3_14_quantity: float = 0, + WH3_x3_y5_z3_15_materialType: str = "", WH3_x3_y5_z3_15_materialId: str = "", WH3_x3_y5_z3_15_quantity: float = 0, + ) -> Dict[str, Any]: + """ + 组合函数：先启动调度，然后执行自动化上料 + + 此函数简化了工作流操作，将两个有顺序依赖的操作组合在一起： + 1. 启动调度（scheduler_start） + 2. 自动化上料（auto_feeding4to3） + + 参数与 auto_feeding4to3 完全相同，支持 Excel 和手动参数两种模式 + + Returns: + 包含调度启动结果和上料结果的字典 + """ + logger.info("=" * 60) + logger.info("开始执行组合操作：启动调度 + 自动化上料") + logger.info("=" * 60) + + # 步骤1: 启动调度 + logger.info("【步骤 1/2】启动调度...") + scheduler_result = self.scheduler_start() + logger.info(f"调度启动结果: {scheduler_result}") + + # 检查调度是否启动成功 + if scheduler_result.get("code") != 1: + logger.error(f"调度启动失败: {scheduler_result}") + return { + "success": False, + "step": "scheduler_start", + "scheduler_result": scheduler_result, + "error": "调度启动失败" + } + + logger.info("✓ 调度启动成功") + + # 步骤2: 执行自动化上料 + logger.info("【步骤 2/2】执行自动化上料...") + feeding_result = self.auto_feeding4to3( + xlsx_path=xlsx_path, + WH4_x1_y1_z1_1_materialName=WH4_x1_y1_z1_1_materialName, WH4_x1_y1_z1_1_quantity=WH4_x1_y1_z1_1_quantity, + WH4_x2_y1_z1_2_materialName=WH4_x2_y1_z1_2_materialName, WH4_x2_y1_z1_2_quantity=WH4_x2_y1_z1_2_quantity, + WH4_x3_y1_z1_3_materialName=WH4_x3_y1_z1_3_materialName, WH4_x3_y1_z1_3_quantity=WH4_x3_y1_z1_3_quantity, + WH4_x4_y1_z1_4_materialName=WH4_x4_y1_z1_4_materialName, WH4_x4_y1_z1_4_quantity=WH4_x4_y1_z1_4_quantity, + WH4_x5_y1_z1_5_materialName=WH4_x5_y1_z1_5_materialName, WH4_x5_y1_z1_5_quantity=WH4_x5_y1_z1_5_quantity, + WH4_x1_y2_z1_6_materialName=WH4_x1_y2_z1_6_materialName, WH4_x1_y2_z1_6_quantity=WH4_x1_y2_z1_6_quantity, + WH4_x2_y2_z1_7_materialName=WH4_x2_y2_z1_7_materialName, WH4_x2_y2_z1_7_quantity=WH4_x2_y2_z1_7_quantity, + WH4_x3_y2_z1_8_materialName=WH4_x3_y2_z1_8_materialName, WH4_x3_y2_z1_8_quantity=WH4_x3_y2_z1_8_quantity, + WH4_x4_y2_z1_9_materialName=WH4_x4_y2_z1_9_materialName, WH4_x4_y2_z1_9_quantity=WH4_x4_y2_z1_9_quantity, + WH4_x5_y2_z1_10_materialName=WH4_x5_y2_z1_10_materialName, WH4_x5_y2_z1_10_quantity=WH4_x5_y2_z1_10_quantity, + WH4_x1_y3_z1_11_materialName=WH4_x1_y3_z1_11_materialName, WH4_x1_y3_z1_11_quantity=WH4_x1_y3_z1_11_quantity, + WH4_x2_y3_z1_12_materialName=WH4_x2_y3_z1_12_materialName, WH4_x2_y3_z1_12_quantity=WH4_x2_y3_z1_12_quantity, + WH4_x1_y1_z2_1_materialName=WH4_x1_y1_z2_1_materialName, WH4_x1_y1_z2_1_quantity=WH4_x1_y1_z2_1_quantity, + WH4_x1_y1_z2_1_materialType=WH4_x1_y1_z2_1_materialType, WH4_x1_y1_z2_1_targetWH=WH4_x1_y1_z2_1_targetWH, + WH4_x2_y1_z2_2_materialName=WH4_x2_y1_z2_2_materialName, WH4_x2_y1_z2_2_quantity=WH4_x2_y1_z2_2_quantity, + WH4_x2_y1_z2_2_materialType=WH4_x2_y1_z2_2_materialType, WH4_x2_y1_z2_2_targetWH=WH4_x2_y1_z2_2_targetWH, + WH4_x3_y1_z2_3_materialName=WH4_x3_y1_z2_3_materialName, WH4_x3_y1_z2_3_quantity=WH4_x3_y1_z2_3_quantity, + WH4_x3_y1_z2_3_materialType=WH4_x3_y1_z2_3_materialType, WH4_x3_y1_z2_3_targetWH=WH4_x3_y1_z2_3_targetWH, + WH4_x1_y2_z2_4_materialName=WH4_x1_y2_z2_4_materialName, WH4_x1_y2_z2_4_quantity=WH4_x1_y2_z2_4_quantity, + WH4_x1_y2_z2_4_materialType=WH4_x1_y2_z2_4_materialType, WH4_x1_y2_z2_4_targetWH=WH4_x1_y2_z2_4_targetWH, + WH4_x2_y2_z2_5_materialName=WH4_x2_y2_z2_5_materialName, WH4_x2_y2_z2_5_quantity=WH4_x2_y2_z2_5_quantity, + WH4_x2_y2_z2_5_materialType=WH4_x2_y2_z2_5_materialType, WH4_x2_y2_z2_5_targetWH=WH4_x2_y2_z2_5_targetWH, + WH4_x3_y2_z2_6_materialName=WH4_x3_y2_z2_6_materialName, WH4_x3_y2_z2_6_quantity=WH4_x3_y2_z2_6_quantity, + WH4_x3_y2_z2_6_materialType=WH4_x3_y2_z2_6_materialType, WH4_x3_y2_z2_6_targetWH=WH4_x3_y2_z2_6_targetWH, + WH4_x1_y3_z2_7_materialName=WH4_x1_y3_z2_7_materialName, WH4_x1_y3_z2_7_quantity=WH4_x1_y3_z2_7_quantity, + WH4_x1_y3_z2_7_materialType=WH4_x1_y3_z2_7_materialType, WH4_x1_y3_z2_7_targetWH=WH4_x1_y3_z2_7_targetWH, + WH4_x2_y3_z2_8_materialName=WH4_x2_y3_z2_8_materialName, WH4_x2_y3_z2_8_quantity=WH4_x2_y3_z2_8_quantity, + WH4_x2_y3_z2_8_materialType=WH4_x2_y3_z2_8_materialType, WH4_x2_y3_z2_8_targetWH=WH4_x2_y3_z2_8_targetWH, + WH4_x3_y3_z2_9_materialName=WH4_x3_y3_z2_9_materialName, WH4_x3_y3_z2_9_quantity=WH4_x3_y3_z2_9_quantity, + WH4_x3_y3_z2_9_materialType=WH4_x3_y3_z2_9_materialType, WH4_x3_y3_z2_9_targetWH=WH4_x3_y3_z2_9_targetWH, + WH3_x1_y1_z3_1_materialType=WH3_x1_y1_z3_1_materialType, WH3_x1_y1_z3_1_materialId=WH3_x1_y1_z3_1_materialId, WH3_x1_y1_z3_1_quantity=WH3_x1_y1_z3_1_quantity, + WH3_x2_y1_z3_2_materialType=WH3_x2_y1_z3_2_materialType, WH3_x2_y1_z3_2_materialId=WH3_x2_y1_z3_2_materialId, WH3_x2_y1_z3_2_quantity=WH3_x2_y1_z3_2_quantity, + WH3_x3_y1_z3_3_materialType=WH3_x3_y1_z3_3_materialType, WH3_x3_y1_z3_3_materialId=WH3_x3_y1_z3_3_materialId, WH3_x3_y1_z3_3_quantity=WH3_x3_y1_z3_3_quantity, + WH3_x1_y2_z3_4_materialType=WH3_x1_y2_z3_4_materialType, WH3_x1_y2_z3_4_materialId=WH3_x1_y2_z3_4_materialId, WH3_x1_y2_z3_4_quantity=WH3_x1_y2_z3_4_quantity, + WH3_x2_y2_z3_5_materialType=WH3_x2_y2_z3_5_materialType, WH3_x2_y2_z3_5_materialId=WH3_x2_y2_z3_5_materialId, WH3_x2_y2_z3_5_quantity=WH3_x2_y2_z3_5_quantity, + WH3_x3_y2_z3_6_materialType=WH3_x3_y2_z3_6_materialType, WH3_x3_y2_z3_6_materialId=WH3_x3_y2_z3_6_materialId, WH3_x3_y2_z3_6_quantity=WH3_x3_y2_z3_6_quantity, + WH3_x1_y3_z3_7_materialType=WH3_x1_y3_z3_7_materialType, WH3_x1_y3_z3_7_materialId=WH3_x1_y3_z3_7_materialId, WH3_x1_y3_z3_7_quantity=WH3_x1_y3_z3_7_quantity, + WH3_x2_y3_z3_8_materialType=WH3_x2_y3_z3_8_materialType, WH3_x2_y3_z3_8_materialId=WH3_x2_y3_z3_8_materialId, WH3_x2_y3_z3_8_quantity=WH3_x2_y3_z3_8_quantity, + WH3_x3_y3_z3_9_materialType=WH3_x3_y3_z3_9_materialType, WH3_x3_y3_z3_9_materialId=WH3_x3_y3_z3_9_materialId, WH3_x3_y3_z3_9_quantity=WH3_x3_y3_z3_9_quantity, + WH3_x1_y4_z3_10_materialType=WH3_x1_y4_z3_10_materialType, WH3_x1_y4_z3_10_materialId=WH3_x1_y4_z3_10_materialId, WH3_x1_y4_z3_10_quantity=WH3_x1_y4_z3_10_quantity, + WH3_x2_y4_z3_11_materialType=WH3_x2_y4_z3_11_materialType, WH3_x2_y4_z3_11_materialId=WH3_x2_y4_z3_11_materialId, WH3_x2_y4_z3_11_quantity=WH3_x2_y4_z3_11_quantity, + WH3_x3_y4_z3_12_materialType=WH3_x3_y4_z3_12_materialType, WH3_x3_y4_z3_12_materialId=WH3_x3_y4_z3_12_materialId, WH3_x3_y4_z3_12_quantity=WH3_x3_y4_z3_12_quantity, + WH3_x1_y5_z3_13_materialType=WH3_x1_y5_z3_13_materialType, WH3_x1_y5_z3_13_materialId=WH3_x1_y5_z3_13_materialId, WH3_x1_y5_z3_13_quantity=WH3_x1_y5_z3_13_quantity, + WH3_x2_y5_z3_14_materialType=WH3_x2_y5_z3_14_materialType, WH3_x2_y5_z3_14_materialId=WH3_x2_y5_z3_14_materialId, WH3_x2_y5_z3_14_quantity=WH3_x2_y5_z3_14_quantity, + WH3_x3_y5_z3_15_materialType=WH3_x3_y5_z3_15_materialType, WH3_x3_y5_z3_15_materialId=WH3_x3_y5_z3_15_materialId, WH3_x3_y5_z3_15_quantity=WH3_x3_y5_z3_15_quantity, + ) + + logger.info("=" * 60) + logger.info("组合操作完成") + logger.info("=" * 60) + + return { + "success": True, + "scheduler_result": scheduler_result, + "feeding_result": feeding_result + } + + + def scheduler_start_and_auto_feeding_v2( + self, + # ★ Excel路径参数 + xlsx_path: Optional[str] = "D:\\UniLab\\Uni-Lab-OS\\unilabos\\devices\\workstation\\bioyond_studio\\bioyond_cell\\material_template.xlsx", + # ---------------- WH4 - 加样头面 (Z=1, 12个点位) ---------------- + WH4_x1_y1_z1_1_materialName: str = "", WH4_x1_y1_z1_1_quantity: float = 0.0, + WH4_x2_y1_z1_2_materialName: str = "", WH4_x2_y1_z1_2_quantity: float = 0.0, + WH4_x3_y1_z1_3_materialName: str = "", WH4_x3_y1_z1_3_quantity: float = 0.0, + WH4_x4_y1_z1_4_materialName: str = "", WH4_x4_y1_z1_4_quantity: float = 0.0, + WH4_x5_y1_z1_5_materialName: str = "", WH4_x5_y1_z1_5_quantity: float = 0.0, + WH4_x1_y2_z1_6_materialName: str = "", WH4_x1_y2_z1_6_quantity: float = 0.0, + WH4_x2_y2_z1_7_materialName: str = "", WH4_x2_y2_z1_7_quantity: float = 0.0, + WH4_x3_y2_z1_8_materialName: str = "", WH4_x3_y2_z1_8_quantity: float = 0.0, + WH4_x4_y2_z1_9_materialName: str = "", WH4_x4_y2_z1_9_quantity: float = 0.0, + WH4_x5_y2_z1_10_materialName: str = "", WH4_x5_y2_z1_10_quantity: float = 0.0, + WH4_x1_y3_z1_11_materialName: str = "", WH4_x1_y3_z1_11_quantity: float = 0.0, + WH4_x2_y3_z1_12_materialName: str = "", WH4_x2_y3_z1_12_quantity: float = 0.0, + + # ---------------- WH4 - 原液瓶面 (Z=2, 9个点位) ---------------- + WH4_x1_y1_z2_1_materialName: str = "", WH4_x1_y1_z2_1_quantity: float = 0.0, WH4_x1_y1_z2_1_materialType: str = "", WH4_x1_y1_z2_1_targetWH: str = "", + WH4_x2_y1_z2_2_materialName: str = "", WH4_x2_y1_z2_2_quantity: float = 0.0, WH4_x2_y1_z2_2_materialType: str = "", WH4_x2_y1_z2_2_targetWH: str = "", + WH4_x3_y1_z2_3_materialName: str = "", WH4_x3_y1_z2_3_quantity: float = 0.0, WH4_x3_y1_z2_3_materialType: str = "", WH4_x3_y1_z2_3_targetWH: str = "", + WH4_x1_y2_z2_4_materialName: str = "", WH4_x1_y2_z2_4_quantity: float = 0.0, WH4_x1_y2_z2_4_materialType: str = "", WH4_x1_y2_z2_4_targetWH: str = "", + WH4_x2_y2_z2_5_materialName: str = "", WH4_x2_y2_z2_5_quantity: float = 0.0, WH4_x2_y2_z2_5_materialType: str = "", WH4_x2_y2_z2_5_targetWH: str = "", + WH4_x3_y2_z2_6_materialName: str = "", WH4_x3_y2_z2_6_quantity: float = 0.0, WH4_x3_y2_z2_6_materialType: str = "", WH4_x3_y2_z2_6_targetWH: str = "", + WH4_x1_y3_z2_7_materialName: str = "", WH4_x1_y3_z2_7_quantity: float = 0.0, WH4_x1_y3_z2_7_materialType: str = "", WH4_x1_y3_z2_7_targetWH: str = "", + WH4_x2_y3_z2_8_materialName: str = "", WH4_x2_y3_z2_8_quantity: float = 0.0, WH4_x2_y3_z2_8_materialType: str = "", WH4_x2_y3_z2_8_targetWH: str = "", + WH4_x3_y3_z2_9_materialName: str = "", WH4_x3_y3_z2_9_quantity: float = 0.0, WH4_x3_y3_z2_9_materialType: str = "", WH4_x3_y3_z2_9_targetWH: str = "", + + # ---------------- WH3 - 人工堆栈 (Z=3, 15个点位) ---------------- + WH3_x1_y1_z3_1_materialType: str = "", WH3_x1_y1_z3_1_materialId: str = "", WH3_x1_y1_z3_1_quantity: float = 0, + WH3_x2_y1_z3_2_materialType: str = "", WH3_x2_y1_z3_2_materialId: str = "", WH3_x2_y1_z3_2_quantity: float = 0, + WH3_x3_y1_z3_3_materialType: str = "", WH3_x3_y1_z3_3_materialId: str = "", WH3_x3_y1_z3_3_quantity: float = 0, + WH3_x1_y2_z3_4_materialType: str = "", WH3_x1_y2_z3_4_materialId: str = "", WH3_x1_y2_z3_4_quantity: float = 0, + WH3_x2_y2_z3_5_materialType: str = "", WH3_x2_y2_z3_5_materialId: str = "", WH3_x2_y2_z3_5_quantity: float = 0, + WH3_x3_y2_z3_6_materialType: str = "", WH3_x3_y2_z3_6_materialId: str = "", WH3_x3_y2_z3_6_quantity: float = 0, + WH3_x1_y3_z3_7_materialType: str = "", WH3_x1_y3_z3_7_materialId: str = "", WH3_x1_y3_z3_7_quantity: float = 0, + WH3_x2_y3_z3_8_materialType: str = "", WH3_x2_y3_z3_8_materialId: str = "", WH3_x2_y3_z3_8_quantity: float = 0, + WH3_x3_y3_z3_9_materialType: str = "", WH3_x3_y3_z3_9_materialId: str = "", WH3_x3_y3_z3_9_quantity: float = 0, + WH3_x1_y4_z3_10_materialType: str = "", WH3_x1_y4_z3_10_materialId: str = "", WH3_x1_y4_z3_10_quantity: float = 0, + WH3_x2_y4_z3_11_materialType: str = "", WH3_x2_y4_z3_11_materialId: str = "", WH3_x2_y4_z3_11_quantity: float = 0, + WH3_x3_y4_z3_12_materialType: str = "", WH3_x3_y4_z3_12_materialId: str = "", WH3_x3_y4_z3_12_quantity: float = 0, + WH3_x1_y5_z3_13_materialType: str = "", WH3_x1_y5_z3_13_materialId: str = "", WH3_x1_y5_z3_13_quantity: float = 0, + WH3_x2_y5_z3_14_materialType: str = "", WH3_x2_y5_z3_14_materialId: str = "", WH3_x2_y5_z3_14_quantity: float = 0, + WH3_x3_y5_z3_15_materialType: str = "", WH3_x3_y5_z3_15_materialId: str = "", WH3_x3_y5_z3_15_quantity: float = 0, + ) -> Dict[str, Any]: + """ + 组合函数 V2 版本（测试版）：先启动调度，然后执行自动化上料 + + ⚠️ 这是测试版本，使用非阻塞轮询等待方式，避免 ROS2 Action feedback publisher 失效 + + 与 V1 的区别： + - 使用 wait_for_order_finish_polling 替代原有的阻塞等待 + - 允许 ROS2 在等待期间正常发布 feedback 消息 + - 适用于长时间运行的任务 + + 参数与 scheduler_start_and_auto_feeding 完全相同 + + Returns: + 包含调度启动结果和上料结果的字典 + """ + logger.info("=" * 60) + logger.info("[V2测试版本] 开始执行组合操作：启动调度 + 自动化上料") + logger.info("=" * 60) + + # 步骤1: 启动调度 + logger.info("【步骤 1/2】启动调度...") + scheduler_result = self.scheduler_start() + logger.info(f"调度启动结果: {scheduler_result}") + + # 检查调度是否启动成功 + if scheduler_result.get("code") != 1: + logger.error(f"调度启动失败: {scheduler_result}") + return { + "success": False, + "step": "scheduler_start", + "scheduler_result": scheduler_result, + "error": "调度启动失败" + } + + logger.info("✓ 调度启动成功") + + # 步骤2: 执行自动化上料（这里会调用 auto_feeding4to3，内部使用轮询等待） + logger.info("【步骤 2/2】执行自动化上料...") + + # 临时替换 wait_for_order_finish 为轮询版本 + original_wait_func = self.wait_for_order_finish + self.wait_for_order_finish = self.wait_for_order_finish_polling + + try: + feeding_result = self.auto_feeding4to3( + xlsx_path=xlsx_path, + WH4_x1_y1_z1_1_materialName=WH4_x1_y1_z1_1_materialName, WH4_x1_y1_z1_1_quantity=WH4_x1_y1_z1_1_quantity, + WH4_x2_y1_z1_2_materialName=WH4_x2_y1_z1_2_materialName, WH4_x2_y1_z1_2_quantity=WH4_x2_y1_z1_2_quantity, + WH4_x3_y1_z1_3_materialName=WH4_x3_y1_z1_3_materialName, WH4_x3_y1_z1_3_quantity=WH4_x3_y1_z1_3_quantity, + WH4_x4_y1_z1_4_materialName=WH4_x4_y1_z1_4_materialName, WH4_x4_y1_z1_4_quantity=WH4_x4_y1_z1_4_quantity, + WH4_x5_y1_z1_5_materialName=WH4_x5_y1_z1_5_materialName, WH4_x5_y1_z1_5_quantity=WH4_x5_y1_z1_5_quantity, + WH4_x1_y2_z1_6_materialName=WH4_x1_y2_z1_6_materialName, WH4_x1_y2_z1_6_quantity=WH4_x1_y2_z1_6_quantity, + WH4_x2_y2_z1_7_materialName=WH4_x2_y2_z1_7_materialName, WH4_x2_y2_z1_7_quantity=WH4_x2_y2_z1_7_quantity, + WH4_x3_y2_z1_8_materialName=WH4_x3_y2_z1_8_materialName, WH4_x3_y2_z1_8_quantity=WH4_x3_y2_z1_8_quantity, + WH4_x4_y2_z1_9_materialName=WH4_x4_y2_z1_9_materialName, WH4_x4_y2_z1_9_quantity=WH4_x4_y2_z1_9_quantity, + WH4_x5_y2_z1_10_materialName=WH4_x5_y2_z1_10_materialName, WH4_x5_y2_z1_10_quantity=WH4_x5_y2_z1_10_quantity, + WH4_x1_y3_z1_11_materialName=WH4_x1_y3_z1_11_materialName, WH4_x1_y3_z1_11_quantity=WH4_x1_y3_z1_11_quantity, + WH4_x2_y3_z1_12_materialName=WH4_x2_y3_z1_12_materialName, WH4_x2_y3_z1_12_quantity=WH4_x2_y3_z1_12_quantity, + WH4_x1_y1_z2_1_materialName=WH4_x1_y1_z2_1_materialName, WH4_x1_y1_z2_1_quantity=WH4_x1_y1_z2_1_quantity, + WH4_x1_y1_z2_1_materialType=WH4_x1_y1_z2_1_materialType, WH4_x1_y1_z2_1_targetWH=WH4_x1_y1_z2_1_targetWH, + WH4_x2_y1_z2_2_materialName=WH4_x2_y1_z2_2_materialName, WH4_x2_y1_z2_2_quantity=WH4_x2_y1_z2_2_quantity, + WH4_x2_y1_z2_2_materialType=WH4_x2_y1_z2_2_materialType, WH4_x2_y1_z2_2_targetWH=WH4_x2_y1_z2_2_targetWH, + WH4_x3_y1_z2_3_materialName=WH4_x3_y1_z2_3_materialName, WH4_x3_y1_z2_3_quantity=WH4_x3_y1_z2_3_quantity, + WH4_x3_y1_z2_3_materialType=WH4_x3_y1_z2_3_materialType, WH4_x3_y1_z2_3_targetWH=WH4_x3_y1_z2_3_targetWH, + WH4_x1_y2_z2_4_materialName=WH4_x1_y2_z2_4_materialName, WH4_x1_y2_z2_4_quantity=WH4_x1_y2_z2_4_quantity, + WH4_x1_y2_z2_4_materialType=WH4_x1_y2_z2_4_materialType, WH4_x1_y2_z2_4_targetWH=WH4_x1_y2_z2_4_targetWH, + WH4_x2_y2_z2_5_materialName=WH4_x2_y2_z2_5_materialName, WH4_x2_y2_z2_5_quantity=WH4_x2_y2_z2_5_quantity, + WH4_x2_y2_z2_5_materialType=WH4_x2_y2_z2_5_materialType, WH4_x2_y2_z2_5_targetWH=WH4_x2_y2_z2_5_targetWH, + WH4_x3_y2_z2_6_materialName=WH4_x3_y2_z2_6_materialName, WH4_x3_y2_z2_6_quantity=WH4_x3_y2_z2_6_quantity, + WH4_x3_y2_z2_6_materialType=WH4_x3_y2_z2_6_materialType, WH4_x3_y2_z2_6_targetWH=WH4_x3_y2_z2_6_targetWH, + WH4_x1_y3_z2_7_materialName=WH4_x1_y3_z2_7_materialName, WH4_x1_y3_z2_7_quantity=WH4_x1_y3_z2_7_quantity, + WH4_x1_y3_z2_7_materialType=WH4_x1_y3_z2_7_materialType, WH4_x1_y3_z2_7_targetWH=WH4_x1_y3_z2_7_targetWH, + WH4_x2_y3_z2_8_materialName=WH4_x2_y3_z2_8_materialName, WH4_x2_y3_z2_8_quantity=WH4_x2_y3_z2_8_quantity, + WH4_x2_y3_z2_8_materialType=WH4_x2_y3_z2_8_materialType, WH4_x2_y3_z2_8_targetWH=WH4_x2_y3_z2_8_targetWH, + WH4_x3_y3_z2_9_materialName=WH4_x3_y3_z2_9_materialName, WH4_x3_y3_z2_9_quantity=WH4_x3_y3_z2_9_quantity, + WH4_x3_y3_z2_9_materialType=WH4_x3_y3_z2_9_materialType, WH4_x3_y3_z2_9_targetWH=WH4_x3_y3_z2_9_targetWH, + WH3_x1_y1_z3_1_materialType=WH3_x1_y1_z3_1_materialType, WH3_x1_y1_z3_1_materialId=WH3_x1_y1_z3_1_materialId, WH3_x1_y1_z3_1_quantity=WH3_x1_y1_z3_1_quantity, + WH3_x2_y1_z3_2_materialType=WH3_x2_y1_z3_2_materialType, WH3_x2_y1_z3_2_materialId=WH3_x2_y1_z3_2_materialId, WH3_x2_y1_z3_2_quantity=WH3_x2_y1_z3_2_quantity, + WH3_x3_y1_z3_3_materialType=WH3_x3_y1_z3_3_materialType, WH3_x3_y1_z3_3_materialId=WH3_x3_y1_z3_3_materialId, WH3_x3_y1_z3_3_quantity=WH3_x3_y1_z3_3_quantity, + WH3_x1_y2_z3_4_materialType=WH3_x1_y2_z3_4_materialType, WH3_x1_y2_z3_4_materialId=WH3_x1_y2_z3_4_materialId, WH3_x1_y2_z3_4_quantity=WH3_x1_y2_z3_4_quantity, + WH3_x2_y2_z3_5_materialType=WH3_x2_y2_z3_5_materialType, WH3_x2_y2_z3_5_materialId=WH3_x2_y2_z3_5_materialId, WH3_x2_y2_z3_5_quantity=WH3_x2_y2_z3_5_quantity, + WH3_x3_y2_z3_6_materialType=WH3_x3_y2_z3_6_materialType, WH3_x3_y2_z3_6_materialId=WH3_x3_y2_z3_6_materialId, WH3_x3_y2_z3_6_quantity=WH3_x3_y2_z3_6_quantity, + WH3_x1_y3_z3_7_materialType=WH3_x1_y3_z3_7_materialType, WH3_x1_y3_z3_7_materialId=WH3_x1_y3_z3_7_materialId, WH3_x1_y3_z3_7_quantity=WH3_x1_y3_z3_7_quantity, + WH3_x2_y3_z3_8_materialType=WH3_x2_y3_z3_8_materialType, WH3_x2_y3_z3_8_materialId=WH3_x2_y3_z3_8_materialId, WH3_x2_y3_z3_8_quantity=WH3_x2_y3_z3_8_quantity, + WH3_x3_y3_z3_9_materialType=WH3_x3_y3_z3_9_materialType, WH3_x3_y3_z3_9_materialId=WH3_x3_y3_z3_9_materialId, WH3_x3_y3_z3_9_quantity=WH3_x3_y3_z3_9_quantity, + WH3_x1_y4_z3_10_materialType=WH3_x1_y4_z3_10_materialType, WH3_x1_y4_z3_10_materialId=WH3_x1_y4_z3_10_materialId, WH3_x1_y4_z3_10_quantity=WH3_x1_y4_z3_10_quantity, + WH3_x2_y4_z3_11_materialType=WH3_x2_y4_z3_11_materialType, WH3_x2_y4_z3_11_materialId=WH3_x2_y4_z3_11_materialId, WH3_x2_y4_z3_11_quantity=WH3_x2_y4_z3_11_quantity, + WH3_x3_y4_z3_12_materialType=WH3_x3_y4_z3_12_materialType, WH3_x3_y4_z3_12_materialId=WH3_x3_y4_z3_12_materialId, WH3_x3_y4_z3_12_quantity=WH3_x3_y4_z3_12_quantity, + WH3_x1_y5_z3_13_materialType=WH3_x1_y5_z3_13_materialType, WH3_x1_y5_z3_13_materialId=WH3_x1_y5_z3_13_materialId, WH3_x1_y5_z3_13_quantity=WH3_x1_y5_z3_13_quantity, + WH3_x2_y5_z3_14_materialType=WH3_x2_y5_z3_14_materialType, WH3_x2_y5_z3_14_materialId=WH3_x2_y5_z3_14_materialId, WH3_x2_y5_z3_14_quantity=WH3_x2_y5_z3_14_quantity, + WH3_x3_y5_z3_15_materialType=WH3_x3_y5_z3_15_materialType, WH3_x3_y5_z3_15_materialId=WH3_x3_y5_z3_15_materialId, WH3_x3_y5_z3_15_quantity=WH3_x3_y5_z3_15_quantity, + ) + finally: + # 恢复原有函数 + self.wait_for_order_finish = original_wait_func + + logger.info("=" * 60) + logger.info("[V2测试版本] 组合操作完成") + logger.info("=" * 60) + + return { + "success": True, + "scheduler_result": scheduler_result, + "feeding_result": feeding_result, + "version": "v2_polling" + } + + + # 2.24 物料变更推送 + def report_material_change(self, material_obj: Dict[str, Any]) -> Dict[str, Any]: + """ + material_obj 按 2.24 的裸对象格式（包含 id/typeName/locations/detail 等） + """ + return self._post_report_raw("/report/material_change", material_obj) + + # 2.32 3-2-1 物料转运 + def transfer_3_to_2_to_1(self, + # source_wh_id: Optional[str] = None, + source_wh_id: Optional[str] = '3a19debc-84b4-0359-e2d4-b3beea49348b', + source_x: int = 1, source_y: int = 1, source_z: int = 1) -> Dict[str, Any]: + payload: Dict[str, Any] = { + "sourcePosX": source_x, "sourcePosY": source_y, "sourcePosZ": source_z + } + if source_wh_id: + payload["sourceWHID"] = source_wh_id + + response = self._post_lims("/api/lims/order/transfer-task3To2To1", payload) + # 等待任务报送成功 + order_code = response.get("data", {}).get("orderCode") + if not order_code: + logger.error("上料任务未返回有效 orderCode！") + return response + # 等待完成报送 + result = self.wait_for_order_finish(order_code) + return result + + def transfer_3_to_2(self, + source_wh_id: Optional[str] = '3a19debc-84b4-0359-e2d4-b3beea49348b', + source_x: int = 1, + source_y: int = 1, + source_z: int = 1) -> Dict[str, Any]: + """ + 2.34 3-2 物料转运接口 + + 新建从 3 -> 2 的搬运任务 + + Args: + source_wh_id: 来源仓库 Id (默认为3号仓库) + source_x: 来源位置 X 坐标 + source_y: 来源位置 Y 坐标 + source_z: 来源位置 Z 坐标 + + Returns: + dict: 包含任务 orderId 和 orderCode 的响应 + """ + payload: Dict[str, Any] = { + "sourcePosX": source_x, + "sourcePosY": source_y, + "sourcePosZ": source_z + } + if source_wh_id: + payload["sourceWHID"] = source_wh_id + + logger.info(f"[transfer_3_to_2] 开始转运: 仓库={source_wh_id}, 位置=({source_x}, {source_y}, {source_z})") + response = self._post_lims("/api/lims/order/transfer-task3To2", payload) + + # 等待任务报送成功 + order_code = response.get("data", {}).get("orderCode") + if not order_code: + logger.error("[transfer_3_to_2] 转运任务未返回有效 orderCode！") + return response + + logger.info(f"[transfer_3_to_2] 转运任务已创建: {order_code}") + # 等待完成报送 + result = self.wait_for_order_finish(order_code) + logger.info(f"[transfer_3_to_2] 转运任务完成: {order_code}") + return result + + # 3.35 1→2 物料转运 + def transfer_1_to_2(self) -> Dict[str, Any]: + """ + 1→2 物料转运 + URL: /api/lims/order/transfer-task1To2 + 只需要 apiKey 和 requestTime + """ + logger.info("[transfer_1_to_2] 开始 1→2 物料转运") + response = self._post_lims("/api/lims/order/transfer-task1To2") + logger.info(f"[transfer_1_to_2] API Response: {response}") + + # 等待任务报送成功 - 处理不同的响应格式 + order_code = None + data_field = response.get("data") + + if isinstance(data_field, dict): + order_code = data_field.get("orderCode") + elif isinstance(data_field, str): + # 某些接口可能直接返回 orderCode 字符串 + order_code = data_field + + if not order_code: + logger.error(f"[transfer_1_to_2] 转运任务未返回有效 orderCode！响应: {response}") + return response + + logger.info(f"[transfer_1_to_2] 转运任务已创建: {order_code}") + # 等待完成报送 + result = self.wait_for_order_finish(order_code) + logger.info(f"[transfer_1_to_2] 转运任务完成: {order_code}") + return result + + # 2.5 批量查询实验报告(post过滤关键字查询) + def order_list_v2(self, + timeType: str = "", + beginTime: str = "", + endTime: str = "", + status: str = "", # 60表示正在运行,80表示完成，90表示失败 + filter: str = "", + skipCount: int = 0, + pageCount: int = 1, # 显示多少页数据 + sorting: str = "") -> Dict[str, Any]: + """ + 批量查询实验报告的详细信息 (2.5) + URL: /api/lims/order/order-list + 参数默认值和接口文档保持一致 + """ + data: Dict[str, Any] = { + "timeType": timeType, + "beginTime": beginTime, + "endTime": endTime, + "status": status, + "filter": filter, + "skipCount": skipCount, + "pageCount": pageCount, + "sorting": sorting + } + return self._post_lims("/api/lims/order/order-list", data) + + # 一直post执行bioyond接口查询任务状态 + def wait_for_transfer_task(self, timeout: int = 3000, interval: int = 5, filter_text: Optional[str] = None) -> bool: + """ + 轮询查询物料转移任务是否成功完成 (status=80) + - timeout: 最大等待秒数 (默认600秒) + - interval: 轮询间隔秒数 (默认3秒) + 返回 True 表示找到并成功完成，False 表示超时未找到 + """ + now = datetime.now() + beginTime = now.strftime("%Y-%m-%dT%H:%M:%SZ") + endTime = (now + timedelta(minutes=5)).strftime("%Y-%m-%dT%H:%M:%SZ") + print(beginTime, endTime) + + deadline = time.time() + timeout + + while time.time() < deadline: + result = self.order_list_v2( + timeType="", + beginTime=beginTime, + endTime=endTime, + status="", + filter=filter_text, + skipCount=0, + pageCount=1, + sorting="" + ) + print(result) + + items = result.get("data", {}).get("items", []) + for item in items: + name = item.get("name", "") + status = item.get("status") + # 改成用 filter_text 判断 + if (not filter_text or filter_text in name) and status == 80: + logger.info(f"硬件转移动作完成: {name}, status={status}") + return True + + logger.info(f"等待中: {name}, status={status}") + time.sleep(interval) + + logger.warning("超时未找到成功的物料转移任务") + return False + + def create_materials(self, mappings: Dict[str, Dict[str, Any]]) -> List[Dict[str, Any]]: + """ + 将 SOLID_LIQUID_MAPPINGS 中的所有物料逐个 POST 到 /api/lims/storage/material + """ + results = [] + + for name, data in mappings.items(): + data = { + "typeId": data["typeId"], + "code": data.get("code", ""), + "barCode": data.get("barCode", ""), + "name": data["name"], + "unit": data.get("unit", "g"), + "parameters": data.get("parameters", ""), + "quantity": data.get("quantity", ""), + "warningQuantity": data.get("warningQuantity", ""), + "details": data.get("details", []) + } + + logger.info(f"正在创建第 {i}/{total} 个固体物料: {name}") + result = self._post_lims("/api/lims/storage/material", material_data) + + if result and result.get("code") == 1: + # data 字段可能是字符串（物料ID）或字典（包含id字段） + data = result.get("data") + if isinstance(data, str): + # data 直接是物料ID字符串 + material_id = data + elif isinstance(data, dict): + # data 是字典，包含id字段 + material_id = data.get("id") + else: + material_id = None + + if material_id: + created_materials.append({ + "name": name, + "materialId": material_id, + "typeId": type_id + }) + logger.info(f"✓ 成功创建物料: {name}, ID: {material_id}") + else: + logger.error(f"✗ 创建物料失败: {name}, 未返回ID") + logger.error(f" 响应数据: {result}") + else: + error_msg = result.get("error") or result.get("message", "未知错误") + logger.error(f"✗ 创建物料失败: {name}") + logger.error(f" 错误信息: {error_msg}") + logger.error(f" 完整响应: {result}") + + # 避免请求过快 + time.sleep(0.3) + + logger.info(f"物料创建完成，成功创建 {len(created_materials)}/{total} 个固体物料") + return created_materials + + def _sync_materials_safe(self) -> bool: + """仅使用 BioyondResourceSynchronizer 执行同步（与 station.py 保持一致）。""" + if hasattr(self, 'resource_synchronizer') and self.resource_synchronizer: + try: + return bool(self.resource_synchronizer.sync_from_external()) + except Exception as e: + logger.error(f"同步失败: {e}") + return False + logger.warning("资源同步器未初始化") + return False + + def _load_warehouse_locations(self, warehouse_name: str) -> tuple[List[str], List[str]]: + """从配置加载仓库位置信息 + + Args: + warehouse_name: 仓库名称 + + Returns: + (location_ids, position_names) 元组 + """ + warehouse_mapping = self.bioyond_config.get("warehouse_mapping", WAREHOUSE_MAPPING) + + if warehouse_name not in warehouse_mapping: + raise ValueError(f"配置中未找到仓库: {warehouse_name}。可用: {list(warehouse_mapping.keys())}") + + site_uuids = warehouse_mapping[warehouse_name].get("site_uuids", {}) + if not site_uuids: + raise ValueError(f"仓库 {warehouse_name} 没有配置位置") + + # 按顺序获取位置ID和名称 + location_ids = [] + position_names = [] + for key in sorted(site_uuids.keys()): + location_ids.append(site_uuids[key]) + position_names.append(key) + + return location_ids, position_names + + + def create_and_inbound_materials( + self, + material_names: Optional[List[str]] = None, + type_id: str = "3a190ca0-b2f6-9aeb-8067-547e72c11469", + warehouse_name: str = "粉末加样头堆栈" + ) -> Dict[str, Any]: + """ + 传参与默认列表方式创建物料并入库（不使用CSV）。 + + Args: + material_names: 物料名称列表；默认使用 [LiPF6, LiDFOB, DTD, LiFSI, LiPO2F2] + type_id: 物料类型ID + warehouse_name: 目标仓库名（用于取位置信息） + + Returns: + 执行结果字典 + """ + logger.info("=" * 60) + logger.info(f"开始执行：从参数创建物料并批量入库到 {warehouse_name}") + logger.info("=" * 60) + + try: + # 1) 准备物料名称（默认值） + default_materials = ["LiPF6", "LiDFOB", "DTD", "LiFSI", "LiPO2F2"] + mat_names = [m.strip() for m in (material_names or default_materials) if str(m).strip()] + if not mat_names: + return {"success": False, "error": "物料名称列表为空"} + + # 2) 加载仓库位置信息 + all_location_ids, position_names = self._load_warehouse_locations(warehouse_name) + logger.info(f"✓ 加载 {len(all_location_ids)} 个位置 ({position_names[0]} ~ {position_names[-1]})") + + # 限制数量不超过可用位置 + if len(mat_names) > len(all_location_ids): + logger.warning(f"物料数量超出位置数量，仅处理前 {len(all_location_ids)} 个") + mat_names = mat_names[:len(all_location_ids)] + + # 3) 创建物料 + logger.info(f"\n【步骤1/3】创建 {len(mat_names)} 个固体物料...") + created_materials = self.create_solid_materials(mat_names, type_id) + if not created_materials: + return {"success": False, "error": "没有成功创建任何物料"} + + # 4) 批量入库 + logger.info(f"\n【步骤2/3】批量入库物料...") + location_ids = all_location_ids[:len(created_materials)] + selected_positions = position_names[:len(created_materials)] + + inbound_items = [ + {"materialId": mat["materialId"], "locationId": loc_id} + for mat, loc_id in zip(created_materials, location_ids) + ] + + for material, position in zip(created_materials, selected_positions): + logger.info(f" - {material['name']} → {position}") + + result = self.storage_batch_inbound(inbound_items) + if result.get("code") != 1: + logger.error(f"✗ 批量入库失败: {result}") + return {"success": False, "error": "批量入库失败", "created_materials": created_materials, "inbound_result": result} + + logger.info("✓ 批量入库成功") + + # 5) 同步 + logger.info(f"\n【步骤3/3】同步物料数据...") + if self._sync_materials_safe(): + logger.info("✓ 物料数据同步完成") + else: + logger.warning("⚠ 物料数据同步未完成（可忽略，不影响已创建与入库的数据）") + + logger.info("\n" + "=" * 60) + logger.info("流程完成") + logger.info("=" * 60 + "\n") + + return { + "success": True, + "created_materials": created_materials, + "inbound_result": result, + "total_created": len(created_materials), + "total_inbound": len(inbound_items), + "warehouse": warehouse_name, + "positions": selected_positions + } + + except Exception as e: + logger.error(f"✗ 执行失败: {e}") + return {"success": False, "error": str(e)} + + def create_material( + self, + material_name: str, + type_id: str, + warehouse_name: str, + location_name_or_id: Optional[str] = None + ) -> Dict[str, Any]: + """创建单个物料并可选入库。 + Args: + material_name: 物料名称（会优先匹配配置模板）。 + type_id: 物料类型 ID（若为空则尝试从配置推断）。 + warehouse_name: 需要入库的仓库名称；若为空则仅创建不入库。 + location_name_or_id: 具体库位名称（如 A01）或库位 UUID，由用户指定。 + Returns: + 包含创建结果、物料ID以及入库结果的字典。 + """ + material_name = (material_name or "").strip() + + resolved_type_id = (type_id or "").strip() + # 优先从配置中获取模板数据 + template = self.bioyond_config.get('solid_liquid_mappings', {}).get(material_name) + if not template: + raise ValueError(f"在配置中未找到物料 {material_name} 的模板，请检查 bioyond_config.solid_liquid_mappings。") + material_data: Dict[str, Any] + material_data = deepcopy(template) + # 最终确保 typeId 为调用方传入的值 + if resolved_type_id: + material_data["typeId"] = resolved_type_id + material_data["name"] = material_name + # 生成唯一编码 + def _generate_code(prefix: str) -> str: + normalized = re.sub(r"\W+", "_", prefix) + normalized = normalized.strip("_") or "material" + return f"{normalized}_{datetime.now().strftime('%Y%m%d%H%M%S')}" + if not material_data.get("code"): + material_data["code"] = _generate_code(material_name) + if not material_data.get("barCode"): + material_data["barCode"] = "" + # 处理数量字段类型 + def _to_number(value: Any, default: float = 0.0) -> float: + try: + if value is None: + return default + if isinstance(value, (int, float)): + return float(value) + if isinstance(value, str) and value.strip() == "": + return default + return float(value) + except (TypeError, ValueError): + return default + material_data["quantity"] = _to_number(material_data.get("quantity"), 1.0) + material_data["warningQuantity"] = _to_number(material_data.get("warningQuantity"), 0.0) + unit = material_data.get("unit") or "个" + material_data["unit"] = unit + if not material_data.get("parameters"): + material_data["parameters"] = json.dumps({"unit": unit}, ensure_ascii=False) + # 补充子物料信息 + details = material_data.get("details") or [] + if not isinstance(details, list): + logger.warning("details 字段不是列表，已忽略。") + details = [] + else: + for idx, detail in enumerate(details, start=1): + if not isinstance(detail, dict): + continue + if not detail.get("code"): + detail["code"] = f"{material_data['code']}_{idx:02d}" + if not detail.get("name"): + detail["name"] = f"{material_name}_detail_{idx:02d}" + if not detail.get("unit"): + detail["unit"] = unit + if not detail.get("parameters"): + detail["parameters"] = json.dumps({"unit": detail.get("unit", unit)}, ensure_ascii=False) + if "quantity" in detail: + detail["quantity"] = _to_number(detail.get("quantity"), 1.0) + material_data["details"] = details + create_result = self._post_lims("/api/lims/storage/material", material_data) + # 解析创建结果中的物料 ID + material_id: Optional[str] = None + if isinstance(create_result, dict): + data_field = create_result.get("data") + if isinstance(data_field, str): + material_id = data_field + elif isinstance(data_field, dict): + material_id = data_field.get("id") or data_field.get("materialId") + inbound_result: Optional[Dict[str, Any]] = None + location_id: Optional[str] = None + # 按用户指定位置入库 + if warehouse_name and material_id and location_name_or_id: + try: + location_ids, position_names = self._load_warehouse_locations(warehouse_name) + position_to_id = {name: loc_id for name, loc_id in zip(position_names, location_ids)} + target_location_id = position_to_id.get(location_name_or_id, location_name_or_id) + if target_location_id: + location_id = target_location_id + inbound_result = self.storage_inbound(material_id, target_location_id) + else: + inbound_result = {"error": f"未找到匹配的库位: {location_name_or_id}"} + except Exception as exc: + logger.error(f"获取仓库 {warehouse_name} 位置失败: {exc}") + inbound_result = {"error": str(exc)} + return { + "success": bool(isinstance(create_result, dict) and create_result.get("code") == 1 and material_id), + "material_name": material_name, + "material_id": material_id, + "warehouse": warehouse_name, + "location_id": location_id, + "location_name_or_id": location_name_or_id, + "create_result": create_result, + "inbound_result": inbound_result, + } + def resource_tree_transfer(self, old_parent: ResourcePLR, plr_resource: ResourcePLR, parent_resource: ResourcePLR): + # ROS2DeviceNode.run_async_func(self._ros_node.resource_tree_transfer, True, **{ + # "old_parent": old_parent, + # "plr_resource": plr_resource, + # "parent_resource": parent_resource, + # }) + print("resource_tree_transfer", plr_resource, parent_resource) + if hasattr(plr_resource, "unilabos_extra") and plr_resource.unilabos_extra: + if "update_resource_site" in plr_resource.unilabos_extra: + site = plr_resource.unilabos_extra["update_resource_site"] + plr_model = plr_resource.model + board_type = None + for key, (moudle_name,moudle_uuid) in self.bioyond_config['material_type_mappings'].items(): + if plr_model == moudle_name: + board_type = key + break + if board_type is None: + pass + bottle1 = plr_resource.children[0] + + bottle_moudle = bottle1.model + bottle_type = None + for key, (moudle_name, moudle_uuid) in self.bioyond_config['material_type_mappings'].items(): + if bottle_moudle == moudle_name: + bottle_type = key + break + + # 从 parent_resource 获取仓库名称 + warehouse_name = parent_resource.name if parent_resource else "手动堆栈" + logger.info(f"拖拽上料: {plr_resource.name} -> {warehouse_name} / {site}") + + self.create_sample(plr_resource.name, board_type, bottle_type, site, warehouse_name) + return + self.lab_logger().warning(f"无库位的上料，不处理，{plr_resource} 挂载到 {parent_resource}") + + def create_sample( + self, + name: str, + board_type: str, + bottle_type: str, + location_code: str, + warehouse_name: str = "手动堆栈" + ) -> Dict[str, Any]: + """创建配液板物料并自动入库。 + Args: + name: 物料名称 + board_type: 板类型，如 "5ml分液瓶板"、"配液瓶(小)板" + bottle_type: 瓶类型，如 "5ml分液瓶"、"配液瓶(小)" + location_code: 库位编号，例如 "A01" + warehouse_name: 仓库名称，默认为 "手动堆栈"，支持 "自动堆栈-左"、"自动堆栈-右" 等 + """ + carrier_type_id = self.bioyond_config['material_type_mappings'][board_type][1] + bottle_type_id = self.bioyond_config['material_type_mappings'][bottle_type][1] + + # 从指定仓库获取库位UUID + if warehouse_name not in self.bioyond_config['warehouse_mapping']: + logger.error(f"未找到仓库: {warehouse_name}，回退到手动堆栈") + warehouse_name = "手动堆栈" + + if location_code not in self.bioyond_config['warehouse_mapping'][warehouse_name]["site_uuids"]: + logger.error(f"仓库 {warehouse_name} 中未找到库位 {location_code}") + raise ValueError(f"库位 {location_code} 在仓库 {warehouse_name} 中不存在") + + location_id = self.bioyond_config['warehouse_mapping'][warehouse_name]["site_uuids"][location_code] + logger.info(f"创建样品入库: {name} -> {warehouse_name}/{location_code} (UUID: {location_id})") + + # 新建小瓶 + details = [] + for y in range(1, 5): + for x in range(1, 3): + details.append({ + "typeId": bottle_type_id, + "code": "", + "name": str(bottle_type) + str(x) + str(y), + "quantity": "1", + "x": x, + "y": y, + "z": 1, + "unit": "个", + "parameters": json.dumps({"unit": "个"}, ensure_ascii=False), + }) + + data = { + "typeId": carrier_type_id, + "code": "", + "barCode": "", + "name": name, + "unit": "块", + "parameters": json.dumps({"unit": "块"}, ensure_ascii=False), + "quantity": "1", + "details": details, + } + # print("xxx:",data) + create_result = self._post_lims("/api/lims/storage/material", data) + sample_uuid = create_result.get("data") + + final_result = self._post_lims("/api/lims/storage/inbound", { + "materialId": sample_uuid, + "locationId": location_id, + }) + return final_result + + + + +if __name__ == "__main__": + lab_registry.setup() + deck = BIOYOND_YB_Deck(setup=True) + ws = BioyondCellWorkstation(deck=deck) + # ws.create_sample(name="test", board_type="配液瓶(小)板", bottle_type="配液瓶(小)", location_code="B01") + # logger.info(ws.scheduler_stop()) + # logger.info(ws.scheduler_start()) + + # 继续后续流程 + logger.info(ws.auto_feeding4to3()) #搬运物料到3号箱 + # # # 使用正斜杠或 Path 对象来指定文件路径 + # excel_path = Path("unilabos\\devices\\workstation\\bioyond_studio\\bioyond_cell\\2025092701.xlsx") + # logger.info(ws.create_orders(excel_path)) + # logger.info(ws.transfer_3_to_2_to_1()) + + # logger.info(ws.transfer_1_to_2()) + # logger.info(ws.scheduler_start()) + + + while True: + time.sleep(1) + # re=ws.scheduler_stop() + # re = ws.transfer_3_to_2_to_1() + + # print(re) + # logger.info("调度启动完成") + + # ws.scheduler_continue() + # 3.30 上料：读取模板 Excel 自动解析并 POST + # r1 = ws.auto_feeding4to3_from_xlsx(r"C:\ML\GitHub\Uni-Lab-OS\unilabos\devices\workstation\bioyond_cell\样品导入模板.xlsx") + # ws.wait_for_transfer_task(filter_text="物料转移任务") + # logger.info("4号箱向3号箱转运物料转移任务已完成") + + # ws.scheduler_start() + # print(r1["payload"]["data"]) # 调试模式下可直接看到要发的 JSON items + + # # 新建实验 + # response = ws.create_orders("C:/ML/GitHub/Uni-Lab-OS/unilabos/devices/workstation/bioyond_cell/2025092701.xlsx") + # logger.info(response) + # data_list = response.get("data", []) + # order_name = data_list[0].get("orderName", "") + + # ws.wait_for_transfer_task(filter_text=order_name) + # ws.wait_for_transfer_task(filter_text='DP20250927001') + # logger.info("3号站内实验完成") + # # ws.scheduler_start() + # # print(res) + # ws.transfer_3_to_2_to_1() + # ws.wait_for_transfer_task(filter_text="物料转移任务") + # logger.info("3号站向2号站向1号站转移任务完成") + # r321 = self.wait_for_transfer_task() + #1号站启动 + # ws.transfer_1_to_2() + # ws.wait_for_transfer_task(filter_text="物料转移任务") + # logger.info("1号站向2号站转移任务完成") + # logger.info("全流程结束") + + # 3.31 下料：同理 + # r2 = ws.auto_batch_outbound_from_xlsx(r"C:/path/样品导入模板 (8).xlsx") + # print(r2["payload"]["data"]) diff --git a/unilabos/devices/workstation/bioyond_studio/bioyond_cell/material_template.xlsx b/unilabos/devices/workstation/bioyond_studio/bioyond_cell/material_template.xlsx new file mode 100644 index 0000000000000000000000000000000000000000..88b233daa2fae48e13e53695798580f473a95c90 GIT binary patch literal 10674 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 literal 0 HcmV?d00001 diff --git a/unilabos/devices/workstation/bioyond_studio/bioyond_cell/smiles&molweight.py b/unilabos/devices/workstation/bioyond_studio/bioyond_cell/smiles&molweight.py new file mode 100644 index 0000000..195e87a --- /dev/null +++ b/unilabos/devices/workstation/bioyond_studio/bioyond_cell/smiles&molweight.py @@ -0,0 +1,12 @@ +import pubchempy as pcp + +cas = "21324-40-3" # 示例 +comps = pcp.get_compounds(cas, namespace="name") +if not comps: + raise ValueError("No hit") + +c = comps[0] + +print("Canonical SMILES:", c.canonical_smiles) +print("Isomeric SMILES:", c.isomeric_smiles) +print("MW:", c.molecular_weight) diff --git a/unilabos/devices/workstation/bioyond_studio/bioyond_cell/solid_materials.csv b/unilabos/devices/workstation/bioyond_studio/bioyond_cell/solid_materials.csv new file mode 100644 index 0000000..8db9a5c --- /dev/null +++ b/unilabos/devices/workstation/bioyond_studio/bioyond_cell/solid_materials.csv @@ -0,0 +1,7 @@ +material_name +LiPF6 +LiDFOB +DTD +LiFSI +LiPO2F2 + diff --git a/unilabos/devices/workstation/bioyond_studio/bioyond_rpc.py b/unilabos/devices/workstation/bioyond_studio/bioyond_rpc.py index afd515a..77cac12 100644 --- a/unilabos/devices/workstation/bioyond_studio/bioyond_rpc.py +++ b/unilabos/devices/workstation/bioyond_studio/bioyond_rpc.py @@ -9,7 +9,7 @@ from datetime import datetime, timezone from unilabos.device_comms.rpc import BaseRequest from typing import Optional, List, Dict, Any import json -from unilabos.devices.workstation.bioyond_studio.config import LOCATION_MAPPING + class SimpleLogger: @@ -277,7 +277,8 @@ class BioyondV1RPC(BaseRequest): def material_outbound(self, material_id: str, location_name: str, quantity: int) -> dict: """指定库位出库物料（通过库位名称）""" - location_id = LOCATION_MAPPING.get(location_name, location_name) + # location_name 参数实际上应该直接是 location_id (UUID) + location_id = location_name params = { "materialId": material_id, diff --git a/unilabos/devices/workstation/bioyond_studio/config.py b/unilabos/devices/workstation/bioyond_studio/config.py deleted file mode 100644 index e06c413..0000000 --- a/unilabos/devices/workstation/bioyond_studio/config.py +++ /dev/null @@ -1,142 +0,0 @@ -# config.py -""" -配置文件 - 包含所有配置信息和映射关系 -""" - -# API配置 -API_CONFIG = { - "api_key": "", - "api_host": "" -} - -# 工作流映射配置 -WORKFLOW_MAPPINGS = { - "reactor_taken_out": "", - "reactor_taken_in": "", - "Solid_feeding_vials": "", - "Liquid_feeding_vials(non-titration)": "", - "Liquid_feeding_solvents": "", - "Liquid_feeding(titration)": "", - "liquid_feeding_beaker": "", - "Drip_back": "", -} - -# 工作流名称到DisplaySectionName的映射 -WORKFLOW_TO_SECTION_MAP = { - 'reactor_taken_in': '反应器放入', - 'liquid_feeding_beaker': '液体投料-烧杯', - 'Liquid_feeding_vials(non-titration)': '液体投料-小瓶（非滴定）', - 'Liquid_feeding_solvents': '液体投料-溶剂', - 'Solid_feeding_vials': '固体投料-小瓶', - 'Liquid_feeding(titration)': '液体投料-滴定', - 'reactor_taken_out': '反应器取出' -} - -# 库位映射配置 -WAREHOUSE_MAPPING = { - "粉末堆栈": { - "uuid": "", - "site_uuids": { - # 样品板 - "A1": "3a14198e-6929-31f0-8a22-0f98f72260df", - "A2": "3a14198e-6929-4379-affa-9a2935c17f99", - "A3": "3a14198e-6929-56da-9a1c-7f5fbd4ae8af", - "A4": "3a14198e-6929-5e99-2b79-80720f7cfb54", - "B1": "3a14198e-6929-f525-9a1b-1857552b28ee", - "B2": "3a14198e-6929-bf98-0fd5-26e1d68bf62d", - "B3": "3a14198e-6929-2d86-a468-602175a2b5aa", - "B4": "3a14198e-6929-1a98-ae57-e97660c489ad", - # 分装板 - "C1": "3a14198e-6929-46fe-841e-03dd753f1e4a", - "C2": "3a14198e-6929-1bc9-a9bd-3b7ca66e7f95", - "C3": "3a14198e-6929-72ac-32ce-9b50245682b8", - "C4": "3a14198e-6929-3bd8-e6c7-4a9fd93be118", - "D1": "3a14198e-6929-8a0b-b686-6f4a2955c4e2", - "D2": "3a14198e-6929-dde1-fc78-34a84b71afdf", - "D3": "3a14198e-6929-a0ec-5f15-c0f9f339f963", - "D4": "3a14198e-6929-7ac8-915a-fea51cb2e884" - } - }, - "溶液堆栈": { - "uuid": "", - "site_uuids": { - "A1": "3a14198e-d724-e036-afdc-2ae39a7f3383", - "A2": "3a14198e-d724-afa4-fc82-0ac8a9016791", - "A3": "3a14198e-d724-ca48-bb9e-7e85751e55b6", - "A4": "3a14198e-d724-df6d-5e32-5483b3cab583", - "B1": "3a14198e-d724-d818-6d4f-5725191a24b5", - "B2": "3a14198e-d724-be8a-5e0b-012675e195c6", - "B3": "3a14198e-d724-cc1e-5c2c-228a130f40a8", - "B4": "3a14198e-d724-1e28-c885-574c3df468d0", - "C1": "3a14198e-d724-b5bb-adf3-4c5a0da6fb31", - "C2": "3a14198e-d724-ab4e-48cb-817c3c146707", - "C3": "3a14198e-d724-7f18-1853-39d0c62e1d33", - "C4": "3a14198e-d724-28a2-a760-baa896f46b66", - "D1": "3a14198e-d724-d378-d266-2508a224a19f", - "D2": "3a14198e-d724-f56e-468b-0110a8feb36a", - "D3": "3a14198e-d724-0cf1-dea9-a1f40fe7e13c", - "D4": "3a14198e-d724-0ddd-9654-f9352a421de9" - } - }, - "试剂堆栈": { - "uuid": "", - "site_uuids": { - "A1": "3a14198c-c2cf-8b40-af28-b467808f1c36", - "A2": "3a14198c-c2d0-f3e7-871a-e470d144296f", - "A3": "3a14198c-c2d0-dc7d-b8d0-e1d88cee3094", - "A4": "3a14198c-c2d0-2070-efc8-44e245f10c6f", - "B1": "3a14198c-c2d0-354f-39ad-642e1a72fcb8", - "B2": "3a14198c-c2d0-1559-105d-0ea30682cab4", - "B3": "3a14198c-c2d0-725e-523d-34c037ac2440", - "B4": "3a14198c-c2d0-efce-0939-69ca5a7dfd39" - } - } -} - -# 物料类型配置 -MATERIAL_TYPE_MAPPINGS = { - "烧杯": ("BIOYOND_PolymerStation_1FlaskCarrier", "3a14196b-24f2-ca49-9081-0cab8021bf1a"), - "试剂瓶": ("BIOYOND_PolymerStation_1BottleCarrier", ""), - "样品板": ("BIOYOND_PolymerStation_6StockCarrier", "3a14196e-b7a0-a5da-1931-35f3000281e9"), - "分装板": ("BIOYOND_PolymerStation_6VialCarrier", "3a14196e-5dfe-6e21-0c79-fe2036d052c4"), - "样品瓶": ("BIOYOND_PolymerStation_Solid_Stock", "3a14196a-cf7d-8aea-48d8-b9662c7dba94"), - "90%分装小瓶": ("BIOYOND_PolymerStation_Solid_Vial", "3a14196c-cdcf-088d-dc7d-5cf38f0ad9ea"), - "10%分装小瓶": ("BIOYOND_PolymerStation_Liquid_Vial", "3a14196c-76be-2279-4e22-7310d69aed68"), -} - -# 步骤参数配置（各工作流的步骤UUID） -WORKFLOW_STEP_IDS = { - "reactor_taken_in": { - "config": "" - }, - "liquid_feeding_beaker": { - "liquid": "", - "observe": "" - }, - "liquid_feeding_vials_non_titration": { - "liquid": "", - "observe": "" - }, - "liquid_feeding_solvents": { - "liquid": "", - "observe": "" - }, - "solid_feeding_vials": { - "feeding": "", - "observe": "" - }, - "liquid_feeding_titration": { - "liquid": "", - "observe": "" - }, - "drip_back": { - "liquid": "", - "observe": "" - } -} - -LOCATION_MAPPING = {} - -ACTION_NAMES = {} - -HTTP_SERVICE_CONFIG = {} \ No newline at end of file diff --git a/unilabos/devices/workstation/bioyond_studio/station.py b/unilabos/devices/workstation/bioyond_studio/station.py index e349b08..22b846d 100644 --- a/unilabos/devices/workstation/bioyond_studio/station.py +++ b/unilabos/devices/workstation/bioyond_studio/station.py @@ -23,9 +23,7 @@ from unilabos.ros.nodes.presets.workstation import ROS2WorkstationNode from unilabos.ros.msgs.message_converter import convert_to_ros_msg, Float64, String from pylabrobot.resources.resource import Resource as ResourcePLR -from unilabos.devices.workstation.bioyond_studio.config import ( - API_CONFIG, WORKFLOW_MAPPINGS, MATERIAL_TYPE_MAPPINGS, WAREHOUSE_MAPPING, HTTP_SERVICE_CONFIG -) + from unilabos.devices.workstation.workstation_http_service import WorkstationHTTPService @@ -627,10 +625,10 @@ class BioyondWorkstation(WorkstationBase): self._set_workflow_mappings(bioyond_config["workflow_mappings"]) # 准备 HTTP 报送接收服务配置（延迟到 post_init 启动） - # 从 bioyond_config 中获取，如果没有则使用 HTTP_SERVICE_CONFIG 的默认值 + # 从 bioyond_config 中获取，如果没有则使用默认值 self._http_service_config = { - "host": bioyond_config.get("http_service_host", HTTP_SERVICE_CONFIG["http_service_host"]), - "port": bioyond_config.get("http_service_port", HTTP_SERVICE_CONFIG["http_service_port"]) + "host": bioyond_config.get("http_service_host", bioyond_config.get("HTTP_host", "")), + "port": bioyond_config.get("http_service_port", bioyond_config.get("HTTP_port", 0)) } self.http_service = None # 将在 post_init 中启动 @@ -649,7 +647,11 @@ class BioyondWorkstation(WorkstationBase): self._ros_node = ros_node # 启动 HTTP 报送接收服务（现在 device_id 已可用） - if hasattr(self, '_http_service_config'): + # ⚠️ 检查子类是否已经自己管理 HTTP 服务 + if self.bioyond_config.get("_disable_auto_http_service"): + logger.info("🔧 检测到 _disable_auto_http_service 标志，跳过自动启动 HTTP 服务") + logger.info(" 子类（BioyondCellWorkstation）已自行管理 HTTP 服务") + elif hasattr(self, '_http_service_config'): try: self.http_service = WorkstationHTTPService( workstation_instance=self, @@ -688,19 +690,14 @@ class BioyondWorkstation(WorkstationBase): def _create_communication_module(self, config: Optional[Dict[str, Any]] = None) -> None: """创建Bioyond通信模块""" - # 创建默认配置 - default_config = { - **API_CONFIG, - "workflow_mappings": WORKFLOW_MAPPINGS, - "material_type_mappings": MATERIAL_TYPE_MAPPINGS, - "warehouse_mapping": WAREHOUSE_MAPPING - } - - # 如果传入了 config，合并配置（config 中的值会覆盖默认值） + # 使用传入的 config 参数（来自 bioyond_config） + # 不再依赖全局变量 API_CONFIG 等 if config: - self.bioyond_config = {**default_config, **config} + self.bioyond_config = config else: - self.bioyond_config = default_config + # 如果没有传入配置，创建空配置（用于测试或兼容性） + self.bioyond_config = {} + self.hardware_interface = BioyondV1RPC(self.bioyond_config) diff --git a/unilabos/devices/workstation/coin_cell_assembly/20251230_Modbus_CSV_Mapping_Guide.md b/unilabos/devices/workstation/coin_cell_assembly/20251230_Modbus_CSV_Mapping_Guide.md new file mode 100644 index 0000000..8af63e7 --- /dev/null +++ b/unilabos/devices/workstation/coin_cell_assembly/20251230_Modbus_CSV_Mapping_Guide.md @@ -0,0 +1,84 @@ +# Modbus CSV 地址映射说明 + +本文档说明 `coin_cell_assembly_a.csv` 文件如何将命名节点映射到实际的 Modbus 地址，以及如何在代码中使用它们。 + +## 1. CSV 文件结构 + +地址表文件位于同级目录下：`coin_cell_assembly_a.csv` + +每一行定义了一个 Modbus 节点，包含以下关键列： + +| 列名 | 说明 | 示例 | +|------|------|------| +| **Name** | **节点名称** (代码中引用的 Key) | `COIL_ALUMINUM_FOIL` | +| **DataType** | 数据类型 (BOOL, INT16, FLOAT32, STRING) | `BOOL` | +| **Comment** | 注释说明 | `使用铝箔垫` | +| **Attribute** | 属性 (通常留空或用于额外标记) | | +| **DeviceType** | Modbus 寄存器类型 (`coil`, `hold_register`) | `coil` | +| **Address** | **Modbus 地址** (十进制) | `8340` | + +### 示例行 (铝箔垫片) + +```csv +COIL_ALUMINUM_FOIL,BOOL,,使用铝箔垫,,coil,8340, +``` + +- **名称**: `COIL_ALUMINUM_FOIL` +- **类型**: `coil` (线圈，读写单个位) +- **地址**: `8340` + +--- + +## 2. 加载与注册流程 + +在 `coin_cell_assembly.py` 的初始化代码中： + +1. **加载 CSV**: `BaseClient.load_csv()` 读取 CSV 并解析每行定义。 +2. **注册节点**: `modbus_client.register_node_list()` 将解析后的节点注册到 Modbus 客户端实例中。 + +```python +# 代码位置: coin_cell_assembly.py (L174-175) +self.nodes = BaseClient.load_csv(os.path.join(os.path.dirname(__file__), 'coin_cell_assembly_a.csv')) +self.client = modbus_client.register_node_list(self.nodes) +``` + +--- + +## 3. 代码中的使用方式 + +注册后，通过 `self.client.use_node('节点名称')` 即可获取该节点对象并进行读写操作，无需关心具体地址。 + +### 控制铝箔垫片 (COIL_ALUMINUM_FOIL) + +```python +# 代码位置: qiming_coin_cell_code 函数 (L1048) +self.client.use_node('COIL_ALUMINUM_FOIL').write(not lvbodian) +``` + +- **写入 True**: 对应 Modbus 功能码 05 (Write Single Coil)，向地址 `8340` 写入 `1` (ON)。 +- **写入 False**: 向地址 `8340` 写入 `0` (OFF)。 + +> **注意**: 代码中使用了 `not lvbodian`，这意味着逻辑是反转的。如果 `lvbodian` 参数为 `True` (默认)，写入的是 `False` (不使用铝箔垫)。 + +--- + +## 4. 地址转换注意事项 (Modbus vs PLC) + +CSV 中的 `Address` 列（如 `8340`）是 **Modbus 协议地址**。 + +如果使用 InoProShop (汇川 PLC 编程软件)，看到的可能是 **PLC 内部地址** (如 `%QX...` 或 `%MW...`)。这两者之间通常需要转换。 + +### 常见的转换规则 (示例) + +- **Coil (线圈) %QX**: + - `Modbus地址 = 字节地址 * 8 + 位偏移` + - *例子*: `%QX834.0` -> `834 * 8 + 0` = `6672` + - *注意*: 如果 CSV 中配置的是 `8340`，这可能是一个自定义映射，或者是基于不同规则（如直接对应 Word 地址的某种映射，或者可能就是地址写错了/使用了非标准映射）。 + +- **Register (寄存器) %MW**: + - 通常直接对应，或者有偏移量 (如 Modbus 40001 = PLC MW0)。 + +### 验证方法 +由于 `test_unilab_interact.py` 中发现 `8450` (CSV风格) 不工作，而 `6760` (%QX845.0 计算值) 工作正常，**建议对 CSV 中的其他地址也进行核实**，特别是像 `8340` 这样以 0 结尾看起来像是 "字节地址+0" 的数值，可能实际上应该是 `%QX834.0` 对应的 `6672`。 + +如果发现设备控制无反应，请尝试按照标准的 Modbus 计算方式转换 PLC 地址。 diff --git a/unilabos/devices/workstation/coin_cell_assembly/20260113_物料搜寻确认弹窗自动处理功能.md b/unilabos/devices/workstation/coin_cell_assembly/20260113_物料搜寻确认弹窗自动处理功能.md new file mode 100644 index 0000000..96104b6 --- /dev/null +++ b/unilabos/devices/workstation/coin_cell_assembly/20260113_物料搜寻确认弹窗自动处理功能.md @@ -0,0 +1,352 @@ +# 2026-01-13 物料搜寻确认弹窗自动处理功能 + +## 概述 + +本次更新为设备初始化流程添加了**物料搜寻确认弹窗自动检测与处理功能**。在设备初始化过程中，PLC 会弹出物料搜寻确认对话框，现在系统可以根据用户参数自动点击"是"或"否"按钮，无需手动干预。 + +## 背景问题 + +### 原有流程 +1. 调用 `func_pack_device_init_auto_start_combined()` 初始化设备 +2. PLC 在初始化过程中弹出物料搜寻确认对话框 +3. **需要人工手动点击**"是"或"否"按钮 +4. PLC 继续完成初始化并启动 + +### 存在的问题 +- 需要人工干预，无法实现全自动化 +- 影响批量生产效率 +- 容易遗忘点击导致流程卡住 + +## 解决方案 + +### 新增 Modbus 地址配置 + +在 `coin_cell_assembly_b.csv` 第 69-71 行添加三个 coil： + +| Name | DeviceType | Address | 说明 | +|------|-----------|---------|------| +| COIL_MATERIAL_SEARCH_DIALOG_APPEAR | coil | 6470 | 物料搜寻确认弹窗画面是否出现 | +| COIL_MATERIAL_SEARCH_CONFIRM_YES | coil | 6480 | 初始化物料搜寻确认按钮"是" | +| COIL_MATERIAL_SEARCH_CONFIRM_NO | coil | 6490 | 初始化物料搜寻确认按钮"否" | + +**Modbus 地址转换：** +- CSV 6470 → Modbus 5176 (弹窗出现) +- CSV 6480 → Modbus 5184 (按钮"是") +- CSV 6490 → Modbus 5192 (按钮"否") + +## 代码修改详情 + +### 1. coin_cell_assembly.py + +#### 1.1 新增辅助方法 `_handle_material_search_dialog()` + +**位置：** 第 799-901 行 + +**功能：** +- 监测物料搜寻确认弹窗是否出现（Coil 5176） +- 根据 `enable_search` 参数自动点击对应按钮 +- 使用**脉冲模式**模拟真实按钮操作：`True` → 保持 0.5 秒 → `False` + +**参数：** +- `enable_search: bool` - True=点击"是"(启用物料搜寻), False=点击"否"(不启用) +- `timeout: int = 30` - 等待弹窗出现的最大时间（秒） + +**逻辑流程：** +```python +1. 监测 COIL_MATERIAL_SEARCH_DIALOG_APPEAR (每 0.5 秒检查一次) +2. 检测到弹窗出现 (Coil = True) +3. 选择按钮： + - enable_search=True → COIL_MATERIAL_SEARCH_CONFIRM_YES + - enable_search=False → COIL_MATERIAL_SEARCH_CONFIRM_NO +4. 执行脉冲操作： + - 写入 True (按下按钮) + - 等待 0.5 秒 + - 写入 False (释放按钮) + - 验证状态 +``` + +#### 1.2 修改 `func_pack_device_init_auto_start_combined()` + +**位置：** 第 904-1115 行 + +**主要改动：** + +1. **添加新参数** + ```python + def func_pack_device_init_auto_start_combined( + self, + material_search_enable: bool = False # 新增参数 + ) -> bool: + ``` + +2. **内联初始化逻辑并集成弹窗检测** + - 不再调用 `self.func_pack_device_init()` + - 将初始化逻辑直接实现在函数内 + - **在等待初始化完成的循环中实时检测弹窗** + - 避免死锁：PLC 等待弹窗确认 ↔ 代码等待初始化完成 + +3. **关键代码片段** + ```python + # 等待初始化完成，同时检测物料搜寻弹窗 + while (self._sys_init_status()) == False: + # 检查超时 + if time.time() - start_wait > max_wait_time: + raise RuntimeError(f"初始化超时") + + # 如果还没处理弹窗，检测弹窗是否出现 + if not dialog_handled: + dialog_state = self.client.use_node('COIL_MATERIAL_SEARCH_DIALOG_APPEAR').read(1) + if dialog_actual: # 弹窗出现 + # 执行脉冲按钮点击 + button_node.write(True) # 按下 + time.sleep(0.5) # 保持 + button_node.write(False) # 释放 + dialog_handled = True + + time.sleep(1) + ``` + +4. **步骤调整** + - 步骤 0: 前置条件检查 + - 步骤 1: 设备初始化（**包含弹窗检测**） + - 步骤 1.5: 已在步骤 1 中完成 + - 步骤 2: 切换自动模式 + - 步骤 3: 启动设备 + +### 2. coin_cell_workstation.yaml + +**位置：** 第 292-312 行 + +**修改内容：** + +```yaml +auto-func_pack_device_init_auto_start_combined: + goal_default: + material_search_enable: false # 新增默认值 + + schema: + description: 组合函数:设备初始化 + 物料搜寻确认 + 切换自动模式 + 启动。初始化过程中会自动检测物料搜寻确认弹窗，并根据参数自动点击"是"或"否"按钮 + + goal: + properties: + material_search_enable: # 新增参数配置 + default: false + description: 是否启用物料搜寻功能。设备初始化后会弹出物料搜寻确认弹窗，此参数控制自动点击"是"(启用)或"否"(不启用)。默认为false(不启用物料搜寻) + type: boolean +``` + +### 3. 测试脚本（已创建，用户已删除） + +#### 3.1 test_material_search_dialog.py +- 从 CSV 动态加载 Modbus 地址 +- 支持 4 种测试模式： + - `query` - 查询所有状态 + - `dialog <0|1>` - 设置弹窗出现/消失 + - `yes` - 脉冲点击"是"按钮 + - `no` - 脉冲点击"否"按钮 +- 兼容 pymodbus 3.x API + +#### 3.2 更新其他测试脚本 +- `test_coin_cell_reset.py` - 更新为 pymodbus 3.x API +- `test_unilab_interact.py` - 更新为 pymodbus 3.x API + +## 使用方法 + +### 参数说明 + +| 参数 | 类型 | 默认值 | 说明 | +|------|------|--------|------| +| `material_search_enable` | boolean | `false` | 是否启用物料搜寻功能 | + +### 调用示例 + +#### 1. 不启用物料搜寻（默认） +```python +# 默认参数，点击"否"按钮 +await device.func_pack_device_init_auto_start_combined() +``` + +或在 YAML workflow 中： +```yaml +# 使用默认值 false，不启用物料搜寻 +- BatteryStation/auto-func_pack_device_init_auto_start_combined: {} +``` + +#### 2. 启用物料搜寻 +```python +# 显式设置为 True，点击"是"按钮 +await device.func_pack_device_init_auto_start_combined( + material_search_enable=True +) +``` + +或在 YAML workflow 中： +```yaml +- BatteryStation/auto-func_pack_device_init_auto_start_combined: + goal: + material_search_enable: true # 启用物料搜寻 +``` + +## 执行日志示例 + +``` +26-01-13 [21:32:44] [INFO] 开始组合操作：设备初始化 → 物料搜寻确认 → 自动模式 → 启动 +26-01-13 [21:32:44] [INFO] 【步骤 0/4】前置条件检查... +26-01-13 [21:32:44] [INFO] ✓ REG_UNILAB_INTERACT 检查通过 +26-01-13 [21:32:44] [INFO] ✓ COIL_GB_L_IGNORE_CMD 检查通过 +26-01-13 [21:32:44] [INFO] 【步骤 1/4】设备初始化... +26-01-13 [21:32:44] [INFO] 切换手动模式... +26-01-13 [21:32:46] [INFO] 发送初始化命令... +26-01-13 [21:32:47] [INFO] 等待初始化完成（同时监测物料搜寻弹窗）... +26-01-13 [21:33:05] [INFO] ✓ 在初始化过程中检测到物料搜寻确认弹窗！ +26-01-13 [21:33:05] [INFO] 用户选择: 不启用物料搜寻（点击否） +26-01-13 [21:33:05] [INFO] → 按下按钮 '否' +26-01-13 [21:33:06] [INFO] → 释放按钮 '否' +26-01-13 [21:33:07] [INFO] ✓ 成功处理物料搜寻确认弹窗（选择: 否） +26-01-13 [21:33:08] [INFO] ✓ 初始化状态完成 +26-01-13 [21:33:12] [INFO] ✓ 设备初始化完成 +26-01-13 [21:33:12] [INFO] 【步骤 1.5/4】物料搜寻确认已在初始化过程中完成 +26-01-13 [21:33:12] [INFO] 【步骤 2/4】切换自动模式... +26-01-13 [21:33:15] [INFO] ✓ 切换自动模式完成 +26-01-13 [21:33:15] [INFO] 【步骤 3/4】启动设备... +26-01-13 [21:33:18] [INFO] ✓ 启动设备完成 +26-01-13 [21:33:18] [INFO] 组合操作完成：设备已成功初始化、确认物料搜寻、切换自动模式并启动 +``` + +## 技术要点 + +### 1. 脉冲模式按钮操作 +模拟真实按钮按压过程： +1. 写入 `True` (按下) +2. 保持 0.5 秒 +3. 写入 `False` (释放) +4. 验证状态 + +### 2. 避免死锁 +**问题：** PLC 在初始化过程中等待弹窗确认，而代码等待初始化完成 +**解决：** 在初始化等待循环中实时检测弹窗，一旦出现立即处理 + +### 3. 超时保护 +- 弹窗检测超时：30 秒（在 `_handle_material_search_dialog` 中） +- 初始化超时：120 秒（在 `func_pack_device_init_auto_start_combined` 中） + +### 4. PyModbus 3.x API 兼容 +所有 Modbus 操作使用 keyword arguments： +```python +# 读取 +client.read_coils(address=5176, count=1) + +# 写入 +client.write_coil(address=5184, value=True) +``` + +## 向后兼容性 + +### 保留的原有函数 +- `func_pack_device_init()` - 单独的初始化函数，不包含弹窗处理 +- 仍可在 YAML 中通过 `auto-func_pack_device_init` 调用 +- 用于不需要自动处理弹窗的场景 + +### 新增的功能 +- 在 `func_pack_device_init_auto_start_combined()` 中集成弹窗处理 +- 通过参数控制，默认行为与之前兼容（点击"否"） + +## 验证测试 + +### 测试场景 + +#### 场景 1：默认参数（不启用物料搜寻） +```bash +# 调用时不传参数 +BatteryStation/auto-func_pack_device_init_auto_start_combined: {} +``` +**预期结果：** +- ✅ 检测到弹窗 +- ✅ 自动点击"否"按钮 +- ✅ 初始化完成并启动成功 + +#### 场景 2：启用物料搜寻 +```bash +# 设置 material_search_enable=true +BatteryStation/auto-func_pack_device_init_auto_start_combined: + goal: + material_search_enable: true +``` +**预期结果：** +- ✅ 检测到弹窗 +- ✅ 自动点击"是"按钮 +- ✅ 初始化完成并启动成功 + +### 实际测试结果 + +**测试时间：** 2026-01-13 21:32:43 +**测试参数：** `material_search_enable: false` +**测试结果：** ✅ 成功 + +**关键时间节点：** +- 21:33:05 - 检测到弹窗 +- 21:33:05 - 按下"否"按钮 +- 21:33:06 - 释放"否"按钮 +- 21:33:07 - 弹窗处理完成 +- 21:33:08 - 初始化状态完成 +- 21:33:18 - 整个流程完成 + +**总耗时：** 约 35 秒（包含初始化全过程） + +## 注意事项 + +1. **CSV 配置依赖** + - 确保 `coin_cell_assembly_b.csv` 包含 69-71 行的 coil 配置 + - 地址转换逻辑：`modbus_addr = (csv_addr // 10) * 8 + (csv_addr % 10)` + +2. **默认行为** + - 默认 `material_search_enable=false`，即不启用物料搜寻 + - 如需启用，必须显式设置为 `true` + +3. **日志级别** + - 弹窗检测过程中的 `waiting for init_cmd` 使用 DEBUG 级别 + - 关键操作（检测到弹窗、按钮操作）使用 INFO 级别 + +4. **原有函数保留** + - `func_pack_device_init()` 仍然可用，但不包含弹窗处理 + - 如果单独调用此函数，仍需手动处理弹窗 + +## 文件清单 + +### 修改的文件 +1. `d:\UniLabdev\Uni-Lab-OS\unilabos\devices\workstation\coin_cell_assembly\coin_cell_assembly.py` + - 新增 `_handle_material_search_dialog()` 方法 + - 修改 `func_pack_device_init_auto_start_combined()` 函数 + +2. `d:\UniLabdev\Uni-Lab-OS\unilabos\registry\devices\coin_cell_workstation.yaml` + - 更新 `auto-func_pack_device_init_auto_start_combined` 配置 + - 添加 `material_search_enable` 参数说明 + +3. `d:\UniLabdev\Uni-Lab-OS\unilabos\devices\workstation\coin_cell_assembly\coin_cell_assembly_b.csv` + - 第 69-71 行添加三个 coil 配置 + +### 创建的测试文件（已删除） +1. `test_material_search_dialog.py` - 物料搜寻弹窗测试脚本 +2. `test_coin_cell_reset.py` - 复位功能测试（更新为 pymodbus 3.x） +3. `test_unilab_interact.py` - Unilab 交互测试（更新为 pymodbus 3.x） + +## 总结 + +本次更新成功实现了设备初始化过程中物料搜寻确认弹窗的自动化处理，主要优势： + +✅ **全自动化** - 无需人工干预 +✅ **参数可配** - 灵活控制是否启用物料搜寻 +✅ **实时检测** - 在初始化等待循环中检测，避免死锁 +✅ **脉冲模式** - 模拟真实按钮操作 +✅ **向后兼容** - 保留原有函数，不影响现有流程 +✅ **完整日志** - 详细记录每一步操作 +✅ **超时保护** - 防止无限等待 + +该功能已通过实际测试验证，可投入生产使用。 + +--- + +**文档版本：** 1.0 +**创建日期：** 2026-01-13 +**作者：** Antigravity AI Assistant +**最后更新：** 2026-01-13 21:36 diff --git a/unilabos/devices/workstation/coin_cell_assembly/YB_YH_materials.py b/unilabos/devices/workstation/coin_cell_assembly/YB_YH_materials.py new file mode 100644 index 0000000..c9187e6 --- /dev/null +++ b/unilabos/devices/workstation/coin_cell_assembly/YB_YH_materials.py @@ -0,0 +1,645 @@ +""" +纽扣电池组装工作站物料类定义 +Button Battery Assembly Station Resource Classes +""" + +from __future__ import annotations + +from collections import OrderedDict +from typing import Any, Dict, List, Optional, TypedDict, Union, cast + +from pylabrobot.resources.coordinate import Coordinate +from pylabrobot.resources.container import Container +from pylabrobot.resources.deck import Deck +from pylabrobot.resources.itemized_resource import ItemizedResource +from pylabrobot.resources.resource import Resource +from pylabrobot.resources.resource_stack import ResourceStack +from pylabrobot.resources.tip_rack import TipRack, TipSpot +from pylabrobot.resources.trash import Trash +from pylabrobot.resources.utils import create_ordered_items_2d + +from unilabos.resources.battery.magazine import MagazineHolder_4_Cathode, MagazineHolder_6_Cathode, MagazineHolder_6_Anode, MagazineHolder_6_Battery +from unilabos.resources.battery.bottle_carriers import YIHUA_Electrolyte_12VialCarrier +from unilabos.resources.battery.electrode_sheet import ElectrodeSheet + + + +# TODO: 这个应该只能放一个极片 +class MaterialHoleState(TypedDict): + diameter: int + depth: int + max_sheets: int + info: Optional[str] # 附加信息 + +class MaterialHole(Resource): + """料板洞位类""" + children: List[ElectrodeSheet] = [] + + def __init__( + self, + name: str, + size_x: float, + size_y: float, + size_z: float, + category: str = "material_hole", + **kwargs + ): + super().__init__( + name=name, + size_x=size_x, + size_y=size_y, + size_z=size_z, + category=category, + ) + self._unilabos_state: MaterialHoleState = MaterialHoleState( + diameter=20, + depth=10, + max_sheets=1, + info=None + ) + + def get_all_sheet_info(self): + info_list = [] + for sheet in self.children: + info_list.append(sheet._unilabos_state["info"]) + return info_list + + #这个函数函数好像没用，一般不会集中赋值质量 + def set_all_sheet_mass(self): + for sheet in self.children: + sheet._unilabos_state["mass"] = 0.5 # 示例：设置质量为0.5g + + def load_state(self, state: Dict[str, Any]) -> None: + """格式不变""" + super().load_state(state) + self._unilabos_state = state + + def serialize_state(self) -> Dict[str, Dict[str, Any]]: + """格式不变""" + data = super().serialize_state() + data.update(self._unilabos_state) # Container自身的信息，云端物料将保存这一data，本地也通过这里的data进行读写，当前类用来表示这个物料的长宽高大小的属性，而data（state用来表示物料的内容，细节等） + return data + #移动极片前先取出对象 + def get_sheet_with_name(self, name: str) -> Optional[ElectrodeSheet]: + for sheet in self.children: + if sheet.name == name: + return sheet + return None + + def has_electrode_sheet(self) -> bool: + """检查洞位是否有极片""" + return len(self.children) > 0 + + def assign_child_resource( + self, + resource: ElectrodeSheet, + location: Optional[Coordinate], + reassign: bool = True, + ): + """放置极片""" + # TODO: 这里要改，diameter找不到，加入._unilabos_state后应该没问题 + #if resource._unilabos_state["diameter"] > self._unilabos_state["diameter"]: + # raise ValueError(f"极片直径 {resource._unilabos_state['diameter']} 超过洞位直径 {self._unilabos_state['diameter']}") + #if len(self.children) >= self._unilabos_state["max_sheets"]: + # raise ValueError(f"洞位已满，无法放置更多极片") + super().assign_child_resource(resource, location, reassign) + + # 根据children的编号取物料对象。 + def get_electrode_sheet_info(self, index: int) -> ElectrodeSheet: + return self.children[index] + + +class MaterialPlateState(TypedDict): + hole_spacing_x: float + hole_spacing_y: float + hole_diameter: float + info: Optional[str] # 附加信息 + +class MaterialPlate(ItemizedResource[MaterialHole]): + """料板类 - 4x4个洞位，每个洞位放1个极片""" + + children: List[MaterialHole] + + def __init__( + self, + name: str, + size_x: float, + size_y: float, + size_z: float, + ordered_items: Optional[Dict[str, MaterialHole]] = None, + ordering: Optional[OrderedDict[str, str]] = None, + category: str = "material_plate", + model: Optional[str] = None, + fill: bool = False + ): + """初始化料板 + + Args: + name: 料板名称 + size_x: 长度 (mm) + size_y: 宽度 (mm) + size_z: 高度 (mm) + hole_diameter: 洞直径 (mm) + hole_depth: 洞深度 (mm) + hole_spacing_x: X方向洞位间距 (mm) + hole_spacing_y: Y方向洞位间距 (mm) + number: 编号 + category: 类别 + model: 型号 + """ + self._unilabos_state: MaterialPlateState = MaterialPlateState( + hole_spacing_x=24.0, + hole_spacing_y=24.0, + hole_diameter=20.0, + info="", + ) + # 创建4x4的洞位 + # TODO: 这里要改，对应不同形状 + holes = create_ordered_items_2d( + klass=MaterialHole, + num_items_x=4, + num_items_y=4, + dx=(size_x - 4 * self._unilabos_state["hole_spacing_x"]) / 2, # 居中 + dy=(size_y - 4 * self._unilabos_state["hole_spacing_y"]) / 2, # 居中 + dz=size_z, + item_dx=self._unilabos_state["hole_spacing_x"], + item_dy=self._unilabos_state["hole_spacing_y"], + size_x = 16, + size_y = 16, + size_z = 16, + ) + if fill: + super().__init__( + name=name, + size_x=size_x, + size_y=size_y, + size_z=size_z, + ordered_items=holes, + category=category, + model=model, + ) + else: + super().__init__( + name=name, + size_x=size_x, + size_y=size_y, + size_z=size_z, + ordered_items=ordered_items, + ordering=ordering, + category=category, + model=model, + ) + + def update_locations(self): + # TODO:调多次相加 + holes = create_ordered_items_2d( + klass=MaterialHole, + num_items_x=4, + num_items_y=4, + dx=(self._size_x - 3 * self._unilabos_state["hole_spacing_x"]) / 2, # 居中 + dy=(self._size_y - 3 * self._unilabos_state["hole_spacing_y"]) / 2, # 居中 + dz=self._size_z, + item_dx=self._unilabos_state["hole_spacing_x"], + item_dy=self._unilabos_state["hole_spacing_y"], + size_x = 1, + size_y = 1, + size_z = 1, + ) + for item, original_item in zip(holes.items(), self.children): + original_item.location = item[1].location + + +class PlateSlot(ResourceStack): + """板槽位类 - 1个槽上能堆放8个板，移板只能操作最上方的板""" + + def __init__( + self, + name: str, + size_x: float, + size_y: float, + size_z: float, + max_plates: int = 8, + category: str = "plate_slot", + model: Optional[str] = None + ): + """初始化板槽位 + + Args: + name: 槽位名称 + max_plates: 最大板数量 + category: 类别 + """ + super().__init__( + name=name, + direction="z", # Z方向堆叠 + resources=[], + ) + self.max_plates = max_plates + self.category = category + + def can_add_plate(self) -> bool: + """检查是否可以添加板""" + return len(self.children) < self.max_plates + + def add_plate(self, plate: MaterialPlate) -> None: + """添加料板""" + if not self.can_add_plate(): + raise ValueError(f"槽位 {self.name} 已满，无法添加更多板") + self.assign_child_resource(plate) + + def get_top_plate(self) -> MaterialPlate: + """获取最上方的板""" + if len(self.children) == 0: + raise ValueError(f"槽位 {self.name} 为空") + return cast(MaterialPlate, self.get_top_item()) + + def take_top_plate(self) -> MaterialPlate: + """取出最上方的板""" + top_plate = self.get_top_plate() + self.unassign_child_resource(top_plate) + return top_plate + + def can_access_for_picking(self) -> bool: + """检查是否可以进行取料操作（只有最上方的板能进行取料操作）""" + return len(self.children) > 0 + + def serialize(self) -> dict: + return { + **super().serialize(), + "max_plates": self.max_plates, + } + + +#是一种类型注解，不用self +class BatteryState(TypedDict): + """电池状态字典""" + diameter: float + height: float + assembly_pressure: float + electrolyte_volume: float + electrolyte_name: str + +class Battery(Resource): + """电池类 - 可容纳极片""" + children: List[ElectrodeSheet] = [] + + def __init__( + self, + name: str, + size_x=1, + size_y=1, + size_z=1, + category: str = "battery", + ): + """初始化电池 + + Args: + name: 电池名称 + diameter: 直径 (mm) + height: 高度 (mm) + max_volume: 最大容量 (μL) + barcode: 二维码编号 + category: 类别 + model: 型号 + """ + super().__init__( + name=name, + size_x=1, + size_y=1, + size_z=1, + category=category, + ) + self._unilabos_state: BatteryState = BatteryState( + diameter = 1.0, + height = 1.0, + assembly_pressure = 1.0, + electrolyte_volume = 1.0, + electrolyte_name = "DP001" + ) + + def add_electrolyte_with_bottle(self, bottle: Bottle) -> bool: + to_add_name = bottle._unilabos_state["electrolyte_name"] + if bottle.aspirate_electrolyte(10): + if self.add_electrolyte(to_add_name, 10): + pass + else: + bottle._unilabos_state["electrolyte_volume"] += 10 + + def set_electrolyte(self, name: str, volume: float) -> None: + """设置电解液信息""" + self._unilabos_state["electrolyte_name"] = name + self._unilabos_state["electrolyte_volume"] = volume + #这个应该没用，不会有加了后再加的事情 + def add_electrolyte(self, name: str, volume: float) -> bool: + """添加电解液信息""" + if name != self._unilabos_state["electrolyte_name"]: + return False + self._unilabos_state["electrolyte_volume"] += volume + + def load_state(self, state: Dict[str, Any]) -> None: + """格式不变""" + super().load_state(state) + self._unilabos_state = state + + def serialize_state(self) -> Dict[str, Dict[str, Any]]: + """格式不变""" + data = super().serialize_state() + data.update(self._unilabos_state) # Container自身的信息，云端物料将保存这一data，本地也通过这里的data进行读写，当前类用来表示这个物料的长宽高大小的属性，而data（state用来表示物料的内容，细节等） + return data + +# 电解液作为属性放进去 + +class BatteryPressSlotState(TypedDict): + """电池状态字典""" + diameter: float =20.0 + depth: float = 4.0 + +class BatteryPressSlot(Resource): + """电池压制槽类 - 设备，可容纳一个电池""" + children: List[Battery] = [] + + def __init__( + self, + name: str = "BatteryPressSlot", + category: str = "battery_press_slot", + ): + """初始化电池压制槽 + + Args: + name: 压制槽名称 + diameter: 直径 (mm) + depth: 深度 (mm) + category: 类别 + model: 型号 + """ + super().__init__( + name=name, + size_x=10, + size_y=12, + size_z=13, + category=category, + ) + self._unilabos_state: BatteryPressSlotState = BatteryPressSlotState() + + def has_battery(self) -> bool: + """检查是否有电池""" + return len(self.children) > 0 + + def load_state(self, state: Dict[str, Any]) -> None: + """格式不变""" + super().load_state(state) + self._unilabos_state = state + + def serialize_state(self) -> Dict[str, Dict[str, Any]]: + """格式不变""" + data = super().serialize_state() + data.update(self._unilabos_state) # Container自身的信息，云端物料将保存这一data，本地也通过这里的data进行读写，当前类用来表示这个物料的长宽高大小的属性，而data（state用来表示物料的内容，细节等） + return data + + def assign_child_resource( + self, + resource: Battery, + location: Optional[Coordinate], + reassign: bool = True, + ): + """放置极片""" + # TODO: 让高京看下槽位只有一个电池时是否这么写。 + if self.has_battery(): + raise ValueError(f"槽位已含有一个电池，无法再放置其他电池") + super().assign_child_resource(resource, location, reassign) + + # 根据children的编号取物料对象。 + def get_battery_info(self, index: int) -> Battery: + return self.children[0] + + +def TipBox64( + name: str, + size_x: float = 127.8, + size_y: float = 85.5, + size_z: float = 60.0, + category: str = "tip_rack", + model: Optional[str] = None, +): + """64孔枪头盒类""" + from pylabrobot.resources.tip import Tip + + # 创建12x8=96个枪头位 + def make_tip(): + return Tip( + has_filter=False, + total_tip_length=20.0, + maximal_volume=1000, # 1mL + fitting_depth=8.0, + ) + + tip_spots = create_ordered_items_2d( + klass=TipSpot, + num_items_x=12, + num_items_y=8, + dx=8.0, + dy=8.0, + dz=0.0, + item_dx=9.0, + item_dy=9.0, + size_x=10, + size_y=10, + size_z=0.0, + make_tip=make_tip, + ) + idx_available = list(range(0, 32)) + list(range(64, 96)) + tip_spots_available = {k: v for i, (k, v) in enumerate(tip_spots.items()) if i in idx_available} + tip_rack = TipRack( + name=name, + size_x=size_x, + size_y=size_y, + size_z=size_z, + # ordered_items=tip_spots_available, + ordered_items=tip_spots, + category=category, + model=model, + with_tips=False, + ) + tip_rack.set_tip_state([True]*32 + [False]*32 + [True]*32) # 前32和后32个有枪头，中间32个无枪头 + return tip_rack + + +class WasteTipBoxstate(TypedDict): + """"废枪头盒状态字典""" + max_tips: int = 100 + tip_count: int = 0 + +#枪头不是一次性的（同一溶液则反复使用），根据寄存器判断 +class WasteTipBox(Trash): + """废枪头盒类 - 100个枪头容量""" + + def __init__( + self, + name: str, + size_x: float = 127.8, + size_y: float = 85.5, + size_z: float = 60.0, + material_z_thickness=0, + max_volume=float("inf"), + category="trash", + model=None, + compute_volume_from_height=None, + compute_height_from_volume=None, + ): + """初始化废枪头盒 + + Args: + name: 废枪头盒名称 + size_x: 长度 (mm) + size_y: 宽度 (mm) + size_z: 高度 (mm) + max_tips: 最大枪头容量 + category: 类别 + model: 型号 + """ + super().__init__( + name=name, + size_x=size_x, + size_y=size_y, + size_z=size_z, + category=category, + model=model, + ) + self._unilabos_state: WasteTipBoxstate = WasteTipBoxstate() + + def add_tip(self) -> None: + """添加废枪头""" + if self._unilabos_state["tip_count"] >= self._unilabos_state["max_tips"]: + raise ValueError(f"废枪头盒 {self.name} 已满") + self._unilabos_state["tip_count"] += 1 + + def get_tip_count(self) -> int: + """获取枪头数量""" + return self._unilabos_state["tip_count"] + + def empty(self) -> None: + """清空废枪头盒""" + self._unilabos_state["tip_count"] = 0 + + + def load_state(self, state: Dict[str, Any]) -> None: + """格式不变""" + super().load_state(state) + self._unilabos_state = state + + def serialize_state(self) -> Dict[str, Dict[str, Any]]: + """格式不变""" + data = super().serialize_state() + data.update(self._unilabos_state) # Container自身的信息，云端物料将保存这一data，本地也通过这里的data进行读写，当前类用来表示这个物料的长宽高大小的属性，而data（state用来表示物料的内容，细节等） + return data + + +class CoincellDeck(Deck): + """纽扣电池组装工作站台面类""" + + def __init__( + self, + name: str = "coin_cell_deck", + size_x: float = 1450.0, # 1m + size_y: float = 1450.0, # 1m + size_z: float = 100.0, # 0.9m + origin: Coordinate = Coordinate(-2200, 0, 0), + category: str = "coin_cell_deck", + setup: bool = False, # 是否自动执行 setup + ): + """初始化纽扣电池组装工作站台面 + + Args: + name: 台面名称 + size_x: 长度 (mm) - 1m + size_y: 宽度 (mm) - 1m + size_z: 高度 (mm) - 0.9m + origin: 原点坐标 + category: 类别 + setup: 是否自动执行 setup 配置标准布局 + """ + super().__init__( + name=name, + size_x=1450.0, + size_y=1450.0, + size_z=100.0, + origin=origin, + ) + if setup: + self.setup() + + def setup(self) -> None: + """设置工作站的标准布局 - 包含子弹夹、料盘、瓶架等完整配置""" + # ====================================== 子弹夹 ============================================ + + # 正极片（4个洞位，2x2布局） + zhengji_zip = MagazineHolder_4_Cathode("正极&铝箔弹夹") + self.assign_child_resource(zhengji_zip, Coordinate(x=402.0, y=830.0, z=0)) + + # 正极壳、平垫片（6个洞位，2x2+2布局） + zhengjike_zip = MagazineHolder_6_Cathode("正极壳&平垫片弹夹") + self.assign_child_resource(zhengjike_zip, Coordinate(x=566.0, y=272.0, z=0)) + + # 负极壳、弹垫片（6个洞位，2x2+2布局） + fujike_zip = MagazineHolder_6_Anode("负极壳&弹垫片弹夹") + self.assign_child_resource(fujike_zip, Coordinate(x=474.0, y=276.0, z=0)) + + # 成品弹夹（6个洞位，3x2布局） + chengpindanjia_zip = MagazineHolder_6_Battery("成品弹夹") + self.assign_child_resource(chengpindanjia_zip, Coordinate(x=260.0, y=156.0, z=0)) + + # ====================================== 物料板 ============================================ + # 创建物料板（料盘carrier）- 4x4布局 + # 负极料盘 + fujiliaopan = MaterialPlate(name="负极料盘", size_x=120, size_y=100, size_z=10.0, fill=True) + self.assign_child_resource(fujiliaopan, Coordinate(x=708.0, y=794.0, z=0)) + # for i in range(16): + # fujipian = ElectrodeSheet(name=f"{fujiliaopan.name}_jipian_{i}", size_x=12, size_y=12, size_z=0.1) + # fujiliaopan.children[i].assign_child_resource(fujipian, location=None) + + # 隔膜料盘 + gemoliaopan = MaterialPlate(name="隔膜料盘", size_x=120, size_y=100, size_z=10.0, fill=True) + self.assign_child_resource(gemoliaopan, Coordinate(x=718.0, y=918.0, z=0)) + # for i in range(16): + # gemopian = ElectrodeSheet(name=f"{gemoliaopan.name}_jipian_{i}", size_x=12, size_y=12, size_z=0.1) + # gemoliaopan.children[i].assign_child_resource(gemopian, location=None) + + # ====================================== 瓶架、移液枪 ============================================ + # 在台面上放置 3x4 瓶架、6x2 瓶架 与 64孔移液枪头盒 + # 奔耀上料5ml分液瓶小板 - 由奔曜跨站转运而来，不单独写，但是这里应该有一个堆栈用于摆放分液瓶小板 + + # bottle_rack_3x4 = BottleRack( + # name="bottle_rack_3x4", + # size_x=210.0, + # size_y=140.0, + # size_z=100.0, + # num_items_x=2, + # num_items_y=4, + # position_spacing=35.0, + # orientation="vertical", + # ) + # self.assign_child_resource(bottle_rack_3x4, Coordinate(x=1542.0, y=717.0, z=0)) + + # 电解液缓存位 - 6x2布局 + bottle_rack_6x2 = YIHUA_Electrolyte_12VialCarrier(name="bottle_rack_6x2") + self.assign_child_resource(bottle_rack_6x2, Coordinate(x=1050.0, y=358.0, z=0)) + # 电解液回收位6x2 + bottle_rack_6x2_2 = YIHUA_Electrolyte_12VialCarrier(name="bottle_rack_6x2_2") + self.assign_child_resource(bottle_rack_6x2_2, Coordinate(x=914.0, y=358.0, z=0)) + + tip_box = TipBox64(name="tip_box_64") + self.assign_child_resource(tip_box, Coordinate(x=782.0, y=514.0, z=0)) + + waste_tip_box = WasteTipBox(name="waste_tip_box") + self.assign_child_resource(waste_tip_box, Coordinate(x=778.0, y=622.0, z=0)) + + +def YH_Deck(name=""): + cd = CoincellDeck(name=name) + cd.setup() + return cd + + +if __name__ == "__main__": + deck = create_coin_cell_deck() + print(deck) \ No newline at end of file diff --git a/unilabos/devices/workstation/coin_cell_assembly/button_battery_station.py b/unilabos/devices/workstation/coin_cell_assembly/button_battery_station.py deleted file mode 100644 index f663a21..0000000 --- a/unilabos/devices/workstation/coin_cell_assembly/button_battery_station.py +++ /dev/null @@ -1,1289 +0,0 @@ -""" -纽扣电池组装工作站物料类定义 -Button Battery Assembly Station Resource Classes -""" - -from __future__ import annotations - -from collections import OrderedDict -from typing import Any, Dict, List, Optional, TypedDict, Union, cast - -from pylabrobot.resources.coordinate import Coordinate -from pylabrobot.resources.container import Container -from pylabrobot.resources.deck import Deck -from pylabrobot.resources.itemized_resource import ItemizedResource -from pylabrobot.resources.resource import Resource -from pylabrobot.resources.resource_stack import ResourceStack -from pylabrobot.resources.tip_rack import TipRack, TipSpot -from pylabrobot.resources.trash import Trash -from pylabrobot.resources.utils import create_ordered_items_2d - - -class ElectrodeSheetState(TypedDict): - diameter: float # 直径 (mm) - thickness: float # 厚度 (mm) - mass: float # 质量 (g) - material_type: str # 材料类型（正极、负极、隔膜、弹片、垫片、铝箔等） - info: Optional[str] # 附加信息 - -class ElectrodeSheet(Resource): - """极片类 - 包含正负极片、隔膜、弹片、垫片、铝箔等所有片状材料""" - - def __init__( - self, - name: str = "极片", - size_x=10, - size_y=10, - size_z=10, - category: str = "electrode_sheet", - model: Optional[str] = None, - ): - """初始化极片 - - Args: - name: 极片名称 - category: 类别 - model: 型号 - """ - super().__init__( - name=name, - size_x=size_x, - size_y=size_y, - size_z=size_z, - category=category, - model=model, - ) - self._unilabos_state: ElectrodeSheetState = ElectrodeSheetState( - diameter=14, - thickness=0.1, - mass=0.5, - material_type="copper", - info=None - ) - - def load_state(self, state: Dict[str, Any]) -> None: - """格式不变""" - super().load_state(state) - self._unilabos_state = state - #序列化 - def serialize_state(self) -> Dict[str, Dict[str, Any]]: - """格式不变""" - data = super().serialize_state() - data.update(self._unilabos_state) # Container自身的信息，云端物料将保存这一data，本地也通过这里的data进行读写，当前类用来表示这个物料的长宽高大小的属性，而data（state用来表示物料的内容，细节等） - return data - -# TODO: 这个应该只能放一个极片 -class MaterialHoleState(TypedDict): - diameter: int - depth: int - max_sheets: int - info: Optional[str] # 附加信息 - -class MaterialHole(Resource): - """料板洞位类""" - children: List[ElectrodeSheet] = [] - - def __init__( - self, - name: str, - size_x: float, - size_y: float, - size_z: float, - category: str = "material_hole", - **kwargs - ): - super().__init__( - name=name, - size_x=size_x, - size_y=size_y, - size_z=size_z, - category=category, - ) - self._unilabos_state: MaterialHoleState = MaterialHoleState( - diameter=20, - depth=10, - max_sheets=1, - info=None - ) - - def get_all_sheet_info(self): - info_list = [] - for sheet in self.children: - info_list.append(sheet._unilabos_state["info"]) - return info_list - - #这个函数函数好像没用，一般不会集中赋值质量 - def set_all_sheet_mass(self): - for sheet in self.children: - sheet._unilabos_state["mass"] = 0.5 # 示例：设置质量为0.5g - - def load_state(self, state: Dict[str, Any]) -> None: - """格式不变""" - super().load_state(state) - self._unilabos_state = state - - def serialize_state(self) -> Dict[str, Dict[str, Any]]: - """格式不变""" - data = super().serialize_state() - data.update(self._unilabos_state) # Container自身的信息，云端物料将保存这一data，本地也通过这里的data进行读写，当前类用来表示这个物料的长宽高大小的属性，而data（state用来表示物料的内容，细节等） - return data - #移动极片前先取出对象 - def get_sheet_with_name(self, name: str) -> Optional[ElectrodeSheet]: - for sheet in self.children: - if sheet.name == name: - return sheet - return None - - def has_electrode_sheet(self) -> bool: - """检查洞位是否有极片""" - return len(self.children) > 0 - - def assign_child_resource( - self, - resource: ElectrodeSheet, - location: Optional[Coordinate], - reassign: bool = True, - ): - """放置极片""" - # TODO: 这里要改，diameter找不到，加入._unilabos_state后应该没问题 - if resource._unilabos_state["diameter"] > self._unilabos_state["diameter"]: - raise ValueError(f"极片直径 {resource._unilabos_state['diameter']} 超过洞位直径 {self._unilabos_state['diameter']}") - if len(self.children) >= self._unilabos_state["max_sheets"]: - raise ValueError(f"洞位已满，无法放置更多极片") - super().assign_child_resource(resource, location, reassign) - - # 根据children的编号取物料对象。 - def get_electrode_sheet_info(self, index: int) -> ElectrodeSheet: - return self.children[index] - - - -class MaterialPlateState(TypedDict): - hole_spacing_x: float - hole_spacing_y: float - hole_diameter: float - info: Optional[str] # 附加信息 - - - -class MaterialPlate(ItemizedResource[MaterialHole]): - """料板类 - 4x4个洞位，每个洞位放1个极片""" - - children: List[MaterialHole] - - def __init__( - self, - name: str, - size_x: float, - size_y: float, - size_z: float, - ordered_items: Optional[Dict[str, MaterialHole]] = None, - ordering: Optional[OrderedDict[str, str]] = None, - category: str = "material_plate", - model: Optional[str] = None, - fill: bool = False - ): - """初始化料板 - - Args: - name: 料板名称 - size_x: 长度 (mm) - size_y: 宽度 (mm) - size_z: 高度 (mm) - hole_diameter: 洞直径 (mm) - hole_depth: 洞深度 (mm) - hole_spacing_x: X方向洞位间距 (mm) - hole_spacing_y: Y方向洞位间距 (mm) - number: 编号 - category: 类别 - model: 型号 - """ - self._unilabos_state: MaterialPlateState = MaterialPlateState( - hole_spacing_x=24.0, - hole_spacing_y=24.0, - hole_diameter=20.0, - info="", - ) - # 创建4x4的洞位 - # TODO: 这里要改，对应不同形状 - holes = create_ordered_items_2d( - klass=MaterialHole, - num_items_x=4, - num_items_y=4, - dx=(size_x - 4 * self._unilabos_state["hole_spacing_x"]) / 2, # 居中 - dy=(size_y - 4 * self._unilabos_state["hole_spacing_y"]) / 2, # 居中 - dz=size_z, - item_dx=self._unilabos_state["hole_spacing_x"], - item_dy=self._unilabos_state["hole_spacing_y"], - size_x = 16, - size_y = 16, - size_z = 16, - ) - if fill: - super().__init__( - name=name, - size_x=size_x, - size_y=size_y, - size_z=size_z, - ordered_items=holes, - category=category, - model=model, - ) - else: - super().__init__( - name=name, - size_x=size_x, - size_y=size_y, - size_z=size_z, - ordered_items=ordered_items, - ordering=ordering, - category=category, - model=model, - ) - - def update_locations(self): - # TODO:调多次相加 - holes = create_ordered_items_2d( - klass=MaterialHole, - num_items_x=4, - num_items_y=4, - dx=(self._size_x - 3 * self._unilabos_state["hole_spacing_x"]) / 2, # 居中 - dy=(self._size_y - 3 * self._unilabos_state["hole_spacing_y"]) / 2, # 居中 - dz=self._size_z, - item_dx=self._unilabos_state["hole_spacing_x"], - item_dy=self._unilabos_state["hole_spacing_y"], - size_x = 1, - size_y = 1, - size_z = 1, - ) - for item, original_item in zip(holes.items(), self.children): - original_item.location = item[1].location - - -class PlateSlot(ResourceStack): - """板槽位类 - 1个槽上能堆放8个板，移板只能操作最上方的板""" - - def __init__( - self, - name: str, - size_x: float, - size_y: float, - size_z: float, - max_plates: int = 8, - category: str = "plate_slot", - model: Optional[str] = None - ): - """初始化板槽位 - - Args: - name: 槽位名称 - max_plates: 最大板数量 - category: 类别 - """ - super().__init__( - name=name, - direction="z", # Z方向堆叠 - resources=[], - ) - self.max_plates = max_plates - self.category = category - - def can_add_plate(self) -> bool: - """检查是否可以添加板""" - return len(self.children) < self.max_plates - - def add_plate(self, plate: MaterialPlate) -> None: - """添加料板""" - if not self.can_add_plate(): - raise ValueError(f"槽位 {self.name} 已满，无法添加更多板") - self.assign_child_resource(plate) - - def get_top_plate(self) -> MaterialPlate: - """获取最上方的板""" - if len(self.children) == 0: - raise ValueError(f"槽位 {self.name} 为空") - return cast(MaterialPlate, self.get_top_item()) - - def take_top_plate(self) -> MaterialPlate: - """取出最上方的板""" - top_plate = self.get_top_plate() - self.unassign_child_resource(top_plate) - return top_plate - - def can_access_for_picking(self) -> bool: - """检查是否可以进行取料操作（只有最上方的板能进行取料操作）""" - return len(self.children) > 0 - - def serialize(self) -> dict: - return { - **super().serialize(), - "max_plates": self.max_plates, - } - - -class ClipMagazineHole(Container): - """子弹夹洞位类""" - children: List[ElectrodeSheet] = [] - def __init__( - self, - name: str, - diameter: float, - depth: float, - category: str = "clip_magazine_hole", - ): - """初始化子弹夹洞位 - - Args: - name: 洞位名称 - diameter: 洞直径 (mm) - depth: 洞深度 (mm) - category: 类别 - """ - super().__init__( - name=name, - size_x=diameter, - size_y=diameter, - size_z=depth, - category=category, - ) - self.diameter = diameter - self.depth = depth - - def can_add_sheet(self, sheet: ElectrodeSheet) -> bool: - """检查是否可以添加极片 - - 根据洞的深度和极片的厚度来判断是否可以添加极片 - """ - # 检查极片直径是否适合洞的直径 - if sheet._unilabos_state["diameter"] > self.diameter: - return False - - # 计算当前已添加极片的总厚度 - current_thickness = sum(s._unilabos_state["thickness"] for s in self.children) - - # 检查添加新极片后总厚度是否超过洞的深度 - if current_thickness + sheet._unilabos_state["thickness"] > self.depth: - return False - - return True - - - def assign_child_resource( - self, - resource: ElectrodeSheet, - location: Optional[Coordinate] = None, - reassign: bool = True, - ): - """放置极片到洞位中 - - Args: - resource: 要放置的极片 - location: 极片在洞位中的位置（对于洞位，通常为None） - reassign: 是否允许重新分配 - """ - # 检查是否可以添加极片 - if not self.can_add_sheet(resource): - raise ValueError(f"无法向洞位 {self.name} 添加极片：直径或厚度不匹配") - - # 调用父类方法实际执行分配 - super().assign_child_resource(resource, location, reassign) - - def unassign_child_resource(self, resource: ElectrodeSheet): - """从洞位中移除极片 - - Args: - resource: 要移除的极片 - """ - if resource not in self.children: - raise ValueError(f"极片 {resource.name} 不在洞位 {self.name} 中") - - # 调用父类方法实际执行移除 - super().unassign_child_resource(resource) - - - - def serialize_state(self) -> Dict[str, Any]: - return { - "sheet_count": len(self.children), - "sheets": [sheet.serialize() for sheet in self.children], - } -class ClipMagazine_four(ItemizedResource[ClipMagazineHole]): - """子弹夹类 - 有4个洞位，每个洞位放多个极片""" - children: List[ClipMagazineHole] - def __init__( - self, - name: str, - size_x: float, - size_y: float, - size_z: float, - hole_diameter: float = 14.0, - hole_depth: float = 10.0, - hole_spacing: float = 25.0, - max_sheets_per_hole: int = 100, - category: str = "clip_magazine_four", - model: Optional[str] = None, - ): - """初始化子弹夹 - - Args: - name: 子弹夹名称 - size_x: 长度 (mm) - size_y: 宽度 (mm) - size_z: 高度 (mm) - hole_diameter: 洞直径 (mm) - hole_depth: 洞深度 (mm) - hole_spacing: 洞位间距 (mm) - max_sheets_per_hole: 每个洞位最大极片数量 - category: 类别 - model: 型号 - """ - # 创建4个洞位，排成2x2布局 - holes = create_ordered_items_2d( - klass=ClipMagazineHole, - num_items_x=2, - num_items_y=2, - dx=(size_x - 2 * hole_spacing) / 2, # 居中 - dy=(size_y - hole_spacing) / 2, # 居中 - dz=size_z - 0, - item_dx=hole_spacing, - item_dy=hole_spacing, - diameter=hole_diameter, - depth=hole_depth, - ) - - super().__init__( - name=name, - size_x=size_x, - size_y=size_y, - size_z=size_z, - ordered_items=holes, - category=category, - model=model, - ) - - # 保存洞位的直径和深度 - self.hole_diameter = hole_diameter - self.hole_depth = hole_depth - self.max_sheets_per_hole = max_sheets_per_hole - - def serialize(self) -> dict: - return { - **super().serialize(), - "hole_diameter": self.hole_diameter, - "hole_depth": self.hole_depth, - "max_sheets_per_hole": self.max_sheets_per_hole, - } -# TODO: 这个要改 -class ClipMagazine(ItemizedResource[ClipMagazineHole]): - """子弹夹类 - 有6个洞位，每个洞位放多个极片""" - children: List[ClipMagazineHole] - def __init__( - self, - name: str, - size_x: float, - size_y: float, - size_z: float, - hole_diameter: float = 14.0, - hole_depth: float = 10.0, - hole_spacing: float = 25.0, - max_sheets_per_hole: int = 100, - category: str = "clip_magazine", - model: Optional[str] = None, - ): - """初始化子弹夹 - - Args: - name: 子弹夹名称 - size_x: 长度 (mm) - size_y: 宽度 (mm) - size_z: 高度 (mm) - hole_diameter: 洞直径 (mm) - hole_depth: 洞深度 (mm) - hole_spacing: 洞位间距 (mm) - max_sheets_per_hole: 每个洞位最大极片数量 - category: 类别 - model: 型号 - """ - # 创建6个洞位，排成2x3布局 - holes = create_ordered_items_2d( - klass=ClipMagazineHole, - num_items_x=3, - num_items_y=2, - dx=(size_x - 2 * hole_spacing) / 2, # 居中 - dy=(size_y - hole_spacing) / 2, # 居中 - dz=size_z - 0, - item_dx=hole_spacing, - item_dy=hole_spacing, - diameter=hole_diameter, - depth=hole_depth, - ) - - super().__init__( - name=name, - size_x=size_x, - size_y=size_y, - size_z=size_z, - ordered_items=holes, - category=category, - model=model, - ) - - # 保存洞位的直径和深度 - self.hole_diameter = hole_diameter - self.hole_depth = hole_depth - self.max_sheets_per_hole = max_sheets_per_hole - - def serialize(self) -> dict: - return { - **super().serialize(), - "hole_diameter": self.hole_diameter, - "hole_depth": self.hole_depth, - "max_sheets_per_hole": self.max_sheets_per_hole, - } -#是一种类型注解，不用self -class BatteryState(TypedDict): - """电池状态字典""" - diameter: float - height: float - - electrolyte_name: str - electrolyte_volume: float - -class Battery(Resource): - """电池类 - 可容纳极片""" - children: List[ElectrodeSheet] = [] - - def __init__( - self, - name: str, - category: str = "battery", - ): - """初始化电池 - - Args: - name: 电池名称 - diameter: 直径 (mm) - height: 高度 (mm) - max_volume: 最大容量 (μL) - barcode: 二维码编号 - category: 类别 - model: 型号 - """ - super().__init__( - name=name, - size_x=1, - size_y=1, - size_z=1, - category=category, - ) - self._unilabos_state: BatteryState = BatteryState() - - def add_electrolyte_with_bottle(self, bottle: Bottle) -> bool: - to_add_name = bottle._unilabos_state["electrolyte_name"] - if bottle.aspirate_electrolyte(10): - if self.add_electrolyte(to_add_name, 10): - pass - else: - bottle._unilabos_state["electrolyte_volume"] += 10 - - def set_electrolyte(self, name: str, volume: float) -> None: - """设置电解液信息""" - self._unilabos_state["electrolyte_name"] = name - self._unilabos_state["electrolyte_volume"] = volume - #这个应该没用，不会有加了后再加的事情 - def add_electrolyte(self, name: str, volume: float) -> bool: - """添加电解液信息""" - if name != self._unilabos_state["electrolyte_name"]: - return False - self._unilabos_state["electrolyte_volume"] += volume - - def load_state(self, state: Dict[str, Any]) -> None: - """格式不变""" - super().load_state(state) - self._unilabos_state = state - - def serialize_state(self) -> Dict[str, Dict[str, Any]]: - """格式不变""" - data = super().serialize_state() - data.update(self._unilabos_state) # Container自身的信息，云端物料将保存这一data，本地也通过这里的data进行读写，当前类用来表示这个物料的长宽高大小的属性，而data（state用来表示物料的内容，细节等） - return data - -# 电解液作为属性放进去 - -class BatteryPressSlotState(TypedDict): - """电池状态字典""" - diameter: float =20.0 - depth: float = 4.0 - -class BatteryPressSlot(Resource): - """电池压制槽类 - 设备，可容纳一个电池""" - children: List[Battery] = [] - - def __init__( - self, - name: str = "BatteryPressSlot", - category: str = "battery_press_slot", - ): - """初始化电池压制槽 - - Args: - name: 压制槽名称 - diameter: 直径 (mm) - depth: 深度 (mm) - category: 类别 - model: 型号 - """ - super().__init__( - name=name, - size_x=10, - size_y=12, - size_z=13, - category=category, - ) - self._unilabos_state: BatteryPressSlotState = BatteryPressSlotState() - - def has_battery(self) -> bool: - """检查是否有电池""" - return len(self.children) > 0 - - def load_state(self, state: Dict[str, Any]) -> None: - """格式不变""" - super().load_state(state) - self._unilabos_state = state - - def serialize_state(self) -> Dict[str, Dict[str, Any]]: - """格式不变""" - data = super().serialize_state() - data.update(self._unilabos_state) # Container自身的信息，云端物料将保存这一data，本地也通过这里的data进行读写，当前类用来表示这个物料的长宽高大小的属性，而data（state用来表示物料的内容，细节等） - return data - - def assign_child_resource( - self, - resource: Battery, - location: Optional[Coordinate], - reassign: bool = True, - ): - """放置极片""" - if self.has_battery(): - raise ValueError(f"槽位已含有一个电池，无法再放置其他电池") - super().assign_child_resource(resource, location, reassign) - - # 根据children的编号取物料对象。 - def get_battery_info(self, index: int) -> Battery: - return self.children[0] - -class TipBox64State(TypedDict): - """电池状态字典""" - tip_diameter: float = 5.0 - tip_length: float = 50.0 - with_tips: bool = True - -class TipBox64(TipRack): - """64孔枪头盒类""" - - children: List[TipSpot] = [] - def __init__( - self, - name: str, - size_x: float = 127.8, - size_y: float = 85.5, - size_z: float = 60.0, - category: str = "tip_box_64", - model: Optional[str] = None, - ): - """初始化64孔枪头盒 - - Args: - name: 枪头盒名称 - size_x: 长度 (mm) - size_y: 宽度 (mm) - size_z: 高度 (mm) - tip_diameter: 枪头直径 (mm) - tip_length: 枪头长度 (mm) - category: 类别 - model: 型号 - with_tips: 是否带枪头 - """ - from pylabrobot.resources.tip import Tip - - # 创建8x8=64个枪头位 - def make_tip(): - return Tip( - has_filter=False, - total_tip_length=20.0, - maximal_volume=1000, # 1mL - fitting_depth=8.0, - ) - - tip_spots = create_ordered_items_2d( - klass=TipSpot, - num_items_x=8, - num_items_y=8, - dx=8.0, - dy=8.0, - dz=0.0, - item_dx=9.0, - item_dy=9.0, - size_x=10, - size_y=10, - size_z=0.0, - make_tip=make_tip, - ) - self._unilabos_state: WasteTipBoxstate = WasteTipBoxstate() - # 记录网格参数用于前端渲染 - self._grid_params = { - "num_items_x": 8, - "num_items_y": 8, - "dx": 8.0, - "dy": 8.0, - "item_dx": 9.0, - "item_dy": 9.0, - } - super().__init__( - name=name, - size_x=size_x, - size_y=size_y, - size_z=size_z, - ordered_items=tip_spots, - category=category, - model=model, - with_tips=True, - ) - - def serialize(self) -> dict: - return { - **super().serialize(), - **self._grid_params, - } - - - -class WasteTipBoxstate(TypedDict): - """"废枪头盒状态字典""" - max_tips: int = 100 - tip_count: int = 0 - -#枪头不是一次性的（同一溶液则反复使用），根据寄存器判断 -class WasteTipBox(Trash): - """废枪头盒类 - 100个枪头容量""" - - def __init__( - self, - name: str, - size_x: float = 127.8, - size_y: float = 85.5, - size_z: float = 60.0, - category: str = "waste_tip_box", - model: Optional[str] = None, - ): - """初始化废枪头盒 - - Args: - name: 废枪头盒名称 - size_x: 长度 (mm) - size_y: 宽度 (mm) - size_z: 高度 (mm) - max_tips: 最大枪头容量 - category: 类别 - model: 型号 - """ - super().__init__( - name=name, - size_x=size_x, - size_y=size_y, - size_z=size_z, - category=category, - model=model, - ) - self._unilabos_state: WasteTipBoxstate = WasteTipBoxstate() - - def add_tip(self) -> None: - """添加废枪头""" - if self._unilabos_state["tip_count"] >= self._unilabos_state["max_tips"]: - raise ValueError(f"废枪头盒 {self.name} 已满") - self._unilabos_state["tip_count"] += 1 - - def get_tip_count(self) -> int: - """获取枪头数量""" - return self._unilabos_state["tip_count"] - - def empty(self) -> None: - """清空废枪头盒""" - self._unilabos_state["tip_count"] = 0 - - - def load_state(self, state: Dict[str, Any]) -> None: - """格式不变""" - super().load_state(state) - self._unilabos_state = state - - def serialize_state(self) -> Dict[str, Dict[str, Any]]: - """格式不变""" - data = super().serialize_state() - data.update(self._unilabos_state) # Container自身的信息，云端物料将保存这一data，本地也通过这里的data进行读写，当前类用来表示这个物料的长宽高大小的属性，而data（state用来表示物料的内容，细节等） - return data - - -class BottleRackState(TypedDict): - """ bottle_diameter: 瓶子直径 (mm) - bottle_height: 瓶子高度 (mm) - position_spacing: 位置间距 (mm)""" - bottle_diameter: float - bottle_height: float - name_to_index: dict - - -class BottleRackState(TypedDict): - """ bottle_diameter: 瓶子直径 (mm) - bottle_height: 瓶子高度 (mm) - position_spacing: 位置间距 (mm)""" - bottle_diameter: float - bottle_height: float - position_spacing: float - name_to_index: dict - - -class BottleRack(Resource): - """瓶架类 - 12个待配位置+12个已配位置""" - children: List[Resource] = [] - - def __init__( - self, - name: str, - size_x: float, - size_y: float, - size_z: float, - category: str = "bottle_rack", - model: Optional[str] = None, - num_items_x: int = 3, - num_items_y: int = 4, - position_spacing: float = 35.0, - orientation: str = "horizontal", - padding_x: float = 20.0, - padding_y: float = 20.0, - ): - """初始化瓶架 - - Args: - name: 瓶架名称 - size_x: 长度 (mm) - size_y: 宽度 (mm) - size_z: 高度 (mm) - category: 类别 - model: 型号 - """ - super().__init__( - name=name, - size_x=size_x, - size_y=size_y, - size_z=size_z, - category=category, - model=model, - ) - # 初始化状态 - self._unilabos_state: BottleRackState = BottleRackState( - bottle_diameter=30.0, - bottle_height=100.0, - position_spacing=position_spacing, - name_to_index={}, - ) - # 基于网格生成瓶位坐标映射（居中摆放） - # 使用内边距，避免点跑到容器外（前端渲染不按mm等比缩放时更稳妥） - origin_x = padding_x - origin_y = padding_y - self.index_to_pos = {} - for j in range(num_items_y): - for i in range(num_items_x): - idx = j * num_items_x + i - if orientation == "vertical": - # 纵向：沿 y 方向优先排列 - self.index_to_pos[idx] = Coordinate( - x=origin_x + j * position_spacing, - y=origin_y + i * position_spacing, - z=0, - ) - else: - # 横向（默认）：沿 x 方向优先排列 - self.index_to_pos[idx] = Coordinate( - x=origin_x + i * position_spacing, - y=origin_y + j * position_spacing, - z=0, - ) - self.name_to_index = {} - self.name_to_pos = {} - self.num_items_x = num_items_x - self.num_items_y = num_items_y - self.orientation = orientation - self.padding_x = padding_x - self.padding_y = padding_y - - def load_state(self, state: Dict[str, Any]) -> None: - """格式不变""" - super().load_state(state) - self._unilabos_state = state - - def serialize_state(self) -> Dict[str, Dict[str, Any]]: - """格式不变""" - data = super().serialize_state() - data.update( - self._unilabos_state) # Container自身的信息，云端物料将保存这一data，本地也通过这里的data进行读写，当前类用来表示这个物料的长宽高大小的属性，而data（state用来表示物料的内容，细节等） - return data - - # TODO: 这里有些问题要重新写一下 - def assign_child_resource_old(self, resource: Resource, location=Coordinate.zero(), reassign=True): - capacity = self.num_items_x * self.num_items_y - assert len(self.children) < capacity, "瓶架已满，无法添加更多瓶子" - index = len(self.children) - location = self.index_to_pos.get(index, Coordinate.zero()) - self.name_to_pos[resource.name] = location - self.name_to_index[resource.name] = index - return super().assign_child_resource(resource, location, reassign) - - def assign_child_resource(self, resource: Resource, index: int): - capacity = self.num_items_x * self.num_items_y - assert 0 <= index < capacity, "无效的瓶子索引" - self.name_to_index[resource.name] = index - location = self.index_to_pos[index] - return super().assign_child_resource(resource, location) - - def unassign_child_resource(self, resource: Bottle): - super().unassign_child_resource(resource) - self.index_to_pos.pop(self.name_to_index.pop(resource.name, None), None) - - def serialize(self) -> dict: - return { - **super().serialize(), - "num_items_x": self.num_items_x, - "num_items_y": self.num_items_y, - "position_spacing": self._unilabos_state.get("position_spacing", 35.0), - "orientation": self.orientation, - "padding_x": self.padding_x, - "padding_y": self.padding_y, - } - - -class BottleState(TypedDict): - diameter: float - height: float - electrolyte_name: str - electrolyte_volume: float - max_volume: float - -class Bottle(Resource): - """瓶子类 - 容纳电解液""" - - def __init__( - self, - name: str, - category: str = "bottle", - ): - """初始化瓶子 - - Args: - name: 瓶子名称 - diameter: 直径 (mm) - height: 高度 (mm) - max_volume: 最大体积 (μL) - barcode: 二维码 - category: 类别 - model: 型号 - """ - super().__init__( - name=name, - size_x=1, - size_y=1, - size_z=1, - category=category, - ) - self._unilabos_state: BottleState = BottleState() - - def aspirate_electrolyte(self, volume: float) -> bool: - current_volume = self._unilabos_state["electrolyte_volume"] - assert current_volume > volume, f"Cannot aspirate {volume}μL, only {current_volume}μL available." - self._unilabos_state["electrolyte_volume"] -= volume - return True - - def load_state(self, state: Dict[str, Any]) -> None: - """格式不变""" - super().load_state(state) - self._unilabos_state = state - - def serialize_state(self) -> Dict[str, Dict[str, Any]]: - """格式不变""" - data = super().serialize_state() - data.update(self._unilabos_state) # Container自身的信息，云端物料将保存这一data，本地也通过这里的data进行读写，当前类用来表示这个物料的长宽高大小的属性，而data（state用来表示物料的内容，细节等） - return data - -class CoincellDeck(Deck): - """纽扣电池组装工作站台面类""" - - def __init__( - self, - name: str = "coin_cell_deck", - size_x: float = 1620.0, # 3.66m - size_y: float = 1270.0, # 1.23m - size_z: float = 500.0, - origin: Coordinate = Coordinate(0, 0, 0), - category: str = "coin_cell_deck", - ): - """初始化纽扣电池组装工作站台面 - - Args: - name: 台面名称 - size_x: 长度 (mm) - 3.66m - size_y: 宽度 (mm) - 1.23m - size_z: 高度 (mm) - origin: 原点坐标 - category: 类别 - """ - super().__init__( - name=name, - size_x=size_x, - size_y=size_y, - size_z=size_z, - origin=origin, - category=category, - ) - -#if __name__ == "__main__": -# # 转移极片的测试代码 -# deck = CoincellDeck("coin_cell_deck") -# ban_cao_wei = PlateSlot("ban_cao_wei", max_plates=8) -# deck.assign_child_resource(ban_cao_wei, Coordinate(x=0, y=0, z=0)) -# -# plate_1 = MaterialPlate("plate_1", 1,1,1, fill=True) -# for i, hole in enumerate(plate_1.children): -# sheet = ElectrodeSheet(f"hole_{i}_sheet_1") -# sheet._unilabos_state = { -# "diameter": 14, -# "info": "NMC", -# "mass": 5.0, -# "material_type": "positive_electrode", -# "thickness": 0.1 -# } -# hole._unilabos_state = { -# "depth": 1.0, -# "diameter": 14, -# "info": "", -# "max_sheets": 1 -# } -# hole.assign_child_resource(sheet, Coordinate.zero()) -# plate_1._unilabos_state = { -# "hole_spacing_x": 20.0, -# "hole_spacing_y": 20.0, -# "hole_diameter": 5, -# "info": "这是第一块料板" -# } -# plate_1.update_locations() -# ban_cao_wei.assign_child_resource(plate_1, Coordinate.zero()) -# # zi_dan_jia = ClipMagazine("zi_dan_jia", 1, 1, 1) -# # deck.assign_child_resource(ban_cao_wei, Coordinate(x=200, y=200, z=0)) -# -# from unilabos.resources.graphio import * -# A = tree_to_list([resource_plr_to_ulab(deck)]) -# with open("test.json", "w") as f: -# json.dump(A, f) -# -# -#def get_plate_with_14mm_hole(name=""): -# plate = MaterialPlate(name=name) -# for i in range(4): -# for j in range(4): -# hole = MaterialHole(f"{i+1}x{j+1}") -# hole._unilabos_state["diameter"] = 14 -# hole._unilabos_state["max_sheets"] = 1 -# plate.assign_child_resource(hole) -# return plate - -def create_a_liaopan(): - liaopan = MaterialPlate(name="liaopan", size_x=120.8, size_y=120.5, size_z=10.0, fill=True) - for i in range(16): - jipian = ElectrodeSheet(name=f"jipian_{i}", size_x= 12, size_y=12, size_z=0.1) - liaopan1.children[i].assign_child_resource(jipian, location=None) - return liaopan - -def create_a_coin_cell_deck(): - deck = Deck(size_x=1200, - size_y=800, - size_z=900) - - #liaopan = TipBox64(name="liaopan") - - #创建一个4*4的物料板 - liaopan1 = MaterialPlate(name="liaopan1", size_x=120.8, size_y=120.5, size_z=10.0, fill=True) - #把物料板放到桌子上 - deck.assign_child_resource(liaopan1, Coordinate(x=0, y=0, z=0)) - #创建一个极片 - for i in range(16): - jipian = ElectrodeSheet(name=f"jipian_{i}", size_x= 12, size_y=12, size_z=0.1) - liaopan1.children[i].assign_child_resource(jipian, location=None) - #创建一个4*4的物料板 - liaopan2 = MaterialPlate(name="liaopan2", size_x=120.8, size_y=120.5, size_z=10.0, fill=True) - #把物料板放到桌子上 - deck.assign_child_resource(liaopan2, Coordinate(x=500, y=0, z=0)) - - #创建一个4*4的物料板 - liaopan3 = MaterialPlate(name="liaopan3", size_x=120.8, size_y=120.5, size_z=10.0, fill=True) - #把物料板放到桌子上 - deck.assign_child_resource(liaopan3, Coordinate(x=1000, y=0, z=0)) - - print(deck) - - return deck - - -import json - -if __name__ == "__main__": - electrode1 = BatteryPressSlot() - #print(electrode1.get_size_x()) - #print(electrode1.get_size_y()) - #print(electrode1.get_size_z()) - #jipian = ElectrodeSheet() - #jipian._unilabos_state["diameter"] = 18 - #print(jipian.serialize()) - #print(jipian.serialize_state()) - - deck = CoincellDeck() - """======================================子弹夹============================================""" - zip_dan_jia = ClipMagazine_four("zi_dan_jia", 80, 80, 10) - deck.assign_child_resource(zip_dan_jia, Coordinate(x=1400, y=50, z=0)) - zip_dan_jia2 = ClipMagazine_four("zi_dan_jia2", 80, 80, 10) - deck.assign_child_resource(zip_dan_jia2, Coordinate(x=1600, y=200, z=0)) - zip_dan_jia3 = ClipMagazine("zi_dan_jia3", 80, 80, 10) - deck.assign_child_resource(zip_dan_jia3, Coordinate(x=1500, y=200, z=0)) - zip_dan_jia4 = ClipMagazine("zi_dan_jia4", 80, 80, 10) - deck.assign_child_resource(zip_dan_jia4, Coordinate(x=1500, y=300, z=0)) - zip_dan_jia5 = ClipMagazine("zi_dan_jia5", 80, 80, 10) - deck.assign_child_resource(zip_dan_jia5, Coordinate(x=1600, y=300, z=0)) - zip_dan_jia6 = ClipMagazine("zi_dan_jia6", 80, 80, 10) - deck.assign_child_resource(zip_dan_jia6, Coordinate(x=1530, y=500, z=0)) - zip_dan_jia7 = ClipMagazine("zi_dan_jia7", 80, 80, 10) - deck.assign_child_resource(zip_dan_jia7, Coordinate(x=1180, y=400, z=0)) - zip_dan_jia8 = ClipMagazine("zi_dan_jia8", 80, 80, 10) - deck.assign_child_resource(zip_dan_jia8, Coordinate(x=1280, y=400, z=0)) - for i in range(4): - jipian = ElectrodeSheet(name=f"zi_dan_jia_jipian_{i}", size_x=12, size_y=12, size_z=0.1) - zip_dan_jia2.children[i].assign_child_resource(jipian, location=None) - for i in range(4): - jipian2 = ElectrodeSheet(name=f"zi_dan_jia2_jipian_{i}", size_x=12, size_y=12, size_z=0.1) - zip_dan_jia.children[i].assign_child_resource(jipian2, location=None) - for i in range(6): - jipian3 = ElectrodeSheet(name=f"zi_dan_jia3_jipian_{i}", size_x=12, size_y=12, size_z=0.1) - zip_dan_jia3.children[i].assign_child_resource(jipian3, location=None) - for i in range(6): - jipian4 = ElectrodeSheet(name=f"zi_dan_jia4_jipian_{i}", size_x=12, size_y=12, size_z=0.1) - zip_dan_jia4.children[i].assign_child_resource(jipian4, location=None) - for i in range(6): - jipian5 = ElectrodeSheet(name=f"zi_dan_jia5_jipian_{i}", size_x=12, size_y=12, size_z=0.1) - zip_dan_jia5.children[i].assign_child_resource(jipian5, location=None) - for i in range(6): - jipian6 = ElectrodeSheet(name=f"zi_dan_jia6_jipian_{i}", size_x=12, size_y=12, size_z=0.1) - zip_dan_jia6.children[i].assign_child_resource(jipian6, location=None) - for i in range(6): - jipian7 = ElectrodeSheet(name=f"zi_dan_jia7_jipian_{i}", size_x=12, size_y=12, size_z=0.1) - zip_dan_jia7.children[i].assign_child_resource(jipian7, location=None) - for i in range(6): - jipian8 = ElectrodeSheet(name=f"zi_dan_jia8_jipian_{i}", size_x=12, size_y=12, size_z=0.1) - zip_dan_jia8.children[i].assign_child_resource(jipian8, location=None) - """======================================子弹夹============================================""" - #liaopan = TipBox64(name="liaopan") - """======================================物料板============================================""" - #创建一个4*4的物料板 - liaopan1 = MaterialPlate(name="liaopan1", size_x=120, size_y=100, size_z=10.0, fill=True) - deck.assign_child_resource(liaopan1, Coordinate(x=1010, y=50, z=0)) - for i in range(16): - jipian_1 = ElectrodeSheet(name=f"{liaopan1.name}_jipian_{i}", size_x=12, size_y=12, size_z=0.1) - liaopan1.children[i].assign_child_resource(jipian_1, location=None) - - liaopan2 = MaterialPlate(name="liaopan2", size_x=120, size_y=100, size_z=10.0, fill=True) - deck.assign_child_resource(liaopan2, Coordinate(x=1130, y=50, z=0)) - - liaopan3 = MaterialPlate(name="liaopan3", size_x=120, size_y=100, size_z=10.0, fill=True) - deck.assign_child_resource(liaopan3, Coordinate(x=1250, y=50, z=0)) - - liaopan4 = MaterialPlate(name="liaopan4", size_x=120, size_y=100, size_z=10.0, fill=True) - deck.assign_child_resource(liaopan4, Coordinate(x=1010, y=150, z=0)) - for i in range(16): - jipian_4 = ElectrodeSheet(name=f"{liaopan4.name}_jipian_{i}", size_x=12, size_y=12, size_z=0.1) - liaopan4.children[i].assign_child_resource(jipian_4, location=None) - liaopan5 = MaterialPlate(name="liaopan5", size_x=120, size_y=100, size_z=10.0, fill=True) - deck.assign_child_resource(liaopan5, Coordinate(x=1130, y=150, z=0)) - liaopan6 = MaterialPlate(name="liaopan6", size_x=120, size_y=100, size_z=10.0, fill=True) - deck.assign_child_resource(liaopan6, Coordinate(x=1250, y=150, z=0)) - #liaopan.children[3].assign_child_resource(jipian, location=None) - """======================================物料板============================================""" - """======================================瓶架，移液枪============================================""" - # 在台面上放置 3x4 瓶架、6x2 瓶架 与 64孔移液枪头盒 - bottle_rack_3x4 = BottleRack( - name="bottle_rack_3x4", - size_x=210.0, - size_y=140.0, - size_z=100.0, - num_items_x=3, - num_items_y=4, - position_spacing=35.0, - orientation="vertical", - ) - deck.assign_child_resource(bottle_rack_3x4, Coordinate(x=100, y=200, z=0)) - - bottle_rack_6x2 = BottleRack( - name="bottle_rack_6x2", - size_x=120.0, - size_y=250.0, - size_z=100.0, - num_items_x=6, - num_items_y=2, - position_spacing=35.0, - orientation="vertical", - ) - deck.assign_child_resource(bottle_rack_6x2, Coordinate(x=300, y=300, z=0)) - - bottle_rack_6x2_2 = BottleRack( - name="bottle_rack_6x2_2", - size_x=120.0, - size_y=250.0, - size_z=100.0, - num_items_x=6, - num_items_y=2, - position_spacing=35.0, - orientation="vertical", - ) - deck.assign_child_resource(bottle_rack_6x2_2, Coordinate(x=430, y=300, z=0)) - - - # 将 ElectrodeSheet 放满 3x4 与 6x2 的所有孔位 - for idx in range(bottle_rack_3x4.num_items_x * bottle_rack_3x4.num_items_y): - sheet = ElectrodeSheet(name=f"sheet_3x4_{idx}", size_x=12, size_y=12, size_z=0.1) - bottle_rack_3x4.assign_child_resource(sheet, index=idx) - - for idx in range(bottle_rack_6x2.num_items_x * bottle_rack_6x2.num_items_y): - sheet = ElectrodeSheet(name=f"sheet_6x2_{idx}", size_x=12, size_y=12, size_z=0.1) - bottle_rack_6x2.assign_child_resource(sheet, index=idx) - - tip_box = TipBox64(name="tip_box_64") - deck.assign_child_resource(tip_box, Coordinate(x=300, y=100, z=0)) - - waste_tip_box = WasteTipBox(name="waste_tip_box") - deck.assign_child_resource(waste_tip_box, Coordinate(x=300, y=200, z=0)) - """======================================瓶架，移液枪============================================""" - print(deck) - - - from unilabos.resources.graphio import convert_resources_from_type - from unilabos.config.config import BasicConfig - BasicConfig.ak = "56bbed5b-6e30-438c-b06d-f69eaa63bb45" - BasicConfig.sk = "238222fe-0bf7-4350-a426-e5ced8011dcf" - from unilabos.app.web.client import http_client - - resources = convert_resources_from_type([deck], [Resource]) - - # 检查序列化后的资源 - - json.dump({"nodes": resources, "links": []}, open("button_battery_decks_unilab.json", "w"), indent=2) - - - #print(resources) - http_client.remote_addr = "https://uni-lab.test.bohrium.com/api/v1" - - http_client.resource_add(resources) \ No newline at end of file diff --git a/unilabos/devices/workstation/coin_cell_assembly/coin_cell_assembly.py b/unilabos/devices/workstation/coin_cell_assembly/coin_cell_assembly.py index 4758bdd..91efd45 100644 --- a/unilabos/devices/workstation/coin_cell_assembly/coin_cell_assembly.py +++ b/unilabos/devices/workstation/coin_cell_assembly/coin_cell_assembly.py @@ -1,44 +1,171 @@ import csv +import inspect import json import os import threading import time +import types from datetime import datetime from typing import Any, Dict, Optional -from pylabrobot.resources import Resource as PLRResource +from functools import wraps +from pylabrobot.resources import Deck, Resource as PLRResource from unilabos_msgs.msg import Resource from unilabos.device_comms.modbus_plc.client import ModbusTcpClient -from unilabos.devices.workstation.coin_cell_assembly.button_battery_station import MaterialHole, MaterialPlate from unilabos.devices.workstation.workstation_base import WorkstationBase from unilabos.device_comms.modbus_plc.client import TCPClient, ModbusNode, PLCWorkflow, ModbusWorkflow, WorkflowAction, BaseClient from unilabos.device_comms.modbus_plc.modbus import DeviceType, Base as ModbusNodeBase, DataType, WorderOrder -from unilabos.devices.workstation.coin_cell_assembly.button_battery_station import * +from unilabos.devices.workstation.coin_cell_assembly.YB_YH_materials import * from unilabos.ros.nodes.base_device_node import ROS2DeviceNode, BaseROS2DeviceNode from unilabos.ros.nodes.presets.workstation import ROS2WorkstationNode +from unilabos.devices.workstation.coin_cell_assembly.YB_YH_materials import CoincellDeck +from unilabos.resources.graphio import convert_resources_to_type +from unilabos.utils.log import logger +import struct + + +def _decode_float32_correct(registers): + """ + 正确解码FLOAT32类型的Modbus寄存器 + + Args: + registers: 从Modbus读取的原始寄存器值列表 + + Returns: + 正确解码的浮点数值 + + Note: + 根据test_glove_box_pressure.py验证的配置: + - Byte Order: Big (Modbus标准) + - Word Order: Little (PLC配置) + """ + if not registers or len(registers) < 2: + return 0.0 + + try: + # Word Order: Little - 交换两个寄存器的顺序 + # Byte Order: Big - 每个寄存器内部使用大端字节序 + low_word = registers[0] + high_word = registers[1] + + # 将两个16位寄存器组合成一个32位值 (Little Word Order) + # 使用大端字节序 ('>') 将每个寄存器转换为字节 + byte_string = struct.pack('>HH', high_word, low_word) + + # 将字节字符串解码为浮点数 (大端) + value = struct.unpack('>f', byte_string)[0] + + return value + except Exception as e: + logger.error(f"解码FLOAT32失败: {e}, registers: {registers}") + return 0.0 + + +def _ensure_modbus_slave_kw_alias(modbus_client): + if modbus_client is None: + return + + method_names = [ + "read_coils", + "write_coils", + "write_coil", + "read_discrete_inputs", + "read_holding_registers", + "write_register", + "write_registers", + ] + + def _wrap(func): + signature = inspect.signature(func) + has_var_kwargs = any(param.kind == param.VAR_KEYWORD for param in signature.parameters.values()) + accepts_unit = has_var_kwargs or "unit" in signature.parameters + accepts_slave = has_var_kwargs or "slave" in signature.parameters + + @wraps(func) + def _wrapped(self, *args, **kwargs): + if "slave" in kwargs and not accepts_slave: + slave_value = kwargs.pop("slave") + if accepts_unit and "unit" not in kwargs: + kwargs["unit"] = slave_value + if "unit" in kwargs and not accepts_unit: + unit_value = kwargs.pop("unit") + if accepts_slave and "slave" not in kwargs: + kwargs["slave"] = unit_value + return func(self, *args, **kwargs) + + _wrapped._has_slave_alias = True + return _wrapped + + for name in method_names: + if not hasattr(modbus_client, name): + continue + bound_method = getattr(modbus_client, name) + func = getattr(bound_method, "__func__", None) + if func is None: + continue + if getattr(func, "_has_slave_alias", False): + continue + wrapped = _wrap(func) + setattr(modbus_client, name, types.MethodType(wrapped, modbus_client)) + + +def _coerce_deck_input(deck: Any) -> Optional[Deck]: + if deck is None: + return None + + if isinstance(deck, Deck): + return deck + + if isinstance(deck, PLRResource): + return deck if isinstance(deck, Deck) else None + + candidates = None + if isinstance(deck, dict): + if "nodes" in deck and isinstance(deck["nodes"], list): + candidates = deck["nodes"] + else: + candidates = [deck] + elif isinstance(deck, list): + candidates = deck + + if candidates is None: + return None + + try: + converted = convert_resources_to_type(resources_list=candidates, resource_type=Deck) + if isinstance(converted, Deck): + return converted + if isinstance(converted, list): + for item in converted: + if isinstance(item, Deck): + return item + except Exception as exc: + logger.warning(f"deck 转换 Deck 失败: {exc}") + return None + #构建物料系统 class CoinCellAssemblyWorkstation(WorkstationBase): - def __init__( - self, - deck: CoincellDeck, - address: str = "192.168.1.20", + def __init__(self, + config: dict = None, + deck=None, + address: str = "172.16.28.102", port: str = "502", - debug_mode: bool = True, + debug_mode: bool = False, *args, - **kwargs, - ): - super().__init__( - #桌子 - deck=deck, - *args, - **kwargs, - ) + **kwargs): + + if deck is None and config: + deck = config.get('deck') + if deck is None: + logger.info("没有传入依华deck，检查启动json文件") + super().__init__(deck=deck, *args, **kwargs,) self.debug_mode = debug_mode - self.deck = deck + """ 连接初始化 """ modbus_client = TCPClient(addr=address, port=port) - print("modbus_client", modbus_client) + logger.debug(f"创建 Modbus 客户端: {modbus_client}") + _ensure_modbus_slave_kw_alias(modbus_client.client) if not debug_mode: modbus_client.client.connect() count = 100 @@ -49,27 +176,21 @@ class CoinCellAssemblyWorkstation(WorkstationBase): time.sleep(2) if not modbus_client.client.is_socket_open(): raise ValueError('modbus tcp connection failed') + self.nodes = BaseClient.load_csv(os.path.join(os.path.dirname(__file__), 'coin_cell_assembly_b.csv')) + self.client = modbus_client.register_node_list(self.nodes) else: print("测试模式，跳过连接") + self.nodes, self.client = None, None """ 工站的配置 """ - self.nodes = BaseClient.load_csv(os.path.join(os.path.dirname(__file__), 'coin_cell_assembly_a.csv')) - self.client = modbus_client.register_node_list(self.nodes) + self.success = False self.allow_data_read = False #允许读取函数运行标志位 self.csv_export_thread = None self.csv_export_running = False self.csv_export_file = None - #创建一个物料台面，包含两个极片板 - #self.deck = create_a_coin_cell_deck() - - #self._ros_node.update_resource(self.deck) - - #ROS2DeviceNode.run_async_func(self._ros_node.update_resource, True, **{ - # "resources": [self.deck] - #}) + self.coin_num_N = 0 #已组装电池数量 - def post_init(self, ros_node: ROS2WorkstationNode): self._ros_node = ros_node #self.deck = create_a_coin_cell_deck() @@ -418,48 +539,72 @@ class CoinCellAssemblyWorkstation(WorkstationBase): """单颗电池组装时间 (秒, REAL/FLOAT32)""" if self.debug_mode: return 0 - time, read_err = self.client.use_node('REG_DATA_ASSEMBLY_PER_TIME').read(2, word_order=WorderOrder.LITTLE) - return time + # 读取原始寄存器并正确解码FLOAT32 + result = self.client.client.read_holding_registers(address=self.client.use_node('REG_DATA_ASSEMBLY_PER_TIME').address, count=2) + if result.isError(): + logger.error(f"读取组装时间失败") + return 0.0 + return _decode_float32_correct(result.registers) @property def data_open_circuit_voltage(self) -> float: """开路电压值 (FLOAT32)""" if self.debug_mode: return 0 - vol, read_err = self.client.use_node('REG_DATA_OPEN_CIRCUIT_VOLTAGE').read(2, word_order=WorderOrder.LITTLE) - return vol + # 读取原始寄存器并正确解码FLOAT32 + result = self.client.client.read_holding_registers(address=self.client.use_node('REG_DATA_OPEN_CIRCUIT_VOLTAGE').address, count=2) + if result.isError(): + logger.error(f"读取开路电压失败") + return 0.0 + return _decode_float32_correct(result.registers) @property def data_axis_x_pos(self) -> float: """分液X轴当前位置 (FLOAT32)""" if self.debug_mode: return 0 - pos, read_err = self.client.use_node('REG_DATA_AXIS_X_POS').read(2, word_order=WorderOrder.LITTLE) - return pos + # 读取原始寄存器并正确解码FLOAT32 + result = self.client.client.read_holding_registers(address=self.client.use_node('REG_DATA_AXIS_X_POS').address, count=2) + if result.isError(): + logger.error(f"读取X轴位置失败") + return 0.0 + return _decode_float32_correct(result.registers) @property def data_axis_y_pos(self) -> float: """分液Y轴当前位置 (FLOAT32)""" if self.debug_mode: return 0 - pos, read_err = self.client.use_node('REG_DATA_AXIS_Y_POS').read(2, word_order=WorderOrder.LITTLE) - return pos + # 读取原始寄存器并正确解码FLOAT32 + result = self.client.client.read_holding_registers(address=self.client.use_node('REG_DATA_AXIS_Y_POS').address, count=2) + if result.isError(): + logger.error(f"读变Y轴位置失败") + return 0.0 + return _decode_float32_correct(result.registers) @property def data_axis_z_pos(self) -> float: """分液Z轴当前位置 (FLOAT32)""" if self.debug_mode: return 0 - pos, read_err = self.client.use_node('REG_DATA_AXIS_Z_POS').read(2, word_order=WorderOrder.LITTLE) - return pos + # 读取原始寄存器并正确解码FLOAT32 + result = self.client.client.read_holding_registers(address=self.client.use_node('REG_DATA_AXIS_Z_POS').address, count=2) + if result.isError(): + logger.error(f"读取Z轴位置失败") + return 0.0 + return _decode_float32_correct(result.registers) @property def data_pole_weight(self) -> float: """当前电池正极片称重数据 (FLOAT32)""" if self.debug_mode: return 0 - weight, read_err = self.client.use_node('REG_DATA_POLE_WEIGHT').read(2, word_order=WorderOrder.LITTLE) - return weight + # 读取原始寄存器并正确解码FLOAT32 + result = self.client.client.read_holding_registers(address=self.client.use_node('REG_DATA_POLE_WEIGHT').address, count=2) + if result.isError(): + logger.error(f"读取极片质量失败") + return 0.0 + return _decode_float32_correct(result.registers) @property def data_assembly_pressure(self) -> int: @@ -489,52 +634,97 @@ class CoinCellAssemblyWorkstation(WorkstationBase): def data_coin_cell_code(self) -> str: """电池二维码序列号 (STRING)""" try: - # 尝试不同的字节序读取 + # 读取 STRING 类型数据 code_little, read_err = self.client.use_node('REG_DATA_COIN_CELL_CODE').read(10, word_order=WorderOrder.LITTLE) - print(code_little) - clean_code = code_little[-8:][::-1] - return clean_code + + # PyModbus 3.x 返回 string 类型 + if not isinstance(code_little, str): + logger.warning(f"电池二维码返回的类型不支持: {type(code_little)}, 值: {repr(code_little)}") + return "N/A" + + # 从字符串末尾查找连续的字母数字字符（反转字符串） + import re + reversed_str = code_little[::-1] + match = re.match(r'^([A-Za-z0-9]+)', reversed_str) + + if not match: + logger.warning(f"未找到有效的电池二维码数据，原始字符串: {repr(code_little)}") + return "N/A" + + # 提取匹配到的字符串（已经是正确顺序） + decoded = match.group(1)[:8] # 只取前8个字符 + + return decoded if decoded else "N/A" except Exception as e: - print(f"读取电池二维码失败: {e}") + logger.error(f"读取电池二维码失败: {e}") return "N/A" @property def data_electrolyte_code(self) -> str: + """电解液二维码序列号 (STRING)""" try: - # 尝试不同的字节序读取 + # 读取 STRING 类型数据 code_little, read_err = self.client.use_node('REG_DATA_ELECTROLYTE_CODE').read(10, word_order=WorderOrder.LITTLE) - print(code_little) - clean_code = code_little[-8:][::-1] - return clean_code + + # PyModbus 3.x 返回 string 类型 + if not isinstance(code_little, str): + logger.warning(f"电解液二维码返回的类型不支持: {type(code_little)}, 值: {repr(code_little)}") + return "N/A" + + # 从字符串末尾查找连续的字母数字字符（反转字符串） + import re + reversed_str = code_little[::-1] + match = re.match(r'^([A-Za-z0-9]+)', reversed_str) + + if not match: + logger.warning(f"未找到有效的电解液二维码数据，原始字符串: {repr(code_little)}") + return "N/A" + + # 提取匹配到的字符串（已经是正确顺序） + decoded = match.group(1)[:8] # 只取前8个字符 + + return decoded if decoded else "N/A" except Exception as e: - print(f"读取电解液二维码失败: {e}") + logger.error(f"读取电解液二维码失败: {e}") return "N/A" # ===================== 环境监控区 ====================== @property def data_glove_box_pressure(self) -> float: - """手套箱压力 (bar, FLOAT32)""" + """手套箱压力 (mbar, FLOAT32)""" if self.debug_mode: return 0 - status, read_err = self.client.use_node('REG_DATA_GLOVE_BOX_PRESSURE').read(2, word_order=WorderOrder.LITTLE) - return status + # 读取原始寄存器并正确解码FLOAT32 + result = self.client.client.read_holding_registers(address=self.client.use_node('REG_DATA_GLOVE_BOX_PRESSURE').address, count=2) + if result.isError(): + logger.error(f"读取手套箱压力失败") + return 0.0 + return _decode_float32_correct(result.registers) @property def data_glove_box_o2_content(self) -> float: """手套箱氧含量 (ppm, FLOAT32)""" if self.debug_mode: return 0 - value, read_err = self.client.use_node('REG_DATA_GLOVE_BOX_O2_CONTENT').read(2, word_order=WorderOrder.LITTLE) - return value + # 读取原始寄存器并正确解码FLOAT32 + result = self.client.client.read_holding_registers(address=self.client.use_node('REG_DATA_GLOVE_BOX_O2_CONTENT').address, count=2) + if result.isError(): + logger.error(f"读取手套箱氧含量失败") + return 0.0 + return _decode_float32_correct(result.registers) @property def data_glove_box_water_content(self) -> float: """手套箱水含量 (ppm, FLOAT32)""" if self.debug_mode: return 0 - value, read_err = self.client.use_node('REG_DATA_GLOVE_BOX_WATER_CONTENT').read(2, word_order=WorderOrder.LITTLE) - return value + # 读取原始寄存器并正确解码FLOAT32 + result = self.client.client.read_holding_registers(address=self.client.use_node('REG_DATA_GLOVE_BOX_WATER_CONTENT').address, count=2) + if result.isError(): + logger.error(f"读取手套箱水含量失败") + return 0.0 + return _decode_float32_correct(result.registers) # @property # def data_stack_vision_code(self) -> int: @@ -606,7 +796,326 @@ class CoinCellAssemblyWorkstation(WorkstationBase): print("waiting for start_cmd") time.sleep(1) - def func_pack_send_bottle_num(self, bottle_num: int): + def _handle_material_search_dialog(self, enable_search: bool, timeout: int = 30) -> None: + """处理物料搜寻确认弹窗 + + 监测弹窗是否出现，并根据参数自动点击"是"或"否"按钮（脉冲模式） + + Args: + enable_search: True=点击"是"启用物料搜寻, False=点击"否"不启用物料搜寻 + timeout: 等待弹窗出现的最大时间（秒），默认30秒 + + Raises: + RuntimeError: 超时未检测到弹窗，或操作失败 + """ + logger.info(f"开始监测物料搜寻确认弹窗（超时: {timeout}秒）...") + logger.info(f"用户选择: {'启用物料搜寻（点击是）' if enable_search else '不启用物料搜寻（点击否）'}") + + start_time = time.time() + dialog_appeared = False + + # 步骤1: 监测弹窗是否出现 + while time.time() - start_time < timeout: + try: + dialog_node = self.client.use_node('COIL_MATERIAL_SEARCH_DIALOG_APPEAR') + dialog_state, read_err = dialog_node.read(1) + + if read_err: + logger.warning("读取弹窗状态时出错，继续监测...") + time.sleep(0.5) + continue + + # 提取实际值 + if isinstance(dialog_state, (list, tuple)): + dialog_actual = dialog_state[0] if len(dialog_state) > 0 else False + else: + dialog_actual = dialog_state + + if dialog_actual: + logger.info("✓ 检测到物料搜寻确认弹窗出现！") + dialog_appeared = True + break + + except Exception as e: + logger.warning(f"读取弹窗状态异常: {e}，继续监测...") + + time.sleep(0.5) # 每0.5秒检查一次 + + if not dialog_appeared: + error_msg = f"❌ 超时未检测到物料搜寻确认弹窗（等待了 {timeout} 秒）" + logger.error(error_msg) + raise RuntimeError(error_msg) + + # 步骤2: 执行脉冲按钮点击 + button_name = "是" if enable_search else "否" + coil_name = "COIL_MATERIAL_SEARCH_CONFIRM_YES" if enable_search else "COIL_MATERIAL_SEARCH_CONFIRM_NO" + + logger.info(f"执行脉冲按钮点击: '{button_name}'") + + try: + button_node = self.client.use_node(coil_name) + + # 读取初始状态 + initial_state, _ = button_node.read(1) + logger.debug(f"按钮'{button_name}'初始状态: {initial_state}") + + # 脉冲步骤1: 设置为 True + logger.info(f" → 按下按钮 '{button_name}' (设置为 True)") + button_node.write(True) + time.sleep(0.5) # 保持0.5秒 + + # 验证已按下 + pressed_state, _ = button_node.read(1) + if isinstance(pressed_state, (list, tuple)): + pressed_actual = pressed_state[0] if len(pressed_state) > 0 else False + else: + pressed_actual = pressed_state + + if pressed_actual: + logger.info(f" ✓ 按钮 '{button_name}' 已按下") + else: + logger.warning(f" ⚠ 按钮 '{button_name}' 状态未变为 True，当前值: {pressed_actual}") + + # 脉冲步骤2: 释放按钮 (设置为 False) + logger.info(f" → 释放按钮 '{button_name}' (设置为 False)") + button_node.write(False) + time.sleep(0.3) + + # 验证已释放 + released_state, _ = button_node.read(1) + if isinstance(released_state, (list, tuple)): + released_actual = released_state[0] if len(released_state) > 0 else False + else: + released_actual = released_state + + if not released_actual: + logger.info(f" ✓ 按钮 '{button_name}' 已释放（脉冲完成）") + else: + logger.warning(f" ⚠ 按钮 '{button_name}' 未正确释放，当前值: {released_actual}") + + logger.info(f"✓ 成功处理物料搜寻确认弹窗（选择: {button_name}）") + + except Exception as e: + error_msg = f"❌ 执行按钮'{button_name}'脉冲操作时失败: {e}" + logger.error(error_msg) + raise RuntimeError(error_msg) + + + def func_pack_device_init_auto_start_combined(self, material_search_enable: bool = False) -> bool: + """ + 组合函数：设备初始化 + 切换自动模式 + 启动 + + 整合了原有的三个独立函数： + 1. func_pack_device_init() - 设备初始化 + 2. func_pack_device_auto() - 切换自动模式 + 3. func_pack_device_start() - 启动设备 + + Args: + material_search_enable: 是否启用物料搜寻功能。 + 设备初始化后会弹出物料搜寻确认弹窗， + 此参数控制自动点击'是'（启用）或'否'（不启用）。 + 默认为False（不启用物料搜寻）。 + + Returns: + bool: 操作成功返回 True，失败返回 False + """ + logger.info("=" * 60) + logger.info("开始组合操作：设备初始化 → 物料搜寻确认 → 自动模式 → 启动") + logger.info("=" * 60) + + # 步骤0: 前置条件检查 + logger.info("\n【步骤 0/4】前置条件检查...") + try: + # 检查 REG_UNILAB_INTERACT (应该为False，表示使用Unilab交互) + unilab_interact_node = self.client.use_node('REG_UNILAB_INTERACT') + unilab_interact_value, read_err = unilab_interact_node.read(1) + + if read_err: + error_msg = "❌ 无法读取 REG_UNILAB_INTERACT 状态！请检查设备连接。" + logger.error(error_msg) + raise RuntimeError(error_msg) + + # 提取实际值（处理可能的列表或单值） + if isinstance(unilab_interact_value, (list, tuple)): + unilab_interact_actual = unilab_interact_value[0] if len(unilab_interact_value) > 0 else None + else: + unilab_interact_actual = unilab_interact_value + + logger.info(f" REG_UNILAB_INTERACT 当前值: {unilab_interact_actual}") + + if unilab_interact_actual != False: + error_msg = ( + "❌ 前置条件检查失败！\n" + f" REG_UNILAB_INTERACT = {unilab_interact_actual} (期望值: False)\n" + " 说明: 当前设备设置为'忽略Unilab交互'模式\n" + " 操作: 请在HMI上确认并切换为'使用Unilab交互'模式\n" + " 提示: REG_UNILAB_INTERACT应该为False才能继续" + ) + logger.error(error_msg) + raise RuntimeError(error_msg) + + logger.info(" ✓ REG_UNILAB_INTERACT 检查通过 (值为False，使用Unilab交互)") + + # 检查 COIL_GB_L_IGNORE_CMD (应该为False，表示使用左手套箱) + gb_l_ignore_node = self.client.use_node('COIL_GB_L_IGNORE_CMD') + gb_l_ignore_value, read_err = gb_l_ignore_node.read(1) + + if read_err: + error_msg = "❌ 无法读取 COIL_GB_L_IGNORE_CMD 状态！请检查设备连接。" + logger.error(error_msg) + raise RuntimeError(error_msg) + + # 提取实际值 + if isinstance(gb_l_ignore_value, (list, tuple)): + gb_l_ignore_actual = gb_l_ignore_value[0] if len(gb_l_ignore_value) > 0 else None + else: + gb_l_ignore_actual = gb_l_ignore_value + + logger.info(f" COIL_GB_L_IGNORE_CMD 当前值: {gb_l_ignore_actual}") + + if gb_l_ignore_actual != False: + error_msg = ( + "❌ 前置条件检查失败！\n" + f" COIL_GB_L_IGNORE_CMD = {gb_l_ignore_actual} (期望值: False)\n" + " 说明: 当前设备设置为'忽略左手套箱'模式\n" + " 操作: 请在HMI上确认并切换为'使用左手套箱'模式\n" + " 提示: COIL_GB_L_IGNORE_CMD应该为False才能继续" + ) + logger.error(error_msg) + raise RuntimeError(error_msg) + + logger.info(" ✓ COIL_GB_L_IGNORE_CMD 检查通过 (值为False，使用左手套箱)") + logger.info("✓ 所有前置条件检查通过！") + + except ValueError as e: + # 节点未找到 + error_msg = f"❌ 配置错误：{str(e)}\n请检查CSV配置文件是否包含必要的节点。" + logger.error(error_msg) + raise RuntimeError(error_msg) + except Exception as e: + # 其他异常 + error_msg = f"❌ 前置条件检查异常：{str(e)}" + logger.error(error_msg) + raise + + # 步骤1: 设备初始化（包含弹窗检测） + logger.info("\n【步骤 1/4】设备初始化...") + try: + # 切换手动模式 + logger.info("切换手动模式...") + self._sys_hand_cmd(True) + time.sleep(1) + while (self._sys_hand_status()) == False: + logger.debug("waiting for hand_cmd") + time.sleep(1) + + # 设备初始化命令 + logger.info("发送初始化命令...") + self._sys_init_cmd(True) + time.sleep(1) + + # 等待初始化完成，同时检测物料搜寻弹窗 + logger.info("等待初始化完成（同时监测物料搜寻弹窗）...") + dialog_handled = False + max_wait_time = 120 # 最多等待120秒 + start_wait = time.time() + + while (self._sys_init_status()) == False: + # 检查是否超时 + if time.time() - start_wait > max_wait_time: + raise RuntimeError(f"初始化超时（超过 {max_wait_time} 秒）") + + # 如果还没处理弹窗，检测弹窗是否出现 + if not dialog_handled: + try: + dialog_node = self.client.use_node('COIL_MATERIAL_SEARCH_DIALOG_APPEAR') + dialog_state, read_err = dialog_node.read(1) + + if not read_err: + # 提取实际值 + if isinstance(dialog_state, (list, tuple)): + dialog_actual = dialog_state[0] if len(dialog_state) > 0 else False + else: + dialog_actual = dialog_state + + # 如果弹窗出现，立即处理 + if dialog_actual: + logger.info("✓ 在初始化过程中检测到物料搜寻确认弹窗！") + logger.info(f"用户选择: {'启用物料搜寻（点击是）' if material_search_enable else '不启用物料搜寻（点击否）'}") + + # 执行脉冲按钮点击 + button_name = "是" if material_search_enable else "否" + coil_name = "COIL_MATERIAL_SEARCH_CONFIRM_YES" if material_search_enable else "COIL_MATERIAL_SEARCH_CONFIRM_NO" + + button_node = self.client.use_node(coil_name) + + # 脉冲：True -> 等待 -> False + logger.info(f" → 按下按钮 '{button_name}'") + button_node.write(True) + time.sleep(0.5) + logger.info(f" → 释放按钮 '{button_name}'") + button_node.write(False) + time.sleep(0.3) + + logger.info(f"✓ 成功处理物料搜寻确认弹窗（选择: {button_name}）") + dialog_handled = True + + except Exception as e: + logger.debug(f"检测弹窗时出错: {e}") + + logger.debug("waiting for init_cmd") + time.sleep(1) + + logger.info("✓ 初始化状态完成") + + # 手动按钮置回False + self._sys_hand_cmd(False) + time.sleep(1) + while (self._sys_hand_cmd()) == True: + logger.debug("waiting for hand_cmd to False") + time.sleep(1) + + # 初始化命令置回False + self._sys_init_cmd(False) + time.sleep(1) + while (self._sys_init_cmd()) == True: + logger.debug("waiting for init_cmd to False") + time.sleep(1) + + logger.info("✓ 设备初始化完成") + except Exception as e: + logger.error(f"❌ 设备初始化失败: {e}") + return False + + # 步骤1.5已经在步骤1中处理，跳过 + logger.info("\n【步骤 1.5/4】物料搜寻确认已在初始化过程中完成") + + # 步骤2: 切换自动模式 + logger.info("\n【步骤 2/4】切换自动模式...") + try: + self.func_pack_device_auto() + logger.info("✓ 切换自动模式完成") + except Exception as e: + logger.error(f"❌ 切换自动模式失败: {e}") + return False + + # 步骤3: 启动设备 + logger.info("\n【步骤 3/4】启动设备...") + try: + self.func_pack_device_start() + logger.info("✓ 启动设备完成") + except Exception as e: + logger.error(f"❌ 启动设备失败: {e}") + return False + + logger.info("\n" + "=" * 60) + logger.info("组合操作完成：设备已成功初始化、确认物料搜寻、切换自动模式并启动") + logger.info("=" * 60) + + return True + + def func_pack_send_bottle_num(self, bottle_num): + bottle_num = int(bottle_num) #发送电解液平台数 print("启动") while (self._unilab_rece_electrolyte_bottle_num()) == False: @@ -628,6 +1137,111 @@ class CoinCellAssemblyWorkstation(WorkstationBase): time.sleep(1) #自动按钮置False + def func_sendbottle_allpack_multi( + self, + elec_num, + elec_use_num, + elec_vol: int = 50, + # 电解液双滴模式参数 + dual_drop_mode: bool = False, + dual_drop_first_volume: int = 25, + dual_drop_suction_timing: bool = False, + dual_drop_start_timing: bool = False, + assembly_type: int = 7, + assembly_pressure: int = 4200, + # 来自原 qiming_coin_cell_code 的参数 + fujipian_panshu: int = 0, + fujipian_juzhendianwei: int = 0, + gemopanshu: int = 0, + gemo_juzhendianwei: int = 0, + qiangtou_juzhendianwei: int = 0, + lvbodian: bool = True, + battery_pressure_mode: bool = True, + battery_clean_ignore: bool = False, + file_path: str = "/Users/sml/work" + ) -> Dict[str, Any]: + """ + 发送瓶数+简化组装函数（适用于第二批次及后续批次） + + 合并了发送瓶数和简化组装流程，用于连续批次生产。 + 适用场景：设备已完成初始化和启动，仍在自动模式下运行。 + + Args: + elec_num: 电解液瓶数 + elec_use_num: 每瓶电解液组装的电池数 + elec_vol: 电解液吸液量 (μL) + dual_drop_mode: 电解液添加模式 (False=单次滴液, True=二次滴液) + dual_drop_first_volume: 二次滴液第一次排液体积 (μL) + dual_drop_suction_timing: 二次滴液吸液时机 (False=正常吸液, True=先吸液) + dual_drop_start_timing: 二次滴液开始滴液时机 (False=正极片前, True=正极片后) + assembly_type: 组装类型 (7=不用铝箔垫, 8=使用铝箔垫) + assembly_pressure: 电池压制力 (N) + fujipian_panshu: 负极片盘数 + fujipian_juzhendianwei: 负极片矩阵点位 + gemopanshu: 隔膜盘数 + gemo_juzhendianwei: 隔膜矩阵点位 + qiangtou_juzhendianwei: 枪头盒矩阵点位 + lvbodian: 是否使用铝箔垫片 + battery_pressure_mode: 是否启用压力模式 + battery_clean_ignore: 是否忽略电池清洁 + file_path: 实验记录保存路径 + + Returns: + dict: 包含组装结果的字典 + + 注意： + - 第一次启动需先调用 func_pack_device_init_auto_start_combined() + - 后续批次直接调用此函数即可 + """ + logger.info("=" * 60) + logger.info("开始发送瓶数+简化组装流程...") + logger.info(f"电解液瓶数: {elec_num}, 每瓶电池数: {elec_use_num}") + logger.info("=" * 60) + + # 步骤1: 发送电解液瓶数（触发物料搬运） + logger.info("步骤1/2: 发送电解液瓶数，触发物料搬运...") + try: + self.func_pack_send_bottle_num(elec_num) + logger.info("✓ 瓶数发送完成，物料搬运中...") + except Exception as e: + logger.error(f"发送瓶数失败: {e}") + return { + "success": False, + "error": f"发送瓶数失败: {e}", + "total_batteries": 0, + "batteries": [] + } + + # 步骤2: 执行简化组装流程 + logger.info("步骤2/2: 开始简化组装流程...") + result = self.func_allpack_cmd_simp( + elec_num=elec_num, + elec_use_num=elec_use_num, + elec_vol=elec_vol, + dual_drop_mode=dual_drop_mode, + dual_drop_first_volume=dual_drop_first_volume, + dual_drop_suction_timing=dual_drop_suction_timing, + dual_drop_start_timing=dual_drop_start_timing, + assembly_type=assembly_type, + assembly_pressure=assembly_pressure, + fujipian_panshu=fujipian_panshu, + fujipian_juzhendianwei=fujipian_juzhendianwei, + gemopanshu=gemopanshu, + gemo_juzhendianwei=gemo_juzhendianwei, + qiangtou_juzhendianwei=qiangtou_juzhendianwei, + lvbodian=lvbodian, + battery_pressure_mode=battery_pressure_mode, + battery_clean_ignore=battery_clean_ignore, + file_path=file_path + ) + + logger.info("=" * 60) + logger.info("发送瓶数+简化组装流程完成") + logger.info(f"总组装电池数: {result.get('total_batteries', 0)}") + logger.info("=" * 60) + + return result + # 下发参数 #def func_pack_send_msg_cmd(self, elec_num: int, elec_use_num: int, elec_vol: float, assembly_type: int, assembly_pressure: int) -> bool: @@ -654,16 +1268,25 @@ class CoinCellAssemblyWorkstation(WorkstationBase): # self.success = True # return self.success - def func_pack_send_msg_cmd(self, elec_use_num) -> bool: + def func_pack_send_msg_cmd(self, elec_use_num, elec_vol, assembly_type, assembly_pressure) -> bool: """UNILAB写参数""" while (self.request_rec_msg_status) == False: print("wait for request_rec_msg_status to True") time.sleep(1) self.success = False #self._unilab_send_msg_electrolyte_num(elec_num) - time.sleep(1) + #设置平行样数目 self._unilab_send_msg_electrolyte_use_num(elec_use_num) time.sleep(1) + #发送电解液加注量 + self._unilab_send_msg_electrolyte_vol(elec_vol) + time.sleep(1) + #发送电解液组装类型 + self._unilab_send_msg_assembly_type(assembly_type) + time.sleep(1) + #发送电池压制力 + self._unilab_send_msg_assembly_pressure(assembly_pressure) + time.sleep(1) self._unilab_send_msg_succ_cmd(True) time.sleep(1) while (self.request_rec_msg_status) == True: @@ -680,23 +1303,111 @@ class CoinCellAssemblyWorkstation(WorkstationBase): while self.request_send_msg_status == False: print("waiting for send_read_msg_status to True") time.sleep(1) - data_open_circuit_voltage = self.data_open_circuit_voltage - data_pole_weight = self.data_pole_weight + + # 处理开路电压 - 确保是数值类型 + try: + data_open_circuit_voltage = self.data_open_circuit_voltage + if isinstance(data_open_circuit_voltage, (list, tuple)) and len(data_open_circuit_voltage) > 0: + data_open_circuit_voltage = float(data_open_circuit_voltage[0]) + else: + data_open_circuit_voltage = float(data_open_circuit_voltage) + except Exception as e: + print(f"读取开路电压失败: {e}") + logger.error(f"读取开路电压失败: {e}") + data_open_circuit_voltage = 0.0 + + # 处理极片质量 - 确保是数值类型 + try: + data_pole_weight = self.data_pole_weight + if isinstance(data_pole_weight, (list, tuple)) and len(data_pole_weight) > 0: + data_pole_weight = float(data_pole_weight[0]) + else: + data_pole_weight = float(data_pole_weight) + except Exception as e: + print(f"读取正极片重量失败: {e}") + logger.error(f"读取正极片重量失败: {e}") + data_pole_weight = 0.0 + data_assembly_time = self.data_assembly_time data_assembly_pressure = self.data_assembly_pressure data_electrolyte_volume = self.data_electrolyte_volume data_coin_num = self.data_coin_num - data_electrolyte_code = self.data_electrolyte_code - data_coin_cell_code = self.data_coin_cell_code - print("data_open_circuit_voltage", data_open_circuit_voltage) - print("data_pole_weight", data_pole_weight) - print("data_assembly_time", data_assembly_time) - print("data_assembly_pressure", data_assembly_pressure) - print("data_electrolyte_volume", data_electrolyte_volume) - print("data_coin_num", data_coin_num) - print("data_electrolyte_code", data_electrolyte_code) - print("data_coin_cell_code", data_coin_cell_code) + + # 处理电解液二维码 - 确保是字符串类型 + try: + data_electrolyte_code = self.data_electrolyte_code + if isinstance(data_electrolyte_code, str): + data_electrolyte_code = data_electrolyte_code.strip() + else: + data_electrolyte_code = str(data_electrolyte_code) + except Exception as e: + print(f"读取电解液二维码失败: {e}") + logger.error(f"读取电解液二维码失败: {e}") + data_electrolyte_code = "N/A" + + # 处理电池二维码 - 确保是字符串类型 + try: + data_coin_cell_code = self.data_coin_cell_code + if isinstance(data_coin_cell_code, str): + data_coin_cell_code = data_coin_cell_code.strip() + else: + data_coin_cell_code = str(data_coin_cell_code) + except Exception as e: + print(f"读取电池二维码失败: {e}") + logger.error(f"读取电池二维码失败: {e}") + data_coin_cell_code = "N/A" + logger.debug(f"data_open_circuit_voltage: {data_open_circuit_voltage}") + logger.debug(f"data_pole_weight: {data_pole_weight}") + logger.debug(f"data_assembly_time: {data_assembly_time}") + logger.debug(f"data_assembly_pressure: {data_assembly_pressure}") + logger.debug(f"data_electrolyte_volume: {data_electrolyte_volume}") + logger.debug(f"data_coin_num: {data_coin_num}") + logger.debug(f"data_electrolyte_code: {data_electrolyte_code}") + logger.debug(f"data_coin_cell_code: {data_coin_cell_code}") #接收完信息后，读取完毕标志位置True + liaopan3 = self.deck.get_resource("成品弹夹") + + # 生成唯一的电池名称（使用时间戳确保唯一性） + 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 = { + "electrolyte_name": data_coin_cell_code, + "data_electrolyte_code": data_electrolyte_code, + "open_circuit_voltage": data_open_circuit_voltage, + "assembly_pressure": data_assembly_pressure, + "electrolyte_volume": data_electrolyte_volume + } + + # 分配新资源到目标位置 + try: + target_slot.assign_child_resource(battery, location=None) + logger.info(f"成功分配电池 {battery_name} 到位置 {self.coin_num_N}") + except Exception as e: + logger.error(f"分配电池资源失败: {e}") + # 如果分配失败，尝试使用更简单的方法 + raise + + #print(jipian2.parent) + ROS2DeviceNode.run_async_func(self._ros_node.update_resource, True, **{ + "resources": [self.deck] + }) + + self._unilab_rec_msg_succ_cmd(True) time.sleep(1) #等待允许读取标志位置False @@ -754,10 +1465,27 @@ class CoinCellAssemblyWorkstation(WorkstationBase): self.success = True return self.success + def qiming_coin_cell_code(self, fujipian_panshu:int, fujipian_juzhendianwei:int=0, gemopanshu:int=0, gemo_juzhendianwei:int=0, lvbodian:bool=True, battery_pressure_mode:bool=True, battery_pressure:int=4000, battery_clean_ignore:bool=False) -> bool: + self.success = False + self.client.use_node('REG_MSG_NE_PLATE_NUM').write(fujipian_panshu) + self.client.use_node('REG_MSG_NE_PLATE_MATRIX').write(fujipian_juzhendianwei) + self.client.use_node('REG_MSG_SEPARATOR_PLATE_NUM').write(gemopanshu) + self.client.use_node('REG_MSG_SEPARATOR_PLATE_MATRIX').write(gemo_juzhendianwei) + self.client.use_node('COIL_ALUMINUM_FOIL').write(not lvbodian) + self.client.use_node('REG_MSG_PRESS_MODE').write(not battery_pressure_mode) + # self.client.use_node('REG_MSG_ASSEMBLY_PRESSURE').write(battery_pressure) + self.client.use_node('REG_MSG_BATTERY_CLEAN_IGNORE').write(battery_clean_ignore) + self.success = True + + return self.success - - def func_allpack_cmd(self, elec_num, elec_use_num, file_path: str="D:\\coin_cell_data") -> bool: + def func_allpack_cmd(self, elec_num, elec_use_num, elec_vol:int=50, assembly_type:int=7, assembly_pressure:int=4200, file_path: str="/Users/sml/work") -> Dict[str, Any]: + elec_num, elec_use_num, elec_vol, assembly_type, assembly_pressure = int(elec_num), int(elec_use_num), int(elec_vol), int(assembly_type), int(assembly_pressure) summary_csv_file = os.path.join(file_path, "duandian.csv") + + # 用于收集所有电池的数据 + battery_data_list = [] + # 如果断点文件存在，先读取之前的进度 if os.path.exists(summary_csv_file): read_status_flag = True @@ -775,7 +1503,12 @@ class CoinCellAssemblyWorkstation(WorkstationBase): print("断点文件与当前任务匹配，继续") else: print("断点文件中elec_num、elec_use_num与当前任务不匹配，请检查任务下发参数或修改断点文件") - return False + return { + "success": False, + "error": "断点文件参数不匹配", + "total_batteries": 0, + "batteries": [] + } print(f"从断点文件读取进度: elec_num_N={elec_num_N}, elec_use_num_N={elec_use_num_N}, coin_num_N={coin_num_N}") else: @@ -784,54 +1517,88 @@ class CoinCellAssemblyWorkstation(WorkstationBase): elec_num_N = 0 elec_use_num_N = 0 coin_num_N = 0 - - print(f"剩余电解液瓶数: {elec_num}, 已组装电池数: {elec_use_num}") - + for i in range(20): + print(f"剩余电解液瓶数: {elec_num}, 已组装电池数: {elec_use_num}") + print(f"剩余电解液瓶数: {type(elec_num)}, 已组装电池数: {type(elec_use_num)}") + print(f"剩余电解液瓶数: {type(int(elec_num))}, 已组装电池数: {type(int(elec_use_num))}") #如果是第一次运行，则进行初始化、切换自动、启动, 如果是断点重启则跳过。 if read_status_flag == False: + pass #初始化 - self.func_pack_device_init() + #self.func_pack_device_init() #切换自动 - self.func_pack_device_auto() + #self.func_pack_device_auto() #启动，小车收回 - self.func_pack_device_start() + #self.func_pack_device_start() #发送电解液瓶数量，启动搬运,多搬运没事 - self.func_pack_send_bottle_num(elec_num) + #self.func_pack_send_bottle_num(elec_num) last_i = elec_num_N last_j = elec_use_num_N for i in range(last_i, elec_num): print(f"开始第{last_i+i+1}瓶电解液的组装") #第一个循环从上次断点继续，后续循环从0开始 j_start = last_j if i == last_i else 0 - self.func_pack_send_msg_cmd(elec_use_num-j_start) + self.func_pack_send_msg_cmd(elec_use_num-j_start, elec_vol, assembly_type, assembly_pressure) for j in range(j_start, elec_use_num): print(f"开始第{last_i+i+1}瓶电解液的第{j+j_start+1}个电池组装") + #读取电池组装数据并存入csv self.func_pack_get_msg_cmd(file_path) + + # 收集当前电池的数据 + # 处理电池二维码 + try: + battery_qr_code = self.data_coin_cell_code + except Exception as e: + print(f"读取电池二维码失败: {e}") + battery_qr_code = "N/A" + + # 处理电解液二维码 + try: + electrolyte_qr_code = self.data_electrolyte_code + except Exception as e: + print(f"读取电解液二维码失败: {e}") + electrolyte_qr_code = "N/A" + + # 处理开路电压 - 确保是数值类型 + try: + open_circuit_voltage = self.data_open_circuit_voltage + if isinstance(open_circuit_voltage, (list, tuple)) and len(open_circuit_voltage) > 0: + open_circuit_voltage = float(open_circuit_voltage[0]) + else: + open_circuit_voltage = float(open_circuit_voltage) + except Exception as e: + print(f"读取开路电压失败: {e}") + open_circuit_voltage = 0.0 + + # 处理极片质量 - 确保是数值类型 + try: + pole_weight = self.data_pole_weight + if isinstance(pole_weight, (list, tuple)) and len(pole_weight) > 0: + pole_weight = float(pole_weight[0]) + else: + pole_weight = float(pole_weight) + except Exception as e: + print(f"读取正极片重量失败: {e}") + pole_weight = 0.0 + + battery_info = { + "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 + } + battery_data_list.append(battery_info) + print(f"已收集第 {coin_num_N + 1} 个电池数据: 电池码={battery_info['battery_barcode']}, 电解液码={battery_info['electrolyte_barcode']}") + time.sleep(1) - - #这里定义物料系统 # TODO:读完再将电池数加一还是进入循环就将电池数加一需要考虑 - liaopan1 = self.deck.get_resource("liaopan1") - liaopan4 = self.deck.get_resource("liaopan4") - jipian1 = liaopan1.children[coin_num_N].children[0] - jipian4 = liaopan4.children[coin_num_N].children[0] - #print(jipian1) - #从料盘上去物料解绑后放到另一盘上 - jipian1.parent.unassign_child_resource(jipian1) - jipian4.parent.unassign_child_resource(jipian4) - - #print(jipian2.parent) - battery = Battery(name = f"battery_{coin_num_N}") - battery.assign_child_resource(jipian1, location=None) - battery.assign_child_resource(jipian4, location=None) - - zidanjia6 = self.deck.get_resource("zi_dan_jia6") - - zidanjia6.children[0].assign_child_resource(battery, location=None) - # 生成断点文件 # 生成包含elec_num_N、coin_num_N、timestamp的CSV文件 @@ -842,6 +1609,7 @@ class CoinCellAssemblyWorkstation(WorkstationBase): writer.writerow([elec_num, elec_use_num, elec_num_N, elec_use_num_N, coin_num_N, timestamp]) csvfile.flush() coin_num_N += 1 + self.coin_num_N = coin_num_N elec_use_num_N += 1 elec_num_N += 1 elec_use_num_N = 0 @@ -850,8 +1618,284 @@ class CoinCellAssemblyWorkstation(WorkstationBase): os.remove(summary_csv_file) #全部完成后等待依华发送完成信号 self.func_pack_send_finished_cmd() + + # 返回JSON格式数据 + result = { + "success": True, + "total_batteries": len(battery_data_list), + "batteries": battery_data_list, + "summary": { + "electrolyte_bottles_used": elec_num, + "batteries_per_bottle": elec_use_num, + "electrolyte_volume": elec_vol, + "assembly_type": assembly_type, + "assembly_pressure": assembly_pressure + } + } + + print(f"\n{'='*60}") + print(f"组装完成统计:") + print(f" 总组装电池数: {result['total_batteries']}") + print(f" 使用电解液瓶数: {elec_num}") + print(f" 每瓶电池数: {elec_use_num}") + print(f"{'='*60}\n") + + return result + def func_allpack_cmd_simp( + self, + elec_num, + elec_use_num, + elec_vol: int = 50, + # 电解液双滴模式参数 + dual_drop_mode: bool = False, + dual_drop_first_volume: int = 25, + dual_drop_suction_timing: bool = False, + dual_drop_start_timing: bool = False, + assembly_type: int = 7, + assembly_pressure: int = 4200, + # 来自原 qiming_coin_cell_code 的参数 + fujipian_panshu: int = 0, + fujipian_juzhendianwei: int = 0, + gemopanshu: int = 0, + gemo_juzhendianwei: int = 0, + qiangtou_juzhendianwei: int = 0, + lvbodian: bool = True, + battery_pressure_mode: bool = True, + battery_clean_ignore: bool = False, + file_path: str = "/Users/sml/work" + ) -> Dict[str, Any]: + """ + 简化版电池组装函数，整合了原 qiming_coin_cell_code 的参数设置和双滴模式 + + 此函数是 func_allpack_cmd 的增强版本，自动处理以下配置： + - 负极片和隔膜的盘数及矩阵点位 + - 枪头盒矩阵点位 + - 铝箔垫片使用设置 + - 压力模式和清洁忽略选项 + - 电解液双滴模式（分两次滴液） + + Args: + elec_num: 电解液瓶数 + elec_use_num: 每瓶电解液组装的电池数 + elec_vol: 电解液吸液量 (μL) + dual_drop_mode: 电解液添加模式 (False=单次滴液, True=二次滴液) + dual_drop_first_volume: 二次滴液第一次排液体积 (μL) + dual_drop_suction_timing: 二次滴液吸液时机 (False=正常吸液, True=先吸液) + dual_drop_start_timing: 二次滴液开始滴液时机 (False=正极片前, True=正极片后) + assembly_type: 组装类型 (7=不用铝箔垫, 8=使用铝箔垫) + assembly_pressure: 电池压制力 (N) + fujipian_panshu: 负极片盘数 + fujipian_juzhendianwei: 负极片矩阵点位 + gemopanshu: 隔膜盘数 + gemo_juzhendianwei: 隔膜矩阵点位 + qiangtou_juzhendianwei: 枪头盒矩阵点位 + lvbodian: 是否使用铝箔垫片 + battery_pressure_mode: 是否启用压力模式 + battery_clean_ignore: 是否忽略电池清洁 + file_path: 实验记录保存路径 + + Returns: + dict: 包含组装结果的字典 + """ + # 参数类型转换 + elec_num = int(elec_num) + elec_use_num = int(elec_use_num) + elec_vol = int(elec_vol) + dual_drop_first_volume = int(dual_drop_first_volume) + assembly_type = int(assembly_type) + assembly_pressure = int(assembly_pressure) + fujipian_panshu = int(fujipian_panshu) + fujipian_juzhendianwei = int(fujipian_juzhendianwei) + gemopanshu = int(gemopanshu) + gemo_juzhendianwei = int(gemo_juzhendianwei) + qiangtou_juzhendianwei = int(qiangtou_juzhendianwei) + + # 步骤1: 设置设备参数（原 qiming_coin_cell_code 的功能） + logger.info("=" * 60) + logger.info("设置设备参数...") + logger.info(f" 负极片盘数: {fujipian_panshu}, 矩阵点位: {fujipian_juzhendianwei}") + logger.info(f" 隔膜盘数: {gemopanshu}, 矩阵点位: {gemo_juzhendianwei}") + logger.info(f" 枪头盒矩阵点位: {qiangtou_juzhendianwei}") + logger.info(f" 铝箔垫片: {lvbodian}, 压力模式: {battery_pressure_mode}") + logger.info(f" 压制力: {assembly_pressure}") + logger.info(f" 忽略电池清洁: {battery_clean_ignore}") + logger.info("=" * 60) + + # 写入基础参数到PLC + self.client.use_node('REG_MSG_NE_PLATE_NUM').write(fujipian_panshu) + self.client.use_node('REG_MSG_NE_PLATE_MATRIX').write(fujipian_juzhendianwei) + self.client.use_node('REG_MSG_SEPARATOR_PLATE_NUM').write(gemopanshu) + self.client.use_node('REG_MSG_SEPARATOR_PLATE_MATRIX').write(gemo_juzhendianwei) + self.client.use_node('REG_MSG_TIP_BOX_MATRIX').write(qiangtou_juzhendianwei) + self.client.use_node('COIL_ALUMINUM_FOIL').write(not lvbodian) + self.client.use_node('REG_MSG_PRESS_MODE').write(not battery_pressure_mode) + self.client.use_node('REG_MSG_BATTERY_CLEAN_IGNORE').write(battery_clean_ignore) + + # 设置电解液双滴模式参数 + self.client.use_node('COIL_ELECTROLYTE_DUAL_DROP_MODE').write(dual_drop_mode) + self.client.use_node('REG_MSG_DUAL_DROP_FIRST_VOLUME').write(dual_drop_first_volume) + self.client.use_node('COIL_DUAL_DROP_SUCTION_TIMING').write(dual_drop_suction_timing) + self.client.use_node('COIL_DUAL_DROP_START_TIMING').write(dual_drop_start_timing) + + if dual_drop_mode: + logger.info(f"✓ 双滴模式已启用: 第一次排液={dual_drop_first_volume}μL, " + f"吸液时机={'先吸液' if dual_drop_suction_timing else '正常吸液'}, " + f"滴液时机={'正极片后' if dual_drop_start_timing else '正极片前'}") + else: + logger.info("✓ 单次滴液模式") + + logger.info("✓ 设备参数设置完成") + + # 步骤2: 执行组装流程（复用 func_allpack_cmd 的主体逻辑） + summary_csv_file = os.path.join(file_path, "duandian.csv") + + # 用于收集所有电池的数据 + battery_data_list = [] + + # 如果断点文件存在，先读取之前的进度 + if os.path.exists(summary_csv_file): + read_status_flag = True + with open(summary_csv_file, 'r', newline='', encoding='utf-8') as csvfile: + reader = csv.reader(csvfile) + header = next(reader) # 跳过标题行 + data_row = next(reader) # 读取数据行 + if len(data_row) >= 2: + elec_num_r = int(data_row[0]) + elec_use_num_r = int(data_row[1]) + elec_num_N = int(data_row[2]) + elec_use_num_N = int(data_row[3]) + coin_num_N = int(data_row[4]) + if elec_num_r == elec_num and elec_use_num_r == elec_use_num: + print("断点文件与当前任务匹配，继续") + else: + print("断点文件中elec_num、elec_use_num与当前任务不匹配，请检查任务下发参数或修改断点文件") + return { + "success": False, + "error": "断点文件参数不匹配", + "total_batteries": 0, + "batteries": [] + } + print(f"从断点文件读取进度: elec_num_N={elec_num_N}, elec_use_num_N={elec_use_num_N}, coin_num_N={coin_num_N}") + + else: + read_status_flag = False + print("未找到断点文件，从头开始") + elec_num_N = 0 + elec_use_num_N = 0 + coin_num_N = 0 + + for i in range(20): + print(f"剩余电解液瓶数: {elec_num}, 已组装电池数: {elec_use_num}") + print(f"剩余电解液瓶数: {type(elec_num)}, 已组装电池数: {type(elec_use_num)}") + print(f"剩余电解液瓶数: {type(int(elec_num))}, 已组装电池数: {type(int(elec_use_num))}") + + last_i = elec_num_N + last_j = elec_use_num_N + for i in range(last_i, elec_num): + print(f"开始第{last_i+i+1}瓶电解液的组装") + # 第一个循环从上次断点继续，后续循环从0开始 + j_start = last_j if i == last_i else 0 + self.func_pack_send_msg_cmd(elec_use_num-j_start, elec_vol, assembly_type, assembly_pressure) + + for j in range(j_start, elec_use_num): + print(f"开始第{last_i+i+1}瓶电解液的第{j+j_start+1}个电池组装") + + # 读取电池组装数据并存入csv + self.func_pack_get_msg_cmd(file_path) + + # 收集当前电池的数据 + try: + battery_qr_code = self.data_coin_cell_code + except Exception as e: + print(f"读取电池二维码失败: {e}") + battery_qr_code = "N/A" + + try: + electrolyte_qr_code = self.data_electrolyte_code + except Exception as e: + print(f"读取电解液二维码失败: {e}") + electrolyte_qr_code = "N/A" + + try: + open_circuit_voltage = self.data_open_circuit_voltage + if isinstance(open_circuit_voltage, (list, tuple)) and len(open_circuit_voltage) > 0: + open_circuit_voltage = float(open_circuit_voltage[0]) + else: + open_circuit_voltage = float(open_circuit_voltage) + except Exception as e: + print(f"读取开路电压失败: {e}") + open_circuit_voltage = 0.0 + + try: + pole_weight = self.data_pole_weight + if isinstance(pole_weight, (list, tuple)) and len(pole_weight) > 0: + pole_weight = float(pole_weight[0]) + else: + pole_weight = float(pole_weight) + except Exception as e: + print(f"读取正极片重量失败: {e}") + pole_weight = 0.0 + + battery_info = { + "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 + } + battery_data_list.append(battery_info) + print(f"已收集第 {coin_num_N + 1} 个电池数据: 电池码={battery_info['battery_barcode']}, 电解液码={battery_info['electrolyte_barcode']}") + + time.sleep(1) + + # 生成断点文件 + timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") + with open(summary_csv_file, 'w', newline='', encoding='utf-8') as csvfile: + writer = csv.writer(csvfile) + writer.writerow(['elec_num','elec_use_num', 'elec_num_N', 'elec_use_num_N', 'coin_num_N', 'timestamp']) + writer.writerow([elec_num, elec_use_num, elec_num_N, elec_use_num_N, coin_num_N, timestamp]) + csvfile.flush() + coin_num_N += 1 + self.coin_num_N = coin_num_N + elec_use_num_N += 1 + elec_num_N += 1 + elec_use_num_N = 0 + + # 循环正常结束，则删除断点文件 + os.remove(summary_csv_file) + # 全部完成后等待依华发送完成信号 + self.func_pack_send_finished_cmd() + + # 返回JSON格式数据 + result = { + "success": True, + "total_batteries": len(battery_data_list), + "batteries": battery_data_list, + "summary": { + "electrolyte_bottles_used": elec_num, + "batteries_per_bottle": elec_use_num, + "electrolyte_volume": elec_vol, + "assembly_type": assembly_type, + "assembly_pressure": assembly_pressure, + "dual_drop_mode": dual_drop_mode + } + } + + print(f"\n{'='*60}") + print(f"组装完成统计:") + print(f" 总组装电池数: {result['total_batteries']}") + print(f" 使用电解液瓶数: {elec_num}") + print(f" 每瓶电池数: {elec_use_num}") + print(f" 双滴模式: {'启用' if dual_drop_mode else '禁用'}") + print(f"{'='*60}\n") + + return result + def func_pack_device_stop(self) -> bool: """打包指令：设备停止""" for i in range(3): @@ -878,36 +1922,27 @@ class CoinCellAssemblyWorkstation(WorkstationBase): def fun_wuliao_test(self) -> bool: #找到data_init中构建的2个物料盘 - #liaopan1 = self.deck.get_resource("liaopan1") - #liaopan4 = self.deck.get_resource("liaopan4") - #for coin_num_N in range(16): - # liaopan1 = self.deck.get_resource("liaopan1") - # liaopan4 = self.deck.get_resource("liaopan4") - # jipian1 = liaopan1.children[coin_num_N].children[0] - # jipian4 = liaopan4.children[coin_num_N].children[0] - # #print(jipian1) - # #从料盘上去物料解绑后放到另一盘上 - # jipian1.parent.unassign_child_resource(jipian1) - # jipian4.parent.unassign_child_resource(jipian4) - # - # #print(jipian2.parent) - # battery = Battery(name = f"battery_{coin_num_N}") - # battery.assign_child_resource(jipian1, location=None) - # battery.assign_child_resource(jipian4, location=None) - # - # zidanjia6 = self.deck.get_resource("zi_dan_jia6") - # zidanjia6.children[0].assign_child_resource(battery, location=None) - # ROS2DeviceNode.run_async_func(self._ros_node.update_resource, True, **{ - # "resources": [self.deck] - # }) - # time.sleep(2) - for i in range(20): - print(f"输出{i}") - time.sleep(2) - + liaopan3 = self.deck.get_resource("\u7535\u6c60\u6599\u76d8") + for i in range(16): + battery = ElectrodeSheet(name=f"battery_{i}", size_x=16, size_y=16, size_z=2) + battery._unilabos_state = { + "diameter": 20.0, + "height": 20.0, + "assembly_pressure": i, + "electrolyte_volume": 20.0, + "electrolyte_name": f"DP{i}" + } + liaopan3.children[i].assign_child_resource(battery, location=None) + ROS2DeviceNode.run_async_func(self._ros_node.update_resource, True, **{ + "resources": [self.deck] + }) + # for i in range(40): + # print(f"fun_wuliao_test 运行结束{i}") + # time.sleep(1) + # time.sleep(40) # 数据读取与输出 - def func_read_data_and_output(self, file_path: str="D:\\coin_cell_data"): + def func_read_data_and_output(self, file_path: str="/Users/sml/work"): # 检查CSV导出是否正在运行，已运行则跳出，防止同时启动两个while循环 if self.csv_export_running: return False, "读取已在运行中" @@ -1012,7 +2047,7 @@ class CoinCellAssemblyWorkstation(WorkstationBase): # else: # print("子弹夹洞位0没有极片") # - # #把电解液从瓶中取到电池夹子中 + # # TODO:#把电解液从瓶中取到电池夹子中 # battery_site = deck.get_resource("battery_press_1") # clip_magazine_battery = deck.get_resource("clip_magazine_battery") # if battery_site.has_battery(): @@ -1102,41 +2137,16 @@ class CoinCellAssemblyWorkstation(WorkstationBase): ''' + if __name__ == "__main__": - from pylabrobot.resources import Resource - Coin_Cell = CoinCellAssemblyWorkstation(Resource("1", 1, 1, 1), debug_mode=True) - #Coin_Cell.func_pack_device_init() - #Coin_Cell.func_pack_device_auto() - #Coin_Cell.func_pack_device_start() - #Coin_Cell.func_pack_send_bottle_num(2) - #Coin_Cell.func_pack_send_msg_cmd(2) - #Coin_Cell.func_pack_get_msg_cmd() - #Coin_Cell.func_pack_get_msg_cmd() - #Coin_Cell.func_pack_send_finished_cmd() -# - #Coin_Cell.func_allpack_cmd(3, 2) - #print(Coin_Cell.data_stack_vision_code) - #print("success") - #创建一个物料台面 - - #deck = create_a_coin_cell_deck() - - ##在台面上找到料盘和极片 - #liaopan1 = deck.get_resource("liaopan1") - #liaopan2 = deck.get_resource("liaopan2") - #jipian1 = liaopan1.children[1].children[0] -# - ##print(jipian1) - ##把物料解绑后放到另一盘上 - #jipian1.parent.unassign_child_resource(jipian1) - #liaopan2.children[1].assign_child_resource(jipian1, location=None) - ##print(jipian2.parent) - from unilabos.resources.graphio import resource_ulab_to_plr, convert_resources_to_type - - with open("./button_battery_decks_unilab.json", "r", encoding="utf-8") as f: - bioyond_resources_unilab = json.load(f) - print(f"成功读取 JSON 文件，包含 {len(bioyond_resources_unilab)} 个资源") - ulab_resources = convert_resources_to_type(bioyond_resources_unilab, List[PLRResource]) - print(f"转换结果类型: {type(ulab_resources)}") - print(ulab_resources) - + # 简单测试 + workstation = CoinCellAssemblyWorkstation(deck=CoincellDeck(setup=True, name="coin_cell_deck")) + # workstation.qiming_coin_cell_code(fujipian_panshu=1, fujipian_juzhendianwei=2, gemopanshu=3, gemo_juzhendianwei=4, lvbodian=False, battery_pressure_mode=False, battery_pressure=4200, battery_clean_ignore=False) + # print(f"工作站创建成功: {workstation.deck.name}") + # print(f"料盘数量: {len(workstation.deck.children)}") + workstation.func_pack_device_init() + workstation.func_pack_device_auto() + workstation.func_pack_device_start() + workstation.func_pack_send_bottle_num(16) + workstation.func_allpack_cmd(elec_num=16, elec_use_num=16, elec_vol=50, assembly_type=7, assembly_pressure=4200, file_path="/Users/calvincao/Desktop/work/Uni-Lab-OS-hhm") + \ No newline at end of file diff --git a/unilabos/devices/workstation/coin_cell_assembly/coin_cell_assembly_20260112.xlsx b/unilabos/devices/workstation/coin_cell_assembly/coin_cell_assembly_20260112.xlsx new file mode 100644 index 0000000000000000000000000000000000000000..d9131f1641e39258cc3f826a3ea8e25f1c57e27f GIT binary patch literal 18578 zcmeIa1AAr7wl=)tj%{^pt7F^f*tV^X-LY+V)UnNuZJQlC@9Jmo^X%DRTj!!1Dih{V(o;%EU3bK1L+b2Z>kVJvyniI)P7Y=K(_~)QWuF z{RxBRMq1ex79ZK+FGxap=$0I{D3fbm%)iIY>uhZr1HuN|l;9%$hr7S(;&Lzy44sj6 zVPeNSYHD2OqTvcKVe9FAH_ZT~IyChuv5IU9N>$>Rqhs*-?PjeEsUmLBG1V| z9pGCsJktE7TmIY#&)c?m8fp(*^zj4j9{ITSrdtSUq??G;C-i)4_?X-4Y-(RC@Zxv! z@i*poNC4pD0}P<>A7>k0 zF~WshO1y>+Kg_SkA_+;m2}-mPsrdRyt|2yjFCfKT@1np%Qo#uX6aUuX`#QS1&h!0b znCO0owK5U~jhm#=?MFz;vx5s1HMwK5m_y}uKeFrm-TZx;xReK_Yex)qMRRGM^vEWO z*z9kSTBJ#OH5_QvBD@d`-ZX#BL0OFr!^bL+c_HQVA0ahO9Jwb6lNsL@lZ%hx`NKG6 z&Suikhn)<~maDvnt%>fQaK0*=b6V6GW;=2bd*~Tkci)I)bfLa^)5&EHD-pAzJTgy; z50T~GebcOG{XLfD(a!c z8QR%d{fS$JUj^-E8PPgPeiIVsY;6t5CDeaU&SSF~DDz*GSXw0kqje z)W}Z;VcBQ!4p16J1|GeIqaI;$?%@|U>zxgpYR~57b8!#=5A6K8RN|U*W;u_+QTVS{ zc(g1x9BiL~vwQTU^)-s+Ee?Lhn@7&Ken9eJ8O zPBe@oSnuGt0g#Mj5>us$8D^0{eVI=iCbLWqSCdUSiWq~gRH)?vF-+Z0k@1A1Z z7?NMy@OIq$3v|5QWGLV7kI!Dl9{4wWu|CKR8+Dn!5gB1D*47ezk%mgX{00g0I@Kdp zPEtVUzIl8p)JpKvNP<9uw59YMe;C0=_F5gv*>U9*?&aJj#SjJF`^>YC{sJKc&CN&X zt#tO{Hl)vNE9yQ_y>_$^v$Zr&crW17f(+u4p-CQTsfeTKZlbn!bM^<8YNJ_0p9|C) zrnjyxRjICKBv>4UB>}MvwDVNL>6nKR4^p_KU;y1vpp@3d`r!^E#NeF6scdOtx<;6s z7IM)vBhD7R1J{yEDDT>-xDL-%dor#~o2}OtTh!SmC0hqZDcjE^jyq(UIC(?*{h%bW z$>M8cA^Z{uole_dvU71ofzJvZ2~*@1G?}R*STKdzCy0_p+Hap4eg8*O@#jlSxdEC; zE6`kU0G~jBrt*)F^6v)oU*QD=INJkq`QLq2D#=RsGa_}szK1fpWw@dvFFP|3pM5<= z{4`QewMtIJ;(NP^OWmrYz97v2W*6ddIX>k2z=p5`hI-dSQyPH+?ulxB$qivQelrgC z$?*IKL4Y^}D$3c(X~j7#Lb?-b3t#*&Z8qAMgGWj-?9hT@Vv*aHnGjaX2}T!YOQ$LP zQJ{MrtKai`4pKh*5m4XM^f{f%bpNA8c=aAKC%}Vn`UV?Xk_X-cFnu&fMDy4qdjILV z{nb>~W5TMZ;2CZouR@xjoQ>Bz#QAgRusGp2s(7dU{Is^Om)p)lFQZgltJkz+x0j}S zBSZ6>z>)s%-c>ySN&gEL0FaRb001BV! zz7*lY^x$ziwJD`qU%$?u{&XPMx4|oE)DZak;YD#!M?>T?E!9m*ddO`?p0IqU+OP*5 zmDEZ@1xqZIi`tsJURTK9sa60@w(z^^;KxO7A$QH~^T}J=vRHl@vbQaz5Xp1jS zh-#&P1MU$4SNn{4L35w-PdFPpzeU}`6~^d%S`}?qXZh50X{=U@LO*W01sJZTP%QJ7 zzE@W=FRwx>2WUBmo8}8~p$Yrft{uxvn-;nQ{pT^{B475#K zlU*b~MCQF63D=8ARLOo*wv5<{-8{PT87}*zt2(eUM4T{mq|c+|Tuq@fO(i-{6z6ED zPF-0Za2%BcefM#Y!PD~�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 **目标受众**: 主要开发 `unilabos/registry/devices` 抽象层的开发者 +> **最后更新**: 2026-01-11 +> **维护者**: Uni-Lab-OS 开发团队 + +本文档详细说明 UniLabOS 资源注册系统的架构、资源的完整生命周期，以及如何实现动态物料位置追踪。 + +--- + +## 📚 目录 + +- [核心概念](#核心概念) +- [三层架构详解](#三层架构详解) +- [资源注册机制](#资源注册机制) +- [物料生命周期管理](#物料生命周期管理) +- [动态物料位置追踪](#动态物料位置追踪) +- [实战案例](#实战案例) +- [常见问题排查](#常见问题排查) + +--- + +## 核心概念 + +### 1. Resources vs Registry + +UniLabOS 采用**声明式注册**模式，将资源的**定义**（Python）与**注册信息**（YAML）分离： + +``` +┌──────────────────────────────────────────────────────────┐ +│ unilabos/resources (Python 实现) │ +│ - 定义资源的物理属性、行为和创建逻辑 │ +│ - 例如: 瓶子的尺寸、容量、材质 │ +├──────────────────────────────────────────────────────────┤ +│ unilabos/registry/resources (YAML 注册表) │ +│ - 声明哪些资源可以被前端使用 │ +│ - 定义资源的分类、图标、初始化参数 │ +└──────────────────────────────────────────────────────────┘ +``` + +**为什么要分离？** + +1. **解耦**: Python 代码可以定义无限多的资源类，但只有在 YAML 中注册的才能被前端识别 +2. **灵活性**: 无需修改 Python 代码，只需修改 YAML 就能添加/移除可用资源 +3. **可扩展性**: 第三方开发者可以通过 YAML 注册自己的资源，无需修改核心代码 + +--- + +## 三层架构详解 + +UniLabOS 资源系统采用**三层架构**，实现从前端UI到底层硬件的完整映射： + +### 架构图 + +``` +┌─────────────────────────────────────────────────────┐ +│ 第1层: YAML 注册表 (registry/resources) │ +│ - 告诉系统"哪些资源可用" │ +│ - 前端通过此层获取可用资源列表 │ +│ - 文件: YB_bottle.yaml, YB_bottle_carriers.yaml │ +├─────────────────────────────────────────────────────┤ +│ 第2层: Python 实现 (resources/bioyond) │ +│ - 定义资源的具体属性和行为 │ +│ - 创建资源实例的工厂函数 │ +│ - 文件: YB_bottles.py, YB_bottle_carriers.py │ +├─────────────────────────────────────────────────────┤ +│ 第3层: Hardware/API 集成 (devices/workstation) │ +│ - 连接 Bioyond 系统 API │ +│ - 同步物料位置和状态 │ +│ - 文件: station.py, bioyond_rpc.py, config.py │ +└─────────────────────────────────────────────────────┘ +``` + +### 第1层: YAML 注册表 + +#### YB_bottle.yaml - 单个瓶子注册 + +```yaml +YB_5ml_fenyeping: + category: + - yb3 # 系统分类 + - YB_bottle # 资源类型 + class: + module: unilabos.resources.bioyond.YB_bottles:YB_5ml_fenyeping # Python 函数路径 + type: pylabrobot # 框架类型 + description: YB_5ml_fenyeping # 前端显示名称 + handles: [] + icon: '' # 图标路径 + init_param_schema: {} # 初始化参数 schema + registry_type: resource + version: 1.0.0 +``` + +**作用:** +- 前端通过读取此文件知道有一个叫 "YB_5ml_fenyeping" 的资源 +- 用户拖拽时，系统会调用 `YB_bottles:YB_5ml_fenyeping()` 创建实例 + +#### YB_bottle_carriers.yaml - 载架（容器）注册 + +```yaml +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 # 5ml分液瓶板 +``` + +**作用:** +- 载架是容器，里面可以放多个瓶子 +- 例如: `YB_5ml_fenyepingban` 是一个 4x2 布局的板，可以放 8 个 5ml 瓶子 + +### 第2层: Python 实现 + +#### YB_bottles.py - 瓶子工厂函数 + +```python +def YB_5ml_fenyeping( + name: str, + diameter: float = 20.0, # 直径 (mm) + height: float = 50.0, # 高度 (mm) + max_volume: float = 5000.0, # 最大容量 (μL) + barcode: str = None, +) -> Bottle: + \"\"\"创建5ml分液瓶\"\"\" + return Bottle( + name=name, + diameter=diameter, + height=height, + max_volume=max_volume, + barcode=barcode, + model="YB_5ml_fenyeping", # ⭐ 与 YAML 中的名称对应 + ) +``` + +**关键点:** +- 函数名 `YB_5ml_fenyeping` 必须与 YAML 中的 `module` 路径末尾一致 +- 返回一个 `Bottle` 对象（PyLabRobot 资源类型） +- `model` 字段用于在 Bioyond 系统中识别资源类型 + +**详细文档请参考完整版 README** + +--- + +## 相关文件索引 + +### 核心文件 + +| 文件 | 功能 | 路径 | +|------|------|------| +| `YB_bottle.yaml` | 瓶子注册表 | `unilabos/registry/resources/bioyond/` | +| `YB_bottle_carriers.yaml` | 载架注册表 | `unilabos/registry/resources/bioyond/` | +| `deck.yaml` | Deck注册表 | `unilabos/registry/resources/bioyond/` | +| `YB_bottles.py` | 瓶子实现 | `unilabos/resources/bioyond/` | +| `YB_bottle_carriers.py` | 载架实现 | `unilabos/resources/bioyond/` | +| `YB_warehouses.py` | 仓库实现 | `unilabos/resources/bioyond/` | +| `decks.py` | Deck布局 | `unilabos/resources/bioyond/` | +| `station.py` | 物料同步 | `unilabos/devices/workstation/bioyond_studio/` | +| `config.py` | UUID映射 | `unilabos/devices/workstation/bioyond_studio/` | + +### 仓库相关文档 + +- [README_WAREHOUSE.md](../../resources/bioyond/README_WAREHOUSE.md) - 仓库系统开发指南 + +--- + +**维护者:** Uni-Lab-OS 开发团队 +**最后更新:** 2026-01-11 diff --git a/unilabos/registry/resources/bioyond/YB_bottle.yaml b/unilabos/registry/resources/bioyond/YB_bottle.yaml new file mode 100644 index 0000000..f8e1726 --- /dev/null +++ b/unilabos/registry/resources/bioyond/YB_bottle.yaml @@ -0,0 +1,92 @@ +YB_20ml_fenyeping: + category: + - yb3 + - YB_bottle + class: + module: unilabos.resources.bioyond.YB_bottles:YB_20ml_fenyeping + type: pylabrobot + description: YB_20ml_fenyeping + handles: [] + icon: '' + init_param_schema: {} + registry_type: resource + version: 1.0.0 +YB_5ml_fenyeping: + category: + - yb3 + - YB_bottle + class: + module: unilabos.resources.bioyond.YB_bottles:YB_5ml_fenyeping + type: pylabrobot + description: YB_5ml_fenyeping + handles: [] + icon: '' + init_param_schema: {} + registry_type: resource + version: 1.0.0 +YB_jia_yang_tou_da: + category: + - yb3 + - YB_bottle + class: + module: unilabos.resources.bioyond.YB_bottles:YB_jia_yang_tou_da + type: pylabrobot + description: YB_jia_yang_tou_da + handles: [] + icon: '' + init_param_schema: {} + registry_type: resource + version: 1.0.0 +YB_pei_ye_da_Bottle: + category: + - yb3 + - YB_bottle + class: + module: unilabos.resources.bioyond.YB_bottles:YB_pei_ye_da_Bottle + type: pylabrobot + description: YB_pei_ye_da_Bottle + handles: [] + icon: '' + init_param_schema: {} + registry_type: resource + version: 1.0.0 +YB_pei_ye_xiao_Bottle: + category: + - yb3 + - YB_bottle + class: + module: unilabos.resources.bioyond.YB_bottles:YB_pei_ye_xiao_Bottle + type: pylabrobot + description: YB_pei_ye_xiao_Bottle + handles: [] + icon: '' + init_param_schema: {} + registry_type: resource + version: 1.0.0 +YB_qiang_tou: + category: + - yb3 + - YB_bottle + class: + module: unilabos.resources.bioyond.YB_bottles:YB_qiang_tou + type: pylabrobot + description: YB_qiang_tou + handles: [] + icon: '' + init_param_schema: {} + registry_type: resource + version: 1.0.0 +YB_ye_Bottle: + category: + - yb3 + - YB_bottle_carriers + - YB_bottle + class: + module: unilabos.resources.bioyond.YB_bottles:YB_ye_Bottle + type: pylabrobot + description: YB_ye_Bottle + handles: [] + icon: '' + init_param_schema: {} + registry_type: resource + version: 1.0.0 diff --git a/unilabos/registry/resources/bioyond/YB_bottle_carriers.yaml b/unilabos/registry/resources/bioyond/YB_bottle_carriers.yaml new file mode 100644 index 0000000..4698a26 --- /dev/null +++ b/unilabos/registry/resources/bioyond/YB_bottle_carriers.yaml @@ -0,0 +1,182 @@ +YB_100ml_yeti: + category: + - yb3 + - YB_bottle_carriers + class: + module: unilabos.resources.bioyond.YB_bottle_carriers:YB_100ml_yeti + type: pylabrobot + description: YB_100ml_yeti + handles: [] + icon: '' + init_param_schema: {} + registry_type: resource + version: 1.0.0 +YB_20ml_fenyepingban: + category: + - yb3 + - YB_bottle_carriers + class: + module: unilabos.resources.bioyond.YB_bottle_carriers:YB_20ml_fenyepingban + type: pylabrobot + description: YB_20ml_fenyepingban + handles: [] + icon: '' + init_param_schema: {} + registry_type: resource + version: 1.0.0 +YB_5ml_fenyepingban: + category: + - yb3 + - YB_bottle_carriers + class: + module: unilabos.resources.bioyond.YB_bottle_carriers:YB_5ml_fenyepingban + type: pylabrobot + description: YB_5ml_fenyepingban + handles: [] + icon: '' + init_param_schema: {} + registry_type: resource + version: 1.0.0 +YB_6StockCarrier: + category: + - yb3 + - YB_bottle_carriers + class: + module: unilabos.resources.bioyond.YB_bottle_carriers:YB_6StockCarrier + type: pylabrobot + description: YB_6StockCarrier + handles: [] + icon: '' + init_param_schema: {} + registry_type: resource + version: 1.0.0 +YB_6VialCarrier: + category: + - yb3 + - YB_bottle_carriers + class: + module: unilabos.resources.bioyond.YB_bottle_carriers:YB_6VialCarrier + type: pylabrobot + description: YB_6VialCarrier + handles: [] + icon: '' + init_param_schema: {} + registry_type: resource + version: 1.0.0 +YB_gao_nian_ye_Bottle: + category: + - yb3 + - YB_bottle_carriers + class: + module: unilabos.resources.bioyond.YB_bottles:YB_gao_nian_ye_Bottle + type: pylabrobot + description: YB_gao_nian_ye_Bottle + handles: [] + icon: '' + init_param_schema: {} + registry_type: resource + version: 1.0.0 +YB_gaonianye: + category: + - yb3 + - YB_bottle_carriers + class: + module: unilabos.resources.bioyond.YB_bottle_carriers:YB_gaonianye + type: pylabrobot + description: YB_gaonianye + handles: [] + icon: '' + init_param_schema: {} + registry_type: resource + version: 1.0.0 +YB_jia_yang_tou_da_Carrier: + category: + - yb3 + - YB_bottle_carriers + class: + module: unilabos.resources.bioyond.YB_bottle_carriers:YB_jia_yang_tou_da_Carrier + type: pylabrobot + description: YB_jia_yang_tou_da_Carrier + handles: [] + icon: '' + init_param_schema: {} + registry_type: resource + version: 1.0.0 +YB_peiyepingdaban: + category: + - yb3 + - YB_bottle_carriers + class: + module: unilabos.resources.bioyond.YB_bottle_carriers:YB_peiyepingdaban + type: pylabrobot + description: YB_peiyepingdaban + handles: [] + icon: '' + init_param_schema: {} + registry_type: resource + version: 1.0.0 +YB_peiyepingxiaoban: + category: + - yb3 + - YB_bottle_carriers + class: + module: unilabos.resources.bioyond.YB_bottle_carriers:YB_peiyepingxiaoban + type: pylabrobot + description: YB_peiyepingxiaoban + handles: [] + icon: '' + init_param_schema: {} + registry_type: resource + version: 1.0.0 +YB_qiang_tou_he: + category: + - yb3 + - YB_bottle_carriers + class: + module: unilabos.resources.bioyond.YB_bottle_carriers:YB_qiang_tou_he + type: pylabrobot + description: YB_qiang_tou_he + handles: [] + icon: '' + init_param_schema: {} + registry_type: resource + version: 1.0.0 +YB_shi_pei_qi_kuai: + category: + - yb3 + - YB_bottle_carriers + class: + module: unilabos.resources.bioyond.YB_bottle_carriers:YB_shi_pei_qi_kuai + type: pylabrobot + description: YB_shi_pei_qi_kuai + handles: [] + icon: '' + init_param_schema: {} + registry_type: resource + version: 1.0.0 +YB_ye: + category: + - yb3 + - YB_bottle_carriers + class: + module: unilabos.resources.bioyond.YB_bottle_carriers:YB_ye + type: pylabrobot + description: YB_ye_Bottle_Carrier + handles: [] + icon: '' + init_param_schema: {} + registry_type: resource + version: 1.0.0 +YB_ye_100ml_Bottle: + category: + - yb3 + - YB_bottle_carriers + class: + module: unilabos.resources.bioyond.YB_bottles:YB_ye_100ml_Bottle + type: pylabrobot + description: YB_ye_100ml_Bottle + handles: [] + icon: '' + init_param_schema: {} + registry_type: resource + version: 1.0.0 diff --git a/unilabos/registry/resources/bioyond/deck.yaml b/unilabos/registry/resources/bioyond/deck.yaml index bc15850..8d6993b 100644 --- a/unilabos/registry/resources/bioyond/deck.yaml +++ b/unilabos/registry/resources/bioyond/deck.yaml @@ -22,15 +22,27 @@ BIOYOND_PolymerReactionStation_Deck: init_param_schema: {} registry_type: resource version: 1.0.0 -YB_Deck11: +BIOYOND_YB_Deck: category: - deck class: module: unilabos.resources.bioyond.decks:YB_Deck type: pylabrobot - description: BIOYOND PolymerReactionStation Deck + description: BIOYOND ElectrolyteFormulationStation Deck handles: [] icon: 配液站.webp init_param_schema: {} registry_type: resource version: 1.0.0 +CoincellDeck: + category: + - deck + class: + module: unilabos.devices.workstation.coin_cell_assembly.YB_YH_materials:YH_Deck + type: pylabrobot + description: YIHUA CoinCellAssembly Deck + handles: [] + icon: koudian.webp + init_param_schema: {} + registry_type: resource + version: 1.0.0 diff --git a/unilabos/resources/battery/__init__.py b/unilabos/resources/battery/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/unilabos/resources/battery/bottle_carriers.py b/unilabos/resources/battery/bottle_carriers.py new file mode 100644 index 0000000..9d9827c --- /dev/null +++ b/unilabos/resources/battery/bottle_carriers.py @@ -0,0 +1,56 @@ +from pylabrobot.resources import create_homogeneous_resources, Coordinate, ResourceHolder, create_ordered_items_2d + +from unilabos.resources.itemized_carrier import Bottle, BottleCarrier +from unilabos.resources.bioyond.YB_bottles import ( + YB_pei_ye_xiao_Bottle, +) +# 命名约定：试剂瓶-Bottle，烧杯-Beaker，烧瓶-Flask，小瓶-Vial + + +def YIHUA_Electrolyte_12VialCarrier(name: str) -> BottleCarrier: + """12瓶载架 - 2x6布局""" + # 载架尺寸 (mm) + carrier_size_x = 120.0 + carrier_size_y = 250.0 + carrier_size_z = 50.0 + + # 瓶位尺寸 + bottle_diameter = 35.0 + bottle_spacing_x = 35.0 # X方向间距 + bottle_spacing_y = 35.0 # Y方向间距 + + # 计算起始位置 (居中排列) + start_x = (carrier_size_x - (2 - 1) * bottle_spacing_x - bottle_diameter) / 2 + start_y = (carrier_size_y - (6 - 1) * bottle_spacing_y - bottle_diameter) / 2 + + sites = create_ordered_items_2d( + klass=ResourceHolder, + num_items_x=2, + num_items_y=6, + dx=start_x, + dy=start_y, + dz=5.0, + item_dx=bottle_spacing_x, + item_dy=bottle_spacing_y, + + size_x=bottle_diameter, + size_y=bottle_diameter, + size_z=carrier_size_z, + ) + for k, v in sites.items(): + v.name = f"{name}_{v.name}" + + carrier = BottleCarrier( + name=name, + size_x=carrier_size_x, + size_y=carrier_size_y, + size_z=carrier_size_z, + sites=sites, + model="Electrolyte_12VialCarrier", + ) + carrier.num_items_x = 2 + carrier.num_items_y = 6 + carrier.num_items_z = 1 + for i in range(12): + carrier[i] = YB_pei_ye_xiao_Bottle(f"{name}_vial_{i+1}") + return carrier diff --git a/unilabos/resources/battery/electrode_sheet.py b/unilabos/resources/battery/electrode_sheet.py new file mode 100644 index 0000000..22f98af --- /dev/null +++ b/unilabos/resources/battery/electrode_sheet.py @@ -0,0 +1,195 @@ +from typing import Any, Dict, Optional, TypedDict + +from pylabrobot.resources import Resource as ResourcePLR +from pylabrobot.resources import Container + + +electrode_colors = { + "PositiveCan": "#ff0000", + "PositiveElectrode": "#cc3333", + "NegativeCan": "#000000", + "NegativeElectrode": "#666666", + "SpringWasher": "#8b7355", + "FlatWasher": "a9a9a9", + "AluminumFoil": "#ffcccc", + "Battery": "#00ff00", +} + +class ElectrodeSheetState(TypedDict): + diameter: float # 直径 (mm) + thickness: float # 厚度 (mm) + mass: float # 质量 (g) + material_type: str # 材料类型（铜、铝、不锈钢、弹簧钢等） + color: str # 材料类型对应的颜色 + info: Optional[str] # 附加信息 + + +class ElectrodeSheet(ResourcePLR): + """极片类 - 包含正负极片、隔膜、弹片、垫片、铝箔等所有片状材料""" + + def __init__( + self, + name: str = "极片", + size_x: float = 10, + size_y: float = 10, + size_z: float = 10, + category: str = "electrode_sheet", + model: Optional[str] = None, + **kwargs + ): + """初始化极片 + + Args: + name: 极片名称 + size_x: 长度 (mm) + size_y: 宽度 (mm) + size_z: 高度 (mm) + category: 类别 + model: 型号 + **kwargs: 其他参数传递给父类 + """ + super().__init__( + name=name, + size_x=size_x, + size_y=size_y, + size_z=size_z, + category=category, + model=model, + **kwargs + ) + self._unilabos_state: ElectrodeSheetState = ElectrodeSheetState( + diameter=14, + thickness=0.1, + mass=0.5, + material_type="copper", + color="#8b4513", + info=None + ) + + # TODO: 这个还要不要？给self._unilabos_state赋值的？ + def load_state(self, state: Dict[str, Any]) -> None: + """格式不变""" + super().load_state(state) + self._unilabos_state = state + #序列化 + def serialize_state(self) -> Dict[str, Dict[str, Any]]: + """格式不变""" + data = super().serialize_state() + data.update(self._unilabos_state) # Container自身的信息，云端物料将保存这一data，本地也通过这里的data进行读写，当前类用来表示这个物料的长宽高大小的属性，而data（state用来表示物料的内容，细节等） + return data + + +def PositiveCan(name: str) -> ElectrodeSheet: + """创建正极壳""" + sheet = ElectrodeSheet(name=name, size_x=12, size_y=12, size_z=3.0, model="PositiveCan") + sheet.load_state({"diameter": 20.0, "thickness": 0.5, "mass": 0.5, "material_type": "aluminum", "color": electrode_colors["PositiveCan"], "info": None}) + return sheet + + +def PositiveElectrode(name: str) -> ElectrodeSheet: + """创建正极片""" + sheet = ElectrodeSheet(name=name, size_x=10, size_y=10, size_z=0.1, model="PositiveElectrode") + sheet.load_state({"material_type": "positive_electrode", "color": electrode_colors["PositiveElectrode"]}) + return sheet + + +def NegativeCan(name: str) -> ElectrodeSheet: + """创建负极壳""" + sheet = ElectrodeSheet(name=name, size_x=12, size_y=12, size_z=2.0, model="NegativeCan") + sheet.load_state({"material_type": "steel", "color": electrode_colors["NegativeCan"]}) + return sheet + + +def NegativeElectrode(name: str) -> ElectrodeSheet: + """创建负极片""" + sheet = ElectrodeSheet(name=name, size_x=10, size_y=10, size_z=0.1, model="NegativeElectrode") + sheet.load_state({"material_type": "negative_electrode", "color": electrode_colors["NegativeElectrode"]}) + return sheet + + +def SpringWasher(name: str) -> ElectrodeSheet: + """创建弹片""" + sheet = ElectrodeSheet(name=name, size_x=10, size_y=10, size_z=0.5, model="SpringWasher") + sheet.load_state({"material_type": "spring_steel", "color": electrode_colors["SpringWasher"]}) + return sheet + + +def FlatWasher(name: str) -> ElectrodeSheet: + """创建垫片""" + sheet = ElectrodeSheet(name=name, size_x=10, size_y=10, size_z=0.2, model="FlatWasher") + sheet.load_state({"material_type": "steel", "color": electrode_colors["FlatWasher"]}) + return sheet + + +def AluminumFoil(name: str) -> ElectrodeSheet: + """创建铝箔""" + sheet = ElectrodeSheet(name=name, size_x=10, size_y=10, size_z=0.05, model="AluminumFoil") + sheet.load_state({"material_type": "aluminum", "color": electrode_colors["AluminumFoil"]}) + return sheet + + +class BatteryState(TypedDict): + color: str # 材料类型对应的颜色 + electrolyte_name: str + data_electrolyte_code: str + open_circuit_voltage: float + assembly_pressure: float + electrolyte_volume: float + + info: Optional[str] # 附加信息 + + +class Battery(Container): + """电池类 - 包含组装好的电池""" + + def __init__( + self, + name: str = "电池", + size_x: float = 12, + size_y: float = 12, + size_z: float = 6, + category: str = "battery", + model: Optional[str] = None, + **kwargs + ): + """初始化电池 + + Args: + name: 电池名称 + size_x: 长度 (mm) + size_y: 宽度 (mm) + size_z: 高度 (mm) + category: 类别 + model: 型号 + **kwargs: 其他参数传递给父类 + """ + super().__init__( + name=name, + size_x=size_x, + size_y=size_y, + size_z=size_z, + category=category, + model=model, + **kwargs + ) + self._unilabos_state: BatteryState = BatteryState( + color=electrode_colors["Battery"], + electrolyte_name="无", + data_electrolyte_code="", + open_circuit_voltage=0.0, + assembly_pressure=0.0, + electrolyte_volume=0.0, + info=None + ) + + def load_state(self, state: Dict[str, Any]) -> None: + """格式不变""" + super().load_state(state) + self._unilabos_state = state + + #序列化 + def serialize_state(self) -> Dict[str, Dict[str, Any]]: + """格式不变""" + data = super().serialize_state() + data.update(self._unilabos_state) # Container自身的信息，云端物料将保存这一data，本地也通过这里的data进行读写，当前类用来表示这个物料的长宽高大小的属性，而data（state用来表示物料的内容，细节等） + return data \ No newline at end of file diff --git a/unilabos/resources/battery/magazine.py b/unilabos/resources/battery/magazine.py new file mode 100644 index 0000000..04328a4 --- /dev/null +++ b/unilabos/resources/battery/magazine.py @@ -0,0 +1,344 @@ +from typing import Dict, List, Optional, OrderedDict, Union, Callable +import math + +from pylabrobot.resources.coordinate import Coordinate +from pylabrobot.resources import Resource, ResourceStack, ItemizedResource +from pylabrobot.resources.carrier import create_homogeneous_resources + +from unilabos.resources.battery.electrode_sheet import ( + PositiveCan, PositiveElectrode, + NegativeCan, NegativeElectrode, + SpringWasher, FlatWasher, + AluminumFoil, + Battery +) + + +class Magazine(ResourceStack): + """子弹夹洞位类""" + + def __init__( + self, + name: str, + direction: str = 'z', + resources: Optional[List[Resource]] = None, + max_sheets: int = 100, + **kwargs + ): + """初始化子弹夹洞位 + + Args: + name: 洞位名称 + direction: 堆叠方向 + resources: 资源列表 + max_sheets: 最大极片数量 + """ + super().__init__( + name=name, + direction=direction, + resources=resources, + ) + self.max_sheets = max_sheets + + @property + def size_x(self) -> float: + return self.get_size_x() + + @property + def size_y(self) -> float: + return self.get_size_y() + + @property + def size_z(self) -> float: + return self.get_size_z() + + def serialize(self) -> dict: + return { + **super().serialize(), + "size_x": self.size_x or 10.0, + "size_y": self.size_y or 10.0, + "size_z": self.size_z or 10.0, + "max_sheets": self.max_sheets, + } + + +class MagazineHolder(ItemizedResource): + """子弹夹类 - 有多个洞位，每个洞位放多个极片""" + + def __init__( + self, + name: str, + size_x: float, + size_y: float, + size_z: float, + ordered_items: Optional[Dict[str, Magazine]] = None, + ordering: Optional[OrderedDict[str, str]] = None, + hole_diameter: float = 14.0, + hole_depth: float = 10.0, + max_sheets_per_hole: int = 100, + cross_section_type: str = "circle", + category: str = "magazine_holder", + model: Optional[str] = None, + ): + """初始化子弹夹 + + Args: + name: 子弹夹名称 + size_x: 长度 (mm) + size_y: 宽度 (mm) + size_z: 高度 (mm) + hole_diameter: 洞直径 (mm) + hole_depth: 洞深度 (mm) + max_sheets_per_hole: 每个洞位最大极片数量 + category: 类别 + model: 型号 + """ + + super().__init__( + name=name, + size_x=size_x, + size_y=size_y, + size_z=size_z, + ordered_items=ordered_items, + ordering=ordering, + category=category, + model=model, + ) + + # 保存洞位的直径和深度 + self.hole_diameter = hole_diameter + self.hole_depth = hole_depth + self.max_sheets_per_hole = max_sheets_per_hole + self.cross_section_type = cross_section_type + + def serialize(self) -> dict: + return { + **super().serialize(), + "hole_diameter": self.hole_diameter, + "hole_depth": self.hole_depth, + "max_sheets_per_hole": self.max_sheets_per_hole, + "cross_section_type": self.cross_section_type, + } + + +def magazine_factory( + name: str, + size_x: float, + size_y: float, + size_z: float, + locations: List[Coordinate], + klasses: Optional[List[Callable[[str], str]]] = None, + hole_diameter: float = 14.0, + hole_depth: float = 10.0, + max_sheets_per_hole: int = 100, + category: str = "magazine_holder", + model: Optional[str] = None, +) -> 'MagazineHolder': + """工厂函数：创建子弹夹 + + Args: + name: 子弹夹名称 + size_x: 长度 (mm) + size_y: 宽度 (mm) + size_z: 高度 (mm) + locations: 洞位坐标列表 + klasses: 每个洞位中极片的类列表 + hole_diameter: 洞直径 (mm) + hole_depth: 洞深度 (mm) + max_sheets_per_hole: 每个洞位最大极片数量 + category: 类别 + model: 型号 + """ + for loc in locations: + loc.x -= hole_diameter / 2 + loc.y -= hole_diameter / 2 + + # 创建洞位 + _sites = create_homogeneous_resources( + klass=Magazine, + locations=locations, + resource_size_x=hole_diameter, + resource_size_y=hole_diameter, + name_prefix=name, + max_sheets=max_sheets_per_hole, + ) + + # 生成编号键 + keys = [f"A{i+1}" for i in range(len(locations))] + sites = dict(zip(keys, _sites.values())) + + holder = MagazineHolder( + name=name, + size_x=size_x, + size_y=size_y, + size_z=size_z, + ordered_items=sites, + hole_diameter=hole_diameter, + hole_depth=hole_depth, + max_sheets_per_hole=max_sheets_per_hole, + category=category, + model=model, + ) + + if klasses is not None: + for i, klass in enumerate(klasses): + hole_key = keys[i] + hole = holder.children[i] + for j in reversed(range(max_sheets_per_hole)): + item_name = f"{hole_key}_sheet{j+1}" + item = klass(name=item_name) + hole.assign_child_resource(item) + return holder + + +def MagazineHolder_6_Cathode( + name: str, + size_x: float = 80.0, + size_y: float = 80.0, + size_z: float = 40.0, + hole_diameter: float = 14.0, + hole_depth: float = 10.0, + hole_spacing: float = 20.0, + max_sheets_per_hole: int = 100, +) -> MagazineHolder: + """创建6孔子弹夹 - 六边形排布""" + center_x = size_x / 2 + center_y = size_y / 2 + + locations = [] + + # 周围6个孔，按六边形排布 + for i in range(6): + angle = i * 60 * math.pi / 180 # 每60度一个孔 + x = center_x + hole_spacing * math.cos(angle) + y = center_y + hole_spacing * math.sin(angle) + locations.append(Coordinate(x, y, size_z - hole_depth)) + + return magazine_factory( + name=name, + size_x=size_x, + size_y=size_y, + size_z=size_z, + locations=locations, + klasses=[FlatWasher, PositiveCan, PositiveCan, FlatWasher, PositiveCan, PositiveCan], + hole_diameter=hole_diameter, + hole_depth=hole_depth, + max_sheets_per_hole=max_sheets_per_hole, + category="magazine_holder", + model="MagazineHolder_6_Cathode", + ) + + +def MagazineHolder_6_Anode( + name: str, + size_x: float = 80.0, + size_y: float = 80.0, + size_z: float = 40.0, + hole_diameter: float = 14.0, + hole_depth: float = 10.0, + hole_spacing: float = 20.0, + max_sheets_per_hole: int = 100, +) -> MagazineHolder: + """创建6孔子弹夹 - 六边形排布""" + center_x = size_x / 2 + center_y = size_y / 2 + + locations = [] + + # 周围6个孔，按六边形排布 + for i in range(6): + angle = i * 60 * math.pi / 180 # 每60度一个孔 + x = center_x + hole_spacing * math.cos(angle) + y = center_y + hole_spacing * math.sin(angle) + locations.append(Coordinate(x, y, size_z - hole_depth)) + + return magazine_factory( + name=name, + size_x=size_x, + size_y=size_y, + size_z=size_z, + locations=locations, + klasses=[SpringWasher, NegativeCan, NegativeCan, SpringWasher, NegativeCan, NegativeCan], + hole_diameter=hole_diameter, + hole_depth=hole_depth, + max_sheets_per_hole=max_sheets_per_hole, + category="magazine_holder", + model="MagazineHolder_6_Anode", + ) + + +def MagazineHolder_6_Battery( + name: str, + size_x: float = 80.0, + size_y: float = 80.0, + size_z: float = 40.0, + hole_diameter: float = 14.0, + hole_depth: float = 10.0, + hole_spacing: float = 20.0, + max_sheets_per_hole: int = 100, +) -> MagazineHolder: + """创建6孔子弹夹 - 六边形排布""" + center_x = size_x / 2 + center_y = size_y / 2 + + locations = [] + + # 周围6个孔，按六边形排布 + for i in range(6): + angle = i * 60 * math.pi / 180 # 每60度一个孔 + x = center_x + hole_spacing * math.cos(angle) + y = center_y + hole_spacing * math.sin(angle) + locations.append(Coordinate(x, y, size_z - hole_depth)) + + return magazine_factory( + name=name, + size_x=size_x, + size_y=size_y, + size_z=size_z, + locations=locations, + klasses=None, # 初始化时，不放入装好的电池 + hole_diameter=hole_diameter, + hole_depth=hole_depth, + max_sheets_per_hole=max_sheets_per_hole, + category="magazine_holder", + model="MagazineHolder_6_Battery", + ) + + +def MagazineHolder_4_Cathode( + name: str, +) -> MagazineHolder: + """创建4孔子弹夹 - 正方形四角排布""" + size_x: float = 80.0 + size_y: float = 80.0 + size_z: float = 10.0 + hole_diameter: float = 14.0 + hole_depth: float = 10.0 + hole_spacing: float = 25.0 + max_sheets_per_hole: int = 100 + + # 计算4个洞位的坐标（正方形四角排布） + center_x = size_x / 2 + center_y = size_y / 2 + offset = hole_spacing / 2 + + locations = [ + Coordinate(center_x - offset, center_y - offset, size_z - hole_depth), # 左下 + Coordinate(center_x + offset, center_y - offset, size_z - hole_depth), # 右下 + Coordinate(center_x - offset, center_y + offset, size_z - hole_depth), # 左上 + Coordinate(center_x + offset, center_y + offset, size_z - hole_depth), # 右上 + ] + + return magazine_factory( + name=name, + size_x=size_x, + size_y=size_y, + size_z=size_z, + locations=locations, + klasses=[AluminumFoil, PositiveElectrode, PositiveElectrode, PositiveElectrode], + hole_diameter=hole_diameter, + hole_depth=hole_depth, + max_sheets_per_hole=max_sheets_per_hole, + category="magazine_holder", + model="MagazineHolder_4_Cathode", + ) diff --git a/unilabos/resources/bioyond/README_WAREHOUSE.md b/unilabos/resources/bioyond/README_WAREHOUSE.md new file mode 100644 index 0000000..6d1a62e --- /dev/null +++ b/unilabos/resources/bioyond/README_WAREHOUSE.md @@ -0,0 +1,548 @@ +# Bioyond 仓库系统开发指南 + +本文档详细说明 Bioyond 仓库（Warehouse）系统的架构、配置和使用方法，帮助开发者快速理解和维护仓库相关代码。 + +## 📚 目录 + +- [系统架构](#系统架构) +- [核心概念](#核心概念) +- [三层映射关系](#三层映射关系) +- [warehouse_factory 详解](#warehouse_factory-详解) +- [创建新仓库](#创建新仓库) +- [常见问题](#常见问题) +- [调试技巧](#调试技巧) + +--- + +## 系统架构 + +Bioyond 仓库系统采用**三层架构**，实现从前端显示到后端 API 的完整映射： + +``` +┌─────────────────────────────────────────────────────────┐ +│ 前端显示层 (YB_warehouses.py) │ +│ - warehouse_factory 自动生成库位网格 │ +│ - 生成库位名称：A01, B02, C03... │ +│ - 存储在 WareHouse.sites 字典中 │ +└────────────────┬────────────────────────────────────────┘ + │ + ▼ +┌─────────────────────────────────────────────────────────┐ +│ Deck 布局层 (decks.py) │ +│ - 定义仓库在 Deck 上的物理位置 │ +│ - 组织多个仓库形成完整布局 │ +└────────────────┬────────────────────────────────────────┘ + │ + ▼ +┌─────────────────────────────────────────────────────────┐ +│ UUID 映射层 (config.py) │ +│ - 将库位名称映射到 Bioyond 系统 UUID │ +│ - 用于 API 调用时的物料入库操作 │ +└─────────────────────────────────────────────────────────┘ +``` + +--- + +## 核心概念 + +### 仓库（Warehouse） + +仓库是一个**三维网格**，用于存放物料。由以下参数定义： + +- **num_items_x**: 列数（X 轴） +- **num_items_y**: 行数（Y 轴） +- **num_items_z**: 层数（Z 轴） + +例如：`5行×3列×1层` = 5×3×1 = 15个库位 + +### 库位（Site） + +库位是仓库中的单个存储位置，由**字母行+数字列**命名： + +- **字母行**：A, B, C, D, E, F...（对应 Y 轴） +- **数字列**：01, 02, 03, 04...（对应 X 轴或 Z 轴） + +示例：`A01`, `B02`, `C03` + +### 布局模式（Layout） + +控制库位的排序和 Y 坐标计算： + +| 模式 | 说明 | 生成顺序 | Y 坐标计算 | 显示效果 | +|------|------|----------|-----------|---------| +| `col-major` | 列优先（默认） | A01, B01, C01, A02... | `dy + (num_y - row - 1) * item_dy` | A 可能在下 | +| `row-major` | 行优先 | A01, A02, A03, B01... | `dy + row * item_dy` | **A 在上** ✓ | + +**重要：** 使用 `row-major` 可以避免上下颠倒问题！ + +--- + +## 三层映射关系 + +### 示例：手动传递窗右（A01-E03） + +#### 1️⃣ 前端显示层 - [`YB_warehouses.py`](YB_warehouses.py) + +```python +def bioyond_warehouse_5x3x1(name: str, row_offset: int = 0) -> WareHouse: + """创建 5行×3列×1层 仓库""" + return warehouse_factory( + name=name, + num_items_x=3, # 3列 + num_items_y=5, # 5行 + num_items_z=1, # 1层 + row_offset=row_offset, + layout="row-major", + ) +``` + +**自动生成的库位：** A01, A02, A03, B01, B02, B03, ..., E01, E02, E03 + +#### 2️⃣ Deck 布局层 - [`decks.py`](decks.py) + +```python +self.warehouses = { + "手动传递窗右": bioyond_warehouse_5x3x1("手动传递窗右", row_offset=0), +} +self.warehouse_locations = { + "手动传递窗右": Coordinate(4160.0, 877.0, 0.0), +} +``` + +**作用：** +- 创建仓库实例 +- 设置在 Deck 上的物理坐标 + +#### 3️⃣ UUID 映射层 - [`config.py`](../../devices/workstation/bioyond_studio/config.py) + +```python +WAREHOUSE_MAPPING = { + "手动传递窗右": { + "uuid": "", + "site_uuids": { + "A01": "3a19deae-2c7a-36f5-5e41-02c5b66feaea", + "A02": "3a19deae-2c7a-dc6d-c41e-ef285d946cfe", + # ... 其他库位 + } + } +} +``` + +**作用：** +- 用户拖拽物料到"手动传递窗右"的"A01"位置时 +- 系统查找 `WAREHOUSE_MAPPING["手动传递窗右"]["site_uuids"]["A01"]` +- 获取 UUID `"3a19deae-2c7a-36f5-5e41-02c5b66feaea"` +- 调用 Bioyond API 将物料入库到该 UUID 位置 + +--- + +## 实际配置案例 + +### 案例：手动传递窗左/右的完整配置 + +本案例展示如何为"手动传递窗右"和"手动传递窗左"建立完整的三层映射。 + +#### 背景需求 +- **手动传递窗右**: 需要 A01-E03（5行×3列=15个库位） +- **手动传递窗左**: 需要 F01-J03（5行×3列=15个库位） +- 这两个仓库共享同一个物理堆栈的 UUID（"手动堆栈"） + +#### 实施步骤 + +**1️⃣ 修复前端布局** - [`YB_warehouses.py`](YB_warehouses.py) + +```python +# 创建新的 5×3×1 仓库函数（之前是错误的 1×3×3） +def bioyond_warehouse_5x3x1(name: str, row_offset: int = 0) -> WareHouse: + """创建5行×3列×1层仓库，支持行偏移生成不同字母行""" + return warehouse_factory( + name=name, + num_items_x=3, # 3列 + num_items_y=5, # 5行 ← 修正 + num_items_z=1, # 1层 ← 修正 + row_offset=row_offset, # ← 支持 F-J 行 + layout="row-major", # ← 避免上下颠倒 + ) +``` + +**2️⃣ 更新 Deck 配置** - [`decks.py`](decks.py) + +```python +from unilabos.resources.bioyond.YB_warehouses import ( + bioyond_warehouse_5x3x1, # 新增导入 +) + +class BIOYOND_YB_Deck(Deck): + def setup(self) -> None: + self.warehouses = { + # 修改前: bioyond_warehouse_1x3x3 (错误尺寸) + # 修改后: bioyond_warehouse_5x3x1 (正确尺寸) + "手动传递窗右": bioyond_warehouse_5x3x1("手动传递窗右", row_offset=0), # A01-E03 + "手动传递窗左": bioyond_warehouse_5x3x1("手动传递窗左", row_offset=5), # F01-J03 + } +``` + +**3️⃣ 添加 UUID 映射** - [`config.py`](../../devices/workstation/bioyond_studio/config.py) + +```python +WAREHOUSE_MAPPING = { + # 保持原有的"手动堆栈"配置不变（A01-J03共30个库位） + "手动堆栈": { + "uuid": "", + "site_uuids": { + "A01": "3a19deae-2c7a-36f5-5e41-02c5b66feaea", + # ... A02-E03 共15个 + "F01": "3a19deae-2c7a-d594-fd6a-0d20de3c7c4a", + # ... F02-J03 共15个 + } + }, + + # [新增] 手动传递窗右 - 复用"手动堆栈"的 A01-E03 UUID + "手动传递窗右": { + "uuid": "", + "site_uuids": { + "A01": "3a19deae-2c7a-36f5-5e41-02c5b66feaea", # ← 与手动堆栈A01相同 + "A02": "3a19deae-2c7a-dc6d-c41e-ef285d946cfe", + "A03": "3a19deae-2c7a-5876-c454-6b7e224ca927", + "B01": "3a19deae-2c7a-2426-6d71-e9de3cb158b1", + "B02": "3a19deae-2c7a-79b0-5e44-efaafd1e4cf3", + "B03": "3a19deae-2c7a-b9eb-f4e3-e308e0cf839a", + "C01": "3a19deae-2c7a-32bc-768e-556647e292f3", + "C02": "3a19deae-2c7a-e97a-8484-f5a4599447c4", + "C03": "3a19deae-2c7a-3056-6504-10dc73fbc276", + "D01": "3a19deae-2c7a-ffad-875e-8c4cda61d440", + "D02": "3a19deae-2c7a-61be-601c-b6fb5610499a", + "D03": "3a19deae-2c7a-c0f7-05a7-e3fe2491e560", + "E01": "3a19deae-2c7a-a6f4-edd1-b436a7576363", + "E02": "3a19deae-2c7a-4367-96dd-1ca2186f4910", + "E03": "3a19deae-2c7a-b163-2219-23df15200311", + } + }, + + # [新增] 手动传递窗左 - 复用"手动堆栈"的 F01-J03 UUID + "手动传递窗左": { + "uuid": "", + "site_uuids": { + "F01": "3a19deae-2c7a-d594-fd6a-0d20de3c7c4a", # ← 与手动堆栈F01相同 + "F02": "3a19deae-2c7a-a194-ea63-8b342b8d8679", + "F03": "3a19deae-2c7a-f7c4-12bd-425799425698", + "G01": "3a19deae-2c7a-0b56-72f1-8ab86e53b955", + "G02": "3a19deae-2c7a-204e-95ed-1f1950f28343", + "G03": "3a19deae-2c7a-392b-62f1-4907c66343f8", + "H01": "3a19deae-2c7a-5602-e876-d27aca4e3201", + "H02": "3a19deae-2c7a-f15c-70e0-25b58a8c9702", + "H03": "3a19deae-2c7a-780b-8965-2e1345f7e834", + "I01": "3a19deae-2c7a-8849-e172-07de14ede928", + "I02": "3a19deae-2c7a-4772-a37f-ff99270bafc0", + "I03": "3a19deae-2c7a-cce7-6e4a-25ea4a2068c4", + "J01": "3a19deae-2c7a-1848-de92-b5d5ed054cc6", + "J02": "3a19deae-2c7a-1d45-b4f8-6f866530e205", + "J03": "3a19deae-2c7a-f237-89d9-8fe19025dee9" + } + }, +} +``` + +#### 关键要点 + +1. **UUID 可以复用**: 三个仓库（手动堆栈、手动传递窗右、手动传递窗左）可以共享相同的物理库位 UUID +2. **库位名称必须匹配**: 前端生成的库位名称（如 F01）必须与 config.py 中的键名完全一致 +3. **row_offset 的妙用**: + - `row_offset=0` → 生成 A-E 行 + - `row_offset=5` → 生成 F-J 行（跳过前5个字母） + +#### 验证结果 + +配置完成后，拖拽测试： + +| 拖拽位置 | 前端库位 | 查找路径 | UUID | 结果 | +|---------|---------|---------|------|------| +| 手动传递窗右/A01 | A01 | `WAREHOUSE_MAPPING["手动传递窗右"]["site_uuids"]["A01"]` | `3a19...eaea` | ✅ 正确入库 | +| 手动传递窗左/F01 | F01 | `WAREHOUSE_MAPPING["手动传递窗左"]["site_uuids"]["F01"]` | `3a19...c4a` | ✅ 正确入库 | +| 手动堆栈/A01 | A01 | `WAREHOUSE_MAPPING["手动堆栈"]["site_uuids"]["A01"]` | `3a19...eaea` | ✅ 仍然正常 | + + +--- + +## warehouse_factory 详解 + +### 函数签名 + +```python +def warehouse_factory( + name: str, + num_items_x: int = 1, # 列数 + num_items_y: int = 4, # 行数 + num_items_z: int = 4, # 层数 + dx: float = 137.0, # X 起始偏移 + dy: float = 96.0, # Y 起始偏移 + dz: float = 120.0, # Z 起始偏移 + item_dx: float = 10.0, # X 间距 + item_dy: float = 10.0, # Y 间距 + item_dz: float = 10.0, # Z 间距 + col_offset: int = 0, # 列偏移（影响数字） + row_offset: int = 0, # 行偏移（影响字母） + layout: str = "col-major", # 布局模式 +) -> WareHouse: +``` + +### 参数说明 + +#### 尺寸参数 +- **num_items_x, y, z**: 定义仓库的网格尺寸 +- **注意**: 当 `num_items_z > 1` 时，Z 轴会被映射为数字列 + +#### 位置参数 +- **dx, dy, dz**: 第一个库位的起始坐标 +- **item_dx, dy, dz**: 库位之间的间距 + +#### 偏移参数 +- **col_offset**: 列起始偏移，用于生成 A05-D08 等命名 + ```python + col_offset=4 # 生成 A05, A06, A07, A08 + ``` + +- **row_offset**: 行起始偏移，用于生成 F01-J03 等命名 + ```python + row_offset=5 # 生成 F01, F02, F03（跳过 A-E） + ``` + +#### 布局参数 +- **layout**: + - `"col-major"`: 列优先（默认），可能导致上下颠倒 + - `"row-major"`: 行优先，**推荐使用**，A 显示在上 + +### 库位生成逻辑 + +```python +# row-major 模式（推荐） +keys = [f"{LETTERS[j + row_offset]}{i + 1 + col_offset:02d}" + for j in range(num_y) + for i in range(num_x)] + +# 示例：num_y=2, num_x=3, row_offset=0, col_offset=0 +# 生成：A01, A02, A03, B01, B02, B03 +``` + +### Y 坐标计算 + +```python +if layout == "row-major": + # A 在上（Y 较小） + y = dy + row * item_dy +else: + # A 在下（Y 较大）- 不推荐 + y = dy + (num_items_y - row - 1) * item_dy +``` + +--- + +## 创建新仓库 + +### 步骤 1: 在 YB_warehouses.py 中创建函数 + +```python +def bioyond_warehouse_3x4x1(name: str) -> WareHouse: + """创建 3行×4列×1层 仓库 + + 布局: + A01 | A02 | A03 | A04 + B01 | B02 | B03 | B04 + C01 | C02 | C03 | C04 + """ + return warehouse_factory( + name=name, + num_items_x=4, # 4列 + num_items_y=3, # 3行 + num_items_z=1, # 1层 + dx=10.0, + dy=10.0, + dz=10.0, + item_dx=137.0, + item_dy=120.0, + item_dz=120.0, + category="warehouse", + layout="row-major", # ⭐ 推荐使用 + ) +``` + +### 步骤 2: 在 decks.py 中使用 + +```python +# 1. 导入函数 +from unilabos.resources.bioyond.YB_warehouses import ( + bioyond_warehouse_3x4x1, # 新增 +) + +# 2. 在 setup() 中添加 +self.warehouses = { + "我的新仓库": bioyond_warehouse_3x4x1("我的新仓库"), +} +self.warehouse_locations = { + "我的新仓库": Coordinate(100.0, 200.0, 0.0), +} +``` + +### 步骤 3: 在 config.py 中配置 UUID（可选） + +```python +WAREHOUSE_MAPPING = { + "我的新仓库": { + "uuid": "", + "site_uuids": { + "A01": "从 Bioyond 系统获取的 UUID", + "A02": "从 Bioyond 系统获取的 UUID", + # ... 其他 11 个库位 + } + } +} +``` + +**注意：** 如果不需要拖拽入库功能，可跳过此步骤。 + +--- + +## 常见问题 + +### Q1: 为什么库位显示上下颠倒（C 在上，A 在下）？ + +**原因：** 使用了默认的 `col-major` 布局。 + +**解决：** 在 `warehouse_factory` 中添加 `layout="row-major"` + +```python +return warehouse_factory( + ... + layout="row-major", # ← 添加这行 +) +``` + +### Q2: 我需要 1×3×3 还是 3×3×1？ + +**判断方法：** +- **1×3×3**: 1列×3行×3**层**（垂直堆叠，有高度） +- **3×3×1**: 3行×3列×1**层**（平面网格） + +**推荐：** 大多数情况使用 `X×Y×1`（平面网格）更直观。 + +### Q3: 如何生成 F01-J03 而非 A01-E03？ + +**方法：** 使用 `row_offset` 参数 + +```python +bioyond_warehouse_5x3x1("仓库名", row_offset=5) +# row_offset=5 跳过 A-E，从 F 开始 +``` + +### Q4: 拖拽物料后找不到 UUID 怎么办？ + +**检查清单：** +1. `config.py` 中是否有该仓库的配置？ +2. 仓库名称是否完全匹配？ +3. 库位名称（如 A01）是否在 `site_uuids` 中？ + +**示例错误：** +```python +# decks.py +"手动传递窗右": bioyond_warehouse_5x3x1(...) + +# config.py - ❌ 名称不匹配 +"手动传递窗": { ... } # 缺少"右"字 +``` + +### Q5: 库位重叠怎么办？ + +**原因：** 间距（`item_dx/dy/dz`）太小。 + +**解决：** 增大间距参数 + +```python +item_dx=150.0, # 增大 X 间距 +item_dy=130.0, # 增大 Y 间距 +``` + +--- + +## 调试技巧 + +### 1. 查看生成的库位 + +```python +warehouse = bioyond_warehouse_5x3x1("测试仓库") +print(list(warehouse.sites.keys())) +# 输出：['A01', 'A02', 'A03', 'B01', 'B02', ...] +``` + +### 2. 检查库位坐标 + +```python +for name, site in warehouse.sites.items(): + print(f"{name}: {site.location}") +# 输出： +# A01: Coordinate(x=10.0, y=10.0, z=120.0) +# A02: Coordinate(x=147.0, y=10.0, z=120.0) +# ... +``` + +### 3. 验证 UUID 映射 + +```python +from unilabos.devices.workstation.bioyond_studio.config import WAREHOUSE_MAPPING + +warehouse_name = "手动传递窗右" +location_code = "A01" + +if warehouse_name in WAREHOUSE_MAPPING: + uuid = WAREHOUSE_MAPPING[warehouse_name]["site_uuids"].get(location_code) + print(f"{warehouse_name}/{location_code} → {uuid}") +else: + print(f"❌ 未找到仓库: {warehouse_name}") +``` + +--- + +## 文件关系图 + +``` +unilabos/ +├── resources/ +│ ├── warehouse.py # warehouse_factory 核心实现 +│ └── bioyond/ +│ ├── YB_warehouses.py # ⭐ 仓库函数定义 +│ ├── decks.py # ⭐ Deck 布局配置 +│ └── README_WAREHOUSE.md # 📖 本文档 +└── devices/ + └── workstation/ + └── bioyond_studio/ + ├── config.py # ⭐ UUID 映射配置 + └── bioyond_cell/ + └── bioyond_cell_workstation.py # 业务逻辑 +``` + +--- + +## 版本历史 + +- **v1.1** (2026-01-08): 补充实际配置案例 + - 添加"手动传递窗右"和"手动传递窗左"的完整配置示例 + - 展示 UUID 复用的实际应用 + - 说明三个仓库共享物理堆栈的配置方法 + +- **v1.0** (2026-01-07): 初始版本 + - 新增 `row_offset` 参数支持 + - 创建 `bioyond_warehouse_5x3x1` 和 `bioyond_warehouse_2x2x1` + - 修复多个仓库的上下颠倒问题 + +--- + +## 相关资源 + +- [warehouse.py](../warehouse.py) - 核心工厂函数实现 +- [YB_warehouses.py](YB_warehouses.py) - 所有仓库定义 +- [decks.py](decks.py) - Deck 布局配置 +- [config.py](../../devices/workstation/bioyond_studio/config.py) - UUID 映射 + +--- + +**维护者：** Uni-Lab-OS 开发团队 +**最后更新：** 2026-01-07 diff --git a/unilabos/resources/bioyond/YB_bottle_carriers.py b/unilabos/resources/bioyond/YB_bottle_carriers.py new file mode 100644 index 0000000..29a5324 --- /dev/null +++ b/unilabos/resources/bioyond/YB_bottle_carriers.py @@ -0,0 +1,653 @@ +from pylabrobot.resources import create_homogeneous_resources, Coordinate, ResourceHolder, create_ordered_items_2d + +from unilabos.resources.itemized_carrier import Bottle, BottleCarrier +from unilabos.resources.bioyond.YB_bottles import ( + YB_jia_yang_tou_da, + YB_ye_Bottle, + YB_ye_100ml_Bottle, + YB_gao_nian_ye_Bottle, + YB_5ml_fenyeping, + YB_20ml_fenyeping, + YB_pei_ye_xiao_Bottle, + YB_pei_ye_da_Bottle, + YB_qiang_tou, +) +# 命名约定：试剂瓶-Bottle，烧杯-Beaker，烧瓶-Flask，小瓶-Vial + + +def BIOYOND_Electrolyte_6VialCarrier(name: str) -> BottleCarrier: + """6瓶载架 - 2x3布局""" + + # 载架尺寸 (mm) + carrier_size_x = 127.8 + carrier_size_y = 85.5 + carrier_size_z = 50.0 + + # 瓶位尺寸 + bottle_diameter = 30.0 + bottle_spacing_x = 42.0 # X方向间距 + bottle_spacing_y = 35.0 # Y方向间距 + + # 计算起始位置 (居中排列) + start_x = (carrier_size_x - (3 - 1) * bottle_spacing_x - bottle_diameter) / 2 + start_y = (carrier_size_y - (2 - 1) * bottle_spacing_y - bottle_diameter) / 2 + + sites = create_ordered_items_2d( + klass=ResourceHolder, + num_items_x=3, + num_items_y=2, + dx=start_x, + dy=start_y, + dz=5.0, + item_dx=bottle_spacing_x, + item_dy=bottle_spacing_y, + + size_x=bottle_diameter, + size_y=bottle_diameter, + size_z=carrier_size_z, + ) + for k, v in sites.items(): + v.name = f"{name}_{v.name}" + + carrier = BottleCarrier( + name=name, + size_x=carrier_size_x, + size_y=carrier_size_y, + size_z=carrier_size_z, + sites=sites, + model="Electrolyte_6VialCarrier", + ) + carrier.num_items_x = 3 + carrier.num_items_y = 2 + carrier.num_items_z = 1 + # for i in range(6): + # carrier[i] = YB_Solid_Vial(f"{name}_vial_{i+1}") + return carrier + + +def BIOYOND_Electrolyte_1BottleCarrier(name: str) -> BottleCarrier: + """1瓶载架 - 单个中央位置""" + + # 载架尺寸 (mm) + carrier_size_x = 127.8 + carrier_size_y = 85.5 + carrier_size_z = 100.0 + + # 烧杯尺寸 + beaker_diameter = 80.0 + + # 计算中央位置 + center_x = (carrier_size_x - beaker_diameter) / 2 + center_y = (carrier_size_y - beaker_diameter) / 2 + center_z = 5.0 + + carrier = BottleCarrier( + name=name, + size_x=carrier_size_x, + size_y=carrier_size_y, + size_z=carrier_size_z, + sites=create_homogeneous_resources( + klass=ResourceHolder, + locations=[Coordinate(center_x, center_y, center_z)], + resource_size_x=beaker_diameter, + resource_size_y=beaker_diameter, + name_prefix=name, + ), + model="Electrolyte_1BottleCarrier", + ) + carrier.num_items_x = 1 + carrier.num_items_y = 1 + carrier.num_items_z = 1 + # carrier[0] = YB_Solution_Beaker(f"{name}_beaker_1") + return carrier + + +def YB_6StockCarrier(name: str) -> BottleCarrier: + """6瓶载架 - 2x3布局""" + + # 载架尺寸 (mm) + carrier_size_x = 127.8 + carrier_size_y = 85.5 + carrier_size_z = 50.0 + + # 瓶位尺寸 + bottle_diameter = 20.0 + bottle_spacing_x = 42.0 # X方向间距 + bottle_spacing_y = 35.0 # Y方向间距 + + # 计算起始位置 (居中排列) + start_x = (carrier_size_x - (3 - 1) * bottle_spacing_x - bottle_diameter) / 2 + start_y = (carrier_size_y - (2 - 1) * bottle_spacing_y - bottle_diameter) / 2 + + sites = create_ordered_items_2d( + klass=ResourceHolder, + num_items_x=3, + num_items_y=2, + dx=start_x, + dy=start_y, + dz=5.0, + item_dx=bottle_spacing_x, + item_dy=bottle_spacing_y, + + size_x=bottle_diameter, + size_y=bottle_diameter, + size_z=carrier_size_z, + ) + for k, v in sites.items(): + v.name = f"{name}_{v.name}" + + carrier = BottleCarrier( + name=name, + size_x=carrier_size_x, + size_y=carrier_size_y, + size_z=carrier_size_z, + sites=sites, + model="6StockCarrier", + ) + carrier.num_items_x = 3 + carrier.num_items_y = 2 + carrier.num_items_z = 1 + ordering = ["A1", "A2", "A3", "B1", "B2", "B3"] # 自定义顺序 + # for i in range(6): + # carrier[i] = YB_Solid_Stock(f"{name}_vial_{ordering[i]}") + return carrier + + +def YB_6VialCarrier(name: str) -> BottleCarrier: + """6瓶载架 - 2x3布局""" + + # 载架尺寸 (mm) + carrier_size_x = 127.8 + carrier_size_y = 85.5 + carrier_size_z = 50.0 + + # 瓶位尺寸 + bottle_diameter = 30.0 + bottle_spacing_x = 42.0 # X方向间距 + bottle_spacing_y = 35.0 # Y方向间距 + + # 计算起始位置 (居中排列) + start_x = (carrier_size_x - (3 - 1) * bottle_spacing_x - bottle_diameter) / 2 + start_y = (carrier_size_y - (2 - 1) * bottle_spacing_y - bottle_diameter) / 2 + + sites = create_ordered_items_2d( + klass=ResourceHolder, + num_items_x=3, + num_items_y=2, + dx=start_x, + dy=start_y, + dz=5.0, + item_dx=bottle_spacing_x, + item_dy=bottle_spacing_y, + + size_x=bottle_diameter, + size_y=bottle_diameter, + size_z=carrier_size_z, + ) + for k, v in sites.items(): + v.name = f"{name}_{v.name}" + + carrier = BottleCarrier( + name=name, + size_x=carrier_size_x, + size_y=carrier_size_y, + size_z=carrier_size_z, + sites=sites, + model="6VialCarrier", + ) + carrier.num_items_x = 3 + carrier.num_items_y = 2 + carrier.num_items_z = 1 + ordering = ["A1", "A2", "A3", "B1", "B2", "B3"] # 自定义顺序 + # for i in range(3): + # carrier[i] = YB_Solid_Vial(f"{name}_solidvial_{ordering[i]}") + # for i in range(3, 6): + # carrier[i] = YB_Liquid_Vial(f"{name}_liquidvial_{ordering[i]}") + return carrier + +# 1瓶载架 - 单个中央位置 +def YB_ye(name: str) -> BottleCarrier: + + # 载架尺寸 (mm) + carrier_size_x = 127.8 + carrier_size_y = 85.5 + carrier_size_z = 20.0 + + # 烧杯尺寸 + beaker_diameter = 60.0 + + # 计算中央位置 + center_x = (carrier_size_x - beaker_diameter) / 2 + center_y = (carrier_size_y - beaker_diameter) / 2 + center_z = 5.0 + + carrier = BottleCarrier( + name=name, + size_x=carrier_size_x, + size_y=carrier_size_y, + size_z=carrier_size_z, + sites=create_homogeneous_resources( + klass=ResourceHolder, + locations=[Coordinate(center_x, center_y, center_z)], + resource_size_x=beaker_diameter, + resource_size_y=beaker_diameter, + name_prefix=name, + ), + model="YB_ye", + ) + carrier.num_items_x = 1 + carrier.num_items_y = 1 + carrier.num_items_z = 1 + carrier[0] = YB_ye_Bottle(f"{name}_flask_1") + return carrier + + +# 高粘液瓶载架 - 单个中央位置 +def YB_gaonianye(name: str) -> BottleCarrier: + + # 载架尺寸 (mm) + carrier_size_x = 127.8 + carrier_size_y = 85.5 + carrier_size_z = 20.0 + + # 烧杯尺寸 + beaker_diameter = 60.0 + + # 计算中央位置 + center_x = (carrier_size_x - beaker_diameter) / 2 + center_y = (carrier_size_y - beaker_diameter) / 2 + center_z = 5.0 + + carrier = BottleCarrier( + name=name, + size_x=carrier_size_x, + size_y=carrier_size_y, + size_z=carrier_size_z, + sites=create_homogeneous_resources( + klass=ResourceHolder, + locations=[Coordinate(center_x, center_y, center_z)], + resource_size_x=beaker_diameter, + resource_size_y=beaker_diameter, + name_prefix=name, + ), + model="YB_gaonianye", + ) + carrier.num_items_x = 1 + carrier.num_items_y = 1 + carrier.num_items_z = 1 + carrier[0] = YB_gao_nian_ye_Bottle(f"{name}_flask_1") + return carrier + + +# 100ml液体瓶载架 - 单个中央位置 +def YB_100ml_yeti(name: str) -> BottleCarrier: + + # 载架尺寸 (mm) + carrier_size_x = 127.8 + carrier_size_y = 85.5 + carrier_size_z = 20.0 + + # 烧杯尺寸 + beaker_diameter = 60.0 + + # 计算中央位置 + center_x = (carrier_size_x - beaker_diameter) / 2 + center_y = (carrier_size_y - beaker_diameter) / 2 + center_z = 5.0 + + carrier = BottleCarrier( + name=name, + size_x=carrier_size_x, + size_y=carrier_size_y, + size_z=carrier_size_z, + sites=create_homogeneous_resources( + klass=ResourceHolder, + locations=[Coordinate(center_x, center_y, center_z)], + resource_size_x=beaker_diameter, + resource_size_y=beaker_diameter, + name_prefix=name, + ), + model="YB_100ml_yeti", + ) + carrier.num_items_x = 1 + carrier.num_items_y = 1 + carrier.num_items_z = 1 + carrier[0] = YB_ye_100ml_Bottle(f"{name}_flask_1") + return carrier + +# 5ml分液瓶板 - 4x2布局，8个位置 +def YB_5ml_fenyepingban(name: str) -> BottleCarrier: + + + # 载架尺寸 (mm) + carrier_size_x = 127.8 + carrier_size_y = 85.5 + carrier_size_z = 50.0 + + # 瓶位尺寸 + bottle_diameter = 15.0 + bottle_spacing_x = 42.0 # X方向间距 + bottle_spacing_y = 35.0 # Y方向间距 + + # 计算起始位置 (居中排列) + start_x = (carrier_size_x - (4 - 1) * bottle_spacing_x - bottle_diameter) / 2 + start_y = (carrier_size_y - (2 - 1) * bottle_spacing_y - bottle_diameter) / 2 + + sites = create_ordered_items_2d( + klass=ResourceHolder, + num_items_x=4, + num_items_y=2, + dx=start_x, + dy=start_y, + dz=5.0, + item_dx=bottle_spacing_x, + item_dy=bottle_spacing_y, + size_x=bottle_diameter, + size_y=bottle_diameter, + size_z=carrier_size_z, + ) + for k, v in sites.items(): + v.name = f"{name}_{v.name}" + + carrier = BottleCarrier( + name=name, + size_x=carrier_size_x, + size_y=carrier_size_y, + size_z=carrier_size_z, + sites=sites, + model="YB_5ml_fenyepingban", + ) + carrier.num_items_x = 4 + carrier.num_items_y = 2 + carrier.num_items_z = 1 + ordering = ["A1", "A2", "A3", "A4", "B1", "B2", "B3", "B4"] + for i in range(8): + carrier[i] = YB_5ml_fenyeping(f"{name}_vial_{ordering[i]}") + return carrier + +# 20ml分液瓶板 - 4x2布局，8个位置 +def YB_20ml_fenyepingban(name: str) -> BottleCarrier: + + + # 载架尺寸 (mm) + carrier_size_x = 127.8 + carrier_size_y = 85.5 + carrier_size_z = 70.0 + + # 瓶位尺寸 + bottle_diameter = 20.0 + bottle_spacing_x = 42.0 # X方向间距 + bottle_spacing_y = 35.0 # Y方向间距 + + # 计算起始位置 (居中排列) + start_x = (carrier_size_x - (4 - 1) * bottle_spacing_x - bottle_diameter) / 2 + start_y = (carrier_size_y - (2 - 1) * bottle_spacing_y - bottle_diameter) / 2 + + sites = create_ordered_items_2d( + klass=ResourceHolder, + num_items_x=4, + num_items_y=2, + dx=start_x, + dy=start_y, + dz=5.0, + item_dx=bottle_spacing_x, + item_dy=bottle_spacing_y, + size_x=bottle_diameter, + size_y=bottle_diameter, + size_z=carrier_size_z, + ) + for k, v in sites.items(): + v.name = f"{name}_{v.name}" + + carrier = BottleCarrier( + name=name, + size_x=carrier_size_x, + size_y=carrier_size_y, + size_z=carrier_size_z, + sites=sites, + model="YB_20ml_fenyepingban", + ) + carrier.num_items_x = 4 + carrier.num_items_y = 2 + carrier.num_items_z = 1 + ordering = ["A1", "A2", "A3", "A4", "B1", "B2", "B3", "B4"] + for i in range(8): + carrier[i] = YB_20ml_fenyeping(f"{name}_vial_{ordering[i]}") + return carrier + +# 配液瓶(小)板 - 4x2布局，8个位置 +def YB_peiyepingxiaoban(name: str) -> BottleCarrier: + + + # 载架尺寸 (mm) + carrier_size_x = 127.8 + carrier_size_y = 85.5 + carrier_size_z = 65.0 + + # 瓶位尺寸 + bottle_diameter = 35.0 + bottle_spacing_x = 42.0 # X方向间距 + bottle_spacing_y = 35.0 # Y方向间距 + + # 计算起始位置 (居中排列) + start_x = (carrier_size_x - (4 - 1) * bottle_spacing_x - bottle_diameter) / 2 + start_y = (carrier_size_y - (2 - 1) * bottle_spacing_y - bottle_diameter) / 2 + + sites = create_ordered_items_2d( + klass=ResourceHolder, + num_items_x=4, + num_items_y=2, + dx=start_x, + dy=start_y, + dz=5.0, + item_dx=bottle_spacing_x, + item_dy=bottle_spacing_y, + size_x=bottle_diameter, + size_y=bottle_diameter, + size_z=carrier_size_z, + ) + for k, v in sites.items(): + v.name = f"{name}_{v.name}" + + carrier = BottleCarrier( + name=name, + size_x=carrier_size_x, + size_y=carrier_size_y, + size_z=carrier_size_z, + sites=sites, + model="YB_peiyepingxiaoban", + ) + carrier.num_items_x = 4 + carrier.num_items_y = 2 + carrier.num_items_z = 1 + ordering = ["A1", "A2", "A3", "A4", "B1", "B2", "B3", "B4"] + for i in range(8): + carrier[i] = YB_pei_ye_xiao_Bottle(f"{name}_bottle_{ordering[i]}") + return carrier + + +# 配液瓶(大)板 - 2x2布局，4个位置 +def YB_peiyepingdaban(name: str) -> BottleCarrier: + + # 载架尺寸 (mm) + carrier_size_x = 127.8 + carrier_size_y = 85.5 + carrier_size_z = 95.0 + + # 瓶位尺寸 + bottle_diameter = 55.0 + bottle_spacing_x = 60.0 # X方向间距 + bottle_spacing_y = 60.0 # Y方向间距 + + # 计算起始位置 (居中排列) + start_x = (carrier_size_x - (2 - 1) * bottle_spacing_x - bottle_diameter) / 2 + start_y = (carrier_size_y - (2 - 1) * bottle_spacing_y - bottle_diameter) / 2 + + sites = create_ordered_items_2d( + klass=ResourceHolder, + num_items_x=2, + num_items_y=2, + dx=start_x, + dy=start_y, + dz=5.0, + item_dx=bottle_spacing_x, + item_dy=bottle_spacing_y, + size_x=bottle_diameter, + size_y=bottle_diameter, + size_z=carrier_size_z, + ) + for k, v in sites.items(): + v.name = f"{name}_{v.name}" + + carrier = BottleCarrier( + name=name, + size_x=carrier_size_x, + size_y=carrier_size_y, + size_z=carrier_size_z, + sites=sites, + model="YB_peiyepingdaban", + ) + carrier.num_items_x = 2 + carrier.num_items_y = 2 + carrier.num_items_z = 1 + ordering = ["A1", "A2", "B1", "B2"] + for i in range(4): + carrier[i] = YB_pei_ye_da_Bottle(f"{name}_bottle_{ordering[i]}") + return carrier + +# 加样头(大)板 - 1x1布局，1个位置 +def YB_jia_yang_tou_da_Carrier(name: str) -> BottleCarrier: + + # 载架尺寸 (mm) + carrier_size_x = 127.8 + carrier_size_y = 85.5 + carrier_size_z = 95.0 + + # 瓶位尺寸 + bottle_diameter = 35.0 + bottle_spacing_x = 42.0 # X方向间距 + bottle_spacing_y = 35.0 # Y方向间距 + + # 计算起始位置 (居中排列) + start_x = (carrier_size_x - (1 - 1) * bottle_spacing_x - bottle_diameter) / 2 + start_y = (carrier_size_y - (1 - 1) * bottle_spacing_y - bottle_diameter) / 2 + + sites = create_ordered_items_2d( + klass=ResourceHolder, + num_items_x=1, + num_items_y=1, + dx=start_x, + dy=start_y, + dz=5.0, + item_dx=bottle_spacing_x, + item_dy=bottle_spacing_y, + size_x=bottle_diameter, + size_y=bottle_diameter, + size_z=carrier_size_z, + ) + for k, v in sites.items(): + v.name = f"{name}_{v.name}" + + carrier = BottleCarrier( + name=name, + size_x=carrier_size_x, + size_y=carrier_size_y, + size_z=carrier_size_z, + sites=sites, + model="YB_jia_yang_tou_da_Carrier", + ) + carrier.num_items_x = 1 + carrier.num_items_y = 1 + carrier.num_items_z = 1 + carrier[0] = YB_jia_yang_tou_da(f"{name}_head_1") + return carrier + + +def YB_shi_pei_qi_kuai(name: str) -> BottleCarrier: + """适配器块 - 单个中央位置""" + + # 载架尺寸 (mm) + carrier_size_x = 127.8 + carrier_size_y = 85.5 + carrier_size_z = 30.0 + + # 适配器尺寸 + adapter_diameter = 80.0 + + # 计算中央位置 + center_x = (carrier_size_x - adapter_diameter) / 2 + center_y = (carrier_size_y - adapter_diameter) / 2 + center_z = 0.0 + + carrier = BottleCarrier( + name=name, + size_x=carrier_size_x, + size_y=carrier_size_y, + size_z=carrier_size_z, + sites=create_homogeneous_resources( + klass=ResourceHolder, + locations=[Coordinate(center_x, center_y, center_z)], + resource_size_x=adapter_diameter, + resource_size_y=adapter_diameter, + name_prefix=name, + ), + model="YB_shi_pei_qi_kuai", + ) + carrier.num_items_x = 1 + carrier.num_items_y = 1 + carrier.num_items_z = 1 + # 适配器块本身不包含瓶子，只是一个支撑结构 + return carrier + + +def YB_qiang_tou_he(name: str) -> BottleCarrier: + """枪头盒 - 8x12布局，96个位置""" + + # 载架尺寸 (mm) + carrier_size_x = 127.8 + carrier_size_y = 85.5 + carrier_size_z = 55.0 + + # 枪头尺寸 + tip_diameter = 10.0 + tip_spacing_x = 9.0 # X方向间距 + tip_spacing_y = 9.0 # Y方向间距 + + # 计算起始位置 (居中排列) + start_x = (carrier_size_x - (12 - 1) * tip_spacing_x - tip_diameter) / 2 + start_y = (carrier_size_y - (8 - 1) * tip_spacing_y - tip_diameter) / 2 + + sites = create_ordered_items_2d( + klass=ResourceHolder, + num_items_x=12, + num_items_y=8, + dx=start_x, + dy=start_y, + dz=5.0, + item_dx=tip_spacing_x, + item_dy=tip_spacing_y, + size_x=tip_diameter, + size_y=tip_diameter, + size_z=carrier_size_z, + ) + for k, v in sites.items(): + v.name = f"{name}_{v.name}" + + carrier = BottleCarrier( + name=name, + size_x=carrier_size_x, + size_y=carrier_size_y, + size_z=carrier_size_z, + sites=sites, + model="YB_qiang_tou_he", + ) + carrier.num_items_x = 12 + carrier.num_items_y = 8 + carrier.num_items_z = 1 + # 创建96个枪头 + for i in range(96): + row = chr(65 + i // 12) # A-H + col = (i % 12) + 1 # 1-12 + carrier[i] = YB_qiang_tou(f"{name}_tip_{row}{col}") + return carrier + diff --git a/unilabos/resources/bioyond/YB_bottles.py b/unilabos/resources/bioyond/YB_bottles.py new file mode 100644 index 0000000..acbbf35 --- /dev/null +++ b/unilabos/resources/bioyond/YB_bottles.py @@ -0,0 +1,163 @@ +from unilabos.resources.itemized_carrier import Bottle, BottleCarrier +# 工厂函数 +"""加样头（大）""" +def YB_jia_yang_tou_da( + name: str, + diameter: float = 20.0, + height: float = 100.0, + max_volume: float = 30000.0, # 30mL + barcode: str = None, +) -> Bottle: + """创建粉末瓶""" + return Bottle( + name=name, + diameter=diameter,# 未知 + height=height, + max_volume=max_volume, + barcode=barcode, + model="YB_jia_yang_tou_da", + ) + +"""液1x1""" +def YB_ye_Bottle( + name: str, + diameter: float = 40.0, + height: float = 70.0, + max_volume: float = 50000.0, # 50mL + barcode: str = None, +) -> Bottle: + """创建液体瓶""" + return Bottle( + name=name, + diameter=diameter, + height=height, + max_volume=max_volume, + barcode=barcode, + model="YB_ye_Bottle", + ) + +"""100ml液体""" +def YB_ye_100ml_Bottle( + name: str, + diameter: float = 50.0, + height: float = 90.0, + max_volume: float = 100000.0, # 100mL + barcode: str = None, +) -> Bottle: + """创建100ml液体瓶""" + return Bottle( + name=name, + diameter=diameter, + height=height, + max_volume=max_volume, + barcode=barcode, + model="YB_100ml_yeti", + ) + +"""高粘液""" +def YB_gao_nian_ye_Bottle( + name: str, + diameter: float = 40.0, + height: float = 70.0, + max_volume: float = 50000.0, # 50mL + barcode: str = None, +) -> Bottle: + """创建高粘液瓶""" + return Bottle( + name=name, + diameter=diameter, + height=height, + max_volume=max_volume, + barcode=barcode, + model="High_Viscosity_Liquid", + ) + +"""5ml分液瓶""" +def YB_5ml_fenyeping( + name: str, + diameter: float = 20.0, + height: float = 50.0, + max_volume: float = 5000.0, # 5mL + barcode: str = None, +) -> Bottle: + """创建5ml分液瓶""" + return Bottle( + name=name, + diameter=diameter, + height=height, + max_volume=max_volume, + barcode=barcode, + model="YB_5ml_fenyeping", + ) + +"""20ml分液瓶""" +def YB_20ml_fenyeping( + name: str, + diameter: float = 30.0, + height: float = 65.0, + max_volume: float = 20000.0, # 20mL + barcode: str = None, +) -> Bottle: + """创建20ml分液瓶""" + return Bottle( + name=name, + diameter=diameter, + height=height, + max_volume=max_volume, + barcode=barcode, + model="YB_20ml_fenyeping", + ) + +"""配液瓶(小)""" +def YB_pei_ye_xiao_Bottle( + name: str, + diameter: float = 35.0, + height: float = 60.0, + max_volume: float = 30000.0, # 30mL + barcode: str = None, +) -> Bottle: + """创建配液瓶(小)""" + return Bottle( + name=name, + diameter=diameter, + height=height, + max_volume=max_volume, + barcode=barcode, + model="YB_pei_ye_xiao_Bottle", + ) + +"""配液瓶(大)""" +def YB_pei_ye_da_Bottle( + name: str, + diameter: float = 55.0, + height: float = 100.0, + max_volume: float = 150000.0, # 150mL + barcode: str = None, +) -> Bottle: + """创建配液瓶(大)""" + return Bottle( + name=name, + diameter=diameter, + height=height, + max_volume=max_volume, + barcode=barcode, + model="YB_pei_ye_da_Bottle", + ) + +"""枪头""" +def YB_qiang_tou( + name: str, + diameter: float = 10.0, + height: float = 50.0, + max_volume: float = 1000.0, # 1mL + barcode: str = None, +) -> Bottle: + """创建枪头""" + return Bottle( + name=name, + diameter=diameter, + height=height, + max_volume=max_volume, + barcode=barcode, + model="YB_qiang_tou", + ) diff --git a/unilabos/resources/bioyond/YB_warehouses.py b/unilabos/resources/bioyond/YB_warehouses.py new file mode 100644 index 0000000..8c49e99 --- /dev/null +++ b/unilabos/resources/bioyond/YB_warehouses.py @@ -0,0 +1,384 @@ +from unilabos.resources.warehouse import WareHouse, warehouse_factory + +# ================ 反应站相关堆栈 ================ + +def bioyond_warehouse_1x4x4(name: str) -> WareHouse: + """创建BioYond 4x4x1仓库 (左侧堆栈: A01～D04) + + 使用行优先排序，前端展示为: + A01 | A02 | A03 | A04 + B01 | B02 | B03 | B04 + C01 | C02 | C03 | C04 + D01 | D02 | D03 | D04 + """ + return warehouse_factory( + name=name, + num_items_x=4, # 4列 + num_items_y=4, # 4行 + num_items_z=1, + dx=10.0, + dy=10.0, + dz=10.0, + item_dx=147.0, + item_dy=106.0, + item_dz=130.0, + category="warehouse", + col_offset=0, # 从01开始: A01, A02, A03, A04 + layout="row-major", # ⭐ 改为行优先排序 + ) + +def bioyond_warehouse_1x4x4_right(name: str) -> WareHouse: + """创建BioYond 4x4x1仓库 (右侧堆栈: A05～D08)""" + return warehouse_factory( + name=name, + num_items_x=4, + num_items_y=4, + num_items_z=1, + dx=10.0, + dy=10.0, + dz=10.0, + item_dx=147.0, + item_dy=106.0, + item_dz=130.0, + category="warehouse", + col_offset=4, # 从05开始: A05, A06, A07, A08 + layout="row-major", # ⭐ 改为行优先排序 + ) + +def bioyond_warehouse_density_vial(name: str) -> WareHouse: + """创建测量小瓶仓库(测密度) A01～B03""" + return warehouse_factory( + name=name, + num_items_x=3, # 3列（01-03） + num_items_y=2, # 2行（A-B） + num_items_z=1, # 1层 + dx=10.0, + dy=10.0, + dz=10.0, + item_dx=40.0, + item_dy=40.0, + item_dz=50.0, + # 用更小的 resource_size 来表现 "小点的孔位" + resource_size_x=30.0, + resource_size_y=30.0, + resource_size_z=12.0, + category="warehouse", + col_offset=0, + layout="row-major", + ) + +def bioyond_warehouse_reagent_storage(name: str) -> WareHouse: + """创建BioYond站内试剂存放堆栈（A01～A02, 1行×2列）""" + return warehouse_factory( + name=name, + num_items_x=2, # 2列（01-02） + num_items_y=1, # 1行（A） + num_items_z=1, # 1层 + dx=10.0, + dy=10.0, + dz=10.0, + item_dx=137.0, + item_dy=96.0, + item_dz=120.0, + category="warehouse", + ) + +def bioyond_warehouse_tipbox_storage(name: str) -> WareHouse: + """创建BioYond站内Tip盒堆栈（A01～B03），用于存放枪头盒""" + return warehouse_factory( + name=name, + num_items_x=3, # 3列（01-03） + num_items_y=2, # 2行（A-B） + num_items_z=1, # 1层 + dx=10.0, + dy=10.0, + dz=10.0, + item_dx=137.0, + item_dy=96.0, + item_dz=120.0, + category="warehouse", + col_offset=0, + layout="row-major", + ) + +def bioyond_warehouse_liquid_preparation(name: str) -> WareHouse: + """已弃用,创建BioYond移液站内10%分装液体准备仓库（A01～B04）""" + return warehouse_factory( + name=name, + num_items_x=4, # 4列（01-04） + num_items_y=2, # 2行（A-B） + num_items_z=1, # 1层 + dx=10.0, + dy=10.0, + dz=10.0, + item_dx=137.0, + item_dy=96.0, + item_dz=120.0, + category="warehouse", + col_offset=0, + layout="row-major", + ) + +# ================ 配液站相关堆栈 ================ + +def bioyond_warehouse_reagent_stack(name: str) -> WareHouse: + """创建BioYond 试剂堆栈 2x4x1 (2行×4列: A01-A04, B01-B04) + + 使用行优先排序，前端展示为: + A01 | A02 | A03 | A04 + B01 | B02 | B03 | B04 + """ + return warehouse_factory( + name=name, + num_items_x=4, # 4列 (01-04) + num_items_y=2, # 2行 (A-B) + num_items_z=1, # 1层 + dx=10.0, + dy=10.0, + dz=10.0, + item_dx=147.0, + item_dy=106.0, + item_dz=130.0, + category="warehouse", + col_offset=0, # 从01开始 + layout="row-major", # ⭐ 使用行优先排序: A01,A02,A03,A04, B01,B02,B03,B04 + ) + + # 定义bioyond的堆栈 + +# =================== Other =================== + +def bioyond_warehouse_1x4x2(name: str) -> WareHouse: + """创建BioYond 4x2x1仓库""" + return warehouse_factory( + name=name, + num_items_x=1, + num_items_y=4, + num_items_z=2, + dx=10.0, + dy=10.0, + dz=10.0, + item_dx=137.0, + item_dy=96.0, + item_dz=120.0, + category="warehouse", + removed_positions=None + ) + +def bioyond_warehouse_1x2x2(name: str) -> WareHouse: + """创建BioYond 1x2x2仓库（1列×2行×2层）- 旧版本，已弃用 + + 布局（2层）: + 层1: A01 + B01 + 层2: A02 + B02 + """ + return warehouse_factory( + name=name, + num_items_x=1, + num_items_y=2, + num_items_z=2, + dx=10.0, + dy=10.0, + dz=10.0, + item_dx=137.0, + item_dy=96.0, + item_dz=120.0, + category="warehouse", + layout="row-major", # 使用行优先避免上下颠倒 + ) + +def bioyond_warehouse_2x2x1(name: str) -> WareHouse: + """创建BioYond 2x2x1仓库（2行×2列×1层） + + 布局: + A01 | A02 + B01 | B02 + """ + return warehouse_factory( + name=name, + num_items_x=2, # 2列 + num_items_y=2, # 2行 + num_items_z=1, # 1层 + dx=10.0, + dy=10.0, + dz=10.0, + item_dx=137.0, + item_dy=96.0, + item_dz=120.0, + category="warehouse", + layout="row-major", # 使用行优先避免上下颠倒 + ) + + +def bioyond_warehouse_10x1x1(name: str) -> WareHouse: + """创建BioYond 10x1x1仓库""" + return warehouse_factory( + name=name, + num_items_x=10, + num_items_y=1, + num_items_z=1, + dx=10.0, + dy=10.0, + dz=10.0, + item_dx=137.0, + item_dy=96.0, + item_dz=120.0, + category="warehouse", + ) + +def bioyond_warehouse_1x3x3(name: str) -> WareHouse: + """创建BioYond 1x3x3仓库""" + return warehouse_factory( + name=name, + num_items_x=1, + num_items_y=3, + num_items_z=3, + dx=10.0, + dy=10.0, + dz=10.0, + item_dx=137.0, + item_dy=120.0, # 增大Y方向间距以避免重叠 + item_dz=120.0, + category="warehouse", + ) + +def bioyond_warehouse_5x3x1(name: str, row_offset: int = 0) -> WareHouse: + """创建BioYond 5x3x1仓库（5行×3列×1层） + + 标准布局（row_offset=0）: + A01 | A02 | A03 + B01 | B02 | B03 + C01 | C02 | C03 + D01 | D02 | D03 + E01 | E02 | E03 + + 带偏移布局（row_offset=5）: + F01 | F02 | F03 + G01 | G02 | G03 + H01 | H02 | H03 + I01 | I02 | I03 + J01 | J02 | J03 + """ + return warehouse_factory( + name=name, + num_items_x=3, # 3列 + num_items_y=5, # 5行 + num_items_z=1, # 1层 + dx=10.0, + dy=10.0, + dz=10.0, + item_dx=137.0, + item_dy=120.0, + item_dz=120.0, + category="warehouse", + col_offset=0, + row_offset=row_offset, # 支持行偏移 + layout="row-major", # 使用行优先避免颠倒 + ) + + +def bioyond_warehouse_3x3x1(name: str) -> WareHouse: + """创建BioYond 3x3x1仓库（3行×3列×1层） + + 布局: + A01 | A02 | A03 + B01 | B02 | B03 + C01 | C02 | C03 + """ + return warehouse_factory( + name=name, + num_items_x=3, + num_items_y=3, + num_items_z=1, + dx=10.0, + dy=10.0, + dz=10.0, + item_dx=137.0, + item_dy=96.0, + item_dz=120.0, + category="warehouse", + layout="row-major", # ⭐ 使用行优先避免上下颠倒 + ) +def bioyond_warehouse_2x1x3(name: str) -> WareHouse: + """创建BioYond 2x1x3仓库""" + return warehouse_factory( + name=name, + num_items_x=2, + num_items_y=1, + num_items_z=3, + dx=10.0, + dy=10.0, + dz=10.0, + item_dx=137.0, + item_dy=96.0, + item_dz=120.0, + category="warehouse", + ) + + +def bioyond_warehouse_5x1x1(name: str) -> WareHouse: + """已弃用：创建BioYond 5x1x1仓库""" + return warehouse_factory( + name=name, + num_items_x=5, + num_items_y=1, + num_items_z=1, + dx=10.0, + dy=10.0, + dz=10.0, + item_dx=137.0, + item_dy=96.0, + item_dz=120.0, + category="warehouse", + ) + +def bioyond_warehouse_3x3x1_2(name: str) -> WareHouse: + """已弃用：创建BioYond 3x3x1仓库""" + return warehouse_factory( + name=name, + num_items_x=3, + num_items_y=3, + num_items_z=1, + dx=12.0, + dy=12.0, + dz=12.0, + item_dx=137.0, + item_dy=96.0, + item_dz=120.0, + category="warehouse", + ) + +def bioyond_warehouse_liquid_and_lid_handling(name: str) -> WareHouse: + """创建BioYond开关盖加液模块台面""" + return warehouse_factory( + name=name, + num_items_x=2, + num_items_y=5, + num_items_z=1, + dx=10.0, + dy=10.0, + dz=10.0, + item_dx=137.0, + item_dy=96.0, + item_dz=120.0, + category="warehouse", + removed_positions=None + ) + +def bioyond_warehouse_1x8x4(name: str) -> WareHouse: + """创建BioYond 8x4x1反应站堆栈（A01～D08）""" + return warehouse_factory( + name=name, + num_items_x=8, # 8列（01-08） + num_items_y=4, # 4行（A-D） + num_items_z=1, # 1层 + dx=10.0, + dy=10.0, + dz=10.0, + item_dx=147.0, + item_dy=106.0, + item_dz=130.0, + category="warehouse", + ) diff --git a/unilabos/resources/bioyond/decks.py b/unilabos/resources/bioyond/decks.py index 5572536..03c7d73 100644 --- a/unilabos/resources/bioyond/decks.py +++ b/unilabos/resources/bioyond/decks.py @@ -1,14 +1,16 @@ from os import name from pylabrobot.resources import Deck, Coordinate, Rotation -from unilabos.resources.bioyond.warehouses import ( +from unilabos.resources.bioyond.YB_warehouses import ( bioyond_warehouse_1x4x4, bioyond_warehouse_1x4x4_right, # 新增：右侧仓库 (A05～D08) bioyond_warehouse_1x4x2, bioyond_warehouse_reagent_stack, # 新增：试剂堆栈 (A1-B4) bioyond_warehouse_liquid_and_lid_handling, bioyond_warehouse_1x2x2, + bioyond_warehouse_2x2x1, # 新增：321和43窗口 (2行×2列) bioyond_warehouse_1x3x3, + bioyond_warehouse_5x3x1, # 新增：手动传递窗仓库 (5行×3列) bioyond_warehouse_10x1x1, bioyond_warehouse_3x3x1, bioyond_warehouse_3x3x1_2, @@ -115,10 +117,10 @@ class BIOYOND_YB_Deck(Deck): def setup(self) -> None: # 添加仓库 self.warehouses = { - "321窗口": bioyond_warehouse_1x2x2("321窗口"), - "43窗口": bioyond_warehouse_1x2x2("43窗口"), - "手动传递窗左": bioyond_warehouse_1x3x3("手动传递窗左"), - "手动传递窗右": bioyond_warehouse_1x3x3("手动传递窗右"), + "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("加样头堆栈左"), "加样头堆栈右": bioyond_warehouse_10x1x1("加样头堆栈右"), @@ -126,6 +128,7 @@ class BIOYOND_YB_Deck(Deck): "母液加样右": bioyond_warehouse_3x3x1_2("母液加样右"), "大瓶母液堆栈左": bioyond_warehouse_5x1x1("大瓶母液堆栈左"), "大瓶母液堆栈右": bioyond_warehouse_5x1x1("大瓶母液堆栈右"), + "2号手套箱内部堆栈": bioyond_warehouse_3x3x1("2号手套箱内部堆栈"), # 新增：3行×3列 (A01-C03) } # warehouse 的位置 self.warehouse_locations = { @@ -140,6 +143,7 @@ class BIOYOND_YB_Deck(Deck): "母液加样右": 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(): diff --git a/unilabos/resources/itemized_carrier.py b/unilabos/resources/itemized_carrier.py index a5207d4..90c7ec0 100644 --- a/unilabos/resources/itemized_carrier.py +++ b/unilabos/resources/itemized_carrier.py @@ -29,7 +29,7 @@ class Bottle(Well): size_x: float = 0.0, size_y: float = 0.0, size_z: float = 0.0, - barcode: Optional[str] = "", + barcode: Optional[str] = None, category: str = "container", model: Optional[str] = None, **kwargs, @@ -54,7 +54,6 @@ class Bottle(Well): **super().serialize(), "diameter": self.diameter, "height": self.height, - "barcode": self.barcode, } T = TypeVar("T", bound=ResourceHolder) diff --git a/unilabos/resources/warehouse.py b/unilabos/resources/warehouse.py index 4dcda6d..3dbd6ad 100644 --- a/unilabos/resources/warehouse.py +++ b/unilabos/resources/warehouse.py @@ -27,6 +27,7 @@ def warehouse_factory( category: str = "warehouse", model: Optional[str] = None, col_offset: int = 0, # 列起始偏移量，用于生成A05-D08等命名 + row_offset: int = 0, # 行起始偏移量，用于生成F01-J03等命名 layout: str = "col-major", # 新增：排序方式，"col-major"=列优先，"row-major"=行优先 ): # 创建位置坐标 @@ -65,10 +66,10 @@ def warehouse_factory( if layout == "row-major": # 行优先顺序: A01,A02,A03,A04, B01,B02,B03,B04 # locations[0] 对应 row=0, y最大（前端顶部）→ 应该是 A01 - keys = [f"{LETTERS[j]}{i + 1 + col_offset:02d}" for j in range(len_y) for i in range(len_x)] + keys = [f"{LETTERS[j + row_offset]}{i + 1 + col_offset:02d}" for j in range(len_y) for i in range(len_x)] else: # 列优先顺序: A01,B01,C01,D01, A02,B02,C02,D02 - keys = [f"{LETTERS[j]}{i + 1 + col_offset:02d}" for i in range(len_x) for j in range(len_y)] + keys = [f"{LETTERS[j + row_offset]}{i + 1 + col_offset:02d}" for i in range(len_x) for j in range(len_y)] sites = {i: site for i, site in zip(keys, _sites.values())} diff --git a/unilabos/ros/nodes/presets/host_node.py b/unilabos/ros/nodes/presets/host_node.py index 69c12f8..dffd204 100644 --- a/unilabos/ros/nodes/presets/host_node.py +++ b/unilabos/ros/nodes/presets/host_node.py @@ -736,7 +736,7 @@ class HostNode(BaseROS2DeviceNode): if bCreate: self.lab_logger().trace(f"Status created: {device_id}.{property_name} = {msg.data}") else: - self.lab_logger().debug(f"Status updated: {device_id}.{property_name} = {msg.data}") + self.lab_logger().trace(f"Status updated: {device_id}.{property_name} = {msg.data}") def send_goal( self, diff --git a/unilabos/utils/README_LOGGING.md b/unilabos/utils/README_LOGGING.md new file mode 100644 index 0000000..9cb551b --- /dev/null +++ b/unilabos/utils/README_LOGGING.md @@ -0,0 +1,187 @@ +# UniLabOS 日志配置说明 + +> **文件位置**: `unilabos/utils/log.py` +> **最后更新**: 2026-01-11 +> **维护者**: Uni-Lab-OS 开发团队 + +本文档说明 UniLabOS 日志系统中对第三方库和内部模块的日志级别配置，避免控制台被过多的 DEBUG 日志淹没。 + +--- + +## 📋 已屏蔽的日志 + +以下库/模块的日志已被设置为 **WARNING** 或 **INFO** 级别，不再显示 DEBUG 日志： + +### 1. pymodbus（Modbus 通信库） + +**配置位置**: `log.py` 第196-200行 + +```python +# 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) +``` + +**屏蔽原因**: +- pymodbus 在 DEBUG 级别会输出每一次 Modbus 通信的详细信息 +- 包括 `Processing: 0x5 0x1e 0x0 0x0...` 等原始数据 +- 包括 `decoded PDU function_code(3 sub -1) -> ReadHoldingRegistersResponse(...)` 等解码信息 +- 这些信息对日常使用价值不大，但会快速刷屏 + +**典型被屏蔽的日志**: +``` +[DEBUG] Processing: 0x5 0x1e 0x0 0x0 0x0 0x7 0x1 0x3 0x4 0x0 0x0 0x0 0x0 [handleFrame:72] [pymodbus.logging.base] +[DEBUG] decoded PDU function_code(3 sub -1) -> ReadHoldingRegistersResponse(...) [decode:79] [pymodbus.logging.decoders] +``` + +--- + +### 2. websockets（WebSocket 库） + +**配置位置**: `log.py` 第202-205行 + +```python +# websockets 库的日志输出较多，设置为 WARNING +logging.getLogger('websockets').setLevel(logging.WARNING) +logging.getLogger('websockets.client').setLevel(logging.WARNING) +logging.getLogger('websockets.server').setLevel(logging.WARNING) +``` + +**屏蔽原因**: +- WebSocket 连接、断开、心跳等信息在 DEBUG 级别会频繁输出 +- 对于长时间运行的服务，这些日志意义不大 + +--- + +### 3. ROS Host Node（设备状态更新） + +**配置位置**: `log.py` 第207-208行 + +```python +# ROS 节点的状态更新日志过于频繁，设置为 INFO +logging.getLogger('unilabos.ros.nodes.presets.host_node').setLevel(logging.INFO) +``` + +**屏蔽原因**: +- 设备状态更新（如手套箱压力）每隔几秒就会更新一次 +- DEBUG 日志会记录每一次状态变化，导致日志刷屏 +- 这些频繁的状态更新对调试价值不大 + +**典型被屏蔽的日志**: +``` +[DEBUG] [/devices/host_node] Status updated: BatteryStation.data_glove_box_pressure = 4.229457855224609 [property_callback:666] [unilabos.ros.nodes.presets.host_node] +``` + +--- + +### 4. asyncio 和 urllib3 + +**配置位置**: `log.py` 第224-225行 + +```python +logging.getLogger("asyncio").setLevel(logging.INFO) +logging.getLogger("urllib3").setLevel(logging.INFO) +``` + +**屏蔽原因**: +- asyncio: 异步 IO 的内部调试信息 +- urllib3: HTTP 请求库的连接池、重试等详细信息 + +--- + +## 🔧 如何临时启用这些日志（调试用） + +### 方法1: 修改 log.py（永久启用） + +在 `log.py` 的 `configure_logger()` 函数中，将对应库的日志级别改为 `logging.DEBUG`: + +```python +# 临时启用 pymodbus 的 DEBUG 日志 +logging.getLogger('pymodbus').setLevel(logging.DEBUG) +logging.getLogger('pymodbus.logging').setLevel(logging.DEBUG) +logging.getLogger('pymodbus.logging.base').setLevel(logging.DEBUG) +logging.getLogger('pymodbus.logging.decoders').setLevel(logging.DEBUG) +``` + +### 方法2: 在代码中临时启用（单次调试） + +在需要调试的代码文件中添加： + +```python +import logging + +# 临时启用 pymodbus DEBUG 日志 +logging.getLogger('pymodbus').setLevel(logging.DEBUG) + +# 你的 Modbus 调试代码 +... + +# 调试完成后恢复 +logging.getLogger('pymodbus').setLevel(logging.WARNING) +``` + +### 方法3: 使用环境变量或配置文件（推荐） + +未来可以考虑在启动参数中添加 `--debug-modbus` 等选项来动态控制。 + +--- + +## 📊 日志级别说明 + +| 级别 | 数值 | 用途 | 是否显示 | +|------|------|------|---------| +| TRACE | 5 | 最详细的跟踪信息 | ✅ | +| DEBUG | 10 | 调试信息 | ✅ | +| INFO | 20 | 一般信息 | ✅ | +| WARNING | 30 | 警告信息 | ✅ | +| ERROR | 40 | 错误信息 | ✅ | +| CRITICAL | 50 | 严重错误 | ✅ | + +**当前配置**: +- UniLabOS 自身代码: DEBUG 及以上全部显示 +- pymodbus/websockets: **WARNING** 及以上显示（屏蔽 DEBUG/INFO） +- ROS host_node: **INFO** 及以上显示（屏蔽 DEBUG） + +--- + +## ⚠️ 重要提示 + +### 修改生效时间 +- 修改 `log.py` 后需要 **重启 unilab 服务** 才能生效 +- 不需要重新安装或重新编译 + +### 调试 Modbus 通信问题 +如果需要调试 Modbus 通信故障，应该： +1. 临时启用 pymodbus DEBUG 日志（方法2） +2. 复现问题 +3. 查看详细的通信日志 +4. 调试完成后记得恢复 WARNING 级别 + +### 调试设备状态问题 +如果需要调试设备状态更新问题： +```python +logging.getLogger('unilabos.ros.nodes.presets.host_node').setLevel(logging.DEBUG) +``` + +--- + +## 📝 维护记录 + +| 日期 | 修改内容 | 操作人 | +|------|---------|--------| +| 2026-01-11 | 初始创建，添加 pymodbus、websockets、ROS host_node 屏蔽 | - | +| 2026-01-07 | 添加 pymodbus 和 websockets 屏蔽（log-0107.py） | - | + +--- + +## 🔗 相关文件 + +- `log.py` - 日志配置主文件 +- `unilabos/devices/workstation/coin_cell_assembly/` - 使用 Modbus 的扣电工作站代码 +- `unilabos/ros/nodes/presets/host_node.py` - ROS 主机节点代码 + +--- + +**维护提示**: 如果添加了新的第三方库或发现新的日志刷屏问题，请在此文档中记录并更新 `log.py` 配置。 diff --git a/unilabos/utils/log.py b/unilabos/utils/log.py index ffe13c0..f10bd51 100644 --- a/unilabos/utils/log.py +++ b/unilabos/utils/log.py @@ -191,6 +191,21 @@ 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) # 如果指定了工作目录，添加文件处理器 if working_dir is not None: @@ -215,6 +230,7 @@ def configure_logger(loglevel=None, working_dir=None): logging.getLogger("urllib3").setLevel(logging.INFO) + # 配置日志系统 configure_logger() diff --git a/yibin_electrolyte_config_example.json b/yibin_electrolyte_config_example.json new file mode 100644 index 0000000..d5efc35 --- /dev/null +++ b/yibin_electrolyte_config_example.json @@ -0,0 +1,126 @@ +{ + "nodes": [ + { + "id": "bioyond_cell_workstation", + "name": "配液分液工站 (示例)", + "parent": null, + "children": [ + "YB_Bioyond_Deck" + ], + "type": "device", + "class": "bioyond_cell", + "config": { + "deck": { + "data": { + "_resource_child_name": "YB_Bioyond_Deck", + "_resource_type": "unilabos.resources.bioyond.decks:BIOYOND_YB_Deck" + } + }, + "protocol_type": [], + "bioyond_config": { + "api_host": "http://YOUR_API_HOST:PORT", + "api_key": "YOUR_API_KEY", + "timeout": 30, + "report_token": "YOUR_REPORT_TOKEN", + "HTTP_host": "YOUR_LOCAL_IP", + "HTTP_port": 8080, + "debug_mode": false, + "material_type_mappings": { + "100ml液体": [ + "YB_100ml_yeti", + "00000000-0000-0000-0000-000000000000" + ], + "液": [ + "YB_ye", + "00000000-0000-0000-0000-000000000000" + ], + "高粘液": [ + "YB_gaonianye", + "00000000-0000-0000-0000-000000000000" + ], + "加样头(大)": [ + "YB_jia_yang_tou_da_Carrier", + "00000000-0000-0000-0000-000000000000" + ], + "5ml分液瓶板": [ + "YB_5ml_fenyepingban", + "00000000-0000-0000-0000-000000000000" + ], + "5ml分液瓶": [ + "YB_5ml_fenyeping", + "00000000-0000-0000-0000-000000000000" + ], + "20ml分液瓶板": [ + "YB_20ml_fenyepingban", + "00000000-0000-0000-0000-000000000000" + ], + "20ml分液瓶": [ + "YB_20ml_fenyeping", + "00000000-0000-0000-0000-000000000000" + ], + "配液瓶(小)板": [ + "YB_peiyepingxiaoban", + "00000000-0000-0000-0000-000000000000" + ], + "配液瓶(小)": [ + "YB_pei_ye_xiao_Bottle", + "00000000-0000-0000-0000-000000000000" + ], + "枪头盒": [ + "YB_qiang_tou_he", + "00000000-0000-0000-0000-000000000000" + ] + }, + "warehouse_mapping": { + "示例堆栈": { + "uuid": "00000000-0000-0000-0000-000000000000", + "site_uuids": { + "A01": "00000000-0000-0000-0000-000000000000", + "B01": "00000000-0000-0000-0000-000000000000" + } + } + }, + "solid_liquid_mappings": { + "示例物料": { + "typeId": "00000000-0000-0000-0000-000000000000", + "code": "", + "barCode": "", + "name": "Example_Material", + "unit": "g", + "parameters": "", + "quantity": "2", + "warningQuantity": "1", + "details": [] + } + } + } + }, + "data": {} + }, + { + "id": "YB_Bioyond_Deck", + "name": "YB_Bioyond_Deck", + "children": [], + "parent": "bioyond_cell_workstation", + "type": "deck", + "class": "BIOYOND_YB_Deck", + "position": { + "x": 0, + "y": 0, + "z": 0 + }, + "config": { + "type": "BIOYOND_YB_Deck", + "setup": true, + "rotation": { + "x": 0, + "y": 0, + "z": 0, + "type": "Rotation" + } + }, + "data": {} + } + ], + "links": [] +} \ No newline at end of file