update version to 0.10.12

print all logs to file
fix resource dict dump error

README.md

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

README_zh.md

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

docs/user_guide/installation.md

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

new_cellconfig.json

@@ -1,54 +0,0 @@
-{
-  "nodes": [
-    {
-      "id": "BatteryStation",
-      "name": "扣电工作站",
-      "parent": null,
-      "children": [
-        "coin_cell_deck"
-      ],
-      "type": "device",
-      "class":"coincellassemblyworkstation_device",
-      "position": {
-        "x": 0,
-        "y": 0,
-        "z": 0
-      },
-      "config": {
-        "deck": {
-          "data": {
-            "_resource_child_name": "YB_YH_Deck",
-            "_resource_type": "unilabos.devices.workstation.coin_cell_assembly.YB_YH_materials:CoincellDeck"
-          }
-        },
-        "debug_mode": true,
-        "protocol_type": []
-      }
-    },
-    {
-      "id": "YB_YH_Deck",
-      "name": "YB_YH_Deck",
-      "children": [],
-      "parent": "BatteryStation",
-      "type": "deck",
-      "class": "CoincellDeck",
-      "position": {
-        "x": 0,
-        "y": 0,
-        "z": 0
-      },
-      "config": {
-        "type": "CoincellDeck",
-        "setup": true,
-        "rotation": {
-          "x": 0,
-          "y": 0,
-          "z": 0,
-          "type": "Rotation"
-        }
-      },
-      "data": {}
-    }
-  ],
-  "links": []
-}

new_cellconfig3c.json

@@ -1,95 +0,0 @@
-{
-  "nodes": [
-    {
-      "id": "bioyond_cell_workstation",
-      "name": "配液分液工站",
-      "parent": null,
-      "children": [
-        "YB_Bioyond_Deck"
-      ],
-      "type": "device",
-      "class": "bioyond_cell",
-      "config": {
-        "deck": {
-          "data": {
-            "_resource_child_name": "YB_Bioyond_Deck",
-            "_resource_type": "unilabos.resources.bioyond.decks:BIOYOND_YB_Deck"
-          }
-        },
-        "protocol_type": []
-      },
-      "data": {}
-    },
-    {
-      "id": "YB_Bioyond_Deck",
-      "name": "YB_Bioyond_Deck",
-      "children": [],
-      "parent": "bioyond_cell_workstation",
-      "type": "deck",
-      "class": "BIOYOND_YB_Deck",
-      "position": {
-        "x": 0,
-        "y": 0,
-        "z": 0
-      },
-      "config": {
-        "type": "BIOYOND_YB_Deck",
-        "setup": true,
-        "rotation": {
-          "x": 0,
-          "y": 0,
-          "z": 0,
-          "type": "Rotation"
-        }
-      },
-      "data": {}
-    },
-    {
-      "id": "BatteryStation",
-      "name": "扣电工作站",
-      "parent": null,
-      "children": [
-        "coin_cell_deck"
-      ],
-      "type": "device",
-      "class":"coincellassemblyworkstation_device",
-      "config": {
-        "deck": {
-          "data": {
-            "_resource_child_name": "YB_YH_Deck",
-            "_resource_type": "unilabos.devices.workstation.coin_cell_assembly.YB_YH_materials:CoincellDeck"
-          }
-        },
-        "protocol_type": []
-      },
-      "position": {
-        "size": {"height": 1450, "width": 1450, "depth": 2100},
-        "position": {
-          "x": -1500,
-          "y": 0,
-          "z": 0
-        }
-      }
-    },
-    {
-      "id": "YB_YH_Deck",
-      "name": "YB_YH_Deck",
-      "children": [],
-      "parent": "BatteryStation",
-      "type": "deck",
-      "class": "CoincellDeck",
-      "config": {
-        "type": "CoincellDeck",
-        "setup": true,
-        "rotation": {
-          "x": 0,
-          "y": 0,
-          "z": 0,
-          "type": "Rotation"
-        }
-      },
-      "data": {}
-    }
-  ],
-  "links": []
-}

scripts/workflow.py

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

test/experiments/reaction_station_bioyond.json

@@ -1,72 +0,0 @@
-{
-    "nodes": [
-        {
-            "id": "reaction_station_bioyond",
-            "name": "reaction_station_bioyond",
-            "parent": null,
-            "children": [
-                "Bioyond_Deck"
-            ],
-            "type": "device",
-            "class": "reaction_station.bioyond",
-            "config": {
-                "config": {
-                    "api_key": "DE9BDDA0",
-                    "api_host": "http://192.168.1.200:44402",
-                    "workflow_mappings": {
-                        "reactor_taken_out": "3a16081e-4788-ca37-eff4-ceed8d7019d1",
-                        "reactor_taken_in": "3a160df6-76b3-0957-9eb0-cb496d5721c6",
-                        "Solid_feeding_vials": "3a160877-87e7-7699-7bc6-ec72b05eb5e6",
-                        "Liquid_feeding_vials(non-titration)": "3a167d99-6158-c6f0-15b5-eb030f7d8e47",
-                        "Liquid_feeding_solvents": "3a160824-0665-01ed-285a-51ef817a9046",
-                        "Liquid_feeding(titration)": "3a16082a-96ac-0449-446a-4ed39f3365b6",
-                        "liquid_feeding_beaker": "3a16087e-124f-8ddb-8ec1-c2dff09ca784",
-                        "Drip_back": "3a162cf9-6aac-565a-ddd7-682ba1796a4a"
-                    },
-                    "material_type_mappings": {
-                        "烧杯": ["YB_1FlaskCarrier", "3a14196b-24f2-ca49-9081-0cab8021bf1a"],
-                        "试剂瓶": ["YB_1BottleCarrier", ""],
-                        "样品板": ["YB_6StockCarrier", "3a14196e-b7a0-a5da-1931-35f3000281e9"],
-                        "分装板": ["YB_6VialCarrier", "3a14196e-5dfe-6e21-0c79-fe2036d052c4"],
-                        "样品瓶": ["YB_Solid_Stock", "3a14196a-cf7d-8aea-48d8-b9662c7dba94"],
-                        "90%分装小瓶": ["YB_Solid_Vial", "3a14196c-cdcf-088d-dc7d-5cf38f0ad9ea"],
-                        "10%分装小瓶": ["YB_Liquid_Vial", "3a14196c-76be-2279-4e22-7310d69aed68"]
-                    }
-                },
-                "deck": {
-                    "data": {
-                        "_resource_child_name": "Bioyond_Deck",
-                        "_resource_type": "unilabos.resources.bioyond.decks:BIOYOND_PolymerReactionStation_Deck"
-                    }
-                },
-                "protocol_type": []
-            },
-            "data": {}
-        },
-        {
-            "id": "Bioyond_Deck",
-            "name": "Bioyond_Deck",
-            "children": [
-            ],
-            "parent": "reaction_station_bioyond",
-            "type": "deck",
-            "class": "BIOYOND_PolymerReactionStation_Deck",
-            "position": {
-                "x": 0,
-                "y": 0,
-                "z": 0
-            },
-            "config": {
-                "type": "BIOYOND_PolymerReactionStation_Deck",
-                "setup": true,
-                "rotation": {
-                    "x": 0,
-                    "y": 0,
-                    "z": 0,
-                    "type": "Rotation"
-                }
-            },
-            "data": {}
-        }
-    ]
-}

test/resources/YB_materials_info.json

@@ -1,52 +0,0 @@
-[
-    {
-        "id": "3a1d377b-299d-d0f2-ced9-48257f60dfad",
-        "typeName": "加样头(大)",
-        "code": "0005-00145",
-        "barCode": "",
-        "name": "LiDFOB",
-        "quantity": 9999.0,
-        "lockQuantity": 0.0,
-        "unit": "个",
-        "status": 1,
-        "isUse": false,
-        "locations": [
-            {
-                "id": "3a19da56-1379-ff7c-1745-07e200b44ce2",
-                "whid": "3a19da56-1378-613b-29f2-871e1a287aa5",
-                "whName": "粉末加样头堆栈",
-                "code": "0005-0001",
-                "x": 1,
-                "y": 1,
-                "z": 1,
-                "quantity": 0
-            }
-        ],
-        "detail": []
-    },
-    {
-        "id": "3a1d377b-6a81-6a7e-147c-f89f6463656d",
-        "typeName": "液",
-        "code": "0006-00141",
-        "barCode": "",
-        "name": "EMC",
-        "quantity": 99999.0,
-        "lockQuantity": 0.0,
-        "unit": "g",
-        "status": 1,
-        "isUse": false,
-        "locations": [
-            {
-                "id": "3a1baa20-a7b1-c665-8b9c-d8099d07d2f6",
-                "whid": "3a1baa20-a7b0-5c19-8844-5de8924d4e78",
-                "whName": "4号手套箱内部堆栈",
-                "code": "0015-0001",
-                "x": 1,
-                "y": 1,
-                "z": 1,
-                "quantity": 0
-            }
-        ],
-        "detail": []
-    }
-]

test/resources/test copy.json

@@ -1,99 +0,0 @@
- {
-        "typeId": "3a190c8b-3284-af78-d29f-9a69463ad047",
-        "code": "",
-        "barCode": "",
-        "name": "test",
-        "unit": "",
-        "parameters": "{}",
-        "quantity": "",
-        "details": [
-            {
-                "typeId": "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb",
-                "code": "",
-                "name": "配液瓶(小)11",
-                "quantity": "1",
-                "x": 1,
-                "y": 1,
-                "z": 1,
-                "unit": "",
-                "parameters": "{}"
-            },
-            {
-                "typeId": "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb",
-                "code": "",
-                "name": "配液瓶(小)21",
-                "quantity": "1",
-                "x": 2,
-                "y": 1,
-                "z": 1,
-                "unit": "",
-                "parameters": "{}"
-            },
-            {
-                "typeId": "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb",
-                "code": "",
-                "name": "配液瓶(小)12",
-                "quantity": "1",
-                "x": 1,
-                "y": 2,
-                "z": 1,
-                "unit": "",
-                "parameters": "{}"
-            },
-            {
-                "typeId": "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb",
-                "code": "",
-                "name": "配液瓶(小)22",
-                "quantity": "1",
-                "x": 2,
-                "y": 2,
-                "z": 1,
-                "unit": "",
-                "parameters": "{}"
-            },
-            {
-                "typeId": "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb",
-                "code": "",
-                "name": "配液瓶(小)13",
-                "quantity": "1",
-                "x": 1,
-                "y": 3,
-                "z": 1,
-                "unit": "",
-                "parameters": "{}"
-            },
-            {
-                "typeId": "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb",
-                "code": "",
-                "name": "配液瓶(小)23",
-                "quantity": "1",
-                "x": 2,
-                "y": 3,
-                "z": 1,
-                "unit": "",
-                "parameters": "{}"
-            },
-            {
-                "typeId": "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb",
-                "code": "",
-                "name": "配液瓶(小)14",
-                "quantity": "1",
-                "x": 1,
-                "y": 4,
-                "z": 1,
-                "unit": "",
-                "parameters": "{}"
-            },
-            {
-                "typeId": "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb",
-                "code": "",
-                "name": "配液瓶(小)24",
-                "quantity": "1",
-                "x": 2,
-                "y": 4,
-                "z": 1,
-                "unit": "",
-                "parameters": "{}"
-            }
-        ]
-    }

test/resources/test.json

@@ -1,148 +0,0 @@
-[
-    {
-        "id": "3a1d4c14-a9fb-d7dc-9e96-7a3ad6e50219",
-        "typeName": "配液瓶(小)板",
-        "code": "0001-00093",
-        "barCode": "",
-        "name": "test",
-        "quantity": 2.0,
-        "lockQuantity": 0.0,
-        "unit": "块",
-        "status": 1,
-        "isUse": false,
-        "locations": [
-            {
-                "id": "3a19deae-2c7a-36f5-5e41-02c5b66feaea",
-                "whid": "3a19deae-2c79-05a3-9c76-8e6760424841",
-                "whName": "手动堆栈",
-                "code": "1",
-                "x": 1,
-                "y": 1,
-                "z": 1,
-                "quantity": 0
-            }
-        ],
-        "detail": [
-            {
-                "id": "3a1d4c14-a9fc-1daa-71fa-146cb1ccb930",
-                "detailMaterialId": "3a1d4c14-a9fc-4f38-4c48-68486c391c42",
-                "code": "0001-00093 - 05",
-                "name": "配液瓶(小)",
-                "quantity": "1",
-                "lockQuantity": "0",
-                "unit": "个",
-                "x": 1,
-                "y": 3,
-                "z": 1,
-                "associateId": null,
-                "typeName": "配液瓶(小)",
-                "typeId": "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb"
-            },
-            {
-                "id": "3a1d4c14-a9fc-3659-ea61-cd587da9e131",
-                "detailMaterialId": "3a1d4c14-a9fc-018f-93e5-c49343d37758",
-                "code": "0001-00093 - 08",
-                "name": "配液瓶(小)",
-                "quantity": "1",
-                "lockQuantity": "0",
-                "unit": "个",
-                "x": 2,
-                "y": 4,
-                "z": 1,
-                "associateId": null,
-                "typeName": "配液瓶(小)",
-                "typeId": "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb"
-            },
-            {
-                "id": "3a1d4c14-a9fc-3f94-de83-979d2646e313",
-                "detailMaterialId": "3a1d4c14-a9fc-9987-c0ef-4b7cbad49e6b",
-                "code": "0001-00093 - 01",
-                "name": "配液瓶(小)",
-                "quantity": "1",
-                "lockQuantity": "0",
-                "unit": "个",
-                "x": 1,
-                "y": 1,
-                "z": 1,
-                "associateId": null,
-                "typeName": "配液瓶(小)",
-                "typeId": "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb"
-            },
-            {
-                "id": "3a1d4c14-a9fc-8c35-6b25-913b11dbaf4e",
-                "detailMaterialId": "3a1d4c14-a9fc-9a83-865b-0c26ea5e8cc4",
-                "code": "0001-00093 - 03",
-                "name": "配液瓶(小)",
-                "quantity": "1",
-                "lockQuantity": "0",
-                "unit": "个",
-                "x": 1,
-                "y": 2,
-                "z": 1,
-                "associateId": null,
-                "typeName": "配液瓶(小)",
-                "typeId": "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb"
-            },
-            {
-                "id": "3a1d4c14-a9fc-b41f-e968-64953bfddccd",
-                "detailMaterialId": "3a1d4c14-a9fc-daf7-9d64-e5ec8d3ae0e2",
-                "code": "0001-00093 - 07",
-                "name": "配液瓶(小)",
-                "quantity": "1",
-                "lockQuantity": "0",
-                "unit": "个",
-                "x": 1,
-                "y": 4,
-                "z": 1,
-                "associateId": null,
-                "typeName": "配液瓶(小)",
-                "typeId": "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb"
-            },
-            {
-                "id": "3a1d4c14-a9fc-c20f-c26e-b1bb2cdc3bca",
-                "detailMaterialId": "3a1d4c14-a9fc-673b-ac83-aaaf71287f1f",
-                "code": "0001-00093 - 06",
-                "name": "配液瓶(小)",
-                "quantity": "1",
-                "lockQuantity": "0",
-                "unit": "个",
-                "x": 2,
-                "y": 3,
-                "z": 1,
-                "associateId": null,
-                "typeName": "配液瓶(小)",
-                "typeId": "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb"
-            },
-            {
-                "id": "3a1d4c14-a9fc-cf21-059c-fde361d82b6f",
-                "detailMaterialId": "3a1d4c14-a9fc-25b1-e736-6b0d8dac0fae",
-                "code": "0001-00093 - 02",
-                "name": "配液瓶(小)",
-                "quantity": "1",
-                "lockQuantity": "0",
-                "unit": "个",
-                "x": 2,
-                "y": 1,
-                "z": 1,
-                "associateId": null,
-                "typeName": "配液瓶(小)",
-                "typeId": "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb"
-            },
-            {
-                "id": "3a1d4c14-a9fc-d732-2b93-9b2bd2bf581b",
-                "detailMaterialId": "3a1d4c14-a9fc-7f5d-b6b6-8bcb2e15f320",
-                "code": "0001-00093 - 04",
-                "name": "配液瓶(小)",
-                "quantity": "1",
-                "lockQuantity": "0",
-                "unit": "个",
-                "x": 2,
-                "y": 2,
-                "z": 1,
-                "associateId": null,
-                "typeName": "配液瓶(小)",
-                "typeId": "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb"
-            }
-        ]
-    }
-]

test/workflow/merge_workflow.py

@@ -1,35 +0,0 @@
-import sys
-from datetime import datetime
-from pathlib import Path
-
-ROOT_DIR = Path(__file__).resolve().parents[2]
-if str(ROOT_DIR) not in sys.path:
-    sys.path.insert(0, str(ROOT_DIR))
-
-import pytest
-
-from unilabos.workflow.convert_from_json import (
-    convert_from_json,
-    normalize_steps as _normalize_steps,
-    normalize_labware as _normalize_labware,
-)
-from unilabos.workflow.common import draw_protocol_graph_with_ports
-
-
-@pytest.mark.parametrize(
-    "protocol_name",
-    [
-        "example_bio",
-        # "bioyond_materials_liquidhandling_1",
-        "example_prcxi",
-    ],
-)
-def test_build_protocol_graph(protocol_name):
-    data_path = Path(__file__).with_name(f"{protocol_name}.json")
-
-    graph = convert_from_json(data_path, workstation_name="PRCXi")
-
-    timestamp = datetime.now().strftime("%Y%m%d_%H%M")
-    output_path = data_path.with_name(f"{protocol_name}_graph_{timestamp}.png")
-    draw_protocol_graph_with_ports(graph, str(output_path))
-    print(graph)

unilabos/app/main.py

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

unilabos/app/web/client.py

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

unilabos/app/ws_client.py

@@ -421,7 +421,7 @@ class MessageProcessor:
                     ssl_context = ssl_module.create_default_context()
 
                 ws_logger = logging.getLogger("websockets.client")
-                # 日志级别已在 unilabos.utils.log 中统一配置为 WARNING
+                ws_logger.setLevel(logging.INFO)
 
                 async with websockets.connect(
                     self.websocket_url,
@@ -438,7 +438,7 @@ class MessageProcessor:
                     self.connected = True
                     self.reconnect_count = 0
 
-                    logger.trace(f"[MessageProcessor] Connected to {self.websocket_url}")
+                    logger.info(f"[MessageProcessor] Connected to {self.websocket_url}")
 
                     # 启动发送协程
                     send_task = asyncio.create_task(self._send_handler())
@@ -503,7 +503,7 @@ class MessageProcessor:
 
     async def _send_handler(self):
         """处理发送队列中的消息"""
-        logger.trace("[MessageProcessor] Send handler started")
+        logger.debug("[MessageProcessor] Send handler started")
 
         try:
             while self.connected and self.websocket:
@@ -965,7 +965,7 @@ class QueueProcessor:
 
     def _run(self):
         """运行队列处理主循环"""
-        logger.trace("[QueueProcessor] Queue processor started")
+        logger.debug("[QueueProcessor] Queue processor started")
 
         while self.is_running:
             try:
@@ -1175,6 +1175,7 @@ class WebSocketClient(BaseCommunicationClient):
         else:
             url = f"{scheme}://{parsed.netloc}/api/v1/ws/schedule"
 
+        logger.debug(f"[WebSocketClient] URL: {url}")
         return url
 
     def start(self) -> None:
@@ -1187,11 +1188,13 @@ class WebSocketClient(BaseCommunicationClient):
             logger.error("[WebSocketClient] WebSocket URL not configured")
             return
 
+        logger.info(f"[WebSocketClient] Starting connection to {self.websocket_url}")
+
         # 启动两个核心线程
         self.message_processor.start()
         self.queue_processor.start()
 
-        logger.trace("[WebSocketClient] All threads started")
+        logger.info("[WebSocketClient] All threads started")
 
     def stop(self) -> None:
         """停止WebSocket客户端"""
@@ -1240,7 +1243,7 @@ class WebSocketClient(BaseCommunicationClient):
             },
         }
         self.message_processor.send_message(message)
-        logger.trace(f"[WebSocketClient] Device status published: {device_id}.{property_name}")
+        logger.debug(f"[WebSocketClient] Device status published: {device_id}.{property_name}")
 
     def publish_job_status(
         self, feedback_data: dict, item: QueueItem, status: str, return_info: Optional[dict] = None

unilabos/config/config.py

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

unilabos/devices/electrolysis_water_platfrom/electrolysis_water_platfrom.py

@@ -1,296 +0,0 @@
-# -*- coding: utf-8 -*-
-import serial
-import time
-import csv
-import threading
-import os
-from collections import deque
-from typing import Dict, Any, Optional
-from pylabrobot.resources import Deck
-
-from unilabos.devices.workstation.workstation_base import WorkstationBase
-
-
-class ElectrolysisWaterPlatform(WorkstationBase):
-    """
-    电解水平台工作站
-    基于 WorkstationBase 的电解水实验平台，支持串口通信和数据采集
-    """
-    
-    def __init__(
-        self, 
-        deck: Deck,
-        port: str = "COM10",
-        baudrate: int = 115200,
-        csv_path: Optional[str] = None,
-        timeout: float = 0.2,
-        **kwargs
-    ):
-        super().__init__(deck, **kwargs)
-        
-        # ========== 配置 ==========
-        self.port = port
-        self.baudrate = baudrate
-        # 如果没有指定路径，默认保存在代码文件所在目录
-        if csv_path is None:
-            current_dir = os.path.dirname(os.path.abspath(__file__))
-            self.csv_path = os.path.join(current_dir, "stm32_data.csv")
-        else:
-            self.csv_path = csv_path
-        self.ser_timeout = timeout
-        self.chunk_read = 128
-        
-        # 串口对象
-        self.ser: Optional[serial.Serial] = None
-        self.stop_flag = False
-        
-        # 线程对象
-        self.rx_thread: Optional[threading.Thread] = None
-        self.tx_thread: Optional[threading.Thread] = None
-        
-        # ==== 接收（下位机->上位机）：固定 1+13+1 = 15 字节 ====
-        self.RX_HEAD = 0x3E
-        self.RX_TAIL = 0x3E
-        self.RX_FRAME_LEN = 1 + 13 + 1  # 15
-        
-        # ==== 发送（上位机->下位机）：固定 1+9+1 = 11 字节 ====
-        self.TX_HEAD = 0x3E
-        self.TX_TAIL = 0xE3  # 协议图中标注 E3 作为帧尾
-        self.TX_FRAME_LEN = 1 + 9 + 1  # 11
-    
-    def open_serial(self, port: Optional[str] = None, baudrate: Optional[int] = None, timeout: Optional[float] = None) -> Optional[serial.Serial]:
-        """打开串口"""
-        port = port or self.port
-        baudrate = baudrate or self.baudrate
-        timeout = timeout or self.ser_timeout
-        try:
-            ser = serial.Serial(port, baudrate, timeout=timeout)
-            print(f"[OK] 串口 {port} 已打开，波特率 {baudrate}")
-            ser.reset_input_buffer()
-            ser.reset_output_buffer()
-            self.ser = ser
-            return ser
-        except serial.SerialException as e:
-            print(f"[ERR] 无法打开串口 {port}: {e}")
-            return None
-
-    def close_serial(self):
-        """关闭串口"""
-        if self.ser and self.ser.is_open:
-            self.ser.close()
-            print("[INFO] 串口已关闭")
-
-    @staticmethod
-    def u16_be(h: int, l: int) -> int:
-        """将两个字节组合成16位无符号整数（大端序）"""
-        return ((h & 0xFF) << 8) | (l & 0xFF)
-
-    @staticmethod
-    def split_u16_be(val: int) -> tuple:
-        """返回 (高字节, 低字节)，输入会夹到 0..65535"""
-        v = int(max(0, min(65535, int(val))))
-        return (v >> 8) & 0xFF, v & 0xFF
-
-    # ================== 接收：固定15字节 ==================
-    def parse_rx_payload(self, dat13: bytes) -> Optional[Dict[str, Any]]:
-        """解析 13 字节数据区（下位机发送到上位机）"""
-        if len(dat13) != 13:
-            return None
-        current_mA      = self.u16_be(dat13[0], dat13[1])
-        voltage_mV      = self.u16_be(dat13[2], dat13[3])
-        temperature_raw = self.u16_be(dat13[4], dat13[5])
-        tds_ppm         = self.u16_be(dat13[6], dat13[7])
-        gas_sccm        = self.u16_be(dat13[8], dat13[9])
-        liquid_mL       = self.u16_be(dat13[10], dat13[11])
-        ph_raw          = dat13[12] & 0xFF
-
-        return {
-            "Current_mA": current_mA,
-            "Voltage_mV": voltage_mV,
-            "Temperature_C": round(temperature_raw / 100.0, 2),
-            "TDS_ppm": tds_ppm,
-            "GasFlow_sccm": gas_sccm,
-            "LiquidFlow_mL": liquid_mL,
-            "pH": round(ph_raw / 10.0, 2)
-        }
-
-    def try_parse_rx_frame(self, frame15: bytes) -> Optional[Dict[str, Any]]:
-        """尝试解析接收帧"""
-        if len(frame15) != self.RX_FRAME_LEN:
-            return None
-        if frame15[0] != self.RX_HEAD or frame15[-1] != self.RX_TAIL:
-            return None
-        return self.parse_rx_payload(frame15[1:-1])
-
-    def rx_thread_fn(self):
-        """接收线程函数"""
-        headers = ["Timestamp", "Current_mA", "Voltage_mV",
-                   "Temperature_C", "TDS_ppm", "GasFlow_sccm", "LiquidFlow_mL", "pH"]
-
-        new_file = not os.path.exists(self.csv_path)
-        f = open(self.csv_path, mode='a', newline='', encoding='utf-8')
-        writer = csv.writer(f)
-        if new_file:
-            writer.writerow(headers)
-            f.flush()
-
-        buf = deque(maxlen=8192)
-        print(f"[RX] 开始接收（帧长 {self.RX_FRAME_LEN} 字节）；写入：{self.csv_path}")
-
-        try:
-            while not self.stop_flag and self.ser and self.ser.is_open:
-                chunk = self.ser.read(self.chunk_read)
-                if chunk:
-                    buf.extend(chunk)
-                    while True:
-                        # 找帧头
-                        try:
-                            start = next(i for i, b in enumerate(buf) if b == self.RX_HEAD)
-                        except StopIteration:
-                            buf.clear()
-                            break
-                        if start > 0:
-                            for _ in range(start):
-                                buf.popleft()
-                        if len(buf) < self.RX_FRAME_LEN:
-                            break
-                        candidate = bytes([buf[i] for i in range(self.RX_FRAME_LEN)])
-                        if candidate[-1] == self.RX_TAIL:
-                            parsed = self.try_parse_rx_frame(candidate)
-                            for _ in range(self.RX_FRAME_LEN):
-                                buf.popleft()
-                            if parsed:
-                                ts = time.strftime("%Y-%m-%d %H:%M:%S")
-                                row = [ts,
-                                       parsed["Current_mA"], parsed["Voltage_mV"],
-                                       parsed["Temperature_C"], parsed["TDS_ppm"],
-                                       parsed["GasFlow_sccm"], parsed["LiquidFlow_mL"],
-                                       parsed["pH"]]
-                                writer.writerow(row)
-                                f.flush()
-                                # 若不想打印可注释下一行
-                                # print(f"[{ts}] I={parsed['Current_mA']} mA, V={parsed['Voltage_mV']} mV, "
-                                #       f"T={parsed['Temperature_C']} °C, TDS={parsed['TDS_ppm']}, "
-                                #       f"Gas={parsed['GasFlow_sccm']} sccm, Liq={parsed['LiquidFlow_mL']} mL, pH={parsed['pH']}")
-                        else:
-                            # 头不变，尾不对，丢1字节继续对齐
-                            buf.popleft()
-                else:
-                    time.sleep(0.01)
-        finally:
-            f.close()
-            print("[RX] 接收线程退出，CSV 已关闭")
-
-    # ================== 发送：固定11字节 ==================
-    def build_tx_frame(self, mode: int, current_ma: int, voltage_mv: int, temp_c: float, ki: float, pump_percent: float) -> bytes:
-        """
-        发送帧：HEAD + [mode, I_hi, I_lo, V_hi, V_lo, T_hi, T_lo, Ki_byte, Pump_byte] + TAIL
-        - mode: 0=恒压, 1=恒流
-        - current_ma: mA (0..65535)
-        - voltage_mv: mV (0..65535)
-        - temp_c: ℃，将 *100 后拆分为高/低字节
-        - ki: 0.0..20.0  -> byte = round(ki * 10) 夹到 0..200
-        - pump_percent: 0..100 -> byte = round(pump * 2) 夹到 0..200
-        """
-        mode_b = 1 if int(mode) == 1 else 0
-
-        i_hi, i_lo = self.split_u16_be(current_ma)
-        v_hi, v_lo = self.split_u16_be(voltage_mv)
-
-        t100 = int(round(float(temp_c) * 100.0))
-        t_hi, t_lo = self.split_u16_be(t100)
-
-        ki_b = int(max(0, min(200, round(float(ki) * 10))))
-        pump_b = int(max(0, min(200, round(float(pump_percent) * 2))))
-
-        return bytes((
-            self.TX_HEAD,
-            mode_b,
-            i_hi, i_lo,
-            v_hi, v_lo,
-            t_hi, t_lo,
-            ki_b,
-            pump_b,
-            self.TX_TAIL
-        ))
-
-    def tx_thread_fn(self):
-        """
-        发送线程函数
-        用户输入 6 个用逗号分隔的数值：
-        mode,current_mA,voltage_mV,set_temp_C,Ki,pump_percent
-        例如： 0,1000,500,0,0,50
-        """
-        print("\n输入 6 个值（用英文逗号分隔），顺序为：")
-        print("mode,current_mA,voltage_mV,set_temp_C,Ki,pump_percent")
-        print("示例恒压：0,500,1000,25,0,100   （stop 结束）\n")
-        print("示例恒流：1,1000,500,25,0,100   （stop 结束）\n")
-        print("示例恒流：1,2000,500,25,0,100   （stop 结束）\n")
-        # 1,2000,500,25,0,100
-
-        while not self.stop_flag and self.ser and self.ser.is_open:
-            try:
-                line = input(">>> ").strip()
-            except EOFError:
-                self.stop_flag = True
-                break
-
-            if not line:
-                continue
-            if line.lower() == "stop":
-                self.stop_flag = True
-                print("[SYS] 停止程序")
-                break
-
-            try:
-                parts = [p.strip() for p in line.split(",")]
-                if len(parts) != 6:
-                    raise ValueError("需要 6 个逗号分隔的数值")
-                mode = int(parts[0])
-                i_ma = int(float(parts[1]))
-                v_mv = int(float(parts[2]))
-                t_c  = float(parts[3])
-                ki   = float(parts[4])
-                pump = float(parts[5])
-
-                frame = self.build_tx_frame(mode, i_ma, v_mv, t_c, ki, pump)
-                self.ser.write(frame)
-                print("[TX]", " ".join(f"{b:02X}" for b in frame))
-            except Exception as e:
-                print("[TX] 输入/打包失败：", e)
-                print("格式：mode,current_mA,voltage_mV,set_temp_C,Ki,pump_percent")
-                continue
-    
-    def start(self):
-        """启动电解水平台"""
-        self.ser = self.open_serial()
-        if self.ser:
-            try:
-                self.rx_thread = threading.Thread(target=self.rx_thread_fn, daemon=True)
-                self.tx_thread = threading.Thread(target=self.tx_thread_fn, daemon=True)
-                self.rx_thread.start()
-                self.tx_thread.start()
-                print("[INFO] 电解水平台已启动")
-                self.tx_thread.join()  # 等待用户输入线程结束（输入 stop）
-            finally:
-                self.close_serial()
-    
-    def stop(self):
-        """停止电解水平台"""
-        self.stop_flag = True
-        if self.rx_thread and self.rx_thread.is_alive():
-            self.rx_thread.join(timeout=2.0)
-        if self.tx_thread and self.tx_thread.is_alive():
-            self.tx_thread.join(timeout=2.0)
-        self.close_serial()
-        print("[INFO] 电解水平台已停止")
-
-
-# ================== 主入口 ==================
-if __name__ == "__main__":
-    # 创建一个简单的 Deck 用于测试
-    from pylabrobot.resources import Deck
-    
-    deck = Deck()
-    platform = ElectrolysisWaterPlatform(deck)
-    platform.start()

unilabos/devices/liquid_handling/liquid_handler_abstract.py

@@ -988,18 +988,6 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
                 dis_vols = [float(dis_vols)]
             else:
                 dis_vols = [float(v) for v in dis_vols]
-
-        # 统一混合次数为标量，防止数组/列表与 int 比较时报错
-        if mix_times is not None and not isinstance(mix_times, (int, float)):
-            try:
-                mix_times = mix_times[0] if len(mix_times) > 0 else None
-            except Exception:
-                try:
-                    mix_times = next(iter(mix_times))
-                except Exception:
-                    pass
-        if mix_times is not None:
-            mix_times = int(mix_times)
             
             # 识别传输模式
             num_sources = len(sources)

unilabos/devices/liquid_handling/prcxi/prcxi.py

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

unilabos/devices/separator/chinwe.py

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

unilabos/devices/workstation/bioyond_studio/bioyond_cell/solid_materials.csv

@@ -1,7 +0,0 @@
-material_name
-LiPF6
-LiDFOB
-DTD
-LiFSI
-LiPO2F2
-

unilabos/devices/workstation/bioyond_studio/bioyond_rpc.py

@@ -47,8 +47,8 @@ class BioyondV1RPC(BaseRequest):
         super().__init__()
         print("开始初始化 BioyondV1RPC")
         self.config = config
-        self.api_key = config.get("api_key", "")
-        self.host = config.get("api_host", "") or config.get("base_url", "")
+        self.api_key = config["api_key"]
+        self.host = config["api_host"]
         self._logger = SimpleLogger()
         self.material_cache = {}
         self._load_material_cache()
@@ -61,7 +61,7 @@ class BioyondV1RPC(BaseRequest):
 
         :return: 当前时间的 ISO 8601 格式字符串
         """
-        current_time = datetime.now().isoformat(
+        current_time = datetime.now(timezone.utc).isoformat(
             timespec='milliseconds'
         )
         # 替换时区部分为 'Z'
@@ -192,6 +192,23 @@ class BioyondV1RPC(BaseRequest):
             return []
         return str(response.get("data", {}))
 
+    def material_type_list(self) -> list:
+        """查询物料类型列表
+
+        返回值:
+            list: 物料类型数组，失败返回空列表
+        """
+        response = self.post(
+            url=f'{self.host}/api/lims/storage/material-type-list',
+            params={
+                "apiKey": self.api_key,
+                "requestTime": self.get_current_time_iso8601(),
+                "data": {},
+            })
+        if not response or response['code'] != 1:
+            return []
+        return response.get("data", [])
+
     def material_inbound(self, material_id: str, location_id: str) -> dict:
         """
             描述：指定库位入库一个物料
@@ -212,8 +229,34 @@ class BioyondV1RPC(BaseRequest):
             })
 
         if not response or response['code'] != 1:
+            if response:
+                error_msg = response.get('message', '未知错误')
+                print(f"[ERROR] 物料入库失败: code={response.get('code')}, message={error_msg}")
+            else:
+                print(f"[ERROR] 物料入库失败: API 无响应")
             return {}
-        return response.get("data", {})
+        # 入库成功时，即使没有 data 字段，也返回成功标识
+        return response.get("data") or {"success": True}
+
+    def batch_inbound(self, inbound_items: List[Dict[str, Any]]) -> int:
+        """批量入库物料
+
+        参数:
+            inbound_items: 入库条目列表，每项包含 materialId/locationId/quantity 等
+
+        返回值:
+            int: 成功返回1，失败返回0
+        """
+        response = self.post(
+            url=f'{self.host}/api/lims/storage/batch-inbound',
+            params={
+                "apiKey": self.api_key,
+                "requestTime": self.get_current_time_iso8601(),
+                "data": inbound_items,
+            })
+        if not response or response['code'] != 1:
+            return 0
+        return response.get("code", 0)
 
     def delete_material(self, material_id: str) -> dict:
         """
@@ -233,7 +276,7 @@ class BioyondV1RPC(BaseRequest):
         return response.get("data", {})
 
     def material_outbound(self, material_id: str, location_name: str, quantity: int) -> dict:
-        """指定库位出库物料"""
+        """指定库位出库物料（通过库位名称）"""
         location_id = LOCATION_MAPPING.get(location_name, location_name)
 
         params = {
@@ -251,9 +294,98 @@ class BioyondV1RPC(BaseRequest):
             })
 
         if not response or response['code'] != 1:
-            return {}
+            return None
         return response
 
+    def material_outbound_by_id(self, material_id: str, location_id: str, quantity: int) -> dict:
+        """指定库位出库物料（直接使用location_id）
+
+        Args:
+            material_id: 物料ID
+            location_id: 库位ID（不是库位名称，是UUID）
+            quantity: 数量
+
+        Returns:
+            dict: API响应，失败返回None
+        """
+        params = {
+            "materialId": material_id,
+            "locationId": location_id,
+            "quantity": quantity
+        }
+
+        response = self.post(
+            url=f'{self.host}/api/lims/storage/outbound',
+            params={
+                "apiKey": self.api_key,
+                "requestTime": self.get_current_time_iso8601(),
+                "data": params
+            })
+
+        if not response or response['code'] != 1:
+            return None
+        return response
+
+    def batch_outbound(self, outbound_items: List[Dict[str, Any]]) -> int:
+        """批量出库物料
+
+        参数:
+            outbound_items: 出库条目列表，每项包含 materialId/locationId/quantity 等
+
+        返回值:
+            int: 成功返回1，失败返回0
+        """
+        response = self.post(
+            url=f'{self.host}/api/lims/storage/batch-outbound',
+            params={
+                "apiKey": self.api_key,
+                "requestTime": self.get_current_time_iso8601(),
+                "data": outbound_items,
+            })
+        if not response or response['code'] != 1:
+            return 0
+        return response.get("code", 0)
+
+    def material_info(self, material_id: str) -> dict:
+        """查询物料详情
+
+        参数:
+            material_id: 物料ID
+
+        返回值:
+            dict: 物料信息字典，失败返回空字典
+        """
+        response = self.post(
+            url=f'{self.host}/api/lims/storage/material-info',
+            params={
+                "apiKey": self.api_key,
+                "requestTime": self.get_current_time_iso8601(),
+                "data": material_id,
+            })
+        if not response or response['code'] != 1:
+            return {}
+        return response.get("data", {})
+
+    def reset_location(self, location_id: str) -> int:
+        """复位库位
+
+        参数:
+            location_id: 库位ID
+
+        返回值:
+            int: 成功返回1，失败返回0
+        """
+        response = self.post(
+            url=f'{self.host}/api/lims/storage/reset-location',
+            params={
+                "apiKey": self.api_key,
+                "requestTime": self.get_current_time_iso8601(),
+                "data": location_id,
+            })
+        if not response or response['code'] != 1:
+            return 0
+        return response.get("code", 0)
+
     # ==================== 工作流查询相关接口 ====================
 
     def query_workflow(self, json_str: str) -> dict:
@@ -297,6 +429,66 @@ class BioyondV1RPC(BaseRequest):
             return {}
         return response.get("data", {})
 
+    def split_workflow_list(self, params: Dict[str, Any]) -> dict:
+        """查询可拆分工作流列表
+
+        参数:
+            params: 查询条件参数
+
+        返回值:
+            dict: 返回数据字典，失败返回空字典
+        """
+        response = self.post(
+            url=f'{self.host}/api/lims/workflow/split-workflow-list',
+            params={
+                "apiKey": self.api_key,
+                "requestTime": self.get_current_time_iso8601(),
+                "data": params,
+            })
+        if not response or response['code'] != 1:
+            return {}
+        return response.get("data", {})
+
+    def merge_workflow(self, data: Dict[str, Any]) -> dict:
+        """合并工作流（无参数版）
+
+        参数:
+            data: 合并请求体，包含待合并的子工作流信息
+
+        返回值:
+            dict: 合并结果，失败返回空字典
+        """
+        response = self.post(
+            url=f'{self.host}/api/lims/workflow/merge-workflow',
+            params={
+                "apiKey": self.api_key,
+                "requestTime": self.get_current_time_iso8601(),
+                "data": data,
+            })
+        if not response or response['code'] != 1:
+            return {}
+        return response.get("data", {})
+
+    def merge_workflow_with_parameters(self, data: Dict[str, Any]) -> dict:
+        """合并工作流（携带参数）
+
+        参数:
+            data: 合并请求体，包含 name、workflows 以及 stepParameters 等
+
+        返回值:
+            dict: 合并结果，失败返回空字典
+        """
+        response = self.post(
+            url=f'{self.host}/api/lims/workflow/merge-workflow-with-parameters',
+            params={
+                "apiKey": self.api_key,
+                "requestTime": self.get_current_time_iso8601(),
+                "data": data,
+            })
+        if not response or response['code'] != 1:
+            return {}
+        return response.get("data", {})
+
     def validate_workflow_parameters(self, workflows: List[Dict[str, Any]]) -> Dict[str, Any]:
         """验证工作流参数格式"""
         try:
@@ -459,18 +651,15 @@ class BioyondV1RPC(BaseRequest):
             return {}
         return response.get("data", {})
 
-    def order_report(self, json_str: str) -> dict:
-        """
-            描述：查询某个任务明细
-            json_str 格式为JSON字符串:
-            '{"order_id": "order123"}'
-        """
-        try:
-            data = json.loads(json_str)
-            order_id = data.get("order_id", "")
-        except json.JSONDecodeError:
-            return {}
+    def order_report(self, order_id: str) -> dict:
+        """查询订单报告
 
+        参数:
+            order_id: 订单ID
+
+        返回值:
+            dict: 报告数据，失败返回空字典
+        """
         response = self.post(
             url=f'{self.host}/api/lims/order/order-report',
             params={
@@ -478,16 +667,18 @@ class BioyondV1RPC(BaseRequest):
                 "requestTime": self.get_current_time_iso8601(),
                 "data": order_id,
             })
-
         if not response or response['code'] != 1:
             return {}
         return response.get("data", {})
 
     def order_takeout(self, json_str: str) -> int:
-        """
-            描述：取出任务产物
-            json_str 格式为JSON字符串:
-            '{"order_id": "order123", "preintake_id": "preintake123"}'
+        """取出任务产物
+
+        参数:
+            json_str: JSON字符串，包含 order_id 与 preintake_id
+
+        返回值:
+            int: 成功返回1，失败返回0
         """
         try:
             data = json.loads(json_str)
@@ -510,14 +701,15 @@ class BioyondV1RPC(BaseRequest):
             return 0
         return response.get("code", 0)
 
+
     def sample_waste_removal(self, order_id: str) -> dict:
-        """
-        样品/废料取出接口
+        """样品/废料取出
 
         参数:
-        - order_id: 订单ID
+            order_id: 订单ID
 
-        返回: 取出结果
+        返回值:
+            dict: 取出结果，失败返回空字典
         """
         params = {"orderId": order_id}
 
@@ -539,10 +731,13 @@ class BioyondV1RPC(BaseRequest):
         return response.get("data", {})
 
     def cancel_order(self, json_str: str) -> bool:
-        """
-            描述：取消指定任务
-            json_str 格式为JSON字符串:
-            '{"order_id": "order123"}'
+        """取消指定任务
+
+        参数:
+            json_str: JSON字符串，包含 order_id
+
+        返回值:
+            bool: 成功返回 True，失败返回 False
         """
         try:
             data = json.loads(json_str)
@@ -562,6 +757,126 @@ class BioyondV1RPC(BaseRequest):
             return False
         return True
 
+    def cancel_experiment(self, order_id: str) -> int:
+        """取消指定实验
+
+        参数:
+            order_id: 订单ID
+
+        返回值:
+            int: 成功返回1，失败返回0
+        """
+        response = self.post(
+            url=f'{self.host}/api/lims/order/cancel-experiment',
+            params={
+                "apiKey": self.api_key,
+                "requestTime": self.get_current_time_iso8601(),
+                "data": order_id,
+            })
+        if not response or response['code'] != 1:
+            return 0
+        return response.get("code", 0)
+
+    def batch_cancel_experiment(self, order_ids: List[str]) -> int:
+        """批量取消实验
+
+        参数:
+            order_ids: 订单ID列表
+
+        返回值:
+            int: 成功返回1，失败返回0
+        """
+        response = self.post(
+            url=f'{self.host}/api/lims/order/batch-cancel-experiment',
+            params={
+                "apiKey": self.api_key,
+                "requestTime": self.get_current_time_iso8601(),
+                "data": order_ids,
+            })
+        if not response or response['code'] != 1:
+            return 0
+        return response.get("code", 0)
+
+    def gantts_by_order_id(self, order_id: str) -> dict:
+        """查询订单甘特图数据
+
+        参数:
+            order_id: 订单ID
+
+        返回值:
+            dict: 甘特数据，失败返回空字典
+        """
+        response = self.post(
+            url=f'{self.host}/api/lims/order/gantts-by-order-id',
+            params={
+                "apiKey": self.api_key,
+                "requestTime": self.get_current_time_iso8601(),
+                "data": order_id,
+            })
+        if not response or response['code'] != 1:
+            return {}
+        return response.get("data", {})
+
+    def simulation_gantt_by_order_id(self, order_id: str) -> dict:
+        """查询订单模拟甘特图数据
+
+        参数:
+            order_id: 订单ID
+
+        返回值:
+            dict: 模拟甘特数据，失败返回空字典
+        """
+        response = self.post(
+            url=f'{self.host}/api/lims/order/simulation-gantt-by-order-id',
+            params={
+                "apiKey": self.api_key,
+                "requestTime": self.get_current_time_iso8601(),
+                "data": order_id,
+            })
+        if not response or response['code'] != 1:
+            return {}
+        return response.get("data", {})
+
+    def reset_order_status(self, order_id: str) -> int:
+        """复位订单状态
+
+        参数:
+            order_id: 订单ID
+
+        返回值:
+            int: 成功返回1，失败返回0
+        """
+        response = self.post(
+            url=f'{self.host}/api/lims/order/reset-order-status',
+            params={
+                "apiKey": self.api_key,
+                "requestTime": self.get_current_time_iso8601(),
+                "data": order_id,
+            })
+        if not response or response['code'] != 1:
+            return 0
+        return response.get("code", 0)
+
+    def gantt_with_simulation_by_order_id(self, order_id: str) -> dict:
+        """查询订单甘特与模拟联合数据
+
+        参数:
+            order_id: 订单ID
+
+        返回值:
+            dict: 联合数据，失败返回空字典
+        """
+        response = self.post(
+            url=f'{self.host}/api/lims/order/gantt-with-simulation-by-order-id',
+            params={
+                "apiKey": self.api_key,
+                "requestTime": self.get_current_time_iso8601(),
+                "data": order_id,
+            })
+        if not response or response['code'] != 1:
+            return {}
+        return response.get("data", {})
+
     # ==================== 设备管理相关接口 ====================
 
     def device_list(self, json_str: str = "") -> list:
@@ -593,9 +908,13 @@ class BioyondV1RPC(BaseRequest):
         return response.get("data", [])
 
     def device_operation(self, json_str: str) -> int:
-        """
-            描述：操作设备
-            json_str 格式为JSON字符串
+        """设备操作
+
+        参数:
+            json_str: JSON字符串，包含 device_no/operationType/operationParams
+
+        返回值:
+            int: 成功返回1，失败返回0
         """
         try:
             data = json.loads(json_str)
@@ -608,7 +927,7 @@ class BioyondV1RPC(BaseRequest):
             return 0
 
         response = self.post(
-            url=f'{self.host}/api/lims/device/device-operation',
+            url=f'{self.host}/api/lims/device/execute-operation',
             params={
                 "apiKey": self.api_key,
                 "requestTime": self.get_current_time_iso8601(),
@@ -619,9 +938,30 @@ class BioyondV1RPC(BaseRequest):
             return 0
         return response.get("code", 0)
 
+    def reset_devices(self) -> int:
+        """复位设备集合
+
+        返回值:
+            int: 成功返回1，失败返回0
+        """
+        response = self.post(
+            url=f'{self.host}/api/lims/device/reset-devices',
+            params={
+                "apiKey": self.api_key,
+                "requestTime": self.get_current_time_iso8601(),
+            })
+        if not response or response['code'] != 1:
+            return 0
+        return response.get("code", 0)
+
     # ==================== 调度器相关接口 ====================
 
     def scheduler_status(self) -> dict:
+        """查询调度器状态
+
+        返回值:
+            dict: 包含 schedulerStatus/hasTask/creationTime 等
+        """
         response = self.post(
             url=f'{self.host}/api/lims/scheduler/scheduler-status',
             params={
@@ -634,7 +974,7 @@ class BioyondV1RPC(BaseRequest):
         return response.get("data", {})
 
     def scheduler_start(self) -> int:
-        """描述：启动调度器"""
+        """启动调度器"""
         response = self.post(
             url=f'{self.host}/api/lims/scheduler/start',
             params={
@@ -647,9 +987,22 @@ class BioyondV1RPC(BaseRequest):
         return response.get("code", 0)
 
     def scheduler_pause(self) -> int:
-        """描述：暂停调度器"""
+        """暂停调度器"""
         response = self.post(
-            url=f'{self.host}/api/lims/scheduler/scheduler-pause',
+            url=f'{self.host}/api/lims/scheduler/pause',
+            params={
+                "apiKey": self.api_key,
+                "requestTime": self.get_current_time_iso8601(),
+            })
+
+        if not response or response['code'] != 1:
+            return 0
+        return response.get("code", 0)
+
+    def scheduler_smart_pause(self) -> int:
+        """智能暂停调度器"""
+        response = self.post(
+            url=f'{self.host}/api/lims/scheduler/smart-pause',
             params={
                 "apiKey": self.api_key,
                 "requestTime": self.get_current_time_iso8601(),
@@ -660,8 +1013,9 @@ class BioyondV1RPC(BaseRequest):
         return response.get("code", 0)
 
     def scheduler_continue(self) -> int:
+        """继续调度器"""
         response = self.post(
-            url=f'{self.host}/api/lims/scheduler/scheduler-continue',
+            url=f'{self.host}/api/lims/scheduler/continue',
             params={
                 "apiKey": self.api_key,
                 "requestTime": self.get_current_time_iso8601(),
@@ -672,9 +1026,9 @@ class BioyondV1RPC(BaseRequest):
         return response.get("code", 0)
 
     def scheduler_stop(self) -> int:
-        """描述：停止调度器"""
+        """停止调度器"""
         response = self.post(
-            url=f'{self.host}/api/lims/scheduler/scheduler-stop',
+            url=f'{self.host}/api/lims/scheduler/stop',
             params={
                 "apiKey": self.api_key,
                 "requestTime": self.get_current_time_iso8601(),
@@ -685,9 +1039,9 @@ class BioyondV1RPC(BaseRequest):
         return response.get("code", 0)
 
     def scheduler_reset(self) -> int:
-        """描述：重置调度器"""
+        """复位调度器"""
         response = self.post(
-            url=f'{self.host}/api/lims/scheduler/scheduler-reset',
+            url=f'{self.host}/api/lims/scheduler/reset',
             params={
                 "apiKey": self.api_key,
                 "requestTime": self.get_current_time_iso8601(),
@@ -697,16 +1051,36 @@ class BioyondV1RPC(BaseRequest):
             return 0
         return response.get("code", 0)
 
+    def scheduler_reply_error_handling(self, data: Dict[str, Any]) -> int:
+        """调度错误处理回复
+
+        参数:
+            data: 错误处理参数
+
+        返回值:
+            int: 成功返回1，失败返回0
+        """
+        response = self.post(
+            url=f'{self.host}/api/lims/scheduler/reply-error-handling',
+            params={
+                "apiKey": self.api_key,
+                "requestTime": self.get_current_time_iso8601(),
+                "data": data,
+            })
+        if not response or response['code'] != 1:
+            return 0
+        return response.get("code", 0)
+
     # ==================== 辅助方法 ====================
 
     def _load_material_cache(self):
         """预加载材料列表到缓存中"""
         try:
             print("正在加载材料列表缓存...")
-            
+
             # 加载所有类型的材料：耗材(0)、样品(1)、试剂(2)
-            material_types = [1, 2]
-            
+            material_types = [0, 1, 2]
+
             for type_mode in material_types:
                 print(f"正在加载类型 {type_mode} 的材料...")
                 stock_query = f'{{"typeMode": {type_mode}, "includeDetail": true}}'
@@ -723,7 +1097,7 @@ class BioyondV1RPC(BaseRequest):
                     material_id = material.get("id")
                     if material_name and material_id:
                         self.material_cache[material_name] = material_id
-                    
+
                     # 处理样品板等容器中的detail材料
                     detail_materials = material.get("detail", [])
                     for detail_material in detail_materials:
@@ -759,4 +1133,24 @@ class BioyondV1RPC(BaseRequest):
 
     def get_available_materials(self):
         """获取所有可用的材料名称列表"""
-        return list(self.material_cache.keys())
+        return list(self.material_cache.keys())
+
+    def get_scheduler_state(self) -> Optional[MachineState]:
+        """将调度状态字符串映射为枚举值
+
+        返回值:
+            Optional[MachineState]: 映射后的枚举，失败返回 None
+        """
+        data = self.scheduler_status()
+        if not isinstance(data, dict):
+            return None
+        status = data.get("schedulerStatus")
+        mapping = {
+            "Init": MachineState.INITIAL,
+            "Stop": MachineState.STOPPED,
+            "Running": MachineState.RUNNING,
+            "Pause": MachineState.PAUSED,
+            "ErrorPause": MachineState.ERROR_PAUSED,
+            "ErrorStop": MachineState.ERROR_STOPPED,
+        }
+        return mapping.get(status)

unilabos/devices/workstation/bioyond_studio/config.py

@@ -2,330 +2,141 @@
 """
 配置文件 - 包含所有配置信息和映射关系
 """
-import os
 
-# ==================== API 基础配置 ====================
-# BioyondCellWorkstation 默认配置（包含所有必需参数）
+# API配置
 API_CONFIG = {
-    # API 连接配置
-    # "api_host": os.getenv("BIOYOND_API_HOST", "http://172.16.11.118:44389"),#实机
-    "api_host": os.getenv("BIOYOND_API_HOST", "http://172.16.11.219:44388"),# 仿真机
-    "api_key": os.getenv("BIOYOND_API_KEY", "8A819E5C"),
-    "timeout": int(os.getenv("BIOYOND_TIMEOUT", "30")),
-    
-    # 报送配置
-    "report_token": os.getenv("BIOYOND_REPORT_TOKEN", "CHANGE_ME_TOKEN"),
-    
-    # HTTP 服务配置
-    "HTTP_host": os.getenv("BIOYOND_HTTP_HOST", "172.16.10.148"),  # HTTP服务监听地址，监听计算机飞连ip地址
-    "HTTP_port": int(os.getenv("BIOYOND_HTTP_PORT", "8080")),
-    "debug_mode": False,# 调试模式
+    "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": {
-            "A01": "3a19da56-1379-ff7c-1745-07e200b44ce2",
-            "B01": "3a19da56-1379-2424-d751-fe6e94cef938",
-            "C01": "3a19da56-1379-271c-03e3-6bdb590e395e",
-            "D01": "3a19da56-1379-277f-2b1b-0d11f7cf92c6",
-            "E01": "3a19da56-1379-2f1c-a15b-e01db90eb39a",
-            "F01": "3a19da56-1379-3fa1-846b-088158ac0b3d",
-            "G01": "3a19da56-1379-5aeb-d0cd-d3b4609d66e1",
-            "H01": "3a19da56-1379-6077-8258-bdc036870b78",
-            "I01": "3a19da56-1379-863b-a120-f606baf04617",
-            "J01": "3a19da56-1379-8a74-74e5-35a9b41d4fd5",
-            "K01": "3a19da56-1379-b270-b7af-f18773918abe",
-            "L01": "3a19da56-1379-ba54-6d78-fd770a671ffc",
-            "M01": "3a19da56-1379-c22d-c96f-0ceb5eb54a04",
-            "N01": "3a19da56-1379-d64e-c6c5-c72ea4829888",
-            "O01": "3a19da56-1379-d887-1a3c-6f9cce90f90e",
-            "P01": "3a19da56-1379-e77d-0e65-7463b238a3b9",
-            "Q01": "3a19da56-1379-edf6-1472-802ddb628774",
-            "R01": "3a19da56-1379-f281-0273-e0ef78f0fd97",
-            "S01": "3a19da56-1379-f924-7f68-df1fa51489f4",
-            "T01": "3a19da56-1379-ff7c-1745-07e200b44ce2"
+            # 样品板
+            "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": {
-            "A01": "3a19da43-57b5-294f-d663-154a1cc32270",
-            "B01": "3a19da43-57b5-7394-5f49-54efe2c9bef2",
-            "C01": "3a19da43-57b5-5e75-552f-8dbd0ad1075f",
-            "A02": "3a19da43-57b5-8441-db94-b4d3875a4b6c",
-            "B02": "3a19da43-57b5-3e41-c181-5119dddaf50c",
-            "C02": "3a19da43-57b5-269b-282d-fba61fe8ce96",
-            "A03": "3a19da43-57b5-7c1e-d02e-c40e8c33f8a1",
-            "B03": "3a19da43-57b5-659f-621f-1dcf3f640363",
-            "C03": "3a19da43-57b5-855a-6e71-f398e376dee1",
+            "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": {
-            "A01": "3a19da51-8f4e-30f3-ea08-4f8498e9b097",
-            "B01": "3a19da51-8f4e-1da7-beb0-80a4a01e67a8",
-            "C01": "3a19da51-8f4e-337d-2675-bfac46880b06",
-            "D01": "3a19da51-8f4e-e514-b92c-9c44dc5e489d",
-            "E01": "3a19da51-8f4e-22d1-dd5b-9774ddc80402",
-            "F01": "3a19da51-8f4e-273a-4871-dff41c29bfd9",
-            "G01": "3a19da51-8f4e-b32f-454f-74bc1a665653",
-            "H01": "3a19da51-8f4e-8c93-68c9-0b4382320f59",
-            "I01": "3a19da51-8f4e-360c-0149-291b47c6089b",
-            "J01": "3a19da51-8f4e-4152-9bca-8d64df8c1af0"
-        }
-    },
-    "自动堆栈-左": {
-        "uuid": "",
-        "site_uuids": {
-            "A01": "3a19debc-84b5-4c1c-d3a1-26830cf273ff",
-            "A02": "3a19debc-84b5-033b-b31f-6b87f7c2bf52",
-            "B01": "3a19debc-84b5-3924-172f-719ab01b125c",
-            "B02": "3a19debc-84b5-aad8-70c6-b8c6bb2d8750"
-        }
-    },
-    "自动堆栈-右": {
-        "uuid": "",
-        "site_uuids": {
-            "A01": "3a19debe-5200-7df2-1dd9-7d202f158864",
-            "A02": "3a19debe-5200-573b-6120-8b51f50e1e50",
-            "B01": "3a19debe-5200-7cd8-7666-851b0a97e309",
-            "B02": "3a19debe-5200-e6d3-96a3-baa6e3d5e484"
-        }
-    },
-    "手动堆栈": {
-        "uuid": "",
-        "site_uuids": {
-            "A01": "3a19deae-2c7a-36f5-5e41-02c5b66feaea",
-            "A02": "3a19deae-2c7a-dc6d-c41e-ef285d946cfe",
-            "A03": "3a19deae-2c7a-5876-c454-6b7e224ca927",
-            "B01": "3a19deae-2c7a-2426-6d71-e9de3cb158b1",
-            "B02": "3a19deae-2c7a-79b0-5e44-efaafd1e4cf3",
-            "B03": "3a19deae-2c7a-b9eb-f4e3-e308e0cf839a",
-            "C01": "3a19deae-2c7a-32bc-768e-556647e292f3",
-            "C02": "3a19deae-2c7a-e97a-8484-f5a4599447c4",
-            "C03": "3a19deae-2c7a-3056-6504-10dc73fbc276",
-            "D01": "3a19deae-2c7a-ffad-875e-8c4cda61d440",
-            "D02": "3a19deae-2c7a-61be-601c-b6fb5610499a",
-            "D03": "3a19deae-2c7a-c0f7-05a7-e3fe2491e560",
-            "E01": "3a19deae-2c7a-a6f4-edd1-b436a7576363",
-            "E02": "3a19deae-2c7a-4367-96dd-1ca2186f4910",
-            "E03": "3a19deae-2c7a-b163-2219-23df15200311",
-            "F01": "3a19deae-2c7a-d594-fd6a-0d20de3c7c4a",
-            "F02": "3a19deae-2c7a-a194-ea63-8b342b8d8679",
-            "F03": "3a19deae-2c7a-f7c4-12bd-425799425698",
-            "G01": "3a19deae-2c7a-0b56-72f1-8ab86e53b955",
-            "G02": "3a19deae-2c7a-204e-95ed-1f1950f28343",
-            "G03": "3a19deae-2c7a-392b-62f1-4907c66343f8",
-            "H01": "3a19deae-2c7a-5602-e876-d27aca4e3201",
-            "H02": "3a19deae-2c7a-f15c-70e0-25b58a8c9702",
-            "H03": "3a19deae-2c7a-780b-8965-2e1345f7e834",
-            "I01": "3a19deae-2c7a-8849-e172-07de14ede928",
-            "I02": "3a19deae-2c7a-4772-a37f-ff99270bafc0",
-            "I03": "3a19deae-2c7a-cce7-6e4a-25ea4a2068c4",
-            "J01": "3a19deae-2c7a-1848-de92-b5d5ed054cc6",
-            "J02": "3a19deae-2c7a-1d45-b4f8-6f866530e205",
-            "J03": "3a19deae-2c7a-f237-89d9-8fe19025dee9"
-        }
-    },
-    "4号手套箱内部堆栈": {
-        "uuid": "",
-        "site_uuids": {
-            "A01": "3a1baa20-a7b1-c665-8b9c-d8099d07d2f6",
-            "A02": "3a1baa20-a7b1-93a7-c988-f9c8ad6c58c9",
-            "A03": "3a1baa20-a7b1-00ee-f751-da9b20b6c464",
-            "A04": "3a1baa20-a7b1-4712-c37b-0b5b658ef7b9",
-            "B01": "3a1baa20-a7b1-9847-fc9c-96d604cd1a8e",
-            "B02": "3a1baa20-a7b1-4ae9-e604-0601db06249c",
-            "B03": "3a1baa20-a7b1-8329-ea75-81ca559d9ce1",
-            "B04": "3a1baa20-a7b1-89c5-d96f-36e98a8f7268",
-            "C01": "3a1baa20-a7b1-32ec-39e6-8044733839d6",
-            "C02": "3a1baa20-a7b1-b573-e426-4c86040348b2",
-            "C03": "3a1baa20-a7b1-cca7-781e-0522b729bf5d",
-            "C04": "3a1baa20-a7b1-7c98-5fd9-5855355ae4b3"
-        }
-    },
-    "大分液瓶堆栈": {
-        "uuid": "",
-        "site_uuids": {
-            "A01": "3a19da3d-4f3d-bcac-2932-7542041e10e0",
-            "A02": "3a19da3d-4f3d-4d75-38ac-fb58ad0687c3",
-            "A03": "3a19da3d-4f3d-b25e-f2b1-85342a5b7eae",
-            "B01": "3a19da3d-4f3d-fd3e-058a-2733a0925767",
-            "B02": "3a19da3d-4f3d-37bd-a944-c391ad56857f",
-            "B03": "3a19da3d-4f3d-e353-7862-c6d1d4bc667f",
-            "C01": "3a19da3d-4f3d-9519-5da7-76179c958e70",
-            "C02": "3a19da3d-4f3d-b586-d7ed-9ec244f6f937",
-            "C03": "3a19da3d-4f3d-5061-249b-35dfef732811"
-        }
-    },
-    "小分液瓶堆栈": {
-        "uuid": "",
-        "site_uuids": {
-            "C03": "3a19da40-55bf-8943-d20d-a8b3ea0d16c0"
-        }
-    },
-    "站内Tip头盒堆栈": {
-        "uuid": "",
-        "site_uuids": {
-            "A01": "3a19deab-d5cc-be1e-5c37-4e9e5a664388",
-            "A02": "3a19deab-d5cc-b394-8141-27cb3853e8ea",
-            "B01": "3a19deab-d5cc-4dca-596e-ca7414d5f501",
-            "B02": "3a19deab-d5cc-9bc0-442b-12d9d59aa62a",
-            "C01": "3a19deab-d5cc-2eaf-b6a4-f0d54e4f1246",
-            "C02": "3a19deab-d5cc-d9f4-25df-b8018c372bc7"
-        }
-    },
-    "配液站内配液大板仓库(无需提前上料)": {
-        "uuid": "",
-        "site_uuids": {
-            "A01": "3a1a21dc-06af-3915-9cb9-80a9dc42f386"
-        }
-    },
-    "配液站内配液小板仓库(无需以前入料)": {
-        "uuid": "",
-        "site_uuids": {
-            "A01": "3a1a21de-8e8b-7938-2d06-858b36c10e31"
-        }
-    },
-    "移液站内大瓶板仓库(无需提前如料)": {
-        "uuid": "",
-        "site_uuids": {
-            "A01": "3a1a224c-c727-fa62-1f2b-0037a84b9fca"
-        }
-    },
-    "移液站内小瓶板仓库(无需提前入料)": {
-        "uuid": "",
-        "site_uuids": {
-            "A01": "3a1a224d-ed49-710c-a9c3-3fc61d479cbb"
-        }
-    },
-    "适配器位仓库": {
-        "uuid": "",
-        "site_uuids": {
-            "A01": "3a1abd46-18fe-1f56-6ced-a1f7fe08e36c"
-        }
-    },
-    "1号2号手套箱交接堆栈": {
-        "uuid": "",
-        "site_uuids": {
-            "A01": "3a1baa49-7f77-35aa-60b1-e55a45d065fa"
-        }
-    },
-    "2号手套箱内部堆栈": {
-        "uuid": "",
-        "site_uuids": {
-            "A01": "3a1baa4b-393e-9f86-3921-7a18b0a8e371",
-            "A02": "3a1baa4b-393e-9425-928b-ee0f6f679d44",
-            "A03": "3a1baa4b-393e-0baf-632b-59dfdc931a3a",
-            "B01": "3a1baa4b-393e-f8aa-c8a9-956f3132f05c",
-            "B02": "3a1baa4b-393e-ef05-42f6-53f4c6e89d70",
-            "B03": "3a1baa4b-393e-c07b-a924-a9f0dfda9711",
-            "C01": "3a1baa4b-393e-4c2b-821a-16a7fe025c48",
-            "C02": "3a1baa4b-393e-2eaf-61a1-9063c832d5a2",
-            "C03": "3a1baa4b-393e-034e-8e28-8626d934a85f"
+            "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 = {
-    "100ml液体": ("YB_100ml_yeti", "d37166b3-ecaa-481e-bd84-3032b795ba07"),
-    "液": ("YB_ye", "3a190ca1-2add-2b23-f8e1-bbd348b7f790"),
-    "高粘液": ("YB_gaonianye", "abe8df30-563d-43d2-85e0-cabec59ddc16"),
-    "加样头(大)": ("YB_jia_yang_tou_da_Carrier", "3a190ca0-b2f6-9aeb-8067-547e72c11469"),
-    # "加样头(大)板": ("YB_jia_yang_tou_da", "a8e714ae-2a4e-4eb9-9614-e4c140ec3f16"),
-    "5ml分液瓶板": ("YB_5ml_fenyepingban", "3a192fa4-007d-ec7b-456e-2a8be7a13f23"),
-    "5ml分液瓶": ("YB_5ml_fenyeping", "3a192c2a-ebb7-58a1-480d-8b3863bf74f4"),
-    "20ml分液瓶板": ("YB_20ml_fenyepingban", "3a192fa4-47db-3449-162a-eaf8aba57e27"),
-    "20ml分液瓶": ("YB_20ml_fenyeping", "3a192c2b-19e8-f0a3-035e-041ca8ca1035"),
-    "配液瓶(小)板": ("YB_peiyepingxiaoban", "3a190c8b-3284-af78-d29f-9a69463ad047"),
-    "配液瓶(小)": ("YB_pei_ye_xiao_Bottle", "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb"),
-    "配液瓶(大)板": ("YB_peiyepingdaban", "53e50377-32dc-4781-b3c0-5ce45bc7dc27"),
-    "配液瓶(大)": ("YB_pei_ye_da_Bottle", "19c52ad1-51c5-494f-8854-576f4ca9c6ca"),
-    "适配器块": ("YB_shi_pei_qi_kuai", "efc3bb32-d504-4890-91c0-b64ed3ac80cf"),
-    "枪头盒": ("YB_qiang_tou_he", "3a192c2e-20f3-a44a-0334-c8301839d0b3"),
-    "枪头": ("YB_qiang_tou", "b6196971-1050-46da-9927-333e8dea062d"),
+    "烧杯": ("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"),
 }
 
-SOLID_LIQUID_MAPPINGS = {
-    # 固体
-    "LiDFOB": {
-        "typeId": "3a190ca0-b2f6-9aeb-8067-547e72c11469",
-        "code": "",
-        "barCode": "",
-        "name": "LiDFOB",
-        "unit": "g",
-        "parameters": "",
-        "quantity": "2",
-        "warningQuantity": "1",
-        "details": []
+# 步骤参数配置（各工作流的步骤UUID）
+WORKFLOW_STEP_IDS = {
+    "reactor_taken_in": {
+        "config": ""
     },
-    # "LiPF6": {
-    #     "typeId": "3a190ca0-b2f6-9aeb-8067-547e72c11469",
-    #     "code": "",
-    #     "barCode": "",
-    #     "name": "LiPF6",
-    #     "unit": "g",
-    #     "parameters": "",
-    #     "quantity": 2,
-    #     "warningQuantity": 1,
-    #     "details": []
-    # },
-    # "LiFSI": {
-    #     "typeId": "3a190ca0-b2f6-9aeb-8067-547e72c11469",
-    #     "code": "",
-    #     "barCode": "",
-    #     "name": "LiFSI",
-    #     "unit": "g",
-    #     "parameters": "",
-    #     "quantity": 2,
-    #     "warningQuantity": 1,
-    #     "details": []
-    # },
-    # "DTC": {
-    #     "typeId": "3a190ca0-b2f6-9aeb-8067-547e72c11469",
-    #     "code": "",
-    #     "barCode": "",
-    #     "name": "DTC",
-    #     "unit": "g",
-    #     "parameters": "",
-    #     "quantity": 2,
-    #     "warningQuantity": 1,
-    #     "details": []
-    # },
-    # "LiPO2F2": {
-    #     "typeId": "3a190ca0-b2f6-9aeb-8067-547e72c11469",
-    #     "code": "",
-    #     "barCode": "",
-    #     "name": "LiPO2F2",
-    #     "unit": "g",
-    #     "parameters": "",
-    #     "quantity": 2,
-    #     "warningQuantity": 1,
-    #     "details": []
-    # },
-    # 液体
-    # "SA": ("BIOYOND_PolymerStation_Solid_Stock", "3a190ca0-b2f6-9aeb-8067-547e72c11469"),
-    # "EC": ("BIOYOND_PolymerStation_Solid_Stock", "3a190ca0-b2f6-9aeb-8067-547e72c11469"),
-    # "VC": ("BIOYOND_PolymerStation_Solid_Stock", "3a190ca0-b2f6-9aeb-8067-547e72c11469"),
-    # "AND": ("BIOYOND_PolymerStation_Solid_Stock", "3a190ca0-b2f6-9aeb-8067-547e72c11469"),
-    # "HTCN": ("BIOYOND_PolymerStation_Solid_Stock", "3a190ca0-b2f6-9aeb-8067-547e72c11469"),
-    # "DENE": ("BIOYOND_PolymerStation_Solid_Stock", "3a190ca0-b2f6-9aeb-8067-547e72c11469"),
-    # "TMSP": ("BIOYOND_PolymerStation_Solid_Stock", "3a190ca0-b2f6-9aeb-8067-547e72c11469"),
-    # "TMSB": ("BIOYOND_PolymerStation_Solid_Stock", "3a190ca0-b2f6-9aeb-8067-547e72c11469"),
-    # "EP": ("BIOYOND_PolymerStation_Solid_Stock", "3a190ca0-b2f6-9aeb-8067-547e72c11469"),
-    # "DEC": ("BIOYOND_PolymerStation_Solid_Stock", "3a190ca0-b2f6-9aeb-8067-547e72c11469"),
-    # "EMC": ("BIOYOND_PolymerStation_Solid_Stock", "3a190ca0-b2f6-9aeb-8067-547e72c11469"),
-    # "SN": ("BIOYOND_PolymerStation_Solid_Stock", "3a190ca0-b2f6-9aeb-8067-547e72c11469"),
-    # "DMC": ("BIOYOND_PolymerStation_Solid_Stock", "3a190ca0-b2f6-9aeb-8067-547e72c11469"),
-    # "FEC": ("BIOYOND_PolymerStation_Solid_Stock", "3a190ca0-b2f6-9aeb-8067-547e72c11469"),
+    "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": ""
+    }
 }
 
-WORKFLOW_MAPPINGS = {}
+LOCATION_MAPPING = {}
 
-LOCATION_MAPPING = {}
+ACTION_NAMES = {}
+
+HTTP_SERVICE_CONFIG = {}

unilabos/devices/workstation/bioyond_studio/dispensing_station.py

@@ -1,8 +1,25 @@
 from datetime import datetime
 import json
+import time
+from typing import Optional, Dict, Any, List
+from typing_extensions import TypedDict
+import requests
+from unilabos.devices.workstation.bioyond_studio.config import API_CONFIG
 
 from unilabos.devices.workstation.bioyond_studio.bioyond_rpc import BioyondException
 from unilabos.devices.workstation.bioyond_studio.station import BioyondWorkstation
+from unilabos.ros.nodes.base_device_node import ROS2DeviceNode, BaseROS2DeviceNode
+import json
+import sys
+from pathlib import Path
+import importlib
+
+class ComputeExperimentDesignReturn(TypedDict):
+    solutions: list
+    titration: dict
+    solvents: dict
+    feeding_order: list
+    return_info: str
 
 
 class BioyondDispensingStation(BioyondWorkstation):
@@ -23,6 +40,111 @@ class BioyondDispensingStation(BioyondWorkstation):
         # self._logger = SimpleLogger()
         # self.is_running = False
 
+        # 用于跟踪任务完成状态的字典: {orderCode: {status, order_id, timestamp}}
+        self.order_completion_status = {}
+
+    def _post_project_api(self, endpoint: str, data: Any) -> Dict[str, Any]:
+        """项目接口通用POST调用
+
+        参数:
+            endpoint: 接口路径（例如 /api/lims/order/brief-step-paramerers）
+            data: 请求体中的 data 字段内容
+
+        返回:
+            dict: 服务端响应，失败时返回 {code:0,message,...}
+        """
+        request_data = {
+            "apiKey": API_CONFIG["api_key"],
+            "requestTime": self.hardware_interface.get_current_time_iso8601(),
+            "data": data
+        }
+        try:
+            response = requests.post(
+                f"{self.hardware_interface.host}{endpoint}",
+                json=request_data,
+                headers={"Content-Type": "application/json"},
+                timeout=30
+            )
+            result = response.json()
+            return result if isinstance(result, dict) else {"code": 0, "message": "非JSON响应"}
+        except json.JSONDecodeError:
+            return {"code": 0, "message": "非JSON响应"}
+        except requests.exceptions.Timeout:
+            return {"code": 0, "message": "请求超时"}
+        except requests.exceptions.RequestException as e:
+            return {"code": 0, "message": str(e)}
+
+    def _delete_project_api(self, endpoint: str, data: Any) -> Dict[str, Any]:
+        """项目接口通用DELETE调用
+
+        参数:
+            endpoint: 接口路径（例如 /api/lims/order/workflows）
+            data: 请求体中的 data 字段内容
+
+        返回:
+            dict: 服务端响应，失败时返回 {code:0,message,...}
+        """
+        request_data = {
+            "apiKey": API_CONFIG["api_key"],
+            "requestTime": self.hardware_interface.get_current_time_iso8601(),
+            "data": data
+        }
+        try:
+            response = requests.delete(
+                f"{self.hardware_interface.host}{endpoint}",
+                json=request_data,
+                headers={"Content-Type": "application/json"},
+                timeout=30
+            )
+            result = response.json()
+            return result if isinstance(result, dict) else {"code": 0, "message": "非JSON响应"}
+        except json.JSONDecodeError:
+            return {"code": 0, "message": "非JSON响应"}
+        except requests.exceptions.Timeout:
+            return {"code": 0, "message": "请求超时"}
+        except requests.exceptions.RequestException as e:
+            return {"code": 0, "message": str(e)}
+
+    def compute_experiment_design(
+        self,
+        ratio: dict,
+        wt_percent: str = "0.25",
+        m_tot: str = "70",
+        titration_percent: str = "0.03",
+    ) -> ComputeExperimentDesignReturn:
+        try:
+            if isinstance(ratio, str):
+                try:
+                    ratio = json.loads(ratio)
+                except Exception:
+                    ratio = {}
+            root = str(Path(__file__).resolve().parents[3])
+            if root not in sys.path:
+                sys.path.append(root)
+            try:
+                mod = importlib.import_module("tem.compute")
+            except Exception as e:
+                raise BioyondException(f"无法导入计算模块: {e}")
+            try:
+                wp = float(wt_percent) if isinstance(wt_percent, str) else wt_percent
+                mt = float(m_tot) if isinstance(m_tot, str) else m_tot
+                tp = float(titration_percent) if isinstance(titration_percent, str) else titration_percent
+            except Exception as e:
+                raise BioyondException(f"参数解析失败: {e}")
+            res = mod.generate_experiment_design(ratio=ratio, wt_percent=wp, m_tot=mt, titration_percent=tp)
+            out = {
+                "solutions": res.get("solutions", []),
+                "titration": res.get("titration", {}),
+                "solvents": res.get("solvents", {}),
+                "feeding_order": res.get("feeding_order", []),
+                "return_info": json.dumps(res, ensure_ascii=False)
+            }
+            return out
+        except BioyondException:
+            raise
+        except Exception as e:
+            raise BioyondException(str(e))
+
     # 90%10%小瓶投料任务创建方法
     def create_90_10_vial_feeding_task(self,
                                        order_name: str = None,
@@ -270,7 +392,45 @@ class BioyondDispensingStation(BioyondWorkstation):
             # 7. 调用create_order方法创建任务
             result = self.hardware_interface.create_order(json_str)
             self.hardware_interface._logger.info(f"创建90%10%小瓶投料任务结果: {result}")
-            return json.dumps({"suc": True})
+
+            # 8. 解析结果获取order_id
+            order_id = None
+            if isinstance(result, str):
+                # result 格式: "{'3a1d895c-4d39-d504-1398-18f5a40bac1e': [{'id': '...', ...}]}"
+                # 第一个键就是order_id (UUID)
+                try:
+                    # 尝试解析字符串为字典
+                    import ast
+                    result_dict = ast.literal_eval(result)
+                    # 获取第一个键作为order_id
+                    if result_dict and isinstance(result_dict, dict):
+                        first_key = list(result_dict.keys())[0]
+                        order_id = first_key
+                        self.hardware_interface._logger.info(f"✓ 成功提取order_id: {order_id}")
+                    else:
+                        self.hardware_interface._logger.warning(f"result_dict格式异常: {result_dict}")
+                except Exception as e:
+                    self.hardware_interface._logger.error(f"✗ 无法从结果中提取order_id: {e}, result类型={type(result)}")
+            elif isinstance(result, dict):
+                # 如果已经是字典
+                if result:
+                    first_key = list(result.keys())[0]
+                    order_id = first_key
+                    self.hardware_interface._logger.info(f"✓ 成功提取order_id(dict): {order_id}")
+
+            if not order_id:
+                self.hardware_interface._logger.warning(
+                    f"⚠ 未能提取order_id，result={result[:100] if isinstance(result, str) else result}"
+                )
+
+            # 返回成功结果和构建的JSON数据
+            return json.dumps({
+                "suc": True,
+                "order_code": order_code,
+                "order_id": order_id,
+                "result": result,
+                "order_params": order_data
+            })
 
         except BioyondException:
             # 重新抛出BioyondException
@@ -398,7 +558,37 @@ class BioyondDispensingStation(BioyondWorkstation):
             result = self.hardware_interface.create_order(json_str)
             self.hardware_interface._logger.info(f"创建二胺溶液配置任务结果: {result}")
 
-            return json.dumps({"suc": True})
+            # 8. 解析结果获取order_id
+            order_id = None
+            if isinstance(result, str):
+                try:
+                    import ast
+                    result_dict = ast.literal_eval(result)
+                    if result_dict and isinstance(result_dict, dict):
+                        first_key = list(result_dict.keys())[0]
+                        order_id = first_key
+                        self.hardware_interface._logger.info(f"✓ 成功提取order_id: {order_id}")
+                    else:
+                        self.hardware_interface._logger.warning(f"result_dict格式异常: {result_dict}")
+                except Exception as e:
+                    self.hardware_interface._logger.error(f"✗ 无法从结果中提取order_id: {e}")
+            elif isinstance(result, dict):
+                if result:
+                    first_key = list(result.keys())[0]
+                    order_id = first_key
+                    self.hardware_interface._logger.info(f"✓ 成功提取order_id(dict): {order_id}")
+
+            if not order_id:
+                self.hardware_interface._logger.warning(f"⚠ 未能提取order_id")
+
+            # 返回成功结果和构建的JSON数据
+            return json.dumps({
+                "suc": True,
+                "order_code": order_code,
+                "order_id": order_id,
+                "result": result,
+                "order_params": order_data
+            })
 
         except BioyondException:
             # 重新抛出BioyondException
@@ -499,15 +689,24 @@ class BioyondDispensingStation(BioyondWorkstation):
                         hold_m_name=hold_m_name
                     )
 
+                    # 解析返回结果以获取order_code和order_id
+                    result_data = json.loads(result) if isinstance(result, str) else result
+                    order_code = result_data.get("order_code")
+                    order_id = result_data.get("order_id")
+                    order_params = result_data.get("order_params", {})
+
                     results.append({
                         "index": idx + 1,
                         "name": name,
                         "success": True,
-                        "hold_m_name": hold_m_name
+                        "order_code": order_code,
+                        "order_id": order_id,
+                        "hold_m_name": hold_m_name,
+                        "order_params": order_params
                     })
                     success_count += 1
                     self.hardware_interface._logger.info(
-                        f"成功创建二胺溶液配置任务: {name}"
+                        f"成功创建二胺溶液配置任务: {name}, order_code={order_code}, order_id={order_id}"
                     )
 
                 except BioyondException as e:
@@ -533,11 +732,17 @@ class BioyondDispensingStation(BioyondWorkstation):
                         f"创建第 {idx + 1} 个任务时发生未知错误: {str(e)}"
                     )
 
+            # 提取所有成功任务的order_code和order_id
+            order_codes = [r["order_code"] for r in results if r["success"]]
+            order_ids = [r["order_id"] for r in results if r["success"]]
+
             # 返回汇总结果
             summary = {
                 "total": len(solutions),
                 "success": success_count,
                 "failed": failed_count,
+                "order_codes": order_codes,
+                "order_ids": order_ids,
                 "details": results
             }
 
@@ -546,8 +751,13 @@ class BioyondDispensingStation(BioyondWorkstation):
                 f"成功={success_count}, 失败={failed_count}"
             )
 
-            # 返回JSON字符串格式
-            return json.dumps(summary, ensure_ascii=False)
+            # 构建返回结果
+            summary["return_info"] = {
+                "order_codes": order_codes,
+                "order_ids": order_ids,
+            }
+
+            return summary
 
         except BioyondException:
             raise
@@ -556,6 +766,40 @@ class BioyondDispensingStation(BioyondWorkstation):
             self.hardware_interface._logger.error(error_msg)
             raise BioyondException(error_msg)
 
+    def brief_step_parameters(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """获取简要步骤参数（站点项目接口）
+
+        参数:
+            data: 查询参数字典
+
+        返回值:
+            dict: 接口返回数据
+        """
+        return self._post_project_api("/api/lims/order/brief-step-paramerers", data)
+
+    def project_order_report(self, order_id: str) -> Dict[str, Any]:
+        """查询项目端订单报告（兼容旧路径）
+
+        参数:
+            order_id: 订单ID
+
+        返回值:
+            dict: 报告数据
+        """
+        return self._post_project_api("/api/lims/order/project-order-report", order_id)
+
+    def workflow_sample_locations(self, workflow_id: str) -> Dict[str, Any]:
+        """查询工作流样品库位（站点项目接口）
+
+        参数:
+            workflow_id: 工作流ID
+
+        返回值:
+            dict: 位置信息数据
+        """
+        return self._post_project_api("/api/lims/storage/workflow-sample-locations", workflow_id)
+
+
     # 批量创建90%10%小瓶投料任务
     def batch_create_90_10_vial_feeding_tasks(self,
                                               titration,
@@ -613,22 +857,15 @@ class BioyondDispensingStation(BioyondWorkstation):
             if not all([name, main_portion is not None, titration_portion is not None, titration_solvent is not None]):
                 raise BioyondException("titration 数据缺少必要参数")
 
-            # 将main_portion平均分成3份作为90%物料（3个小瓶）
-            portion_90 = main_portion / 3
-
             # 调用单个任务创建方法
             result = self.create_90_10_vial_feeding_task(
                 order_name=f"90%10%小瓶投料-{name}",
                 speed=speed,
                 temperature=temperature,
                 delay_time=delay_time,
-                # 90%物料 - 主称固体平均分成3份
+                # 90%物料 - 主称固体直接使用main_portion
                 percent_90_1_assign_material_name=name,
-                percent_90_1_target_weigh=str(round(portion_90, 6)),
-                percent_90_2_assign_material_name=name,
-                percent_90_2_target_weigh=str(round(portion_90, 6)),
-                percent_90_3_assign_material_name=name,
-                percent_90_3_target_weigh=str(round(portion_90, 6)),
+                percent_90_1_target_weigh=str(round(main_portion, 6)),
                 # 10%物料 - 滴定固体 + 滴定溶剂（只使用第1个10%小瓶）
                 percent_10_1_assign_material_name=name,
                 percent_10_1_target_weigh=str(round(titration_portion, 6)),
@@ -637,29 +874,54 @@ class BioyondDispensingStation(BioyondWorkstation):
                 hold_m_name=hold_m_name
             )
 
-            summary = {
+            # 解析返回结果以获取order_code和order_id
+            result_data = json.loads(result) if isinstance(result, str) else result
+            order_code = result_data.get("order_code")
+            order_id = result_data.get("order_id")
+            order_params = result_data.get("order_params", {})
+
+            # 构建详细信息（保持原有结构）
+            detail = {
+                "index": 1,
+                "name": name,
                 "success": True,
+                "order_code": order_code,
+                "order_id": order_id,
                 "hold_m_name": hold_m_name,
-                "material_name": name,
                 "90_vials": {
-                    "count": 3,
-                    "weight_per_vial": round(portion_90, 6),
+                    "count": 1,
+                    "weight_per_vial": round(main_portion, 6),
                     "total_weight": round(main_portion, 6)
                 },
                 "10_vials": {
                     "count": 1,
                     "solid_weight": round(titration_portion, 6),
                     "liquid_volume": round(titration_solvent, 6)
-                }
+                },
+                "order_params": order_params
+            }
+
+            # 构建批量结果格式（与diamine_solution_tasks保持一致）
+            summary = {
+                "total": 1,
+                "success": 1,
+                "failed": 0,
+                "order_codes": [order_code],
+                "order_ids": [order_id],
+                "details": [detail]
             }
 
             self.hardware_interface._logger.info(
-                f"成功创建90%10%小瓶投料任务: {hold_m_name}, "
-                f"90%物料={portion_90:.6f}g×3, 10%物料={titration_portion:.6f}g+{titration_solvent:.6f}mL"
+                f"成功创建90%10%小瓶投料任务: {name}, order_code={order_code}, order_id={order_id}"
             )
 
-            # 返回JSON字符串格式
-            return json.dumps(summary, ensure_ascii=False)
+            # 构建返回结果
+            summary["return_info"] = {
+                "order_codes": [order_code],
+                "order_ids": [order_id],
+            }
+
+            return summary
 
         except BioyondException:
             raise
@@ -668,6 +930,571 @@ class BioyondDispensingStation(BioyondWorkstation):
             self.hardware_interface._logger.error(error_msg)
             raise BioyondException(error_msg)
 
+    def _extract_actuals_from_report(self, report) -> Dict[str, Any]:
+        data = report.get('data') if isinstance(report, dict) else None
+        actual_target_weigh = None
+        actual_volume = None
+        if data:
+            extra = data.get('extraProperties') or {}
+            if isinstance(extra, dict):
+                for v in extra.values():
+                    obj = None
+                    try:
+                        obj = json.loads(v) if isinstance(v, str) else v
+                    except Exception:
+                        obj = None
+                    if isinstance(obj, dict):
+                        tw = obj.get('targetWeigh')
+                        vol = obj.get('volume')
+                        if tw is not None:
+                            try:
+                                actual_target_weigh = float(tw)
+                            except Exception:
+                                pass
+                        if vol is not None:
+                            try:
+                                actual_volume = float(vol)
+                            except Exception:
+                                pass
+        return {
+            'actualTargetWeigh': actual_target_weigh,
+            'actualVolume': actual_volume
+        }
+
+    # 等待多个任务完成并获取实验报告
+    def wait_for_multiple_orders_and_get_reports(self,
+                                                  batch_create_result: str = None,
+                                                  timeout: int = 7200,
+                                                  check_interval: int = 10) -> Dict[str, Any]:
+        """
+        同时等待多个任务完成并获取实验报告
+
+        参数说明:
+        - batch_create_result: 批量创建任务的返回结果JSON字符串，包含order_codes和order_ids数组
+        - timeout: 超时时间（秒），默认7200秒（2小时）
+        - check_interval: 检查间隔（秒），默认10秒
+
+        返回: 包含所有任务状态和报告的字典
+        {
+            "total": 2,
+            "completed": 2,
+            "timeout": 0,
+            "elapsed_time": 120.5,
+            "reports": [
+                {
+                    "order_code": "task_vial_1",
+                    "order_id": "uuid1",
+                    "status": "completed",
+                    "completion_status": 30,
+                    "report": {...}
+                },
+                ...
+            ]
+        }
+
+        异常:
+        - BioyondException: 所有任务都超时或发生错误
+        """
+        try:
+            # 参数类型转换
+            timeout = int(timeout) if timeout else 7200
+            check_interval = int(check_interval) if check_interval else 10
+
+            # 验证batch_create_result参数
+            if not batch_create_result or batch_create_result == "":
+                raise BioyondException("batch_create_result参数为空，请确保从batch_create节点正确连接handle")
+
+            # 解析batch_create_result JSON对象
+            try:
+                # 清理可能存在的截断标记 [...]
+                if isinstance(batch_create_result, str) and '[...]' in batch_create_result:
+                    batch_create_result = batch_create_result.replace('[...]', '[]')
+
+                result_obj = json.loads(batch_create_result) if isinstance(batch_create_result, str) else batch_create_result
+
+                # 兼容外层包装格式 {error, suc, return_value}
+                if isinstance(result_obj, dict) and "return_value" in result_obj:
+                    inner = result_obj.get("return_value")
+                    if isinstance(inner, str):
+                        result_obj = json.loads(inner)
+                    elif isinstance(inner, dict):
+                        result_obj = inner
+
+                # 从summary对象中提取order_codes和order_ids
+                order_codes = result_obj.get("order_codes", [])
+                order_ids = result_obj.get("order_ids", [])
+
+            except json.JSONDecodeError as e:
+                raise BioyondException(f"解析batch_create_result失败: {e}")
+            except Exception as e:
+                raise BioyondException(f"处理batch_create_result时出错: {e}")
+
+            # 验证提取的数据
+            if not order_codes:
+                raise BioyondException("batch_create_result中未找到order_codes字段或为空")
+            if not order_ids:
+                raise BioyondException("batch_create_result中未找到order_ids字段或为空")
+
+            # 确保order_codes和order_ids是列表类型
+            if not isinstance(order_codes, list):
+                order_codes = [order_codes] if order_codes else []
+            if not isinstance(order_ids, list):
+                order_ids = [order_ids] if order_ids else []
+
+            codes_list = order_codes
+            ids_list = order_ids
+
+            if len(codes_list) != len(ids_list):
+                raise BioyondException(
+                    f"order_codes数量({len(codes_list)})与order_ids数量({len(ids_list)})不匹配"
+                )
+
+            if not codes_list or not ids_list:
+                raise BioyondException("order_codes和order_ids不能为空")
+
+            # 初始化跟踪变量
+            total = len(codes_list)
+            pending_orders = {code: {"order_id": ids_list[i], "completed": False}
+                            for i, code in enumerate(codes_list)}
+            reports = []
+
+            start_time = time.time()
+            self.hardware_interface._logger.info(
+                f"开始等待 {total} 个任务完成: {', '.join(codes_list)}"
+            )
+
+            # 轮询检查任务状态
+            while pending_orders:
+                elapsed_time = time.time() - start_time
+
+                # 检查超时
+                if elapsed_time > timeout:
+                    # 收集超时任务
+                    timeout_orders = list(pending_orders.keys())
+                    self.hardware_interface._logger.error(
+                        f"等待任务完成超时，剩余未完成任务: {', '.join(timeout_orders)}"
+                    )
+
+                    # 为超时任务添加记录
+                    for order_code in timeout_orders:
+                        reports.append({
+                            "order_code": order_code,
+                            "order_id": pending_orders[order_code]["order_id"],
+                            "status": "timeout",
+                            "completion_status": None,
+                            "report": None,
+                            "extracted": None,
+                            "elapsed_time": elapsed_time
+                        })
+
+                    break
+
+                # 检查每个待完成的任务
+                completed_in_this_round = []
+                for order_code in list(pending_orders.keys()):
+                    order_id = pending_orders[order_code]["order_id"]
+
+                    # 检查任务是否完成
+                    if order_code in self.order_completion_status:
+                        completion_info = self.order_completion_status[order_code]
+                        self.hardware_interface._logger.info(
+                            f"检测到任务 {order_code} 已完成，状态: {completion_info.get('status')}"
+                        )
+
+                        # 获取实验报告
+                        try:
+                            report = self.project_order_report(order_id)
+
+                            if not report:
+                                self.hardware_interface._logger.warning(
+                                    f"任务 {order_code} 已完成但无法获取报告"
+                                )
+                                report = {"error": "无法获取报告"}
+                            else:
+                                self.hardware_interface._logger.info(
+                                    f"成功获取任务 {order_code} 的实验报告"
+                                )
+
+                            reports.append({
+                                "order_code": order_code,
+                                "order_id": order_id,
+                                "status": "completed",
+                                "completion_status": completion_info.get('status'),
+                                "report": report,
+                                "extracted": self._extract_actuals_from_report(report),
+                                "elapsed_time": elapsed_time
+                            })
+
+                            # 标记为已完成
+                            completed_in_this_round.append(order_code)
+
+                            # 清理完成状态记录
+                            del self.order_completion_status[order_code]
+
+                        except Exception as e:
+                            self.hardware_interface._logger.error(
+                                f"查询任务 {order_code} 报告失败: {str(e)}"
+                            )
+                            reports.append({
+                                "order_code": order_code,
+                                "order_id": order_id,
+                                "status": "error",
+                                "completion_status": completion_info.get('status'),
+                                "report": None,
+                                "extracted": None,
+                                "error": str(e),
+                                "elapsed_time": elapsed_time
+                            })
+                            completed_in_this_round.append(order_code)
+
+                # 从待完成列表中移除已完成的任务
+                for order_code in completed_in_this_round:
+                    del pending_orders[order_code]
+
+                # 如果还有待完成的任务，等待后继续
+                if pending_orders:
+                    time.sleep(check_interval)
+
+                    # 每分钟记录一次等待状态
+                    new_elapsed_time = time.time() - start_time
+                    if int(new_elapsed_time) % 60 == 0 and new_elapsed_time > 0:
+                        self.hardware_interface._logger.info(
+                            f"批量等待任务中... 已完成 {len(reports)}/{total}, "
+                            f"待完成: {', '.join(pending_orders.keys())}, "
+                            f"已等待 {int(new_elapsed_time/60)} 分钟"
+                        )
+
+            # 统计结果
+            completed_count = sum(1 for r in reports if r['status'] == 'completed')
+            timeout_count = sum(1 for r in reports if r['status'] == 'timeout')
+            error_count = sum(1 for r in reports if r['status'] == 'error')
+
+            final_elapsed_time = time.time() - start_time
+
+            summary = {
+                "total": total,
+                "completed": completed_count,
+                "timeout": timeout_count,
+                "error": error_count,
+                "elapsed_time": round(final_elapsed_time, 2),
+                "reports": reports
+            }
+
+            self.hardware_interface._logger.info(
+                f"批量等待任务完成: 总数={total}, 成功={completed_count}, "
+                f"超时={timeout_count}, 错误={error_count}, 耗时={final_elapsed_time:.1f}秒"
+            )
+
+            # 返回字典格式，在顶层包含统计信息
+            return {
+                "return_info": json.dumps(summary, ensure_ascii=False)
+            }
+
+        except BioyondException:
+            raise
+        except Exception as e:
+            error_msg = f"批量等待任务完成时发生未预期的错误: {str(e)}"
+            self.hardware_interface._logger.error(error_msg)
+            raise BioyondException(error_msg)
+
+    def process_order_finish_report(self, report_request, used_materials) -> Dict[str, Any]:
+        """
+        重写父类方法，处理任务完成报送并记录到 order_completion_status
+
+        Args:
+            report_request: WorkstationReportRequest 对象，包含任务完成信息
+            used_materials: 物料使用记录列表
+
+        Returns:
+            Dict[str, Any]: 处理结果
+        """
+        try:
+            # 调用父类方法
+            result = super().process_order_finish_report(report_request, used_materials)
+
+            # 记录任务完成状态
+            data = report_request.data
+            order_code = data.get('orderCode')
+
+            if order_code:
+                self.order_completion_status[order_code] = {
+                    'status': data.get('status'),
+                    'order_name': data.get('orderName'),
+                    'timestamp': datetime.now().isoformat(),
+                    'start_time': data.get('startTime'),
+                    'end_time': data.get('endTime')
+                }
+
+                self.hardware_interface._logger.info(
+                    f"已记录任务完成状态: {order_code}, status={data.get('status')}"
+                )
+
+            return result
+
+        except Exception as e:
+            self.hardware_interface._logger.error(f"处理任务完成报送失败: {e}")
+            return {"processed": False, "error": str(e)}
+
+    def transfer_materials_to_reaction_station(
+        self,
+        target_device_id: str,
+        transfer_groups: list
+    ) -> dict:
+        """
+        将配液站完成的物料转移到指定反应站的堆栈库位
+        支持多组转移任务,每组包含物料名称、目标堆栈和目标库位
+
+        Args:
+            target_device_id: 目标反应站设备ID(所有转移组使用同一个设备)
+            transfer_groups: 转移任务组列表,每组包含:
+                - materials: 物料名称(字符串,将通过RPC查询)
+                - target_stack: 目标堆栈名称(如"堆栈1左")
+                - target_sites: 目标库位(如"A01")
+
+        Returns:
+            dict: 转移结果
+                {
+                    "success": bool,
+                    "total_groups": int,
+                    "successful_groups": int,
+                    "failed_groups": int,
+                    "target_device_id": str,
+                    "details": [...]
+                }
+        """
+        try:
+            # 验证参数
+            if not target_device_id:
+                raise ValueError("目标设备ID不能为空")
+
+            if not transfer_groups:
+                raise ValueError("转移任务组列表不能为空")
+
+            if not isinstance(transfer_groups, list):
+                raise ValueError("transfer_groups必须是列表类型")
+
+            # 标准化设备ID格式: 确保以 /devices/ 开头
+            if not target_device_id.startswith("/devices/"):
+                if target_device_id.startswith("/"):
+                    target_device_id = f"/devices{target_device_id}"
+                else:
+                    target_device_id = f"/devices/{target_device_id}"
+
+            self.hardware_interface._logger.info(
+                f"目标设备ID标准化为: {target_device_id}"
+            )
+
+            self.hardware_interface._logger.info(
+                f"开始执行批量物料转移: {len(transfer_groups)}组任务 -> {target_device_id}"
+            )
+
+            from .config import WAREHOUSE_MAPPING
+            results = []
+            successful_count = 0
+            failed_count = 0
+
+            for idx, group in enumerate(transfer_groups, 1):
+                try:
+                    # 提取参数
+                    material_name = group.get("materials", "")
+                    target_stack = group.get("target_stack", "")
+                    target_sites = group.get("target_sites", "")
+
+                    # 验证必填参数
+                    if not material_name:
+                        raise ValueError(f"第{idx}组: 物料名称不能为空")
+                    if not target_stack:
+                        raise ValueError(f"第{idx}组: 目标堆栈不能为空")
+                    if not target_sites:
+                        raise ValueError(f"第{idx}组: 目标库位不能为空")
+
+                    self.hardware_interface._logger.info(
+                        f"处理第{idx}组转移: {material_name} -> "
+                        f"{target_device_id}/{target_stack}/{target_sites}"
+                    )
+
+                    # 通过物料名称从deck获取ResourcePLR对象
+                    try:
+                        material_resource = self.deck.get_resource(material_name)
+                        if not material_resource:
+                            raise ValueError(f"在deck中未找到物料: {material_name}")
+
+                        self.hardware_interface._logger.info(
+                            f"从deck获取到物料 {material_name}: {material_resource}"
+                        )
+                    except Exception as e:
+                        raise ValueError(
+                            f"获取物料 {material_name} 失败: {str(e)}，请确认物料已正确加载到deck中"
+                        )
+
+                    # 验证目标堆栈是否存在
+                    if target_stack not in WAREHOUSE_MAPPING:
+                        raise ValueError(
+                            f"未知的堆栈名称: {target_stack}，"
+                            f"可选值: {list(WAREHOUSE_MAPPING.keys())}"
+                        )
+
+                    # 验证库位是否有效
+                    stack_sites = WAREHOUSE_MAPPING[target_stack].get("site_uuids", {})
+                    if target_sites not in stack_sites:
+                        raise ValueError(
+                            f"库位 {target_sites} 不存在于堆栈 {target_stack} 中，"
+                            f"可选库位: {list(stack_sites.keys())}"
+                        )
+
+                    # 获取目标库位的UUID
+                    target_site_uuid = stack_sites[target_sites]
+                    if not target_site_uuid:
+                        raise ValueError(
+                            f"库位 {target_sites} 的 UUID 未配置，请在 WAREHOUSE_MAPPING 中完善"
+                        )
+
+                    # 目标位点（包含UUID）
+                    future = ROS2DeviceNode.run_async_func(
+                        self._ros_node.get_resource_with_dir,
+                        True,
+                        **{
+                            "resource_id": f"/reaction_station_bioyond/Bioyond_Deck/{target_stack}",
+                            "with_children": True,
+                        },
+                    )
+                    # 等待异步完成后再获取结果
+                    if not future:
+                        raise ValueError(f"获取目标堆栈资源future无效: {target_stack}")
+                    while not future.done():
+                        time.sleep(0.1)
+                    target_site_resource = future.result()
+
+                    # 调用父类的 transfer_resource_to_another 方法
+                    # 传入ResourcePLR对象和目标位点资源
+                    future = self.transfer_resource_to_another(
+                        resource=[material_resource],
+                        mount_resource=[target_site_resource],
+                        sites=[target_sites],
+                        mount_device_id=target_device_id
+                    )
+
+                    # 等待异步任务完成（轮询直到完成，再取结果）
+                    if future:
+                        try:
+                            while not future.done():
+                                time.sleep(0.1)
+                            future.result()
+                            self.hardware_interface._logger.info(
+                                f"异步转移任务已完成: {material_name}"
+                            )
+                        except Exception as e:
+                            raise ValueError(f"转移任务执行失败: {str(e)}")
+
+                    self.hardware_interface._logger.info(
+                        f"第{idx}组转移成功: {material_name} -> "
+                        f"{target_device_id}/{target_stack}/{target_sites}"
+                    )
+
+                    successful_count += 1
+                    results.append({
+                        "group_index": idx,
+                        "success": True,
+                        "material_name": material_name,
+                        "target_stack": target_stack,
+                        "target_site": target_sites,
+                        "message": "转移成功"
+                    })
+
+                except Exception as e:
+                    error_msg = f"第{idx}组转移失败: {str(e)}"
+                    self.hardware_interface._logger.error(error_msg)
+                    failed_count += 1
+                    results.append({
+                        "group_index": idx,
+                        "success": False,
+                        "material_name": group.get("materials", ""),
+                        "error": str(e)
+                    })
+
+            # 返回汇总结果
+            return {
+                "success": failed_count == 0,
+                "total_groups": len(transfer_groups),
+                "successful_groups": successful_count,
+                "failed_groups": failed_count,
+                "target_device_id": target_device_id,
+                "details": results,
+                "message": f"完成 {len(transfer_groups)} 组转移任务到 {target_device_id}: "
+                          f"{successful_count} 成功, {failed_count} 失败"
+            }
+
+        except Exception as e:
+            error_msg = f"批量转移物料失败: {str(e)}"
+            self.hardware_interface._logger.error(error_msg)
+            return {
+                "success": False,
+                "total_groups": len(transfer_groups) if transfer_groups else 0,
+                "successful_groups": 0,
+                "failed_groups": len(transfer_groups) if transfer_groups else 0,
+                "target_device_id": target_device_id if target_device_id else "",
+                "error": error_msg
+            }
+
+    def query_resource_by_name(self, material_name: str):
+        """
+        通过物料名称查询资源对象(适用于Bioyond系统)
+
+        Args:
+            material_name: 物料名称
+
+        Returns:
+            物料ID或None
+        """
+        try:
+            # Bioyond系统使用material_cache存储物料信息
+            if not hasattr(self.hardware_interface, 'material_cache'):
+                self.hardware_interface._logger.error(
+                    "hardware_interface没有material_cache属性"
+                )
+                return None
+
+            material_cache = self.hardware_interface.material_cache
+
+            self.hardware_interface._logger.info(
+                f"查询物料 '{material_name}', 缓存中共有 {len(material_cache)} 个物料"
+            )
+
+            # 调试: 打印前几个物料信息
+            if material_cache:
+                cache_items = list(material_cache.items())[:5]
+                for name, material_id in cache_items:
+                    self.hardware_interface._logger.debug(
+                        f"缓存物料: name={name}, id={material_id}"
+                    )
+
+            # 直接从缓存中查找
+            if material_name in material_cache:
+                material_id = material_cache[material_name]
+                self.hardware_interface._logger.info(
+                    f"找到物料: {material_name} -> ID: {material_id}"
+                )
+                return material_id
+
+            self.hardware_interface._logger.warning(
+                f"未找到物料: {material_name} (缓存中无此物料)"
+            )
+
+            # 打印所有可用物料名称供参考
+            available_materials = list(material_cache.keys())
+            if available_materials:
+                self.hardware_interface._logger.info(
+                    f"可用物料列表(前10个): {available_materials[:10]}"
+                )
+
+            return None
+
+        except Exception as e:
+            self.hardware_interface._logger.error(
+                f"查询物料失败 {material_name}: {str(e)}"
+            )
+            return None
+
 
 if __name__ == "__main__":
     bioyond = BioyondDispensingStation(config={
@@ -1089,4 +1916,3 @@ if __name__ == "__main__":
 
     # id = "3a1bce3c-4f31-c8f3-5525-f3b273bc34dc"
     # bioyond.sample_waste_removal(id)
-

unilabos/devices/workstation/bioyond_studio/reaction_station.py

@@ -1,7 +1,12 @@
 import json
+import time
 import requests
 from typing import List, Dict, Any
+from pathlib import Path
+from datetime import datetime
 from unilabos.devices.workstation.bioyond_studio.station import BioyondWorkstation
+from unilabos.devices.workstation.bioyond_studio.bioyond_rpc import MachineState
+from unilabos.ros.msgs.message_converter import convert_to_ros_msg, Float64, String
 from unilabos.devices.workstation.bioyond_studio.config import (
     WORKFLOW_STEP_IDS,
     WORKFLOW_TO_SECTION_MAP,
@@ -10,6 +15,37 @@ from unilabos.devices.workstation.bioyond_studio.config import (
 from unilabos.devices.workstation.bioyond_studio.config import API_CONFIG
 
 
+class BioyondReactor:
+    def __init__(self, config: dict = None, deck=None, protocol_type=None, **kwargs):
+        self.in_temperature = 0.0
+        self.out_temperature = 0.0
+        self.pt100_temperature = 0.0
+        self.sensor_average_temperature = 0.0
+        self.target_temperature = 0.0
+        self.setting_temperature = 0.0
+        self.viscosity = 0.0
+        self.average_viscosity = 0.0
+        self.speed = 0.0
+        self.force = 0.0
+
+    def update_metrics(self, payload: Dict[str, Any]):
+        def _f(v):
+            try:
+                return float(v)
+            except Exception:
+                return 0.0
+        self.target_temperature = _f(payload.get("targetTemperature"))
+        self.setting_temperature = _f(payload.get("settingTemperature"))
+        self.in_temperature = _f(payload.get("inTemperature"))
+        self.out_temperature = _f(payload.get("outTemperature"))
+        self.pt100_temperature = _f(payload.get("pt100Temperature"))
+        self.sensor_average_temperature = _f(payload.get("sensorAverageTemperature"))
+        self.speed = _f(payload.get("speed"))
+        self.force = _f(payload.get("force"))
+        self.viscosity = _f(payload.get("viscosity"))
+        self.average_viscosity = _f(payload.get("averageViscosity"))
+
+
 class BioyondReactionStation(BioyondWorkstation):
     """Bioyond反应站类
 
@@ -37,6 +73,19 @@ class BioyondReactionStation(BioyondWorkstation):
         print(f"BioyondReactionStation初始化完成 - workflow_mappings: {self.workflow_mappings}")
         print(f"workflow_mappings长度: {len(self.workflow_mappings)}")
 
+        self.in_temperature = 0.0
+        self.out_temperature = 0.0
+        self.pt100_temperature = 0.0
+        self.sensor_average_temperature = 0.0
+        self.target_temperature = 0.0
+        self.setting_temperature = 0.0
+        self.viscosity = 0.0
+        self.average_viscosity = 0.0
+        self.speed = 0.0
+        self.force = 0.0
+
+        self._frame_to_reactor_id = {1: "reactor_1", 2: "reactor_2", 3: "reactor_3", 4: "reactor_4", 5: "reactor_5"}
+
     # ==================== 工作流方法 ====================
 
     def reactor_taken_out(self):
@@ -232,7 +281,7 @@ class BioyondReactionStation(BioyondWorkstation):
             temperature: 温度设定(°C)
         """
         # 处理 volume 参数:优先使用直接传入的 volume,否则从 solvents 中提取
-        if volume is None and solvents is not None:
+        if not volume and solvents is not None:
             # 参数类型转换:如果是字符串则解析为字典
             if isinstance(solvents, str):
                 try:
@@ -291,22 +340,39 @@ class BioyondReactionStation(BioyondWorkstation):
 
     def liquid_feeding_titration(
         self,
-        volume_formula: str,
         assign_material_name: str,
-        titration_type: str = "1",
+        volume_formula: str = None,
+        x_value: str = None,
+        feeding_order_data: str = None,
+        extracted_actuals: str = None,
+        titration_type: str = "2",
         time: str = "90",
         torque_variation: int = 2,
         temperature: float = 25.00
     ):
         """液体进料(滴定)
 
+        支持两种模式:
+        1. 直接提供 volume_formula (传统方式)
+        2. 自动计算公式: 提供 x_value, feeding_order_data, extracted_actuals (新方式)
+
         Args:
-            volume_formula: 分液公式(μL)
             assign_material_name: 物料名称
-            titration_type: 是否滴定(1=否, 2=是)
+            volume_formula: 分液公式(μL),如果提供则直接使用,否则自动计算
+            x_value: 手工输入的x值,格式如 "1-2-3"
+            feeding_order_data: feeding_order JSON字符串或对象,用于获取m二酐值
+            extracted_actuals: 从报告提取的实际加料量JSON字符串,包含actualTargetWeigh和actualVolume
+            titration_type: 是否滴定(1=否, 2=是),默认2
             time: 观察时间(分钟)
             torque_variation: 是否观察(int类型, 1=否, 2=是)
             temperature: 温度(°C)
+
+        自动公式模板: 1000*(m二酐-x)*V二酐滴定/m二酐滴定
+        其中:
+        - m二酐滴定 = actualTargetWeigh (从extracted_actuals获取)
+        - V二酐滴定 = actualVolume (从extracted_actuals获取)
+        - x = x_value (手工输入)
+        - m二酐 = feeding_order中type为"main_anhydride"的amount值
         """
         self.append_to_workflow_sequence('{"web_workflow_name": "Liquid_feeding(titration)"}')
         material_id = self.hardware_interface._get_material_id_by_name(assign_material_name)
@@ -316,6 +382,84 @@ class BioyondReactionStation(BioyondWorkstation):
         if isinstance(temperature, str):
             temperature = float(temperature)
 
+        # 如果没有直接提供volume_formula,则自动计算
+        if not volume_formula and x_value and feeding_order_data and extracted_actuals:
+            # 1. 解析 feeding_order_data 获取 m二酐
+            if isinstance(feeding_order_data, str):
+                try:
+                    feeding_order_data = json.loads(feeding_order_data)
+                except json.JSONDecodeError as e:
+                    raise ValueError(f"feeding_order_data JSON解析失败: {str(e)}")
+
+            # 支持两种格式:
+            # 格式1: 直接是数组 [{...}, {...}]
+            # 格式2: 对象包裹 {"feeding_order": [{...}, {...}]}
+            if isinstance(feeding_order_data, list):
+                feeding_order_list = feeding_order_data
+            elif isinstance(feeding_order_data, dict):
+                feeding_order_list = feeding_order_data.get("feeding_order", [])
+            else:
+                raise ValueError("feeding_order_data 必须是数组或包含feeding_order的字典")
+
+            # 从feeding_order中找到main_anhydride的amount
+            m_anhydride = None
+            for item in feeding_order_list:
+                if item.get("type") == "main_anhydride":
+                    m_anhydride = item.get("amount")
+                    break
+
+            if m_anhydride is None:
+                raise ValueError("在feeding_order中未找到type为'main_anhydride'的条目")
+
+            # 2. 解析 extracted_actuals 获取 actualTargetWeigh 和 actualVolume
+            if isinstance(extracted_actuals, str):
+                try:
+                    extracted_actuals_obj = json.loads(extracted_actuals)
+                except json.JSONDecodeError as e:
+                    raise ValueError(f"extracted_actuals JSON解析失败: {str(e)}")
+            else:
+                extracted_actuals_obj = extracted_actuals
+
+            # 获取actuals数组
+            actuals_list = extracted_actuals_obj.get("actuals", [])
+            if not actuals_list:
+                # actuals为空,无法自动生成公式,回退到手动模式
+                print(f"警告: extracted_actuals中actuals数组为空,无法自动生成公式,请手动提供volume_formula")
+                volume_formula = None  # 清空,触发后续的错误检查
+            else:
+                # 根据assign_material_name匹配对应的actual数据
+                # 假设order_code中包含物料名称
+                matched_actual = None
+                for actual in actuals_list:
+                    order_code = actual.get("order_code", "")
+                    # 简单匹配:如果order_code包含物料名称
+                    if assign_material_name in order_code:
+                        matched_actual = actual
+                        break
+
+                # 如果没有匹配到,使用第一个
+                if not matched_actual and actuals_list:
+                    matched_actual = actuals_list[0]
+
+                if not matched_actual:
+                    raise ValueError("无法从extracted_actuals中获取实际加料量数据")
+
+                m_anhydride_titration = matched_actual.get("actualTargetWeigh")  # m二酐滴定
+                v_anhydride_titration = matched_actual.get("actualVolume")       # V二酐滴定
+
+                if m_anhydride_titration is None or v_anhydride_titration is None:
+                    raise ValueError(f"实际加料量数据不完整: actualTargetWeigh={m_anhydride_titration}, actualVolume={v_anhydride_titration}")
+
+                # 3. 构建公式: 1000*(m二酐-x)*V二酐滴定/m二酐滴定
+                # x_value 格式如 "{{1-2-3}}",保留完整格式(包括花括号)直接替换到公式中
+                volume_formula = f"1000*({m_anhydride}-{x_value})*{v_anhydride_titration}/{m_anhydride_titration}"
+
+                print(f"自动生成滴定公式: {volume_formula}")
+                print(f"  m二酐={m_anhydride}, x={x_value}, V二酐滴定={v_anhydride_titration}, m二酐滴定={m_anhydride_titration}")
+
+        elif not volume_formula:
+            raise ValueError("必须提供 volume_formula 或 (x_value + feeding_order_data + extracted_actuals)")
+
         liquid_step_id = WORKFLOW_STEP_IDS["liquid_feeding_titration"]["liquid"]
         observe_step_id = WORKFLOW_STEP_IDS["liquid_feeding_titration"]["observe"]
 
@@ -343,9 +487,288 @@ class BioyondReactionStation(BioyondWorkstation):
         print(f"当前队列长度: {len(self.pending_task_params)}")
         return json.dumps({"suc": True})
 
+    def _extract_actuals_from_report(self, report) -> Dict[str, Any]:
+        data = report.get('data') if isinstance(report, dict) else None
+        actual_target_weigh = None
+        actual_volume = None
+        if data:
+            extra = data.get('extraProperties') or {}
+            if isinstance(extra, dict):
+                for v in extra.values():
+                    obj = None
+                    try:
+                        obj = json.loads(v) if isinstance(v, str) else v
+                    except Exception:
+                        obj = None
+                    if isinstance(obj, dict):
+                        tw = obj.get('targetWeigh')
+                        vol = obj.get('volume')
+                        if tw is not None:
+                            try:
+                                actual_target_weigh = float(tw)
+                            except Exception:
+                                pass
+                        if vol is not None:
+                            try:
+                                actual_volume = float(vol)
+                            except Exception:
+                                pass
+        return {
+            'actualTargetWeigh': actual_target_weigh,
+            'actualVolume': actual_volume
+        }
+
+    def extract_actuals_from_batch_reports(self, batch_reports_result: str) -> dict:
+        print(f"[DEBUG] extract_actuals 收到原始数据: {batch_reports_result[:500]}...")  # 打印前500字符
+        try:
+            obj = json.loads(batch_reports_result) if isinstance(batch_reports_result, str) else batch_reports_result
+            if isinstance(obj, dict) and "return_info" in obj:
+                inner = obj["return_info"]
+                obj = json.loads(inner) if isinstance(inner, str) else inner
+            reports = obj.get("reports", []) if isinstance(obj, dict) else []
+            print(f"[DEBUG] 解析后的 reports 数组长度: {len(reports)}")
+        except Exception as e:
+            print(f"[DEBUG] 解析异常: {e}")
+            reports = []
+
+        actuals = []
+        for i, r in enumerate(reports):
+            print(f"[DEBUG] 处理 report[{i}]: order_code={r.get('order_code')}, has_extracted={r.get('extracted') is not None}, has_report={r.get('report') is not None}")
+            order_code = r.get("order_code")
+            order_id = r.get("order_id")
+            ex = r.get("extracted")
+            if isinstance(ex, dict) and (ex.get("actualTargetWeigh") is not None or ex.get("actualVolume") is not None):
+                print(f"[DEBUG] 从 extracted 字段提取: actualTargetWeigh={ex.get('actualTargetWeigh')}, actualVolume={ex.get('actualVolume')}")
+                actuals.append({
+                    "order_code": order_code,
+                    "order_id": order_id,
+                    "actualTargetWeigh": ex.get("actualTargetWeigh"),
+                    "actualVolume": ex.get("actualVolume")
+                })
+                continue
+            report = r.get("report")
+            vals = self._extract_actuals_from_report(report) if report else {"actualTargetWeigh": None, "actualVolume": None}
+            print(f"[DEBUG] 从 report 字段提取: {vals}")
+            actuals.append({
+                "order_code": order_code,
+                "order_id": order_id,
+                **vals
+            })
+
+        print(f"[DEBUG] 最终提取的 actuals 数组长度: {len(actuals)}")
+        result = {
+            "return_info": json.dumps({"actuals": actuals}, ensure_ascii=False)
+        }
+        print(f"[DEBUG] 返回结果: {result}")
+        return result
+
+    def process_temperature_cutoff_report(self, report_request) -> Dict[str, Any]:
+        try:
+            data = report_request.data
+            def _f(v):
+                try:
+                    return float(v)
+                except Exception:
+                    return 0.0
+            self.target_temperature = _f(data.get("targetTemperature"))
+            self.setting_temperature = _f(data.get("settingTemperature"))
+            self.in_temperature = _f(data.get("inTemperature"))
+            self.out_temperature = _f(data.get("outTemperature"))
+            self.pt100_temperature = _f(data.get("pt100Temperature"))
+            self.sensor_average_temperature = _f(data.get("sensorAverageTemperature"))
+            self.speed = _f(data.get("speed"))
+            self.force = _f(data.get("force"))
+            self.viscosity = _f(data.get("viscosity"))
+            self.average_viscosity = _f(data.get("averageViscosity"))
+
+            try:
+                if hasattr(self, "_ros_node") and self._ros_node is not None:
+                    props = [
+                        "in_temperature","out_temperature","pt100_temperature","sensor_average_temperature",
+                        "target_temperature","setting_temperature","viscosity","average_viscosity",
+                        "speed","force"
+                    ]
+                    for name in props:
+                        pub = self._ros_node._property_publishers.get(name)
+                        if pub:
+                            pub.publish_property()
+                    frame = data.get("frameCode")
+                    reactor_id = None
+                    try:
+                        reactor_id = self._frame_to_reactor_id.get(int(frame))
+                    except Exception:
+                        reactor_id = None
+                    if reactor_id and hasattr(self._ros_node, "sub_devices"):
+                        child = self._ros_node.sub_devices.get(reactor_id)
+                        if child and hasattr(child, "driver_instance"):
+                            child.driver_instance.update_metrics(data)
+                            pubs = getattr(child.ros_node_instance, "_property_publishers", {})
+                            for name in props:
+                                p = pubs.get(name)
+                                if p:
+                                    p.publish_property()
+            except Exception:
+                pass
+            event = {
+                "frameCode": data.get("frameCode"),
+                "generateTime": data.get("generateTime"),
+                "targetTemperature": data.get("targetTemperature"),
+                "settingTemperature": data.get("settingTemperature"),
+                "inTemperature": data.get("inTemperature"),
+                "outTemperature": data.get("outTemperature"),
+                "pt100Temperature": data.get("pt100Temperature"),
+                "sensorAverageTemperature": data.get("sensorAverageTemperature"),
+                "speed": data.get("speed"),
+                "force": data.get("force"),
+                "viscosity": data.get("viscosity"),
+                "averageViscosity": data.get("averageViscosity"),
+                "request_time": report_request.request_time,
+                "timestamp": datetime.now().isoformat(),
+                "reactor_id": self._frame_to_reactor_id.get(int(data.get("frameCode", 0))) if str(data.get("frameCode", "")).isdigit() else None,
+            }
+
+            base_dir = Path(__file__).resolve().parents[3] / "unilabos_data"
+            base_dir.mkdir(parents=True, exist_ok=True)
+            out_file = base_dir / "temperature_cutoff_events.json"
+            try:
+                existing = json.loads(out_file.read_text(encoding="utf-8")) if out_file.exists() else []
+                if not isinstance(existing, list):
+                    existing = []
+            except Exception:
+                existing = []
+            existing.append(event)
+            out_file.write_text(json.dumps(existing, ensure_ascii=False, indent=2), encoding="utf-8")
+
+            if hasattr(self, "_ros_node") and self._ros_node is not None:
+                ns = self._ros_node.namespace
+                topics = {
+                    "targetTemperature": f"{ns}/metrics/temperature_cutoff/target_temperature",
+                    "settingTemperature": f"{ns}/metrics/temperature_cutoff/setting_temperature",
+                    "inTemperature": f"{ns}/metrics/temperature_cutoff/in_temperature",
+                    "outTemperature": f"{ns}/metrics/temperature_cutoff/out_temperature",
+                    "pt100Temperature": f"{ns}/metrics/temperature_cutoff/pt100_temperature",
+                    "sensorAverageTemperature": f"{ns}/metrics/temperature_cutoff/sensor_average_temperature",
+                    "speed": f"{ns}/metrics/temperature_cutoff/speed",
+                    "force": f"{ns}/metrics/temperature_cutoff/force",
+                    "viscosity": f"{ns}/metrics/temperature_cutoff/viscosity",
+                    "averageViscosity": f"{ns}/metrics/temperature_cutoff/average_viscosity",
+                }
+                for k, t in topics.items():
+                    v = data.get(k)
+                    if v is not None:
+                        pub = self._ros_node.create_publisher(Float64, t, 10)
+                        pub.publish(convert_to_ros_msg(Float64, float(v)))
+
+                evt_pub = self._ros_node.create_publisher(String, f"{ns}/events/temperature_cutoff", 10)
+                evt_pub.publish(convert_to_ros_msg(String, json.dumps(event, ensure_ascii=False)))
+
+            return {"processed": True, "frame": data.get("frameCode")}
+        except Exception as e:
+            return {"processed": False, "error": str(e)}
+
+    def wait_for_multiple_orders_and_get_reports(self, batch_create_result: str = None, timeout: int = 7200, check_interval: int = 10) -> Dict[str, Any]:
+        try:
+            timeout = int(timeout) if timeout else 7200
+            check_interval = int(check_interval) if check_interval else 10
+            if not batch_create_result or batch_create_result == "":
+                raise ValueError("batch_create_result为空")
+            try:
+                if isinstance(batch_create_result, str) and '[...]' in batch_create_result:
+                    batch_create_result = batch_create_result.replace('[...]', '[]')
+                result_obj = json.loads(batch_create_result) if isinstance(batch_create_result, str) else batch_create_result
+                if isinstance(result_obj, dict) and "return_value" in result_obj:
+                    inner = result_obj.get("return_value")
+                    if isinstance(inner, str):
+                        result_obj = json.loads(inner)
+                    elif isinstance(inner, dict):
+                        result_obj = inner
+                order_codes = result_obj.get("order_codes", [])
+                order_ids = result_obj.get("order_ids", [])
+            except Exception as e:
+                raise ValueError(f"解析batch_create_result失败: {e}")
+            if not order_codes or not order_ids:
+                raise ValueError("缺少order_codes或order_ids")
+            if not isinstance(order_codes, list):
+                order_codes = [order_codes]
+            if not isinstance(order_ids, list):
+                order_ids = [order_ids]
+            if len(order_codes) != len(order_ids):
+                raise ValueError("order_codes与order_ids数量不匹配")
+            total = len(order_codes)
+            pending = {c: {"order_id": order_ids[i], "completed": False} for i, c in enumerate(order_codes)}
+            reports = []
+            start_time = time.time()
+            while pending:
+                elapsed_time = time.time() - start_time
+                if elapsed_time > timeout:
+                    for oc in list(pending.keys()):
+                        reports.append({
+                            "order_code": oc,
+                            "order_id": pending[oc]["order_id"],
+                            "status": "timeout",
+                            "completion_status": None,
+                            "report": None,
+                            "extracted": None,
+                            "elapsed_time": elapsed_time
+                        })
+                    break
+                completed_round = []
+                for oc in list(pending.keys()):
+                    oid = pending[oc]["order_id"]
+                    if oc in self.order_completion_status:
+                        info = self.order_completion_status[oc]
+                        try:
+                            rep = self.hardware_interface.order_report(oid)
+                            if not rep:
+                                rep = {"error": "无法获取报告"}
+                            reports.append({
+                                "order_code": oc,
+                                "order_id": oid,
+                                "status": "completed",
+                                "completion_status": info.get('status'),
+                                "report": rep,
+                                "extracted": self._extract_actuals_from_report(rep),
+                                "elapsed_time": elapsed_time
+                            })
+                            completed_round.append(oc)
+                            del self.order_completion_status[oc]
+                        except Exception as e:
+                            reports.append({
+                                "order_code": oc,
+                                "order_id": oid,
+                                "status": "error",
+                                "completion_status": info.get('status') if 'info' in locals() else None,
+                                "report": None,
+                                "extracted": None,
+                                "error": str(e),
+                                "elapsed_time": elapsed_time
+                            })
+                            completed_round.append(oc)
+                for oc in completed_round:
+                    del pending[oc]
+                if pending:
+                    time.sleep(check_interval)
+            completed_count = sum(1 for r in reports if r['status'] == 'completed')
+            timeout_count = sum(1 for r in reports if r['status'] == 'timeout')
+            error_count = sum(1 for r in reports if r['status'] == 'error')
+            final_elapsed_time = time.time() - start_time
+            summary = {
+                "total": total,
+                "completed": completed_count,
+                "timeout": timeout_count,
+                "error": error_count,
+                "elapsed_time": round(final_elapsed_time, 2),
+                "reports": reports
+            }
+            return {
+                "return_info": json.dumps(summary, ensure_ascii=False)
+            }
+        except Exception as e:
+            raise
+
     def liquid_feeding_beaker(
         self,
-        volume: str = "35000",
+        volume: str = "350",
         assign_material_name: str = "BAPP",
         time: str = "0",
         torque_variation: int = 1,
@@ -355,7 +778,7 @@ class BioyondReactionStation(BioyondWorkstation):
         """液体进料烧杯
 
         Args:
-            volume: 分液量(μL)
+            volume: 分液质量(g)
             assign_material_name: 物料名称(试剂瓶位)
             time: 观察时间(分钟)
             torque_variation: 是否观察(int类型, 1=否, 2=是)
@@ -489,6 +912,106 @@ class BioyondReactionStation(BioyondWorkstation):
         """
         return self.hardware_interface.create_order(json_str)
 
+    def hard_delete_merged_workflows(self, workflow_ids: List[str]) -> Dict[str, Any]:
+        """
+        调用新接口：硬删除合并后的工作流
+
+        Args:
+            workflow_ids: 要删除的工作流ID数组
+
+        Returns:
+            删除结果
+        """
+        try:
+            if not isinstance(workflow_ids, list):
+                raise ValueError("workflow_ids必须是字符串数组")
+            return self._delete_project_api("/api/lims/order/workflows", workflow_ids)
+        except Exception as e:
+            print(f"❌ 硬删除异常: {str(e)}")
+            return {"code": 0, "message": str(e), "timestamp": int(time.time())}
+
+    # ==================== 项目接口通用方法 ====================
+
+    def _post_project_api(self, endpoint: str, data: Any) -> Dict[str, Any]:
+        """项目接口通用POST调用
+
+        参数:
+            endpoint: 接口路径（例如 /api/lims/order/skip-titration-steps）
+            data: 请求体中的 data 字段内容
+
+        返回:
+            dict: 服务端响应，失败时返回 {code:0,message,...}
+        """
+        request_data = {
+            "apiKey": API_CONFIG["api_key"],
+            "requestTime": self.hardware_interface.get_current_time_iso8601(),
+            "data": data
+        }
+        print(f"\n📤 项目POST请求: {self.hardware_interface.host}{endpoint}")
+        print(json.dumps(request_data, indent=4, ensure_ascii=False))
+        try:
+            response = requests.post(
+                f"{self.hardware_interface.host}{endpoint}",
+                json=request_data,
+                headers={"Content-Type": "application/json"},
+                timeout=30
+            )
+            result = response.json()
+            if result.get("code") == 1:
+                print("✅ 请求成功")
+            else:
+                print(f"❌ 请求失败: {result.get('message','未知错误')}")
+            return result
+        except json.JSONDecodeError:
+            print("❌ 非JSON响应")
+            return {"code": 0, "message": "非JSON响应", "timestamp": int(time.time())}
+        except requests.exceptions.Timeout:
+            print("❌ 请求超时")
+            return {"code": 0, "message": "请求超时", "timestamp": int(time.time())}
+        except requests.exceptions.RequestException as e:
+            print(f"❌ 网络异常: {str(e)}")
+            return {"code": 0, "message": str(e), "timestamp": int(time.time())}
+
+    def _delete_project_api(self, endpoint: str, data: Any) -> Dict[str, Any]:
+        """项目接口通用DELETE调用
+
+        参数:
+            endpoint: 接口路径（例如 /api/lims/order/workflows）
+            data: 请求体中的 data 字段内容
+
+        返回:
+            dict: 服务端响应，失败时返回 {code:0,message,...}
+        """
+        request_data = {
+            "apiKey": API_CONFIG["api_key"],
+            "requestTime": self.hardware_interface.get_current_time_iso8601(),
+            "data": data
+        }
+        print(f"\n📤 项目DELETE请求: {self.hardware_interface.host}{endpoint}")
+        print(json.dumps(request_data, indent=4, ensure_ascii=False))
+        try:
+            response = requests.delete(
+                f"{self.hardware_interface.host}{endpoint}",
+                json=request_data,
+                headers={"Content-Type": "application/json"},
+                timeout=30
+            )
+            result = response.json()
+            if result.get("code") == 1:
+                print("✅ 请求成功")
+            else:
+                print(f"❌ 请求失败: {result.get('message','未知错误')}")
+            return result
+        except json.JSONDecodeError:
+            print("❌ 非JSON响应")
+            return {"code": 0, "message": "非JSON响应", "timestamp": int(time.time())}
+        except requests.exceptions.Timeout:
+            print("❌ 请求超时")
+            return {"code": 0, "message": "请求超时", "timestamp": int(time.time())}
+        except requests.exceptions.RequestException as e:
+            print(f"❌ 网络异常: {str(e)}")
+            return {"code": 0, "message": str(e), "timestamp": int(time.time())}
+
     # ==================== 工作流执行核心方法 ====================
 
     def process_web_workflows(self, web_workflow_json: str) -> List[Dict[str, str]]:
@@ -519,69 +1042,6 @@ class BioyondReactionStation(BioyondWorkstation):
             print(f"错误：处理工作流失败: {e}")
             return []
 
-    def process_and_execute_workflow(self, workflow_name: str, task_name: str) -> dict:
-        """
-        一站式处理工作流程：解析网页工作流列表，合并工作流(带参数)，然后发布任务
-
-        Args:
-            workflow_name: 合并后的工作流名称
-            task_name: 任务名称
-
-        Returns:
-            任务创建结果
-        """
-        web_workflow_list = self.get_workflow_sequence()
-        print(f"\n{'='*60}")
-        print(f"📋 处理网页工作流列表: {web_workflow_list}")
-        print(f"{'='*60}")
-
-        web_workflow_json = json.dumps({"web_workflow_list": web_workflow_list})
-        workflows_result = self.process_web_workflows(web_workflow_json)
-
-        if not workflows_result:
-            return self._create_error_result("处理网页工作流列表失败", "process_web_workflows")
-
-        print(f"workflows_result 类型: {type(workflows_result)}")
-        print(f"workflows_result 内容: {workflows_result}")
-
-        workflows_with_params = self._build_workflows_with_parameters(workflows_result)
-
-        merge_data = {
-            "name": workflow_name,
-            "workflows": workflows_with_params
-        }
-
-        # print(f"\n🔄 合并工作流（带参数），名称: {workflow_name}")
-        merged_workflow = self.merge_workflow_with_parameters(json.dumps(merge_data))
-
-        if not merged_workflow:
-            return self._create_error_result("合并工作流失败", "merge_workflow_with_parameters")
-
-        workflow_id = merged_workflow.get("subWorkflows", [{}])[0].get("id", "")
-        # print(f"\n📤 使用工作流创建任务: {workflow_name} (ID: {workflow_id})")
-
-        order_params = [{
-            "orderCode": f"task_{self.hardware_interface.get_current_time_iso8601()}",
-            "orderName": task_name,
-            "workFlowId": workflow_id,
-            "borderNumber": 1,
-            "paramValues": {}
-        }]
-
-        result = self.create_order(json.dumps(order_params))
-
-        if not result:
-            return self._create_error_result("创建任务失败", "create_order")
-
-        # 清空工作流序列和参数，防止下次执行时累积重复
-        self.pending_task_params = []
-        self.clear_workflows()  # 清空工作流序列，避免重复累积
-
-        # print(f"\n✅ 任务创建成功: {result}")
-        # print(f"\n✅ 任务创建成功")
-        print(f"{'='*60}\n")
-        return json.dumps({"success": True, "result": result})
-
     def _build_workflows_with_parameters(self, workflows_result: list) -> list:
         """
         构建带参数的工作流列表
@@ -780,4 +1240,91 @@ class BioyondReactionStation(BioyondWorkstation):
         except Exception as e:
             print(f"   ❌ 工作流ID验证失败: {e}")
             print(f"   💡 将重新合并工作流")
-            return False
+            return False
+
+    def process_and_execute_workflow(self, workflow_name: str, task_name: str) -> dict:
+        """
+        一站式处理工作流程：解析网页工作流列表，合并工作流(带参数)，然后发布任务
+
+        Args:
+            workflow_name: 合并后的工作流名称
+            task_name: 任务名称
+
+        Returns:
+            任务创建结果
+        """
+        web_workflow_list = self.get_workflow_sequence()
+        print(f"\n{'='*60}")
+        print(f"📋 处理网页工作流列表: {web_workflow_list}")
+        print(f"{'='*60}")
+
+        web_workflow_json = json.dumps({"web_workflow_list": web_workflow_list})
+        workflows_result = self.process_web_workflows(web_workflow_json)
+
+        if not workflows_result:
+            return self._create_error_result("处理网页工作流列表失败", "process_web_workflows")
+
+        print(f"workflows_result 类型: {type(workflows_result)}")
+        print(f"workflows_result 内容: {workflows_result}")
+
+        workflows_with_params = self._build_workflows_with_parameters(workflows_result)
+
+        merge_data = {
+            "name": workflow_name,
+            "workflows": workflows_with_params
+        }
+
+        # print(f"\n🔄 合并工作流（带参数），名称: {workflow_name}")
+        merged_workflow = self.merge_workflow_with_parameters(json.dumps(merge_data))
+
+        if not merged_workflow:
+            return self._create_error_result("合并工作流失败", "merge_workflow_with_parameters")
+
+        workflow_id = merged_workflow.get("subWorkflows", [{}])[0].get("id", "")
+        # print(f"\n📤 使用工作流创建任务: {workflow_name} (ID: {workflow_id})")
+
+        order_params = [{
+            "orderCode": f"task_{self.hardware_interface.get_current_time_iso8601()}",
+            "orderName": task_name,
+            "workFlowId": workflow_id,
+            "borderNumber": 1,
+            "paramValues": {}
+        }]
+
+        result = self.create_order(json.dumps(order_params))
+
+        if not result:
+            return self._create_error_result("创建任务失败", "create_order")
+
+        # 清空工作流序列和参数，防止下次执行时累积重复
+        self.pending_task_params = []
+        self.clear_workflows()  # 清空工作流序列，避免重复累积
+
+        # print(f"\n✅ 任务创建成功: {result}")
+        # print(f"\n✅ 任务创建成功")
+        print(f"{'='*60}\n")
+
+        # 返回结果，包含合并后的工作流数据和订单参数
+        return json.dumps({
+            "success": True,
+            "result": result,
+            "merged_workflow": merged_workflow,
+            "order_params": order_params
+        })
+
+    # ==================== 反应器操作接口 ====================
+
+    def skip_titration_steps(self, preintake_id: str) -> Dict[str, Any]:
+        """跳过当前正在进行的滴定步骤
+
+        Args:
+            preintake_id: 通量ID
+
+        Returns:
+            Dict[str, Any]: 服务器响应，包含状态码、消息和时间戳
+        """
+        try:
+            return self._post_project_api("/api/lims/order/skip-titration-steps", preintake_id)
+        except Exception as e:
+            print(f"❌ 跳过滴定异常: {str(e)}")
+            return {"code": 0, "message": str(e), "timestamp": int(time.time())}

unilabos/devices/workstation/coin_cell_assembly/YB_YH_materials.py

@@ -1,645 +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
-
-from unilabos.resources.battery.magazine import MagazineHolder_4_Cathode, MagazineHolder_6_Cathode, MagazineHolder_6_Anode, MagazineHolder_6_Battery
-from unilabos.resources.battery.bottle_carriers import YIHUA_Electrolyte_12VialCarrier
-from unilabos.resources.battery.electrode_sheet import ElectrodeSheet
-
-
-
-# TODO: 这个应该只能放一个极片
-class MaterialHoleState(TypedDict):
-    diameter: int
-    depth: int
-    max_sheets: int
-    info: Optional[str]  # 附加信息
-
-class MaterialHole(Resource):
-    """料板洞位类"""
-    children: List[ElectrodeSheet] = []
-
-    def __init__(
-        self,
-        name: str,
-        size_x: float,
-        size_y: float,
-        size_z: float,
-        category: str = "material_hole",
-        **kwargs
-    ):
-        super().__init__(
-            name=name,
-            size_x=size_x,
-            size_y=size_y,
-            size_z=size_z,
-            category=category,
-        )
-        self._unilabos_state: MaterialHoleState = MaterialHoleState(
-            diameter=20,
-            depth=10,
-            max_sheets=1,
-            info=None
-        )
-
-    def get_all_sheet_info(self):
-        info_list = []
-        for sheet in self.children:
-            info_list.append(sheet._unilabos_state["info"])
-        return info_list
-    
-    #这个函数函数好像没用，一般不会集中赋值质量
-    def set_all_sheet_mass(self):
-        for sheet in self.children:
-            sheet._unilabos_state["mass"] = 0.5  # 示例：设置质量为0.5g
-
-    def load_state(self, state: Dict[str, Any]) -> None:
-        """格式不变"""
-        super().load_state(state)
-        self._unilabos_state = state
-
-    def serialize_state(self) -> Dict[str, Dict[str, Any]]:
-        """格式不变"""
-        data = super().serialize_state()
-        data.update(self._unilabos_state)  # Container自身的信息，云端物料将保存这一data，本地也通过这里的data进行读写，当前类用来表示这个物料的长宽高大小的属性，而data（state用来表示物料的内容，细节等）
-        return data
-    #移动极片前先取出对象
-    def get_sheet_with_name(self, name: str) -> Optional[ElectrodeSheet]:
-        for sheet in self.children:
-            if sheet.name == name:
-                return sheet
-        return None
-
-    def has_electrode_sheet(self) -> bool:
-        """检查洞位是否有极片"""
-        return len(self.children) > 0
-
-    def assign_child_resource(
-        self,
-        resource: ElectrodeSheet,
-        location: Optional[Coordinate],
-        reassign: bool = True,
-    ):
-        """放置极片"""
-        # TODO: 这里要改，diameter找不到，加入._unilabos_state后应该没问题
-        #if resource._unilabos_state["diameter"] > self._unilabos_state["diameter"]:
-        #    raise ValueError(f"极片直径 {resource._unilabos_state['diameter']} 超过洞位直径 {self._unilabos_state['diameter']}")
-        #if len(self.children) >= self._unilabos_state["max_sheets"]:
-        #    raise ValueError(f"洞位已满，无法放置更多极片")
-        super().assign_child_resource(resource, location, reassign)
-
-    # 根据children的编号取物料对象。
-    def get_electrode_sheet_info(self, index: int) -> ElectrodeSheet:
-        return self.children[index]
-
-
-class MaterialPlateState(TypedDict):
-    hole_spacing_x: float
-    hole_spacing_y: float
-    hole_diameter: float
-    info: Optional[str]  # 附加信息
-
-class MaterialPlate(ItemizedResource[MaterialHole]):
-    """料板类 - 4x4个洞位，每个洞位放1个极片"""
-    
-    children: List[MaterialHole]
-
-    def __init__(
-        self,
-        name: str,
-        size_x: float,
-        size_y: float,
-        size_z: float,
-        ordered_items: Optional[Dict[str, MaterialHole]] = None,
-        ordering: Optional[OrderedDict[str, str]] = None,
-        category: str = "material_plate",
-        model: Optional[str] = None,
-        fill: bool = False
-    ):
-        """初始化料板
-
-        Args:
-            name: 料板名称
-            size_x: 长度 (mm)
-            size_y: 宽度 (mm)
-            size_z: 高度 (mm)
-            hole_diameter: 洞直径 (mm)
-            hole_depth: 洞深度 (mm)
-            hole_spacing_x: X方向洞位间距 (mm)
-            hole_spacing_y: Y方向洞位间距 (mm)
-            number: 编号
-            category: 类别
-            model: 型号
-        """
-        self._unilabos_state: MaterialPlateState = MaterialPlateState(
-            hole_spacing_x=24.0,
-            hole_spacing_y=24.0,
-            hole_diameter=20.0,
-            info="",
-        )
-        # 创建4x4的洞位
-        # TODO: 这里要改，对应不同形状
-        holes = create_ordered_items_2d(
-            klass=MaterialHole,
-            num_items_x=4,
-            num_items_y=4,
-            dx=(size_x - 4 * self._unilabos_state["hole_spacing_x"]) / 2,  # 居中
-            dy=(size_y - 4 * self._unilabos_state["hole_spacing_y"]) / 2,  # 居中
-            dz=size_z,
-            item_dx=self._unilabos_state["hole_spacing_x"],
-            item_dy=self._unilabos_state["hole_spacing_y"],
-            size_x = 16,
-            size_y = 16,
-            size_z = 16,
-        )
-        if fill:
-            super().__init__(
-                name=name,
-                size_x=size_x,
-                size_y=size_y,
-                size_z=size_z,
-                ordered_items=holes,
-                category=category,
-                model=model,
-            )
-        else:
-            super().__init__(
-                name=name,
-                size_x=size_x,
-                size_y=size_y,
-                size_z=size_z,
-                ordered_items=ordered_items,
-                ordering=ordering,
-                category=category,
-                model=model,
-            )
-
-    def update_locations(self):
-        # TODO:调多次相加
-        holes = create_ordered_items_2d(
-            klass=MaterialHole,
-            num_items_x=4,
-            num_items_y=4,
-            dx=(self._size_x - 3 * self._unilabos_state["hole_spacing_x"]) / 2,  # 居中
-            dy=(self._size_y - 3 * self._unilabos_state["hole_spacing_y"]) / 2,  # 居中
-            dz=self._size_z,
-            item_dx=self._unilabos_state["hole_spacing_x"],
-            item_dy=self._unilabos_state["hole_spacing_y"],
-            size_x = 1,
-            size_y = 1,
-            size_z = 1,
-        )
-        for item, original_item in zip(holes.items(), self.children):
-            original_item.location = item[1].location
-
-
-class PlateSlot(ResourceStack):
-    """板槽位类 - 1个槽上能堆放8个板，移板只能操作最上方的板"""
-
-    def __init__(
-        self,
-        name: str,
-        size_x: float,
-        size_y: float,
-        size_z: float,
-        max_plates: int = 8,
-        category: str = "plate_slot",
-        model: Optional[str] = None
-    ):
-        """初始化板槽位
-
-        Args:
-            name: 槽位名称
-            max_plates: 最大板数量
-            category: 类别
-        """
-        super().__init__(
-            name=name,
-            direction="z",  # Z方向堆叠
-            resources=[],
-        )
-        self.max_plates = max_plates
-        self.category = category
-
-    def can_add_plate(self) -> bool:
-        """检查是否可以添加板"""
-        return len(self.children) < self.max_plates
-
-    def add_plate(self, plate: MaterialPlate) -> None:
-        """添加料板"""
-        if not self.can_add_plate():
-            raise ValueError(f"槽位 {self.name} 已满，无法添加更多板")
-        self.assign_child_resource(plate)
-
-    def get_top_plate(self) -> MaterialPlate:
-        """获取最上方的板"""
-        if len(self.children) == 0:
-            raise ValueError(f"槽位 {self.name} 为空")
-        return cast(MaterialPlate, self.get_top_item())
-
-    def take_top_plate(self) -> MaterialPlate:
-        """取出最上方的板"""
-        top_plate = self.get_top_plate()
-        self.unassign_child_resource(top_plate)
-        return top_plate
-
-    def can_access_for_picking(self) -> bool:
-        """检查是否可以进行取料操作（只有最上方的板能进行取料操作）"""
-        return len(self.children) > 0
-
-    def serialize(self) -> dict:
-        return {
-            **super().serialize(),
-            "max_plates": self.max_plates,
-        }
-
-
-#是一种类型注解，不用self
-class BatteryState(TypedDict):
-    """电池状态字典"""
-    diameter: float
-    height: float
-    assembly_pressure: float
-    electrolyte_volume: float
-    electrolyte_name: str
-
-class Battery(Resource):
-    """电池类 - 可容纳极片"""
-    children: List[ElectrodeSheet] = []
-
-    def __init__(
-        self,
-        name: str,
-        size_x=1,
-        size_y=1,
-        size_z=1,
-        category: str = "battery",
-    ):
-        """初始化电池
-
-        Args:
-            name: 电池名称
-            diameter: 直径 (mm)
-            height: 高度 (mm)
-            max_volume: 最大容量 (μL)
-            barcode: 二维码编号
-            category: 类别
-            model: 型号
-        """
-        super().__init__(
-            name=name,
-            size_x=1,
-            size_y=1,
-            size_z=1,
-            category=category,
-        )
-        self._unilabos_state: BatteryState = BatteryState(
-                                 diameter = 1.0,
-                                 height = 1.0,
-                                 assembly_pressure = 1.0,
-                                 electrolyte_volume = 1.0,
-                                 electrolyte_name = "DP001"
-                                 )
-
-    def add_electrolyte_with_bottle(self, bottle: Bottle) -> bool:
-        to_add_name = bottle._unilabos_state["electrolyte_name"]
-        if bottle.aspirate_electrolyte(10):
-            if self.add_electrolyte(to_add_name, 10):
-                pass
-            else:
-                bottle._unilabos_state["electrolyte_volume"] += 10
-
-    def set_electrolyte(self, name: str, volume: float) -> None:
-        """设置电解液信息"""
-        self._unilabos_state["electrolyte_name"] = name
-        self._unilabos_state["electrolyte_volume"] = volume
-    #这个应该没用，不会有加了后再加的事情
-    def add_electrolyte(self, name: str, volume: float) -> bool:
-        """添加电解液信息"""
-        if name != self._unilabos_state["electrolyte_name"]:
-            return False
-        self._unilabos_state["electrolyte_volume"] += volume
-
-    def load_state(self, state: Dict[str, Any]) -> None:
-        """格式不变"""
-        super().load_state(state)
-        self._unilabos_state = state
-
-    def serialize_state(self) -> Dict[str, Dict[str, Any]]:
-        """格式不变"""
-        data = super().serialize_state()
-        data.update(self._unilabos_state)  # Container自身的信息，云端物料将保存这一data，本地也通过这里的data进行读写，当前类用来表示这个物料的长宽高大小的属性，而data（state用来表示物料的内容，细节等）
-        return data
-
-# 电解液作为属性放进去
-
-class BatteryPressSlotState(TypedDict):
-    """电池状态字典"""
-    diameter: float =20.0
-    depth: float = 4.0
-
-class BatteryPressSlot(Resource):
-    """电池压制槽类 - 设备，可容纳一个电池"""
-    children: List[Battery] = []
-
-    def __init__(
-        self,
-        name: str = "BatteryPressSlot",
-        category: str = "battery_press_slot",
-    ):
-        """初始化电池压制槽
-
-        Args:
-            name: 压制槽名称
-            diameter: 直径 (mm)
-            depth: 深度 (mm)
-            category: 类别
-            model: 型号
-        """
-        super().__init__(
-            name=name,
-            size_x=10,
-            size_y=12,
-            size_z=13,
-            category=category,
-        )
-        self._unilabos_state: BatteryPressSlotState = BatteryPressSlotState()
-
-    def has_battery(self) -> bool:
-        """检查是否有电池"""
-        return len(self.children) > 0
-
-    def load_state(self, state: Dict[str, Any]) -> None:
-        """格式不变"""
-        super().load_state(state)
-        self._unilabos_state = state
-
-    def serialize_state(self) -> Dict[str, Dict[str, Any]]:
-        """格式不变"""
-        data = super().serialize_state()
-        data.update(self._unilabos_state)  # Container自身的信息，云端物料将保存这一data，本地也通过这里的data进行读写，当前类用来表示这个物料的长宽高大小的属性，而data（state用来表示物料的内容，细节等）
-        return data
-    
-    def assign_child_resource(
-        self,
-        resource: Battery,
-        location: Optional[Coordinate],
-        reassign: bool = True,
-    ):
-        """放置极片"""
-        # TODO: 让高京看下槽位只有一个电池时是否这么写。
-        if self.has_battery():
-            raise ValueError(f"槽位已含有一个电池，无法再放置其他电池")
-        super().assign_child_resource(resource, location, reassign)
-
-    # 根据children的编号取物料对象。
-    def get_battery_info(self, index: int) -> Battery:
-        return self.children[0]
-
-
-def TipBox64(
-        name: str,
-        size_x: float = 127.8,
-        size_y: float = 85.5,
-        size_z: float = 60.0,
-        category: str = "tip_rack",
-        model: Optional[str] = None,
-):
-    """64孔枪头盒类"""
-    from pylabrobot.resources.tip import Tip
-
-    # 创建12x8=96个枪头位
-    def make_tip():
-        return Tip(
-            has_filter=False,
-            total_tip_length=20.0,
-            maximal_volume=1000,  # 1mL
-            fitting_depth=8.0,
-        )
-
-    tip_spots = create_ordered_items_2d(
-        klass=TipSpot,
-        num_items_x=12,
-        num_items_y=8,
-        dx=8.0,
-        dy=8.0,
-        dz=0.0,
-        item_dx=9.0,
-        item_dy=9.0,
-        size_x=10,
-        size_y=10,
-        size_z=0.0,
-        make_tip=make_tip,
-    )
-    idx_available = list(range(0, 32)) + list(range(64, 96))
-    tip_spots_available = {k: v for i, (k, v) in enumerate(tip_spots.items()) if i in idx_available}
-    tip_rack = TipRack(
-        name=name,
-        size_x=size_x,
-        size_y=size_y,
-        size_z=size_z,
-        # ordered_items=tip_spots_available,
-        ordered_items=tip_spots,
-        category=category,
-        model=model,
-        with_tips=False,
-    )
-    tip_rack.set_tip_state([True]*32 + [False]*32 + [True]*32)  # 前32和后32个有枪头，中间32个无枪头
-    return tip_rack
-
-
-class WasteTipBoxstate(TypedDict):
-    """"废枪头盒状态字典"""
-    max_tips: int = 100
-    tip_count: int = 0
-
-#枪头不是一次性的（同一溶液则反复使用），根据寄存器判断
-class WasteTipBox(Trash):
-    """废枪头盒类 - 100个枪头容量"""
-
-    def __init__(
-        self,
-        name: str,
-        size_x: float = 127.8,
-        size_y: float = 85.5,
-        size_z: float = 60.0,
-        material_z_thickness=0,
-        max_volume=float("inf"),
-        category="trash",
-        model=None,
-        compute_volume_from_height=None,
-        compute_height_from_volume=None,
-    ):
-        """初始化废枪头盒
-
-        Args:
-            name: 废枪头盒名称
-            size_x: 长度 (mm)
-            size_y: 宽度 (mm)
-            size_z: 高度 (mm)
-            max_tips: 最大枪头容量
-            category: 类别
-            model: 型号
-        """
-        super().__init__(
-            name=name,
-            size_x=size_x,
-            size_y=size_y,
-            size_z=size_z,
-            category=category,
-            model=model,
-        )
-        self._unilabos_state: WasteTipBoxstate = WasteTipBoxstate()
-
-    def add_tip(self) -> None:
-        """添加废枪头"""
-        if self._unilabos_state["tip_count"] >= self._unilabos_state["max_tips"]:
-            raise ValueError(f"废枪头盒 {self.name} 已满")
-        self._unilabos_state["tip_count"] += 1
-
-    def get_tip_count(self) -> int:
-        """获取枪头数量"""
-        return self._unilabos_state["tip_count"]
-
-    def empty(self) -> None:
-        """清空废枪头盒"""
-        self._unilabos_state["tip_count"] = 0
-
-
-    def load_state(self, state: Dict[str, Any]) -> None:
-        """格式不变"""
-        super().load_state(state)
-        self._unilabos_state = state
-
-    def serialize_state(self) -> Dict[str, Dict[str, Any]]:
-        """格式不变"""
-        data = super().serialize_state()
-        data.update(self._unilabos_state)  # Container自身的信息，云端物料将保存这一data，本地也通过这里的data进行读写，当前类用来表示这个物料的长宽高大小的属性，而data（state用来表示物料的内容，细节等）
-        return data
-
-
-class CoincellDeck(Deck):
-    """纽扣电池组装工作站台面类"""
-
-    def __init__(
-        self,
-        name: str = "coin_cell_deck",
-        size_x: float = 1450.0,  # 1m
-        size_y: float = 1450.0,  # 1m
-        size_z: float = 100.0,   # 0.9m
-        origin: Coordinate = Coordinate(-2200, 0, 0),
-        category: str = "coin_cell_deck",
-        setup: bool = False,  # 是否自动执行 setup
-    ):
-        """初始化纽扣电池组装工作站台面
-
-        Args:
-            name: 台面名称
-            size_x: 长度 (mm) - 1m
-            size_y: 宽度 (mm) - 1m
-            size_z: 高度 (mm) - 0.9m
-            origin: 原点坐标
-            category: 类别
-            setup: 是否自动执行 setup 配置标准布局
-        """
-        super().__init__(
-            name=name,
-            size_x=1450.0,
-            size_y=1450.0,
-            size_z=100.0,
-            origin=origin,
-        )
-        if setup:
-            self.setup()
-
-    def setup(self) -> None:
-        """设置工作站的标准布局 - 包含子弹夹、料盘、瓶架等完整配置"""
-        # ====================================== 子弹夹 ============================================
-        
-        # 正极片（4个洞位，2x2布局）
-        zhengji_zip = MagazineHolder_4_Cathode("正极&铝箔弹夹")
-        self.assign_child_resource(zhengji_zip, Coordinate(x=402.0, y=830.0, z=0))
-        
-        # 正极壳、平垫片（6个洞位，2x2+2布局）
-        zhengjike_zip = MagazineHolder_6_Cathode("正极壳&平垫片弹夹")
-        self.assign_child_resource(zhengjike_zip, Coordinate(x=566.0, y=272.0, z=0))
-        
-        # 负极壳、弹垫片（6个洞位，2x2+2布局）
-        fujike_zip = MagazineHolder_6_Anode("负极壳&弹垫片弹夹")
-        self.assign_child_resource(fujike_zip, Coordinate(x=474.0, y=276.0, z=0))
-        
-        # 成品弹夹（6个洞位，3x2布局）
-        chengpindanjia_zip = MagazineHolder_6_Battery("成品弹夹")
-        self.assign_child_resource(chengpindanjia_zip, Coordinate(x=260.0, y=156.0, z=0))
-        
-        # ====================================== 物料板 ============================================
-        # 创建物料板（料盘carrier）- 4x4布局
-        # 负极料盘
-        fujiliaopan = MaterialPlate(name="负极料盘", size_x=120, size_y=100, size_z=10.0, fill=True)
-        self.assign_child_resource(fujiliaopan, Coordinate(x=708.0, y=794.0, z=0))
-        # for i in range(16):
-        #     fujipian = ElectrodeSheet(name=f"{fujiliaopan.name}_jipian_{i}", size_x=12, size_y=12, size_z=0.1)
-        #     fujiliaopan.children[i].assign_child_resource(fujipian, location=None)
-
-        # 隔膜料盘
-        gemoliaopan = MaterialPlate(name="隔膜料盘", size_x=120, size_y=100, size_z=10.0, fill=True)
-        self.assign_child_resource(gemoliaopan, Coordinate(x=718.0, y=918.0, z=0))
-        # for i in range(16):
-        #     gemopian = ElectrodeSheet(name=f"{gemoliaopan.name}_jipian_{i}", size_x=12, size_y=12, size_z=0.1)
-        #     gemoliaopan.children[i].assign_child_resource(gemopian, location=None)
-
-        # ====================================== 瓶架、移液枪 ============================================
-        # 在台面上放置 3x4 瓶架、6x2 瓶架 与 64孔移液枪头盒
-        # 奔耀上料5ml分液瓶小板 - 由奔曜跨站转运而来，不单独写，但是这里应该有一个堆栈用于摆放分液瓶小板
-        
-        # bottle_rack_3x4 = BottleRack(
-        #     name="bottle_rack_3x4",
-        #     size_x=210.0,
-        #     size_y=140.0,
-        #     size_z=100.0,
-        #     num_items_x=2,
-        #     num_items_y=4,
-        #     position_spacing=35.0,
-        #     orientation="vertical",
-        # )
-        # self.assign_child_resource(bottle_rack_3x4, Coordinate(x=1542.0, y=717.0, z=0))
-        
-        # 电解液缓存位 - 6x2布局
-        bottle_rack_6x2 = YIHUA_Electrolyte_12VialCarrier(name="bottle_rack_6x2")
-        self.assign_child_resource(bottle_rack_6x2, Coordinate(x=1050.0, y=358.0, z=0))
-        # 电解液回收位6x2
-        bottle_rack_6x2_2 = YIHUA_Electrolyte_12VialCarrier(name="bottle_rack_6x2_2")
-        self.assign_child_resource(bottle_rack_6x2_2, Coordinate(x=914.0, y=358.0, z=0))
-
-        tip_box = TipBox64(name="tip_box_64")
-        self.assign_child_resource(tip_box, Coordinate(x=782.0, y=514.0, z=0))
-
-        waste_tip_box = WasteTipBox(name="waste_tip_box")
-        self.assign_child_resource(waste_tip_box, Coordinate(x=778.0, y=622.0, z=0))
-
-
-def YH_Deck(name=""):
-    cd = CoincellDeck(name=name)
-    cd.setup()
-    return cd
-
-
-if __name__ == "__main__":
-    deck = create_coin_cell_deck()
-    print(deck)

unilabos/devices/workstation/coin_cell_assembly/coin_cell_assembly.py

@@ -1,134 +1,44 @@
-      
 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 functools import wraps
-from pylabrobot.resources import Deck, Resource as PLRResource
+from pylabrobot.resources import 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.YB_YH_materials import *
+from unilabos.devices.workstation.coin_cell_assembly.button_battery_station 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
-
-
-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, 
-        config: dict = None, 
-        deck=None, 
-        address: str = "172.16.28.102",
+    def __init__(
+        self,
+        deck: CoincellDeck,
+        address: str = "192.168.1.20",
         port: str = "502",
-        debug_mode: bool = False,
+        debug_mode: bool = True,
         *args,
-        **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,)
+        **kwargs,
+    ):
+        super().__init__(
+            #桌子
+            deck=deck,
+            *args,
+            **kwargs,
+        )
         self.debug_mode = debug_mode
- 
+        self.deck = deck
         """ 连接初始化 """
         modbus_client = TCPClient(addr=address, port=port)
-        logger.debug(f"创建 Modbus 客户端: {modbus_client}")
-        _ensure_modbus_slave_kw_alias(modbus_client.client)
+        print("modbus_client", modbus_client)
         if not debug_mode:
             modbus_client.client.connect()
             count = 100
@@ -139,21 +49,27 @@ 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_1105.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.coin_num_N = 0  #已组装电池数量
+        #创建一个物料台面，包含两个极片板
+        #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]
+        #})
 
+    
     def post_init(self, ros_node: ROS2WorkstationNode):
         self._ros_node = ros_node
         #self.deck = create_a_coin_cell_deck()
@@ -575,11 +491,11 @@ class CoinCellAssemblyWorkstation(WorkstationBase):
         try:
             # 尝试不同的字节序读取
             code_little, read_err = self.client.use_node('REG_DATA_COIN_CELL_CODE').read(10, word_order=WorderOrder.LITTLE)
-            # logger.debug(f"读取电池二维码原始数据: {code_little}")
+            print(code_little)
             clean_code = code_little[-8:][::-1]
             return clean_code
         except Exception as e:
-            logger.error(f"读取电池二维码失败: {e}")
+            print(f"读取电池二维码失败: {e}")
             return "N/A"
 
 
@@ -588,11 +504,11 @@ class CoinCellAssemblyWorkstation(WorkstationBase):
         try:
             # 尝试不同的字节序读取
             code_little, read_err = self.client.use_node('REG_DATA_ELECTROLYTE_CODE').read(10, word_order=WorderOrder.LITTLE)
-            # logger.debug(f"读取电解液二维码原始数据: {code_little}")
+            print(code_little)
             clean_code = code_little[-8:][::-1]
             return clean_code
         except Exception as e:
-            logger.error(f"读取电解液二维码失败: {e}")
+            print(f"读取电解液二维码失败: {e}")
             return "N/A"
 
     # ===================== 环境监控区 ======================
@@ -690,8 +606,7 @@ class CoinCellAssemblyWorkstation(WorkstationBase):
             print("waiting for start_cmd")
             time.sleep(1)      
 
-    def func_pack_send_bottle_num(self, bottle_num):
-        bottle_num = int(bottle_num)
+    def func_pack_send_bottle_num(self, bottle_num: int):
         #发送电解液平台数
         print("启动")
         while (self._unilab_rece_electrolyte_bottle_num()) == False:
@@ -739,25 +654,16 @@ class CoinCellAssemblyWorkstation(WorkstationBase):
     #    self.success = True
     #    return self.success
 
-    def func_pack_send_msg_cmd(self, elec_use_num, elec_vol, assembly_type, assembly_pressure) -> bool:
+    def func_pack_send_msg_cmd(self, elec_use_num) -> 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: 
@@ -782,32 +688,15 @@ class CoinCellAssemblyWorkstation(WorkstationBase):
         data_coin_num = self.data_coin_num
         data_electrolyte_code = self.data_electrolyte_code
         data_coin_cell_code = self.data_coin_cell_code
-        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}")
+        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)
         #接收完信息后，读取完毕标志位置True
-        liaopan3 = self.deck.get_resource("成品弹夹")        
-        #把物料解绑后放到另一盘上
-        battery = ElectrodeSheet(name=f"battery_{self.coin_num_N}", 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
-                            }
-        liaopan3.children[self.coin_num_N].assign_child_resource(battery, location=None)
-        #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
@@ -865,25 +754,11 @@ 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, elec_vol:int=50, assembly_type:int=7, assembly_pressure:int=4200, file_path: str="/Users/sml/work") -> bool:
-        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)
+
+    def func_allpack_cmd(self, elec_num, elec_use_num, file_path: str="D:\\coin_cell_data") -> bool:
         summary_csv_file = os.path.join(file_path, "duandian.csv")
         # 如果断点文件存在，先读取之前的进度
-        
         if os.path.exists(summary_csv_file):
             read_status_flag = True
             with open(summary_csv_file, 'r', newline='', encoding='utf-8') as csvfile:
@@ -909,38 +784,54 @@ class CoinCellAssemblyWorkstation(WorkstationBase):
             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))}")
+
+        print(f"剩余电解液瓶数: {elec_num}, 已组装电池数: {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, elec_vol, assembly_type, assembly_pressure)
+            self.func_pack_send_msg_cmd(elec_use_num-j_start)
 
             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)
                 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文件
@@ -951,7 +842,6 @@ 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
@@ -988,27 +878,36 @@ class CoinCellAssemblyWorkstation(WorkstationBase):
     
     def fun_wuliao_test(self) -> bool: 
         #找到data_init中构建的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)
+        #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)
+
             
-            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="/Users/sml/work"):
+    def func_read_data_and_output(self, file_path: str="D:\\coin_cell_data"):
         # 检查CSV导出是否正在运行，已运行则跳出，防止同时启动两个while循环
         if self.csv_export_running:
             return False, "读取已在运行中"
@@ -1113,7 +1012,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():
@@ -1203,16 +1102,41 @@ class CoinCellAssemblyWorkstation(WorkstationBase):
     '''
 
 
-
 if __name__ == "__main__":
-    # 简单测试
-    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")
-    
+    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)
+

unilabos/devices/workstation/coin_cell_assembly/coin_cell_assembly_1105.csv

@@ -1,64 +0,0 @@
-Name,DataType,InitValue,Comment,Attribute,DeviceType,Address,
-COIL_SYS_START_CMD,BOOL,,,,coil,9010,
-COIL_SYS_STOP_CMD,BOOL,,,,coil,9020,
-COIL_SYS_RESET_CMD,BOOL,,,,coil,9030,
-COIL_SYS_HAND_CMD,BOOL,,,,coil,9040,
-COIL_SYS_AUTO_CMD,BOOL,,,,coil,9050,
-COIL_SYS_INIT_CMD,BOOL,,,,coil,9060,
-COIL_UNILAB_SEND_MSG_SUCC_CMD,BOOL,,,,coil,9700,
-COIL_UNILAB_REC_MSG_SUCC_CMD,BOOL,,,,coil,9710,unilab_rec_msg_succ_cmd
-COIL_SYS_START_STATUS,BOOL,,,,coil,9210,
-COIL_SYS_STOP_STATUS,BOOL,,,,coil,9220,
-COIL_SYS_RESET_STATUS,BOOL,,,,coil,9230,
-COIL_SYS_HAND_STATUS,BOOL,,,,coil,9240,
-COIL_SYS_AUTO_STATUS,BOOL,,,,coil,9250,
-COIL_SYS_INIT_STATUS,BOOL,,,,coil,9260,
-COIL_REQUEST_REC_MSG_STATUS,BOOL,,,,coil,9500,
-COIL_REQUEST_SEND_MSG_STATUS,BOOL,,,,coil,9510,request_send_msg_status
-REG_MSG_ELECTROLYTE_USE_NUM,INT16,,,,hold_register,17000,
-REG_MSG_ELECTROLYTE_NUM,INT16,,,,hold_register,17002,unilab_send_msg_electrolyte_num
-REG_MSG_ELECTROLYTE_VOLUME,INT16,,,,hold_register,17004,unilab_send_msg_electrolyte_vol
-REG_MSG_ASSEMBLY_TYPE,INT16,,,,hold_register,17006,unilab_send_msg_assembly_type
-REG_MSG_ASSEMBLY_PRESSURE,INT16,,,,hold_register,17008,unilab_send_msg_assembly_pressure
-REG_DATA_ASSEMBLY_COIN_CELL_NUM,INT16,,,,hold_register,16000,data_assembly_coin_cell_num
-REG_DATA_OPEN_CIRCUIT_VOLTAGE,FLOAT32,,,,hold_register,16002,data_open_circuit_voltage
-REG_DATA_AXIS_X_POS,FLOAT32,,,,hold_register,16004,
-REG_DATA_AXIS_Y_POS,FLOAT32,,,,hold_register,16006,
-REG_DATA_AXIS_Z_POS,FLOAT32,,,,hold_register,16008,
-REG_DATA_POLE_WEIGHT,FLOAT32,,,,hold_register,16010,data_pole_weight
-REG_DATA_ASSEMBLY_PER_TIME,FLOAT32,,,,hold_register,16012,data_assembly_time
-REG_DATA_ASSEMBLY_PRESSURE,INT16,,,,hold_register,16014,data_assembly_pressure
-REG_DATA_ELECTROLYTE_VOLUME,INT16,,,,hold_register,16016,data_electrolyte_volume
-REG_DATA_COIN_NUM,INT16,,,,hold_register,16018,data_coin_num
-REG_DATA_ELECTROLYTE_CODE,STRING,,,,hold_register,16020,data_electrolyte_code()
-REG_DATA_COIN_CELL_CODE,STRING,,,,hold_register,16030,data_coin_cell_code()
-REG_DATA_STACK_VISON_CODE,STRING,,,,hold_register,18004,data_stack_vision_code()
-REG_DATA_GLOVE_BOX_PRESSURE,FLOAT32,,,,hold_register,16050,data_glove_box_pressure
-REG_DATA_GLOVE_BOX_WATER_CONTENT,FLOAT32,,,,hold_register,16052,data_glove_box_water_content
-REG_DATA_GLOVE_BOX_O2_CONTENT,FLOAT32,,,,hold_register,16054,data_glove_box_o2_content
-UNILAB_SEND_ELECTROLYTE_BOTTLE_NUM,BOOL,,,,coil,9720,
-UNILAB_RECE_ELECTROLYTE_BOTTLE_NUM,BOOL,,,,coil,9520,
-REG_MSG_ELECTROLYTE_NUM_USED,INT16,,,,hold_register,17496,
-REG_DATA_ELECTROLYTE_USE_NUM,INT16,,,,hold_register,16000,
-UNILAB_SEND_FINISHED_CMD,BOOL,,,,coil,9730,
-UNILAB_RECE_FINISHED_CMD,BOOL,,,,coil,9530,
-REG_DATA_ASSEMBLY_TYPE,INT16,,,,hold_register,16018,ASSEMBLY_TYPE7or8
-COIL_ALUMINUM_FOIL,BOOL,,使用铝箔垫,,coil,9340,
-REG_MSG_NE_PLATE_MATRIX,INT16,,负极片矩阵点位,,hold_register,17440,
-REG_MSG_SEPARATOR_PLATE_MATRIX,INT16,,隔膜矩阵点位,,hold_register,17450,
-REG_MSG_TIP_BOX_MATRIX,INT16,,移液枪头矩阵点位,,hold_register,17480,
-REG_MSG_NE_PLATE_NUM,INT16,,负极片盘数,,hold_register,17443,
-REG_MSG_SEPARATOR_PLATE_NUM,INT16,,隔膜盘数,,hold_register,17453,
-REG_MSG_PRESS_MODE,BOOL,,压制模式（false:压力检测模式，True:距离模式）,,coil,9360,电池压制模式
-,,,,,,,
-,BOOL,,视觉对位（false:使用，true:忽略）,,coil,9300,视觉对位
-,BOOL,,复检（false:使用，true:忽略）,,coil,9310,视觉复检
-,BOOL,,手套箱_左仓（false:使用，true:忽略）,,coil,9320,手套箱左仓
-,BOOL,,手套箱_右仓（false:使用，true:忽略）,,coil,9420,手套箱右仓
-,BOOL,,真空检知（false:使用，true:忽略）,,coil,9350,真空检知
-,BOOL,,电解液添加模式（false:单次滴液，true:二次滴液）,,coil,9370,滴液模式
-,BOOL,,正极片称重（false:使用，true:忽略）,,coil,9380,正极片称重
-,BOOL,,正负极片组装方式（false:正装，true:倒装）,,coil,9390,正负极反装
-,BOOL,,压制清洁（false:使用，true:忽略）,,coil,9400,压制清洁
-,BOOL,,物料盘摆盘方式（false:水平摆盘，true:堆叠摆盘）,,coil,9410,负极片摆盘方式
-REG_MSG_BATTERY_CLEAN_IGNORE,BOOL,,忽略电池清洁（false:使用，true:忽略）,,coil,9460,

unilabos/devices/workstation/coin_cell_assembly/coin_cell_assembly_a.csv

@@ -1,64 +0,0 @@
-Name,DataType,InitValue,Comment,Attribute,DeviceType,Address,
-COIL_SYS_START_CMD,BOOL,,,,coil,8010,
-COIL_SYS_STOP_CMD,BOOL,,,,coil,8020,
-COIL_SYS_RESET_CMD,BOOL,,,,coil,8030,
-COIL_SYS_HAND_CMD,BOOL,,,,coil,8040,
-COIL_SYS_AUTO_CMD,BOOL,,,,coil,8050,
-COIL_SYS_INIT_CMD,BOOL,,,,coil,8060,
-COIL_UNILAB_SEND_MSG_SUCC_CMD,BOOL,,,,coil,8700,
-COIL_UNILAB_REC_MSG_SUCC_CMD,BOOL,,,,coil,8710,unilab_rec_msg_succ_cmd
-COIL_SYS_START_STATUS,BOOL,,,,coil,8210,
-COIL_SYS_STOP_STATUS,BOOL,,,,coil,8220,
-COIL_SYS_RESET_STATUS,BOOL,,,,coil,8230,
-COIL_SYS_HAND_STATUS,BOOL,,,,coil,8240,
-COIL_SYS_AUTO_STATUS,BOOL,,,,coil,8250,
-COIL_SYS_INIT_STATUS,BOOL,,,,coil,8260,
-COIL_REQUEST_REC_MSG_STATUS,BOOL,,,,coil,8500,
-COIL_REQUEST_SEND_MSG_STATUS,BOOL,,,,coil,8510,request_send_msg_status
-REG_MSG_ELECTROLYTE_USE_NUM,INT16,,,,hold_register,11000,
-REG_MSG_ELECTROLYTE_NUM,INT16,,,,hold_register,11002,unilab_send_msg_electrolyte_num
-REG_MSG_ELECTROLYTE_VOLUME,INT16,,,,hold_register,11004,unilab_send_msg_electrolyte_vol
-REG_MSG_ASSEMBLY_TYPE,INT16,,,,hold_register,11006,unilab_send_msg_assembly_type
-REG_MSG_ASSEMBLY_PRESSURE,INT16,,,,hold_register,11008,unilab_send_msg_assembly_pressure
-REG_DATA_ASSEMBLY_COIN_CELL_NUM,INT16,,,,hold_register,10000,data_assembly_coin_cell_num
-REG_DATA_OPEN_CIRCUIT_VOLTAGE,FLOAT32,,,,hold_register,10002,data_open_circuit_voltage
-REG_DATA_AXIS_X_POS,FLOAT32,,,,hold_register,10004,
-REG_DATA_AXIS_Y_POS,FLOAT32,,,,hold_register,10006,
-REG_DATA_AXIS_Z_POS,FLOAT32,,,,hold_register,10008,
-REG_DATA_POLE_WEIGHT,FLOAT32,,,,hold_register,10010,data_pole_weight
-REG_DATA_ASSEMBLY_PER_TIME,FLOAT32,,,,hold_register,10012,data_assembly_time
-REG_DATA_ASSEMBLY_PRESSURE,INT16,,,,hold_register,10014,data_assembly_pressure
-REG_DATA_ELECTROLYTE_VOLUME,INT16,,,,hold_register,10016,data_electrolyte_volume
-REG_DATA_COIN_NUM,INT16,,,,hold_register,10018,data_coin_num
-REG_DATA_ELECTROLYTE_CODE,STRING,,,,hold_register,10020,data_electrolyte_code()
-REG_DATA_COIN_CELL_CODE,STRING,,,,hold_register,10030,data_coin_cell_code()
-REG_DATA_STACK_VISON_CODE,STRING,,,,hold_register,12004,data_stack_vision_code()
-REG_DATA_GLOVE_BOX_PRESSURE,FLOAT32,,,,hold_register,10050,data_glove_box_pressure
-REG_DATA_GLOVE_BOX_WATER_CONTENT,FLOAT32,,,,hold_register,10052,data_glove_box_water_content
-REG_DATA_GLOVE_BOX_O2_CONTENT,FLOAT32,,,,hold_register,10054,data_glove_box_o2_content
-UNILAB_SEND_ELECTROLYTE_BOTTLE_NUM,BOOL,,,,coil,8720,
-UNILAB_RECE_ELECTROLYTE_BOTTLE_NUM,BOOL,,,,coil,8520,
-REG_MSG_ELECTROLYTE_NUM_USED,INT16,,,,hold_register,496,
-REG_DATA_ELECTROLYTE_USE_NUM,INT16,,,,hold_register,10000,
-UNILAB_SEND_FINISHED_CMD,BOOL,,,,coil,8730,
-UNILAB_RECE_FINISHED_CMD,BOOL,,,,coil,8530,
-REG_DATA_ASSEMBLY_TYPE,INT16,,,,hold_register,10018,ASSEMBLY_TYPE7or8
-COIL_ALUMINUM_FOIL,BOOL,,使用铝箔垫,,coil,8340,
-REG_MSG_NE_PLATE_MATRIX,INT16,,负极片矩阵点位,,hold_register,440,
-REG_MSG_SEPARATOR_PLATE_MATRIX,INT16,,隔膜矩阵点位,,hold_register,450,
-REG_MSG_TIP_BOX_MATRIX,INT16,,移液枪头矩阵点位,,hold_register,480,
-REG_MSG_NE_PLATE_NUM,INT16,,负极片盘数,,hold_register,443,
-REG_MSG_SEPARATOR_PLATE_NUM,INT16,,隔膜盘数,,hold_register,453,
-REG_MSG_PRESS_MODE,BOOL,,压制模式（false:压力检测模式，True:距离模式）,,coil,8360,电池压制模式
-,,,,,,,
-,BOOL,,视觉对位（false:使用，true:忽略）,,coil,8300,视觉对位
-,BOOL,,复检（false:使用，true:忽略）,,coil,8310,视觉复检
-,BOOL,,手套箱_左仓（false:使用，true:忽略）,,coil,8320,手套箱左仓
-,BOOL,,手套箱_右仓（false:使用，true:忽略）,,coil,8420,手套箱右仓
-,BOOL,,真空检知（false:使用，true:忽略）,,coil,8350,真空检知
-,BOOL,,电解液添加模式（false:单次滴液，true:二次滴液）,,coil,8370,滴液模式
-,BOOL,,正极片称重（false:使用，true:忽略）,,coil,8380,正极片称重
-,BOOL,,正负极片组装方式（false:正装，true:倒装）,,coil,8390,正负极反装
-,BOOL,,压制清洁（false:使用，true:忽略）,,coil,8400,压制清洁
-,BOOL,,物料盘摆盘方式（false:水平摆盘，true:堆叠摆盘）,,coil,8410,负极片摆盘方式
-REG_MSG_BATTERY_CLEAN_IGNORE,BOOL,,忽略电池清洁（false:使用，true:忽略）,,coil,8460,

unilabos/devices/workstation/coin_cell_assembly/new_cellconfig3c.json

@@ -1,39 +0,0 @@
-{
-  "nodes": [
-    {
-      "id": "bioyond_cell_workstation",
-      "name": "配液分液工站",
-      "children": [
-      ],
-      "parent": null,
-      "type": "device",
-      "class": "bioyond_cell",
-      "config": {
-          "protocol_type": [],
-          "station_resource": {}
-      },
-      "data": {}
-  },
-
-  {
-      "id": "BatteryStation",
-      "name": "扣电工作站",
-      "children": [
-          "coin_cell_deck"
-      ],
-      "parent": null,
-      "type": "device",
-      "class": "coincellassemblyworkstation_device",
-      "position": {
-          "x": -600,
-          "y": -400,
-          "z": 0
-      },
-      "config": {
-          "debug_mode": false,
-          "protocol_type": []
-      }
-    }
-  ],
-  "links": []
-}

unilabos/devices/workstation/coin_cell_assembly/new_cellconfig4.json

@@ -1,23 +1,8 @@
 {
   "nodes": [
-    {
-      "id": "bioyond_cell_workstation",
-      "name": "配液分液工站",
-      "children": [
-      ],
-      "parent": null,
-      "type": "device",
-      "class": "bioyond_cell",
-      "config": {
-          "protocol_type": [],
-          "station_resource": {}
-
-      },
-      "data": {}
-  },
     {
       "id": "BatteryStation",
-      "name": "扣电组装工作站",
+      "name": "扣电工作站",
       "children": [
           "coin_cell_deck"
       ],
@@ -113,7 +98,7 @@
         "z": 0
       },
       "config": {
-        "type": "MagazineHolder_4",
+        "type": "ClipMagazine_four",
         "size_x": 80,
         "size_y": 80,
         "size_z": 10,
@@ -154,7 +139,7 @@
         "z": 10
       },
       "config": {
-        "type": "Magazine",
+        "type": "ClipMagazineHole",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -249,7 +234,7 @@
         "z": 10
       },
       "config": {
-        "type": "Magazine",
+        "type": "ClipMagazineHole",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -344,7 +329,7 @@
         "z": 10
       },
       "config": {
-        "type": "Magazine",
+        "type": "ClipMagazineHole",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -439,7 +424,7 @@
         "z": 10
       },
       "config": {
-        "type": "Magazine",
+        "type": "ClipMagazineHole",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -537,7 +522,7 @@
         "z": 0
       },
       "config": {
-        "type": "MagazineHolder_4",
+        "type": "ClipMagazine_four",
         "size_x": 80,
         "size_y": 80,
         "size_z": 10,
@@ -578,7 +563,7 @@
         "z": 10
       },
       "config": {
-        "type": "Magazine",
+        "type": "ClipMagazineHole",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -673,7 +658,7 @@
         "z": 10
       },
       "config": {
-        "type": "Magazine",
+        "type": "ClipMagazineHole",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -768,7 +753,7 @@
         "z": 10
       },
       "config": {
-        "type": "Magazine",
+        "type": "ClipMagazineHole",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -863,7 +848,7 @@
         "z": 10
       },
       "config": {
-        "type": "Magazine",
+        "type": "ClipMagazineHole",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -963,7 +948,7 @@
         "z": 0
       },
       "config": {
-        "type": "MagazineHolder_6",
+        "type": "ClipMagazine",
         "size_x": 80,
         "size_y": 80,
         "size_z": 10,
@@ -1006,7 +991,7 @@
         "z": 10
       },
       "config": {
-        "type": "Magazine",
+        "type": "ClipMagazineHole",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -1101,7 +1086,7 @@
         "z": 10
       },
       "config": {
-        "type": "Magazine",
+        "type": "ClipMagazineHole",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -1196,7 +1181,7 @@
         "z": 10
       },
       "config": {
-        "type": "Magazine",
+        "type": "ClipMagazineHole",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -1291,7 +1276,7 @@
         "z": 10
       },
       "config": {
-        "type": "Magazine",
+        "type": "ClipMagazineHole",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -1386,7 +1371,7 @@
         "z": 10
       },
       "config": {
-        "type": "Magazine",
+        "type": "ClipMagazineHole",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -1481,7 +1466,7 @@
         "z": 10
       },
       "config": {
-        "type": "Magazine",
+        "type": "ClipMagazineHole",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -1581,7 +1566,7 @@
         "z": 0
       },
       "config": {
-        "type": "MagazineHolder_6",
+        "type": "ClipMagazine",
         "size_x": 80,
         "size_y": 80,
         "size_z": 10,
@@ -1624,7 +1609,7 @@
         "z": 10
       },
       "config": {
-        "type": "Magazine",
+        "type": "ClipMagazineHole",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -1719,7 +1704,7 @@
         "z": 10
       },
       "config": {
-        "type": "Magazine",
+        "type": "ClipMagazineHole",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -1814,7 +1799,7 @@
         "z": 10
       },
       "config": {
-        "type": "Magazine",
+        "type": "ClipMagazineHole",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -1909,7 +1894,7 @@
         "z": 10
       },
       "config": {
-        "type": "Magazine",
+        "type": "ClipMagazineHole",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -2004,7 +1989,7 @@
         "z": 10
       },
       "config": {
-        "type": "Magazine",
+        "type": "ClipMagazineHole",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -2099,7 +2084,7 @@
         "z": 10
       },
       "config": {
-        "type": "Magazine",
+        "type": "ClipMagazineHole",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -2199,7 +2184,7 @@
         "z": 0
       },
       "config": {
-        "type": "MagazineHolder_6",
+        "type": "ClipMagazine",
         "size_x": 80,
         "size_y": 80,
         "size_z": 10,
@@ -2242,7 +2227,7 @@
         "z": 10
       },
       "config": {
-        "type": "Magazine",
+        "type": "ClipMagazineHole",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -2337,7 +2322,7 @@
         "z": 10
       },
       "config": {
-        "type": "Magazine",
+        "type": "ClipMagazineHole",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -2432,7 +2417,7 @@
         "z": 10
       },
       "config": {
-        "type": "Magazine",
+        "type": "ClipMagazineHole",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -2527,7 +2512,7 @@
         "z": 10
       },
       "config": {
-        "type": "Magazine",
+        "type": "ClipMagazineHole",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -2622,7 +2607,7 @@
         "z": 10
       },
       "config": {
-        "type": "Magazine",
+        "type": "ClipMagazineHole",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -2717,7 +2702,7 @@
         "z": 10
       },
       "config": {
-        "type": "Magazine",
+        "type": "ClipMagazineHole",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -2817,7 +2802,7 @@
         "z": 0
       },
       "config": {
-        "type": "MagazineHolder_6",
+        "type": "ClipMagazine",
         "size_x": 80,
         "size_y": 80,
         "size_z": 10,
@@ -2860,7 +2845,7 @@
         "z": 10
       },
       "config": {
-        "type": "Magazine",
+        "type": "ClipMagazineHole",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -2955,7 +2940,7 @@
         "z": 10
       },
       "config": {
-        "type": "Magazine",
+        "type": "ClipMagazineHole",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -3050,7 +3035,7 @@
         "z": 10
       },
       "config": {
-        "type": "Magazine",
+        "type": "ClipMagazineHole",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -3145,7 +3130,7 @@
         "z": 10
       },
       "config": {
-        "type": "Magazine",
+        "type": "ClipMagazineHole",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -3240,7 +3225,7 @@
         "z": 10
       },
       "config": {
-        "type": "Magazine",
+        "type": "ClipMagazineHole",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -3335,7 +3320,7 @@
         "z": 10
       },
       "config": {
-        "type": "Magazine",
+        "type": "ClipMagazineHole",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -3435,7 +3420,7 @@
         "z": 0
       },
       "config": {
-        "type": "MagazineHolder_6",
+        "type": "ClipMagazine",
         "size_x": 80,
         "size_y": 80,
         "size_z": 10,
@@ -3478,7 +3463,7 @@
         "z": 10
       },
       "config": {
-        "type": "Magazine",
+        "type": "ClipMagazineHole",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -3573,7 +3558,7 @@
         "z": 10
       },
       "config": {
-        "type": "Magazine",
+        "type": "ClipMagazineHole",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -3668,7 +3653,7 @@
         "z": 10
       },
       "config": {
-        "type": "Magazine",
+        "type": "ClipMagazineHole",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -3763,7 +3748,7 @@
         "z": 10
       },
       "config": {
-        "type": "Magazine",
+        "type": "ClipMagazineHole",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -3858,7 +3843,7 @@
         "z": 10
       },
       "config": {
-        "type": "Magazine",
+        "type": "ClipMagazineHole",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -3953,7 +3938,7 @@
         "z": 10
       },
       "config": {
-        "type": "Magazine",
+        "type": "ClipMagazineHole",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -4053,7 +4038,7 @@
         "z": 0
       },
       "config": {
-        "type": "MagazineHolder_6",
+        "type": "ClipMagazine",
         "size_x": 80,
         "size_y": 80,
         "size_z": 10,
@@ -4096,7 +4081,7 @@
         "z": 10
       },
       "config": {
-        "type": "Magazine",
+        "type": "ClipMagazineHole",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -4191,7 +4176,7 @@
         "z": 10
       },
       "config": {
-        "type": "Magazine",
+        "type": "ClipMagazineHole",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -4286,7 +4271,7 @@
         "z": 10
       },
       "config": {
-        "type": "Magazine",
+        "type": "ClipMagazineHole",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -4381,7 +4366,7 @@
         "z": 10
       },
       "config": {
-        "type": "Magazine",
+        "type": "ClipMagazineHole",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -4476,7 +4461,7 @@
         "z": 10
       },
       "config": {
-        "type": "Magazine",
+        "type": "ClipMagazineHole",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,
@@ -4571,7 +4556,7 @@
         "z": 10
       },
       "config": {
-        "type": "Magazine",
+        "type": "ClipMagazineHole",
         "size_x": 14.0,
         "size_y": 14.0,
         "size_z": 10.0,

unilabos/devices/workstation/workstation_base.py

@@ -147,7 +147,7 @@ class WorkstationBase(ABC):
 
     def __init__(
         self,
-        deck: Deck,
+        deck: Optional[Deck],
         *args,
         **kwargs,  # 必须有kwargs
     ):
@@ -349,5 +349,5 @@ class WorkstationBase(ABC):
 
 
 class ProtocolNode(WorkstationBase):
-    def __init__(self, deck: Optional[PLRResource], *args, **kwargs):
+    def __init__(self, protocol_type: List[str], deck: Optional[PLRResource], *args, **kwargs):
         super().__init__(deck, *args, **kwargs)

unilabos/devices/workstation/workstation_http_service.py

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

unilabos/registry/devices/bioyond.yaml

@@ -0,0 +1,589 @@
+workstation.bioyond_dispensing_station:
+  category:
+  - workstation
+  - bioyond
+  class:
+    action_value_mappings:
+      auto-batch_create_90_10_vial_feeding_tasks:
+        feedback: {}
+        goal: {}
+        goal_default:
+          delay_time: null
+          hold_m_name: null
+          liquid_material_name: NMP
+          speed: null
+          temperature: null
+          titration: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                delay_time:
+                  type: string
+                hold_m_name:
+                  type: string
+                liquid_material_name:
+                  default: NMP
+                  type: string
+                speed:
+                  type: string
+                temperature:
+                  type: string
+                titration:
+                  type: string
+              required:
+              - titration
+              type: object
+            result: {}
+          required:
+          - goal
+          title: batch_create_90_10_vial_feeding_tasks参数
+          type: object
+        type: UniLabJsonCommand
+      auto-batch_create_diamine_solution_tasks:
+        feedback: {}
+        goal: {}
+        goal_default:
+          delay_time: null
+          liquid_material_name: NMP
+          solutions: null
+          speed: null
+          temperature: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                delay_time:
+                  type: string
+                liquid_material_name:
+                  default: NMP
+                  type: string
+                solutions:
+                  type: string
+                speed:
+                  type: string
+                temperature:
+                  type: string
+              required:
+              - solutions
+              type: object
+            result: {}
+          required:
+          - goal
+          title: batch_create_diamine_solution_tasks参数
+          type: object
+        type: UniLabJsonCommand
+      auto-brief_step_parameters:
+        feedback: {}
+        goal: {}
+        goal_default:
+          data: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                data:
+                  type: object
+              required:
+              - data
+              type: object
+            result: {}
+          required:
+          - goal
+          title: brief_step_parameters参数
+          type: object
+        type: UniLabJsonCommand
+      auto-compute_experiment_design:
+        feedback: {}
+        goal: {}
+        goal_default:
+          m_tot: '70'
+          ratio: null
+          titration_percent: '0.03'
+          wt_percent: '0.25'
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                m_tot:
+                  default: '70'
+                  type: string
+                ratio:
+                  type: object
+                titration_percent:
+                  default: '0.03'
+                  type: string
+                wt_percent:
+                  default: '0.25'
+                  type: string
+              required:
+              - ratio
+              type: object
+            result:
+              properties:
+                feeding_order:
+                  items: {}
+                  title: Feeding Order
+                  type: array
+                return_info:
+                  title: Return Info
+                  type: string
+                solutions:
+                  items: {}
+                  title: Solutions
+                  type: array
+                solvents:
+                  additionalProperties: true
+                  title: Solvents
+                  type: object
+                titration:
+                  additionalProperties: true
+                  title: Titration
+                  type: object
+              required:
+              - solutions
+              - titration
+              - solvents
+              - feeding_order
+              - return_info
+              title: ComputeExperimentDesignReturn
+              type: object
+          required:
+          - goal
+          title: compute_experiment_design参数
+          type: object
+        type: UniLabJsonCommand
+      auto-process_order_finish_report:
+        feedback: {}
+        goal: {}
+        goal_default:
+          report_request: null
+          used_materials: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                report_request:
+                  type: string
+                used_materials:
+                  type: string
+              required:
+              - report_request
+              - used_materials
+              type: object
+            result: {}
+          required:
+          - goal
+          title: process_order_finish_report参数
+          type: object
+        type: UniLabJsonCommand
+      auto-project_order_report:
+        feedback: {}
+        goal: {}
+        goal_default:
+          order_id: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                order_id:
+                  type: string
+              required:
+              - order_id
+              type: object
+            result: {}
+          required:
+          - goal
+          title: project_order_report参数
+          type: object
+        type: UniLabJsonCommand
+      auto-query_resource_by_name:
+        feedback: {}
+        goal: {}
+        goal_default:
+          material_name: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                material_name:
+                  type: string
+              required:
+              - material_name
+              type: object
+            result: {}
+          required:
+          - goal
+          title: query_resource_by_name参数
+          type: object
+        type: UniLabJsonCommand
+      auto-transfer_materials_to_reaction_station:
+        feedback: {}
+        goal: {}
+        goal_default:
+          target_device_id: null
+          transfer_groups: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                target_device_id:
+                  type: string
+                transfer_groups:
+                  type: array
+              required:
+              - target_device_id
+              - transfer_groups
+              type: object
+            result: {}
+          required:
+          - goal
+          title: transfer_materials_to_reaction_station参数
+          type: object
+        type: UniLabJsonCommand
+      auto-wait_for_multiple_orders_and_get_reports:
+        feedback: {}
+        goal: {}
+        goal_default:
+          batch_create_result: null
+          check_interval: 10
+          timeout: 7200
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                batch_create_result:
+                  type: string
+                check_interval:
+                  default: 10
+                  type: integer
+                timeout:
+                  default: 7200
+                  type: integer
+              required: []
+              type: object
+            result: {}
+          required:
+          - goal
+          title: wait_for_multiple_orders_and_get_reports参数
+          type: object
+        type: UniLabJsonCommand
+      auto-workflow_sample_locations:
+        feedback: {}
+        goal: {}
+        goal_default:
+          workflow_id: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                workflow_id:
+                  type: string
+              required:
+              - workflow_id
+              type: object
+            result: {}
+          required:
+          - goal
+          title: workflow_sample_locations参数
+          type: object
+        type: UniLabJsonCommand
+      create_90_10_vial_feeding_task:
+        feedback: {}
+        goal:
+          delay_time: delay_time
+          hold_m_name: hold_m_name
+          order_name: order_name
+          percent_10_1_assign_material_name: percent_10_1_assign_material_name
+          percent_10_1_liquid_material_name: percent_10_1_liquid_material_name
+          percent_10_1_target_weigh: percent_10_1_target_weigh
+          percent_10_1_volume: percent_10_1_volume
+          percent_10_2_assign_material_name: percent_10_2_assign_material_name
+          percent_10_2_liquid_material_name: percent_10_2_liquid_material_name
+          percent_10_2_target_weigh: percent_10_2_target_weigh
+          percent_10_2_volume: percent_10_2_volume
+          percent_10_3_assign_material_name: percent_10_3_assign_material_name
+          percent_10_3_liquid_material_name: percent_10_3_liquid_material_name
+          percent_10_3_target_weigh: percent_10_3_target_weigh
+          percent_10_3_volume: percent_10_3_volume
+          percent_90_1_assign_material_name: percent_90_1_assign_material_name
+          percent_90_1_target_weigh: percent_90_1_target_weigh
+          percent_90_2_assign_material_name: percent_90_2_assign_material_name
+          percent_90_2_target_weigh: percent_90_2_target_weigh
+          percent_90_3_assign_material_name: percent_90_3_assign_material_name
+          percent_90_3_target_weigh: percent_90_3_target_weigh
+          speed: speed
+          temperature: temperature
+        goal_default:
+          delay_time: ''
+          hold_m_name: ''
+          order_name: ''
+          percent_10_1_assign_material_name: ''
+          percent_10_1_liquid_material_name: ''
+          percent_10_1_target_weigh: ''
+          percent_10_1_volume: ''
+          percent_10_2_assign_material_name: ''
+          percent_10_2_liquid_material_name: ''
+          percent_10_2_target_weigh: ''
+          percent_10_2_volume: ''
+          percent_10_3_assign_material_name: ''
+          percent_10_3_liquid_material_name: ''
+          percent_10_3_target_weigh: ''
+          percent_10_3_volume: ''
+          percent_90_1_assign_material_name: ''
+          percent_90_1_target_weigh: ''
+          percent_90_2_assign_material_name: ''
+          percent_90_2_target_weigh: ''
+          percent_90_3_assign_material_name: ''
+          percent_90_3_target_weigh: ''
+          speed: ''
+          temperature: ''
+        handles: {}
+        result:
+          return_info: return_info
+        schema:
+          description: ''
+          properties:
+            feedback:
+              properties: {}
+              required: []
+              title: DispenStationVialFeed_Feedback
+              type: object
+            goal:
+              properties:
+                delay_time:
+                  type: string
+                hold_m_name:
+                  type: string
+                order_name:
+                  type: string
+                percent_10_1_assign_material_name:
+                  type: string
+                percent_10_1_liquid_material_name:
+                  type: string
+                percent_10_1_target_weigh:
+                  type: string
+                percent_10_1_volume:
+                  type: string
+                percent_10_2_assign_material_name:
+                  type: string
+                percent_10_2_liquid_material_name:
+                  type: string
+                percent_10_2_target_weigh:
+                  type: string
+                percent_10_2_volume:
+                  type: string
+                percent_10_3_assign_material_name:
+                  type: string
+                percent_10_3_liquid_material_name:
+                  type: string
+                percent_10_3_target_weigh:
+                  type: string
+                percent_10_3_volume:
+                  type: string
+                percent_90_1_assign_material_name:
+                  type: string
+                percent_90_1_target_weigh:
+                  type: string
+                percent_90_2_assign_material_name:
+                  type: string
+                percent_90_2_target_weigh:
+                  type: string
+                percent_90_3_assign_material_name:
+                  type: string
+                percent_90_3_target_weigh:
+                  type: string
+                speed:
+                  type: string
+                temperature:
+                  type: string
+              required:
+              - order_name
+              - percent_90_1_assign_material_name
+              - percent_90_1_target_weigh
+              - percent_90_2_assign_material_name
+              - percent_90_2_target_weigh
+              - percent_90_3_assign_material_name
+              - percent_90_3_target_weigh
+              - percent_10_1_assign_material_name
+              - percent_10_1_target_weigh
+              - percent_10_1_volume
+              - percent_10_1_liquid_material_name
+              - percent_10_2_assign_material_name
+              - percent_10_2_target_weigh
+              - percent_10_2_volume
+              - percent_10_2_liquid_material_name
+              - percent_10_3_assign_material_name
+              - percent_10_3_target_weigh
+              - percent_10_3_volume
+              - percent_10_3_liquid_material_name
+              - speed
+              - temperature
+              - delay_time
+              - hold_m_name
+              title: DispenStationVialFeed_Goal
+              type: object
+            result:
+              properties:
+                return_info:
+                  type: string
+              required:
+              - return_info
+              title: DispenStationVialFeed_Result
+              type: object
+          required:
+          - goal
+          title: DispenStationVialFeed
+          type: object
+        type: DispenStationVialFeed
+      create_diamine_solution_task:
+        feedback: {}
+        goal:
+          delay_time: delay_time
+          hold_m_name: hold_m_name
+          liquid_material_name: liquid_material_name
+          material_name: material_name
+          order_name: order_name
+          speed: speed
+          target_weigh: target_weigh
+          temperature: temperature
+          volume: volume
+        goal_default:
+          delay_time: ''
+          hold_m_name: ''
+          liquid_material_name: ''
+          material_name: ''
+          order_name: ''
+          speed: ''
+          target_weigh: ''
+          temperature: ''
+          volume: ''
+        handles: {}
+        result:
+          return_info: return_info
+        schema:
+          description: ''
+          properties:
+            feedback:
+              properties: {}
+              required: []
+              title: DispenStationSolnPrep_Feedback
+              type: object
+            goal:
+              properties:
+                delay_time:
+                  type: string
+                hold_m_name:
+                  type: string
+                liquid_material_name:
+                  type: string
+                material_name:
+                  type: string
+                order_name:
+                  type: string
+                speed:
+                  type: string
+                target_weigh:
+                  type: string
+                temperature:
+                  type: string
+                volume:
+                  type: string
+              required:
+              - order_name
+              - material_name
+              - target_weigh
+              - volume
+              - liquid_material_name
+              - speed
+              - temperature
+              - delay_time
+              - hold_m_name
+              title: DispenStationSolnPrep_Goal
+              type: object
+            result:
+              properties:
+                return_info:
+                  type: string
+              required:
+              - return_info
+              title: DispenStationSolnPrep_Result
+              type: object
+          required:
+          - goal
+          title: DispenStationSolnPrep
+          type: object
+        type: DispenStationSolnPrep
+    module: unilabos.devices.workstation.bioyond_studio.dispensing_station:BioyondDispensingStation
+    status_types: {}
+    type: python
+  config_info: []
+  description: ''
+  handles: []
+  icon: ''
+  init_param_schema:
+    config:
+      properties:
+        config:
+          type: string
+        deck:
+          type: string
+      required:
+      - config
+      - deck
+      type: object
+    data:
+      properties: {}
+      required: []
+      type: object
+  version: 1.0.0

unilabos/registry/devices/bioyond_dispensing_station.yaml

@@ -174,6 +174,35 @@ bioyond_dispensing_station:
           title: query_resource_by_name参数
           type: object
         type: UniLabJsonCommand
+      auto-transfer_materials_to_reaction_station:
+        feedback: {}
+        goal: {}
+        goal_default:
+          target_device_id: null
+          transfer_groups: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: ''
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                target_device_id:
+                  type: string
+                transfer_groups:
+                  type: array
+              required:
+              - target_device_id
+              - transfer_groups
+              type: object
+            result: {}
+          required:
+          - goal
+          title: transfer_materials_to_reaction_station参数
+          type: object
+        type: UniLabJsonCommand
       auto-workflow_sample_locations:
         feedback: {}
         goal: {}
@@ -591,56 +620,6 @@ bioyond_dispensing_station:
           title: DispenStationSolnPrep
           type: object
         type: DispenStationSolnPrep
-      transfer_materials_to_reaction_station:
-        feedback: {}
-        goal:
-          target_device_id: target_device_id
-          transfer_groups: transfer_groups
-        goal_default:
-          target_device_id: ''
-          transfer_groups: ''
-        handles: {}
-        placeholder_keys:
-          target_device_id: unilabos_devices
-        result: {}
-        schema:
-          description: 将配液站完成的物料（溶液、样品等）转移到指定反应站的堆栈库位。支持配置多组转移任务，每组包含物料名称、目标堆栈和目标库位。
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                target_device_id:
-                  description: 目标反应站设备ID（从设备列表中选择，所有转移组都使用同一个目标设备）
-                  type: string
-                transfer_groups:
-                  description: 转移任务组列表，每组包含物料名称、目标堆栈和目标库位，可以添加多组
-                  items:
-                    properties:
-                      materials:
-                        description: 物料名称（手动输入，系统将通过RPC查询验证）
-                        type: string
-                      target_sites:
-                        description: 目标库位（手动输入，如"A01"）
-                        type: string
-                      target_stack:
-                        description: 目标堆栈名称（手动输入，如"堆栈1左"）
-                        type: string
-                    required:
-                    - materials
-                    - target_stack
-                    - target_sites
-                    type: object
-                  type: array
-              required:
-              - target_device_id
-              - transfer_groups
-              type: object
-            result: {}
-          required:
-          - goal
-          title: transfer_materials_to_reaction_station参数
-          type: object
-        type: UniLabJsonCommand
       wait_for_multiple_orders_and_get_reports:
         feedback: {}
         goal:

unilabos/registry/devices/characterization_chromatic.yaml

@@ -1,3 +1,231 @@
+hplc.agilent:
+  category:
+  - characterization_chromatic
+  class:
+    action_value_mappings:
+      auto-check_status:
+        feedback: {}
+        goal: {}
+        goal_default: {}
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: 检查安捷伦HPLC设备状态的函数。用于监控设备的运行状态、连接状态、错误信息等关键指标。该函数定期查询设备状态，确保系统稳定运行，及时发现和报告设备异常。适用于自动化流程中的设备监控、故障诊断、系统维护等场景。
+          properties:
+            feedback: {}
+            goal:
+              properties: {}
+              required: []
+              type: object
+            result: {}
+          required:
+          - goal
+          title: check_status参数
+          type: object
+        type: UniLabJsonCommand
+      auto-extract_data_from_txt:
+        feedback: {}
+        goal: {}
+        goal_default:
+          file_path: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: 从文本文件中提取分析数据的函数。用于解析安捷伦HPLC生成的结果文件，提取峰面积、保留时间、浓度等关键分析数据。支持多种文件格式的自动识别和数据结构化处理，为后续数据分析和报告生成提供标准化的数据格式。适用于批量数据处理、结果验证、质量控制等分析工作流程。
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                file_path:
+                  type: string
+              required:
+              - file_path
+              type: object
+            result: {}
+          required:
+          - goal
+          title: extract_data_from_txt参数
+          type: object
+        type: UniLabJsonCommand
+      auto-start_sequence:
+        feedback: {}
+        goal: {}
+        goal_default:
+          params: null
+          resource: null
+          wf_name: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: 启动安捷伦HPLC分析序列的函数。用于执行预定义的分析方法序列，包括样品进样、色谱分离、检测等完整的分析流程。支持参数配置、资源分配、工作流程管理等功能，实现全自动的样品分析。适用于批量样品处理、标准化分析、质量检测等需要连续自动分析的应用场景。
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                params:
+                  type: string
+                resource:
+                  type: object
+                wf_name:
+                  type: string
+              required:
+              - wf_name
+              type: object
+            result: {}
+          required:
+          - goal
+          title: start_sequence参数
+          type: object
+        type: UniLabJsonCommand
+      auto-try_close_sub_device:
+        feedback: {}
+        goal: {}
+        goal_default:
+          device_name: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: 尝试关闭HPLC子设备的函数。用于安全地关闭泵、检测器、进样器等各个子模块，确保设备正常断开连接并保护硬件安全。该函数提供错误处理和状态确认机制，避免强制关闭可能造成的设备损坏。适用于设备维护、系统重启、紧急停机等需要安全关闭设备的场景。
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                device_name:
+                  type: string
+              required: []
+              type: object
+            result: {}
+          required:
+          - goal
+          title: try_close_sub_device参数
+          type: object
+        type: UniLabJsonCommand
+      auto-try_open_sub_device:
+        feedback: {}
+        goal: {}
+        goal_default:
+          device_name: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: 尝试打开HPLC子设备的函数。用于初始化和连接泵、检测器、进样器等各个子模块，建立设备通信并进行自检。该函数提供连接验证和错误恢复机制，确保子设备正常启动并准备就绪。适用于设备初始化、系统启动、设备重连等需要建立设备连接的场景。
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                device_name:
+                  type: string
+              required: []
+              type: object
+            result: {}
+          required:
+          - goal
+          title: try_open_sub_device参数
+          type: object
+        type: UniLabJsonCommand
+      execute_command_from_outer:
+        feedback: {}
+        goal:
+          command: command
+        goal_default:
+          command: ''
+        handles: {}
+        result:
+          success: success
+        schema:
+          description: ''
+          properties:
+            feedback:
+              properties:
+                status:
+                  type: string
+              required:
+              - status
+              title: SendCmd_Feedback
+              type: object
+            goal:
+              properties:
+                command:
+                  type: string
+              required:
+              - command
+              title: SendCmd_Goal
+              type: object
+            result:
+              properties:
+                return_info:
+                  type: string
+                success:
+                  type: boolean
+              required:
+              - return_info
+              - success
+              title: SendCmd_Result
+              type: object
+          required:
+          - goal
+          title: SendCmd
+          type: object
+        type: SendCmd
+    module: unilabos.devices.hplc.AgilentHPLC:HPLCDriver
+    status_types:
+      could_run: bool
+      data_file: String
+      device_status: str
+      driver_init_ok: bool
+      finish_status: str
+      is_running: bool
+      status_text: str
+      success: bool
+    type: python
+  config_info: []
+  description: 安捷伦高效液相色谱（HPLC）分析设备，用于复杂化合物的分离、检测和定量分析。该设备通过UI自动化技术控制安捷伦ChemStation软件，实现全自动的样品分析流程。具备序列启动、设备状态监控、数据文件提取、结果处理等功能。支持多样品批量处理和实时状态反馈，适用于药物分析、环境检测、食品安全、化学研究等需要高精度色谱分析的实验室应用。
+  handles: []
+  icon: ''
+  init_param_schema:
+    config:
+      properties:
+        driver_debug:
+          default: false
+          type: string
+      required: []
+      type: object
+    data:
+      properties:
+        could_run:
+          type: boolean
+        data_file:
+          items:
+            type: string
+          type: array
+        device_status:
+          type: string
+        driver_init_ok:
+          type: boolean
+        finish_status:
+          type: string
+        is_running:
+          type: boolean
+        status_text:
+          type: string
+        success:
+          type: boolean
+      required:
+      - status_text
+      - device_status
+      - could_run
+      - driver_init_ok
+      - is_running
+      - success
+      - finish_status
+      - data_file
+      type: object
+  version: 1.0.0
 hplc.agilent-zhida:
   category:
   - characterization_chromatic

unilabos/registry/devices/characterization_optic.yaml

@@ -1 +1,194 @@
-{}
+raman.home_made:
+  category:
+  - characterization_optic
+  class:
+    action_value_mappings:
+      auto-ccd_time:
+        feedback: {}
+        goal: {}
+        goal_default:
+          int_time: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: 设置CCD检测器积分时间的函数。用于配置拉曼光谱仪的信号采集时间，控制光谱数据的质量和信噪比。较长的积分时间可获得更高的信号强度和更好的光谱质量，但会增加测量时间。该函数允许根据样品特性和测量要求动态调整检测参数，优化测量效果。
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                int_time:
+                  type: string
+              required:
+              - int_time
+              type: object
+            result: {}
+          required:
+          - goal
+          title: ccd_time参数
+          type: object
+        type: UniLabJsonCommand
+      auto-laser_on_power:
+        feedback: {}
+        goal: {}
+        goal_default:
+          output_voltage_laser: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: 设置激光器输出功率的函数。用于控制拉曼光谱仪激光器的功率输出，调节激光强度以适应不同样品的测量需求。适当的激光功率能够获得良好的拉曼信号同时避免样品损伤。该函数支持精确的功率控制，确保测量结果的稳定性和重现性。
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                output_voltage_laser:
+                  type: string
+              required:
+              - output_voltage_laser
+              type: object
+            result: {}
+          required:
+          - goal
+          title: laser_on_power参数
+          type: object
+        type: UniLabJsonCommand
+      auto-raman_without_background:
+        feedback: {}
+        goal: {}
+        goal_default:
+          int_time: null
+          laser_power: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: 执行无背景扣除的拉曼光谱测量函数。用于直接采集样品的拉曼光谱信号，不进行背景校正处理。该函数配置积分时间和激光功率参数，获取原始光谱数据用于后续的数据处理分析。适用于对光谱数据质量要求较高或需要自定义背景处理流程的测量场景。
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                int_time:
+                  type: string
+                laser_power:
+                  type: string
+              required:
+              - int_time
+              - laser_power
+              type: object
+            result: {}
+          required:
+          - goal
+          title: raman_without_background参数
+          type: object
+        type: UniLabJsonCommand
+      auto-raman_without_background_average:
+        feedback: {}
+        goal: {}
+        goal_default:
+          average: null
+          int_time: null
+          laser_power: null
+          sample_name: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: 执行多次平均的无背景拉曼光谱测量函数。通过多次测量取平均值来提高光谱数据的信噪比和测量精度，减少随机噪声影响。该函数支持自定义平均次数、积分时间、激光功率等参数，并可为样品指定名称便于数据管理。适用于对测量精度要求较高的定量分析和研究应用。
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                average:
+                  type: string
+                int_time:
+                  type: string
+                laser_power:
+                  type: string
+                sample_name:
+                  type: string
+              required:
+              - sample_name
+              - int_time
+              - laser_power
+              - average
+              type: object
+            result: {}
+          required:
+          - goal
+          title: raman_without_background_average参数
+          type: object
+        type: UniLabJsonCommand
+      raman_cmd:
+        feedback: {}
+        goal:
+          command: command
+        goal_default:
+          command: ''
+        handles: {}
+        result:
+          success: success
+        schema:
+          description: ''
+          properties:
+            feedback:
+              properties:
+                status:
+                  type: string
+              required:
+              - status
+              title: SendCmd_Feedback
+              type: object
+            goal:
+              properties:
+                command:
+                  type: string
+              required:
+              - command
+              title: SendCmd_Goal
+              type: object
+            result:
+              properties:
+                return_info:
+                  type: string
+                success:
+                  type: boolean
+              required:
+              - return_info
+              - success
+              title: SendCmd_Result
+              type: object
+          required:
+          - goal
+          title: SendCmd
+          type: object
+        type: SendCmd
+    module: unilabos.devices.raman_uv.home_made_raman:RamanObj
+    status_types: {}
+    type: python
+  config_info: []
+  description: 拉曼光谱分析设备，用于物质的分子结构和化学成分表征。该设备集成激光器和CCD检测器，通过串口通信控制激光功率和光谱采集。具备背景扣除、多次平均、自动数据处理等功能，支持高精度的拉曼光谱测量。适用于材料表征、化学分析、质量控制、研究开发等需要分子指纹识别和结构分析的实验应用。
+  handles: []
+  icon: ''
+  init_param_schema:
+    config:
+      properties:
+        baudrate_ccd:
+          default: 921600
+          type: string
+        baudrate_laser:
+          default: 9600
+          type: string
+        port_ccd:
+          type: string
+        port_laser:
+          type: string
+      required:
+      - port_laser
+      - port_ccd
+      type: object
+    data:
+      properties: {}
+      required: []
+      type: object
+  version: 1.0.0

unilabos/registry/devices/chinwe.yaml

@@ -1,344 +0,0 @@
-separator.chinwe:
-  category:
-  - separator
-  - chinwe
-  class:
-    action_value_mappings:
-      motor_rotate_quarter:
-        goal:
-          direction: 顺时针
-          motor_id: 4
-          speed: 60
-        handles: {}
-        schema:
-          description: 电机旋转 1/4 圈
-          properties:
-            goal:
-              properties:
-                direction:
-                  default: 顺时针
-                  description: 旋转方向
-                  enum:
-                  - 顺时针
-                  - 逆时针
-                  type: string
-                motor_id:
-                  default: '4'
-                  description: 选择电机 (4:搅拌, 5:旋钮)
-                  enum:
-                  - '4'
-                  - '5'
-                  type: string
-                speed:
-                  default: 60
-                  description: 速度 (RPM)
-                  type: integer
-              required:
-              - motor_id
-              - speed
-              type: object
-        type: UniLabJsonCommand
-      motor_run_continuous:
-        goal:
-          direction: 顺时针
-          motor_id: 4
-          speed: 60
-        handles: {}
-        schema:
-          description: 电机一直旋转 (速度模式)
-          properties:
-            goal:
-              properties:
-                direction:
-                  default: 顺时针
-                  description: 旋转方向
-                  enum:
-                  - 顺时针
-                  - 逆时针
-                  type: string
-                motor_id:
-                  default: '4'
-                  description: 选择电机 (4:搅拌, 5:旋钮)
-                  enum:
-                  - '4'
-                  - '5'
-                  type: string
-                speed:
-                  default: 60
-                  description: 速度 (RPM)
-                  type: integer
-              required:
-              - motor_id
-              - speed
-              type: object
-        type: UniLabJsonCommand
-      motor_stop:
-        goal:
-          motor_id: 4
-        handles: {}
-        schema:
-          description: 停止指定步进电机
-          properties:
-            goal:
-              properties:
-                motor_id:
-                  default: '4'
-                  description: 选择电机
-                  enum:
-                  - '4'
-                  - '5'
-                  title: '注: 4=搅拌, 5=旋钮'
-                  type: string
-              required:
-              - motor_id
-              type: object
-        type: UniLabJsonCommand
-      pump_aspirate:
-        goal:
-          pump_id: 1
-          valve_port: 1
-          volume: 1000
-        handles: {}
-        schema:
-          description: 注射泵吸液
-          properties:
-            goal:
-              properties:
-                pump_id:
-                  default: '1'
-                  description: 选择泵
-                  enum:
-                  - '1'
-                  - '2'
-                  - '3'
-                  type: string
-                valve_port:
-                  default: '1'
-                  description: 阀门端口
-                  enum:
-                  - '1'
-                  - '2'
-                  - '3'
-                  - '4'
-                  - '5'
-                  - '6'
-                  - '7'
-                  - '8'
-                  type: string
-                volume:
-                  default: 1000
-                  description: 吸液步数
-                  type: integer
-              required:
-              - pump_id
-              - volume
-              - valve_port
-              type: object
-        type: UniLabJsonCommand
-      pump_dispense:
-        goal:
-          pump_id: 1
-          valve_port: 1
-          volume: 1000
-        handles: {}
-        schema:
-          description: 注射泵排液
-          properties:
-            goal:
-              properties:
-                pump_id:
-                  default: '1'
-                  description: 选择泵
-                  enum:
-                  - '1'
-                  - '2'
-                  - '3'
-                  type: string
-                valve_port:
-                  default: '1'
-                  description: 阀门端口
-                  enum:
-                  - '1'
-                  - '2'
-                  - '3'
-                  - '4'
-                  - '5'
-                  - '6'
-                  - '7'
-                  - '8'
-                  type: string
-                volume:
-                  default: 1000
-                  description: 排液步数
-                  type: integer
-              required:
-              - pump_id
-              - volume
-              - valve_port
-              type: object
-        type: UniLabJsonCommand
-      pump_initialize:
-        goal:
-          drain_port: 0
-          output_port: 0
-          pump_id: 1
-          speed: 10
-        handles: {}
-        schema:
-          description: 初始化指定注射泵
-          properties:
-            goal:
-              properties:
-                drain_port:
-                  default: 0
-                  description: 排液口索引
-                  type: integer
-                output_port:
-                  default: 0
-                  description: 输出口索引
-                  type: integer
-                pump_id:
-                  default: '1'
-                  description: 选择泵
-                  enum:
-                  - '1'
-                  - '2'
-                  - '3'
-                  title: '注: 1号泵, 2号泵, 3号泵'
-                  type: string
-                speed:
-                  default: 10
-                  description: 运动速度
-                  type: integer
-              required:
-              - pump_id
-              type: object
-        type: UniLabJsonCommand
-      pump_valve:
-        goal:
-          port: 1
-          pump_id: 1
-        handles: {}
-        schema:
-          description: 切换指定泵的阀门端口
-          properties:
-            goal:
-              properties:
-                port:
-                  default: '1'
-                  description: 阀门端口号 (1-8)
-                  enum:
-                  - '1'
-                  - '2'
-                  - '3'
-                  - '4'
-                  - '5'
-                  - '6'
-                  - '7'
-                  - '8'
-                  type: string
-                pump_id:
-                  default: '1'
-                  description: 选择泵
-                  enum:
-                  - '1'
-                  - '2'
-                  - '3'
-                  type: string
-              required:
-              - pump_id
-              - port
-              type: object
-        type: UniLabJsonCommand
-      wait_sensor_level:
-        goal:
-          target_state: 有液
-          timeout: 30
-        handles: {}
-        schema:
-          description: 等待传感器液位条件
-          properties:
-            goal:
-              properties:
-                target_state:
-                  default: 有液
-                  description: 目标液位状态
-                  enum:
-                  - 有液
-                  - 无液
-                  type: string
-                timeout:
-                  default: 30
-                  description: 超时时间 (秒)
-                  type: integer
-              required:
-              - target_state
-              type: object
-        type: UniLabJsonCommand
-      wait_time:
-        goal:
-          duration: 10
-        handles: {}
-        schema:
-          description: 等待指定时间
-          properties:
-            goal:
-              properties:
-                duration:
-                  default: 10
-                  description: 等待时间 (秒)
-                  type: integer
-              required:
-              - duration
-              type: object
-        type: UniLabJsonCommand
-    module: unilabos.devices.separator.chinwe:ChinweDevice
-    status_types:
-      is_connected: bool
-      sensor_level: bool
-      sensor_rssi: int
-    type: python
-  config_info: []
-  description: ChinWe 简易工作站控制器 (3泵, 2电机, 1传感器)
-  handles: []
-  icon: ''
-  init_param_schema:
-    goal:
-      baudrate:
-        default: 9600
-        description: 串口波特率
-        type: integer
-      motor_ids:
-        default:
-        - 4
-        - 5
-        description: 步进电机ID列表
-        items:
-          type: integer
-        type: array
-      port:
-        default: 192.168.1.200:8899
-        description: 串口号或 IP:Port
-        type: string
-      pump_ids:
-        default:
-        - 1
-        - 2
-        - 3
-        description: 注射泵ID列表
-        items:
-          type: integer
-        type: array
-      sensor_id:
-        default: 6
-        description: XKC传感器ID
-        type: integer
-      sensor_threshold:
-        default: 300
-        description: 传感器液位判定阈值
-        type: integer
-      timeout:
-        default: 10
-        description: 通信超时时间 (秒)
-        type: integer
-  version: 2.1.0

unilabos/registry/devices/coin_cell_workstation.yaml

@@ -1,586 +0,0 @@
-coincellassemblyworkstation_device:
-  category:
-  - coin_cell_workstation
-  class:
-    action_value_mappings:
-      auto-change_hole_sheet_to_2:
-        feedback: {}
-        goal: {}
-        goal_default:
-          hole: null
-        handles: {}
-        placeholder_keys: {}
-        result: {}
-        schema:
-          description: ''
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                hole:
-                  type: object
-              required:
-              - hole
-              type: object
-            result: {}
-          required:
-          - goal
-          title: change_hole_sheet_to_2参数
-          type: object
-        type: UniLabJsonCommandAsync
-      auto-fill_plate:
-        feedback: {}
-        goal: {}
-        goal_default: {}
-        handles: {}
-        placeholder_keys: {}
-        result: {}
-        schema:
-          description: ''
-          properties:
-            feedback: {}
-            goal:
-              properties: {}
-              required: []
-              type: object
-            result: {}
-          required:
-          - goal
-          title: fill_plate参数
-          type: object
-        type: UniLabJsonCommandAsync
-      auto-fun_wuliao_test:
-        feedback: {}
-        goal: {}
-        goal_default: {}
-        handles: {}
-        placeholder_keys: {}
-        result: {}
-        schema:
-          description: ''
-          properties:
-            feedback: {}
-            goal:
-              properties: {}
-              required: []
-              type: object
-            result: {}
-          required:
-          - goal
-          title: fun_wuliao_test参数
-          type: object
-        type: UniLabJsonCommand
-      auto-func_allpack_cmd:
-        feedback: {}
-        goal: {}
-        goal_default:
-          assembly_pressure: 4200
-          assembly_type: 7
-          elec_num: null
-          elec_use_num: null
-          elec_vol: 50
-          file_path: /Users/sml/work
-        handles: {}
-        placeholder_keys: {}
-        result: {}
-        schema:
-          description: ''
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                assembly_pressure:
-                  default: 4200
-                  type: integer
-                assembly_type:
-                  default: 7
-                  type: integer
-                elec_num:
-                  type: string
-                elec_use_num:
-                  type: string
-                elec_vol:
-                  default: 50
-                  type: integer
-                file_path:
-                  default: /Users/sml/work
-                  type: string
-              required:
-              - elec_num
-              - elec_use_num
-              type: object
-            result: {}
-          required:
-          - goal
-          title: func_allpack_cmd参数
-          type: object
-        type: UniLabJsonCommand
-      auto-func_get_csv_export_status:
-        feedback: {}
-        goal: {}
-        goal_default: {}
-        handles: {}
-        placeholder_keys: {}
-        result: {}
-        schema:
-          description: ''
-          properties:
-            feedback: {}
-            goal:
-              properties: {}
-              required: []
-              type: object
-            result: {}
-          required:
-          - goal
-          title: func_get_csv_export_status参数
-          type: object
-        type: UniLabJsonCommand
-      auto-func_pack_device_auto:
-        feedback: {}
-        goal: {}
-        goal_default: {}
-        handles: {}
-        placeholder_keys: {}
-        result: {}
-        schema:
-          description: ''
-          properties:
-            feedback: {}
-            goal:
-              properties: {}
-              required: []
-              type: object
-            result: {}
-          required:
-          - goal
-          title: func_pack_device_auto参数
-          type: object
-        type: UniLabJsonCommand
-      auto-func_pack_device_init:
-        feedback: {}
-        goal: {}
-        goal_default: {}
-        handles: {}
-        placeholder_keys: {}
-        result: {}
-        schema:
-          description: ''
-          properties:
-            feedback: {}
-            goal:
-              properties: {}
-              required: []
-              type: object
-            result: {}
-          required:
-          - goal
-          title: func_pack_device_init参数
-          type: object
-        type: UniLabJsonCommand
-      auto-func_pack_device_start:
-        feedback: {}
-        goal: {}
-        goal_default: {}
-        handles: {}
-        placeholder_keys: {}
-        result: {}
-        schema:
-          description: ''
-          properties:
-            feedback: {}
-            goal:
-              properties: {}
-              required: []
-              type: object
-            result: {}
-          required:
-          - goal
-          title: func_pack_device_start参数
-          type: object
-        type: UniLabJsonCommand
-      auto-func_pack_device_stop:
-        feedback: {}
-        goal: {}
-        goal_default: {}
-        handles: {}
-        placeholder_keys: {}
-        result: {}
-        schema:
-          description: ''
-          properties:
-            feedback: {}
-            goal:
-              properties: {}
-              required: []
-              type: object
-            result: {}
-          required:
-          - goal
-          title: func_pack_device_stop参数
-          type: object
-        type: UniLabJsonCommand
-      auto-func_pack_get_msg_cmd:
-        feedback: {}
-        goal: {}
-        goal_default:
-          file_path: D:\coin_cell_data
-        handles: {}
-        placeholder_keys: {}
-        result: {}
-        schema:
-          description: ''
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                file_path:
-                  default: D:\coin_cell_data
-                  type: string
-              required: []
-              type: object
-            result: {}
-          required:
-          - goal
-          title: func_pack_get_msg_cmd参数
-          type: object
-        type: UniLabJsonCommand
-      auto-func_pack_send_bottle_num:
-        feedback: {}
-        goal: {}
-        goal_default:
-          bottle_num: null
-        handles: {}
-        placeholder_keys: {}
-        result: {}
-        schema:
-          description: ''
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                bottle_num:
-                  type: string
-              required:
-              - bottle_num
-              type: object
-            result: {}
-          required:
-          - goal
-          title: func_pack_send_bottle_num参数
-          type: object
-        type: UniLabJsonCommand
-      auto-func_pack_send_finished_cmd:
-        feedback: {}
-        goal: {}
-        goal_default: {}
-        handles: {}
-        placeholder_keys: {}
-        result: {}
-        schema:
-          description: ''
-          properties:
-            feedback: {}
-            goal:
-              properties: {}
-              required: []
-              type: object
-            result: {}
-          required:
-          - goal
-          title: func_pack_send_finished_cmd参数
-          type: object
-        type: UniLabJsonCommand
-      auto-func_pack_send_msg_cmd:
-        feedback: {}
-        goal: {}
-        goal_default:
-          assembly_pressure: null
-          assembly_type: null
-          elec_use_num: null
-          elec_vol: null
-        handles: {}
-        placeholder_keys: {}
-        result: {}
-        schema:
-          description: ''
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                assembly_pressure:
-                  type: string
-                assembly_type:
-                  type: string
-                elec_use_num:
-                  type: string
-                elec_vol:
-                  type: string
-              required:
-              - elec_use_num
-              - elec_vol
-              - assembly_type
-              - assembly_pressure
-              type: object
-            result: {}
-          required:
-          - goal
-          title: func_pack_send_msg_cmd参数
-          type: object
-        type: UniLabJsonCommand
-      auto-func_read_data_and_output:
-        feedback: {}
-        goal: {}
-        goal_default:
-          file_path: /Users/sml/work
-        handles: {}
-        placeholder_keys: {}
-        result: {}
-        schema:
-          description: ''
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                file_path:
-                  default: /Users/sml/work
-                  type: string
-              required: []
-              type: object
-            result: {}
-          required:
-          - goal
-          title: func_read_data_and_output参数
-          type: object
-        type: UniLabJsonCommand
-      auto-func_stop_read_data:
-        feedback: {}
-        goal: {}
-        goal_default: {}
-        handles: {}
-        placeholder_keys: {}
-        result: {}
-        schema:
-          description: ''
-          properties:
-            feedback: {}
-            goal:
-              properties: {}
-              required: []
-              type: object
-            result: {}
-          required:
-          - goal
-          title: func_stop_read_data参数
-          type: object
-        type: UniLabJsonCommand
-      auto-modify_deck_name:
-        feedback: {}
-        goal: {}
-        goal_default:
-          resource_name: null
-        handles: {}
-        placeholder_keys: {}
-        result: {}
-        schema:
-          description: ''
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                resource_name:
-                  type: string
-              required:
-              - resource_name
-              type: object
-            result: {}
-          required:
-          - goal
-          title: modify_deck_name参数
-          type: object
-        type: UniLabJsonCommand
-      auto-post_init:
-        feedback: {}
-        goal: {}
-        goal_default:
-          ros_node: null
-        handles: {}
-        placeholder_keys: {}
-        result: {}
-        schema:
-          description: ''
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                ros_node:
-                  type: object
-              required:
-              - ros_node
-              type: object
-            result: {}
-          required:
-          - goal
-          title: post_init参数
-          type: object
-        type: UniLabJsonCommand
-      auto-qiming_coin_cell_code:
-        feedback: {}
-        goal: {}
-        goal_default:
-          battery_clean_ignore: false
-          battery_pressure: 4000
-          battery_pressure_mode: true
-          fujipian_juzhendianwei: 0
-          fujipian_panshu: null
-          gemo_juzhendianwei: 0
-          gemopanshu: 0
-          lvbodian: true
-        handles: {}
-        placeholder_keys: {}
-        result: {}
-        schema:
-          description: ''
-          properties:
-            feedback: {}
-            goal:
-              properties:
-                battery_clean_ignore:
-                  default: false
-                  type: boolean
-                battery_pressure:
-                  default: 4000
-                  type: integer
-                battery_pressure_mode:
-                  default: true
-                  type: boolean
-                fujipian_juzhendianwei:
-                  default: 0
-                  type: integer
-                fujipian_panshu:
-                  type: integer
-                gemo_juzhendianwei:
-                  default: 0
-                  type: integer
-                gemopanshu:
-                  default: 0
-                  type: integer
-                lvbodian:
-                  default: true
-                  type: boolean
-              required:
-              - fujipian_panshu
-              type: object
-            result: {}
-          required:
-          - goal
-          title: qiming_coin_cell_code参数
-          type: object
-        type: UniLabJsonCommand
-    module: unilabos.devices.workstation.coin_cell_assembly.coin_cell_assembly:CoinCellAssemblyWorkstation
-    status_types:
-      data_assembly_coin_cell_num: int
-      data_assembly_pressure: int
-      data_assembly_time: float
-      data_axis_x_pos: float
-      data_axis_y_pos: float
-      data_axis_z_pos: float
-      data_coin_cell_code: str
-      data_coin_num: int
-      data_electrolyte_code: str
-      data_electrolyte_volume: int
-      data_glove_box_o2_content: float
-      data_glove_box_pressure: float
-      data_glove_box_water_content: float
-      data_open_circuit_voltage: float
-      data_pole_weight: float
-      request_rec_msg_status: bool
-      request_send_msg_status: bool
-      sys_mode: str
-      sys_status: str
-    type: python
-  config_info: []
-  description: ''
-  handles: []
-  icon: koudian.webp
-  init_param_schema:
-    config:
-      properties:
-        address:
-          default: 172.16.28.102
-          type: string
-        config:
-          type: object
-        debug_mode:
-          default: false
-          type: boolean
-        deck:
-          type: string
-        port:
-          default: '502'
-          type: string
-      required: []
-      type: object
-    data:
-      properties:
-        data_assembly_coin_cell_num:
-          type: integer
-        data_assembly_pressure:
-          type: integer
-        data_assembly_time:
-          type: number
-        data_axis_x_pos:
-          type: number
-        data_axis_y_pos:
-          type: number
-        data_axis_z_pos:
-          type: number
-        data_coin_cell_code:
-          type: string
-        data_coin_num:
-          type: integer
-        data_electrolyte_code:
-          type: string
-        data_electrolyte_volume:
-          type: integer
-        data_glove_box_o2_content:
-          type: number
-        data_glove_box_pressure:
-          type: number
-        data_glove_box_water_content:
-          type: number
-        data_open_circuit_voltage:
-          type: number
-        data_pole_weight:
-          type: number
-        request_rec_msg_status:
-          type: boolean
-        request_send_msg_status:
-          type: boolean
-        sys_mode:
-          type: string
-        sys_status:
-          type: string
-      required:
-      - sys_status
-      - sys_mode
-      - request_rec_msg_status
-      - request_send_msg_status
-      - data_assembly_coin_cell_num
-      - data_assembly_time
-      - data_open_circuit_voltage
-      - data_axis_x_pos
-      - data_axis_y_pos
-      - data_axis_z_pos
-      - data_pole_weight
-      - data_assembly_pressure
-      - data_electrolyte_volume
-      - data_coin_num
-      - data_coin_cell_code
-      - data_electrolyte_code
-      - data_glove_box_pressure
-      - data_glove_box_o2_content
-      - data_glove_box_water_content
-      type: object
-  registry_type: device
-  version: 1.0.0

unilabos/registry/devices/liquid_handler.yaml

@@ -9333,34 +9333,7 @@ liquid_handler.prcxi:
           touch_tip: false
           use_channels:
           - 0
-        handles:
-          input:
-          - data_key: liquid
-            data_source: handle
-            data_type: resource
-            handler_key: sources
-            label: sources
-          - data_key: liquid
-            data_source: executor
-            data_type: resource
-            handler_key: targets
-            label: targets
-          - data_key: liquid
-            data_source: executor
-            data_type: resource
-            handler_key: tip_rack
-            label: tip_rack
-          output:
-          - data_key: liquid
-            data_source: handle
-            data_type: resource
-            handler_key: sources_out
-            label: sources
-          - data_key: liquid
-            data_source: executor
-            data_type: resource
-            handler_key: targets_out
-            label: targets
+        handles: {}
         placeholder_keys:
           sources: unilabos_resources
           targets: unilabos_resources

unilabos/registry/devices/robot_linear_motion.yaml

@@ -834,3 +834,174 @@ linear_motion.toyo_xyz.sim:
     mesh: toyo_xyz
     type: device
   version: 1.0.0
+motor.iCL42:
+  category:
+  - robot_linear_motion
+  class:
+    action_value_mappings:
+      auto-execute_run_motor:
+        feedback: {}
+        goal: {}
+        goal_default:
+          mode: null
+          position: null
+          velocity: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: 步进电机执行运动函数。直接执行电机运动命令，包括位置设定、速度控制和路径规划。该函数处理底层的电机控制协议，消除警告信息，设置运动参数并启动电机运行。适用于需要直接控制电机运动的应用场景。
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                mode:
+                  type: string
+                position:
+                  type: number
+                velocity:
+                  type: integer
+              required:
+              - mode
+              - position
+              - velocity
+              type: object
+            result: {}
+          required:
+          - goal
+          title: execute_run_motor参数
+          type: object
+        type: UniLabJsonCommand
+      auto-init_device:
+        feedback: {}
+        goal: {}
+        goal_default: {}
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: iCL42电机设备初始化函数。建立与iCL42步进电机驱动器的串口通信连接，配置通信参数包括波特率、数据位、校验位等。该函数是电机使用前的必要步骤，确保驱动器处于可控状态并准备接收运动指令。
+          properties:
+            feedback: {}
+            goal:
+              properties: {}
+              required: []
+              type: object
+            result: {}
+          required:
+          - goal
+          title: init_device参数
+          type: object
+        type: UniLabJsonCommand
+      auto-run_motor:
+        feedback: {}
+        goal: {}
+        goal_default:
+          mode: null
+          position: null
+          velocity: null
+        handles: {}
+        placeholder_keys: {}
+        result: {}
+        schema:
+          description: 步进电机运动控制函数。根据指定的运动模式、目标位置和速度参数控制电机运动。支持多种运动模式和精确的位置控制，自动处理运动轨迹规划和执行。该函数提供异步执行和状态反馈，确保运动的准确性和可靠性。
+          properties:
+            feedback: {}
+            goal:
+              properties:
+                mode:
+                  type: string
+                position:
+                  type: number
+                velocity:
+                  type: integer
+              required:
+              - mode
+              - position
+              - velocity
+              type: object
+            result: {}
+          required:
+          - goal
+          title: run_motor参数
+          type: object
+        type: UniLabJsonCommand
+      execute_command_from_outer:
+        feedback: {}
+        goal:
+          command: command
+        goal_default:
+          command: ''
+        handles: {}
+        result:
+          success: success
+        schema:
+          description: ''
+          properties:
+            feedback:
+              properties:
+                status:
+                  type: string
+              required:
+              - status
+              title: SendCmd_Feedback
+              type: object
+            goal:
+              properties:
+                command:
+                  type: string
+              required:
+              - command
+              title: SendCmd_Goal
+              type: object
+            result:
+              properties:
+                return_info:
+                  type: string
+                success:
+                  type: boolean
+              required:
+              - return_info
+              - success
+              title: SendCmd_Result
+              type: object
+          required:
+          - goal
+          title: SendCmd
+          type: object
+        type: SendCmd
+    module: unilabos.devices.motor.iCL42:iCL42Driver
+    status_types:
+      is_executing_run: bool
+      motor_position: int
+      success: bool
+    type: python
+  config_info: []
+  description: iCL42步进电机驱动器，用于实验室设备的精密线性运动控制。该设备通过串口通信控制iCL42型步进电机驱动器，支持多种运动模式和精确的位置、速度控制。具备位置反馈、运行状态监控和故障检测功能。适用于自动进样器、样品传送、精密定位平台等需要准确线性运动控制的实验室自动化设备。
+  handles: []
+  icon: ''
+  init_param_schema:
+    config:
+      properties:
+        device_address:
+          default: 1
+          type: integer
+        device_com:
+          default: COM9
+          type: string
+      required: []
+      type: object
+    data:
+      properties:
+        is_executing_run:
+          type: boolean
+        motor_position:
+          type: integer
+        success:
+          type: boolean
+      required:
+      - motor_position
+      - is_executing_run
+      - success
+      type: object
+  version: 1.0.0

unilabos/registry/registry.py

@@ -222,7 +222,7 @@ class Registry:
         abs_path = Path(path).absolute()
         resource_path = abs_path / "resources"
         files = list(resource_path.glob("*/*.yaml"))
-        logger.trace(f"[UniLab Registry] load resources? {resource_path.exists()}, total: {len(files)}")
+        logger.debug(f"[UniLab Registry] resources: {resource_path.exists()}, total: {len(files)}")
         current_resource_number = len(self.resource_type_registry) + 1
         for i, file in enumerate(files):
             with open(file, encoding="utf-8", mode="r") as f:

unilabos/registry/resources/bioyond/YB_bottle.yaml

@@ -1,92 +0,0 @@
-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

unilabos/registry/resources/bioyond/YB_bottle_carriers.yaml

@@ -1,182 +0,0 @@
-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

unilabos/registry/resources/bioyond/deck.yaml

@@ -22,7 +22,7 @@ BIOYOND_PolymerReactionStation_Deck:
   init_param_schema: {}
   registry_type: resource
   version: 1.0.0
-BIOYOND_YB_Deck:
+YB_Deck11:
   category:
   - deck
   class:
@@ -34,15 +34,3 @@ BIOYOND_YB_Deck:
   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: BIOYOND PolymerReactionStation Deck
-  handles: []
-  icon: koudian.webp
-  init_param_schema: {}
-  registry_type: resource
-  version: 1.0.0

unilabos/resources/battery/bottle_carriers.py

@@ -1,56 +0,0 @@
-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

unilabos/resources/battery/electrode_sheet.py

@@ -1,195 +0,0 @@
-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

unilabos/resources/battery/magazine.py

@@ -1,344 +0,0 @@
-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",
-    )

unilabos/resources/bioyond/YB_bottle_carriers.py

@@ -1,653 +0,0 @@
-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
-

unilabos/resources/bioyond/YB_bottles.py

@@ -1,163 +0,0 @@
-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",
-    )    

unilabos/resources/bioyond/decks.py

@@ -1,7 +1,7 @@
 from os import name
 from pylabrobot.resources import Deck, Coordinate, Rotation
 
-from unilabos.resources.bioyond.YB_warehouses import (
+from unilabos.resources.bioyond.warehouses import (
     bioyond_warehouse_1x4x4,
     bioyond_warehouse_1x4x4_right,  # 新增：右侧仓库 (A05～D08)
     bioyond_warehouse_1x4x2,

unilabos/resources/graphio.py

@@ -42,7 +42,7 @@ def canonicalize_nodes_data(
     Returns:
         ResourceTreeSet: 标准化后的资源树集合
     """
-    print_status(f"{len(nodes)} Resources loaded", "info")
+    print_status(f"{len(nodes)} Resources loaded:", "info")
 
     # 第一步：基本预处理（处理graphml的label字段）
     outer_host_node_id = None

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] = None,
+        barcode: Optional[str] = "",
         category: str = "container",
         model: Optional[str] = None,
         **kwargs,

unilabos/ros/nodes/presets/host_node.py

@@ -664,7 +664,7 @@ class HostNode(BaseROS2DeviceNode):
                         if bCreate:
                             self.lab_logger().trace(f"Status created: {device_id}.{property_name} = {msg.data}")
                         else:
-                            self.lab_logger().trace(f"Status updated: {device_id}.{property_name} = {msg.data}")
+                            self.lab_logger().debug(f"Status updated: {device_id}.{property_name} = {msg.data}")
 
     def send_goal(
         self,
@@ -1157,12 +1157,11 @@ class HostNode(BaseROS2DeviceNode):
             响应对象，包含查询到的资源
         """
         try:
-            from unilabos.app.web import http_client
             data = json.loads(request.command)
             if "uuid" in data and data["uuid"] is not None:
-                http_req = http_client.resource_tree_get([data["uuid"]], data["with_children"])
+                http_req = self.bridges[-1].resource_tree_get([data["uuid"]], data["with_children"])
             elif "id" in data and data["id"].startswith("/"):
-                http_req = http_client.resource_get(data["id"], data["with_children"])
+                http_req = self.bridges[-1].resource_get(data["id"], data["with_children"])
             else:
                 raise ValueError("没有使用正确的物料 id 或 uuid")
             response.response = json.dumps(http_req["data"])

unilabos/ros/nodes/resource_tracker.py

@@ -66,8 +66,8 @@ class ResourceDict(BaseModel):
     klass: str = Field(alias="class", description="Resource class name")
     pose: ResourceDictPosition = Field(description="Resource position", default_factory=ResourceDictPosition)
     config: Dict[str, Any] = Field(description="Resource configuration")
-    data: Dict[str, Any] = Field(description="Resource data, eg: container liquid data")
-    extra: Dict[str, Any] = Field(description="Extra data, eg: slot index")
+    data: Dict[str, Any] = Field(description="Resource data")
+    extra: Dict[str, Any] = Field(description="Extra data")
 
     @field_serializer("parent_uuid")
     def _serialize_parent(self, parent_uuid: Optional["ResourceDict"]):

unilabos/test/experiments/chinwe.json

@@ -1,34 +0,0 @@
-{
-    "nodes": [
-        {
-            "id": "ChinWeStation",
-            "name": "分液工作站",
-            "children": [],
-            "parent": null,
-            "type": "device",
-            "class": "separator.chinwe",
-            "position": {
-                "x": 0,
-                "y": 0,
-                "z": 0
-            },
-            "config": {
-                "port": "192.168.31.13:8899",
-                "baudrate": 9600,
-                "pump_ids": [
-                    1,
-                    2,
-                    3
-                ],
-                "motor_ids": [
-                    4,
-                    5
-                ],
-                "sensor_id": 6,
-                "sensor_threshold": 300
-            },
-            "data": {}
-        }
-    ],
-    "links": []
-}

unilabos/test/experiments/reaction_station_bioyond_test.json

@@ -24,9 +24,9 @@
                         "Drip_back": "3a162cf9-6aac-565a-ddd7-682ba1796a4a"
                     },
                     "material_type_mappings": {
-                        "烧杯": "YB_1FlaskCarrier",
-                        "试剂瓶": "YB_1BottleCarrier",
-                        "样品板": "YB_6VialCarrier"
+                        "烧杯": "BIOYOND_PolymerStation_1FlaskCarrier",
+                        "试剂瓶": "BIOYOND_PolymerStation_1BottleCarrier",
+                        "样品板": "BIOYOND_PolymerStation_6VialCarrier"
                     }
                 },
                 "deck": {

unilabos/test/resources/test_bottle_carrier.py

@@ -1,7 +1,7 @@
 import pytest
 
 from unilabos.resources.bioyond.bottle_carriers import BIOYOND_Electrolyte_6VialCarrier, BIOYOND_Electrolyte_1BottleCarrier
-from unilabos.resources.bioyond.bottles import YB_Solid_Vial, YB_Solution_Beaker, YB_Reagent_Bottle
+from unilabos.resources.bioyond.bottles import BIOYOND_PolymerStation_Solid_Vial, BIOYOND_PolymerStation_Solution_Beaker, BIOYOND_PolymerStation_Reagent_Bottle
 
 
 def test_bottle_carrier() -> "BottleCarrier":
@@ -16,9 +16,9 @@ def test_bottle_carrier() -> "BottleCarrier":
     print(f"1烧杯载架: {beaker_carrier.name}, 位置数: {len(beaker_carrier.sites)}")
 
     # 创建瓶子和烧杯
-    powder_bottle = YB_Solid_Vial("powder_bottle_01")
-    solution_beaker = YB_Solution_Beaker("solution_beaker_01")
-    reagent_bottle = YB_Reagent_Bottle("reagent_bottle_01")
+    powder_bottle = BIOYOND_PolymerStation_Solid_Vial("powder_bottle_01")
+    solution_beaker = BIOYOND_PolymerStation_Solution_Beaker("solution_beaker_01")
+    reagent_bottle = BIOYOND_PolymerStation_Reagent_Bottle("reagent_bottle_01")
 
     print(f"\n创建的物料:")
     print(f"粉末瓶: {powder_bottle.name} - {powder_bottle.diameter}mm x {powder_bottle.height}mm, {powder_bottle.max_volume}μL")

unilabos/test/resources/test_converter_bioyond.py

@@ -12,13 +12,13 @@ lab_registry.setup()
 
 
 type_mapping = {
-    "烧杯": ("YB_1FlaskCarrier", "3a14196b-24f2-ca49-9081-0cab8021bf1a"),
-    "试剂瓶": ("YB_1BottleCarrier", ""),
-    "样品板": ("YB_6StockCarrier", "3a14196e-b7a0-a5da-1931-35f3000281e9"),
-    "分装板": ("YB_6VialCarrier", "3a14196e-5dfe-6e21-0c79-fe2036d052c4"),
-    "样品瓶": ("YB_Solid_Stock", "3a14196a-cf7d-8aea-48d8-b9662c7dba94"),
-    "90%分装小瓶": ("YB_Solid_Vial", "3a14196c-cdcf-088d-dc7d-5cf38f0ad9ea"),
-    "10%分装小瓶": ("YB_Liquid_Vial", "3a14196c-76be-2279-4e22-7310d69aed68"),
+    "烧杯": ("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"),
 }
 
 

unilabos/test/resources/test_resourcetreeset.py

@@ -1,4 +1,3 @@
-from ast import If
 import pytest
 import json
 import os
@@ -9,16 +8,18 @@ from unilabos.ros.nodes.resource_tracker import ResourceTreeSet
 from unilabos.registry.registry import lab_registry
 
 from unilabos.resources.bioyond.decks import BIOYOND_PolymerReactionStation_Deck
-from unilabos.resources.bioyond.decks import YB_Deck
 
 lab_registry.setup()
 
 
 type_mapping = {
-    "加样头(大)": ("YB_jia_yang_tou_da", "3a190ca0-b2f6-9aeb-8067-547e72c11469"),
-    "液": ("YB_1BottleCarrier", "3a190ca1-2add-2b23-f8e1-bbd348b7f790"),
-    "配液瓶(小)板": ("YB_peiyepingxiaoban", "3a190c8b-3284-af78-d29f-9a69463ad047"),
-    "配液瓶(小)": ("YB_pei_ye_xiao_Bottler", "3a190c8c-fe8f-bf48-0dc3-97afc7f508eb"),
+    "烧杯": ("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"),
 }
 
 
@@ -56,20 +57,12 @@ def bioyond_materials_liquidhandling_2() -> list[dict]:
     "bioyond_materials_reaction",
     "bioyond_materials_liquidhandling_1",
 ])
-def test_resourcetreeset_from_plr() -> list[dict]:
-    # 直接加载 bioyond_materials_reaction.json 文件
-    current_dir = os.path.dirname(os.path.abspath(__file__))
-    json_path = os.path.join(current_dir, "test.json")
-    with open(json_path, "r", encoding="utf-8") as f:
-        materials = json.load(f)
-    deck = YB_Deck("test_deck")
+def test_resourcetreeset_from_plr(materials_fixture, request) -> list[dict]:
+    materials = request.getfixturevalue(materials_fixture)
+    deck = BIOYOND_PolymerReactionStation_Deck("test_deck")
     output = resource_bioyond_to_plr(materials, type_mapping=type_mapping, deck=deck)
-    print(output)
-    # print(deck.summary())
+    print(deck.summary())
 
     r = ResourceTreeSet.from_plr_resources([deck])
     print(r.dump())
     # json.dump(deck.serialize(), open("test.json", "w", encoding="utf-8"), indent=4)
-
-if __name__ == "__main__":
-    test_resourcetreeset_from_plr()

unilabos/test/workflow/merge_workflow.py

@@ -0,0 +1,94 @@
+import json
+import sys
+from datetime import datetime
+from pathlib import Path
+
+ROOT_DIR = Path(__file__).resolve().parents[2]
+if str(ROOT_DIR) not in sys.path:
+    sys.path.insert(0, str(ROOT_DIR))
+
+import pytest
+
+from scripts.workflow import build_protocol_graph, draw_protocol_graph, draw_protocol_graph_with_ports
+
+
+ROOT_DIR = Path(__file__).resolve().parents[2]
+if str(ROOT_DIR) not in sys.path:
+    sys.path.insert(0, str(ROOT_DIR))
+
+
+def _normalize_steps(data):
+    normalized = []
+    for step in data:
+        action = step.get("action") or step.get("operation")
+        if not action:
+            continue
+        raw_params = step.get("parameters") or step.get("action_args") or {}
+        params = dict(raw_params)
+
+        if "source" in raw_params and "sources" not in raw_params:
+            params["sources"] = raw_params["source"]
+        if "target" in raw_params and "targets" not in raw_params:
+            params["targets"] = raw_params["target"]
+
+        description = step.get("description") or step.get("purpose")
+        step_dict = {"action": action, "parameters": params}
+        if description:
+            step_dict["description"] = description
+        normalized.append(step_dict)
+    return normalized
+
+
+def _normalize_labware(data):
+    labware = {}
+    for item in data:
+        reagent_name = item.get("reagent_name")
+        key = reagent_name or item.get("material_name") or item.get("name")
+        if not key:
+            continue
+        key = str(key)
+        idx = 1
+        original_key = key
+        while key in labware:
+            idx += 1
+            key = f"{original_key}_{idx}"
+
+        labware[key] = {
+            "slot": item.get("positions") or item.get("slot"),
+            "labware": item.get("material_name") or item.get("labware"),
+            "well": item.get("well", []),
+            "type": item.get("type", "reagent"),
+            "role": item.get("role", ""),
+            "name": key,
+        }
+    return labware
+
+
+@pytest.mark.parametrize("protocol_name", [
+    "example_bio",
+    # "bioyond_materials_liquidhandling_1",
+    "example_prcxi",
+])
+def test_build_protocol_graph(protocol_name):
+    data_path = Path(__file__).with_name(f"{protocol_name}.json")
+    with data_path.open("r", encoding="utf-8") as fp:
+        d = json.load(fp)
+
+    if "workflow" in d and "reagent" in d:
+        protocol_steps = d["workflow"]
+        labware_info = d["reagent"]
+    elif "steps_info" in d and "labware_info" in d:
+        protocol_steps = _normalize_steps(d["steps_info"])
+        labware_info = _normalize_labware(d["labware_info"])
+    else:
+        raise ValueError("Unsupported protocol format")
+
+    graph = build_protocol_graph(
+        labware_info=labware_info,
+        protocol_steps=protocol_steps,
+        workstation_name="PRCXi",
+    )
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M")
+    output_path = data_path.with_name(f"{protocol_name}_graph_{timestamp}.png")
+    draw_protocol_graph_with_ports(graph, str(output_path))
+    print(graph)

unilabos/utils/log.py

@@ -191,18 +191,6 @@ 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)
 
     # 如果指定了工作目录，添加文件处理器
     if working_dir is not None:

unilabos/workflow/common.py

@@ -1,547 +0,0 @@
-import re
-import uuid
-
-import networkx as nx
-from networkx.drawing.nx_agraph import to_agraph
-import matplotlib.pyplot as plt
-from typing import Dict, List, Any, Tuple, Optional
-
-Json = Dict[str, Any]
-
-# ---------------- Graph ----------------
-
-
-class WorkflowGraph:
-    """简单的有向图实现：使用 params 单层参数；inputs 内含连线；支持 node-link 导出"""
-
-    def __init__(self):
-        self.nodes: Dict[str, Dict[str, Any]] = {}
-        self.edges: List[Dict[str, Any]] = []
-
-    def add_node(self, node_id: str, **attrs):
-        self.nodes[node_id] = attrs
-
-    def add_edge(self, source: str, target: str, **attrs):
-        # 将 source_port/target_port 映射为服务端期望的 source_handle_key/target_handle_key
-        source_handle_key = attrs.pop("source_port", "") or attrs.pop("source_handle_key", "")
-        target_handle_key = attrs.pop("target_port", "") or attrs.pop("target_handle_key", "")
-
-        edge = {
-            "source": source,
-            "target": target,
-            "source_node_uuid": source,
-            "target_node_uuid": target,
-            "source_handle_key": source_handle_key,
-            "source_handle_io": attrs.pop("source_handle_io", "source"),
-            "target_handle_key": target_handle_key,
-            "target_handle_io": attrs.pop("target_handle_io", "target"),
-            **attrs,
-        }
-        self.edges.append(edge)
-
-    def _materialize_wiring_into_inputs(
-        self,
-        obj: Any,
-        inputs: Dict[str, Any],
-        variable_sources: Dict[str, Dict[str, Any]],
-        target_node_id: str,
-        base_path: List[str],
-    ):
-        has_var = False
-
-        def walk(node: Any, path: List[str]):
-            nonlocal has_var
-            if isinstance(node, dict):
-                if "__var__" in node:
-                    has_var = True
-                    varname = node["__var__"]
-                    placeholder = f"${{{varname}}}"
-                    src = variable_sources.get(varname)
-                    if src:
-                        key = ".".join(path)  # e.g. "params.foo.bar.0"
-                        inputs[key] = {"node": src["node_id"], "output": src.get("output_name", "result")}
-                        self.add_edge(
-                            str(src["node_id"]),
-                            target_node_id,
-                            source_handle_io=src.get("output_name", "result"),
-                            target_handle_io=key,
-                        )
-                    return placeholder
-                return {k: walk(v, path + [k]) for k, v in node.items()}
-            if isinstance(node, list):
-                return [walk(v, path + [str(i)]) for i, v in enumerate(node)]
-            return node
-
-        replaced = walk(obj, base_path[:])
-        return replaced, has_var
-
-    def add_workflow_node(
-        self,
-        node_id: int,
-        *,
-        device_key: Optional[str] = None,  # 实例名，如 "ser"
-        resource_name: Optional[str] = None,  # registry key（原 device_class）
-        module: Optional[str] = None,
-        template_name: Optional[str] = None,  # 动作/模板名（原 action_key）
-        params: Dict[str, Any],
-        variable_sources: Dict[str, Dict[str, Any]],
-        add_ready_if_no_vars: bool = True,
-        prev_node_id: Optional[int] = None,
-        **extra_attrs,
-    ) -> None:
-        """添加工作流节点：params 单层；自动变量连线与 ready 串联；支持附加属性"""
-        node_id_str = str(node_id)
-        inputs: Dict[str, Any] = {}
-
-        params, has_var = self._materialize_wiring_into_inputs(
-            params, inputs, variable_sources, node_id_str, base_path=["params"]
-        )
-
-        if add_ready_if_no_vars and not has_var:
-            last_id = str(prev_node_id) if prev_node_id is not None else "-1"
-            inputs["ready"] = {"node": int(last_id), "output": "ready"}
-            self.add_edge(last_id, node_id_str, source_handle_io="ready", target_handle_io="ready")
-
-        node_obj = {
-            "device_key": device_key,
-            "resource_name": resource_name,  # ✅ 新名字
-            "module": module,
-            "template_name": template_name,  # ✅ 新名字
-            "params": params,
-            "inputs": inputs,
-        }
-        node_obj.update(extra_attrs or {})
-        self.add_node(node_id_str, parameters=node_obj)
-
-    # 顺序工作流导出（连线在 inputs，不返回 edges）
-    def to_dict(self) -> List[Dict[str, Any]]:
-        result = []
-        for node_id, attrs in self.nodes.items():
-            node = {"uuid": node_id}
-            params = dict(attrs.get("parameters", {}) or {})
-            flat = {k: v for k, v in attrs.items() if k != "parameters"}
-            flat.update(params)
-            node.update(flat)
-            result.append(node)
-        return sorted(result, key=lambda n: int(n["uuid"]) if str(n["uuid"]).isdigit() else n["uuid"])
-
-    # node-link 导出（含 edges）
-    def to_node_link_dict(self) -> Dict[str, Any]:
-        nodes_list = []
-        for node_id, attrs in self.nodes.items():
-            node_attrs = attrs.copy()
-            params = node_attrs.pop("parameters", {}) or {}
-            node_attrs.update(params)
-            nodes_list.append({"uuid": node_id, **node_attrs})
-        return {
-            "directed": True,
-            "multigraph": False,
-            "graph": {},
-            "nodes": nodes_list,
-            "edges": self.edges,
-            "links": self.edges,
-        }
-
-
-def refactor_data(
-    data: List[Dict[str, Any]],
-    action_resource_mapping: Optional[Dict[str, str]] = None,
-) -> List[Dict[str, Any]]:
-    """统一的数据重构函数，根据操作类型自动选择模板
-
-    Args:
-        data: 原始步骤数据列表
-        action_resource_mapping: action 到 resource_name 的映射字典，可选
-    """
-    refactored_data = []
-
-    # 定义操作映射，包含生物实验和有机化学的所有操作
-    OPERATION_MAPPING = {
-        # 生物实验操作
-        "transfer_liquid": "transfer_liquid",
-        "transfer": "transfer",
-        "incubation": "incubation",
-        "move_labware": "move_labware",
-        "oscillation": "oscillation",
-        # 有机化学操作
-        "HeatChillToTemp": "HeatChillProtocol",
-        "StopHeatChill": "HeatChillStopProtocol",
-        "StartHeatChill": "HeatChillStartProtocol",
-        "HeatChill": "HeatChillProtocol",
-        "Dissolve": "DissolveProtocol",
-        "Transfer": "TransferProtocol",
-        "Evaporate": "EvaporateProtocol",
-        "Recrystallize": "RecrystallizeProtocol",
-        "Filter": "FilterProtocol",
-        "Dry": "DryProtocol",
-        "Add": "AddProtocol",
-    }
-
-    UNSUPPORTED_OPERATIONS = ["Purge", "Wait", "Stir", "ResetHandling"]
-
-    for step in data:
-        operation = step.get("action")
-        if not operation or operation in UNSUPPORTED_OPERATIONS:
-            continue
-
-        # 处理重复操作
-        if operation == "Repeat":
-            times = step.get("times", step.get("parameters", {}).get("times", 1))
-            sub_steps = step.get("steps", step.get("parameters", {}).get("steps", []))
-            for i in range(int(times)):
-                sub_data = refactor_data(sub_steps, action_resource_mapping)
-                refactored_data.extend(sub_data)
-            continue
-
-        # 获取模板名称
-        template_name = OPERATION_MAPPING.get(operation)
-        if not template_name:
-            # 自动推断模板类型
-            if operation.lower() in ["transfer", "incubation", "move_labware", "oscillation"]:
-                template_name = f"biomek-{operation}"
-            else:
-                template_name = f"{operation}Protocol"
-
-        # 获取 resource_name
-        resource_name = f"device.{operation.lower()}"
-        if action_resource_mapping:
-            resource_name = action_resource_mapping.get(operation, resource_name)
-
-        # 获取步骤编号，生成 name 字段
-        step_number = step.get("step_number")
-        name = f"Step {step_number}" if step_number is not None else None
-
-        # 创建步骤数据
-        step_data = {
-            "template_name": template_name,
-            "resource_name": resource_name,
-            "description": step.get("description", step.get("purpose", f"{operation} operation")),
-            "lab_node_type": "Device",
-            "param": step.get("parameters", step.get("action_args", {})),
-            "footer": f"{template_name}-{resource_name}",
-        }
-        if name:
-            step_data["name"] = name
-        refactored_data.append(step_data)
-
-    return refactored_data
-
-
-def build_protocol_graph(
-    labware_info: List[Dict[str, Any]],
-    protocol_steps: List[Dict[str, Any]],
-    workstation_name: str,
-    action_resource_mapping: Optional[Dict[str, str]] = None,
-) -> WorkflowGraph:
-    """统一的协议图构建函数，根据设备类型自动选择构建逻辑
-
-    Args:
-        labware_info: labware 信息字典
-        protocol_steps: 协议步骤列表
-        workstation_name: 工作站名称
-        action_resource_mapping: action 到 resource_name 的映射字典，可选
-    """
-    G = WorkflowGraph()
-    resource_last_writer = {}
-
-    protocol_steps = refactor_data(protocol_steps, action_resource_mapping)
-    # 有机化学&移液站协议图构建
-    WORKSTATION_ID = workstation_name
-
-    # 为所有labware创建资源节点
-    res_index = 0
-    for labware_id, item in labware_info.items():
-        # item_id = item.get("id") or item.get("name", f"item_{uuid.uuid4()}")
-        node_id = str(uuid.uuid4())
-
-        # 判断节点类型
-        if "Rack" in str(labware_id) or "Tip" in str(labware_id):
-            lab_node_type = "Labware"
-            description = f"Prepare Labware: {labware_id}"
-            liquid_type = []
-            liquid_volume = []
-        elif item.get("type") == "hardware" or "reactor" in str(labware_id).lower():
-            if "reactor" not in str(labware_id).lower():
-                continue
-            lab_node_type = "Sample"
-            description = f"Prepare Reactor: {labware_id}"
-            liquid_type = []
-            liquid_volume = []
-        else:
-            lab_node_type = "Reagent"
-            description = f"Add Reagent to Flask: {labware_id}"
-            liquid_type = [labware_id]
-            liquid_volume = [1e5]
-
-        res_index += 1
-        G.add_node(
-            node_id,
-            template_name="create_resource",
-            resource_name="host_node",
-            name=f"Res {res_index}",
-            description=description,
-            lab_node_type=lab_node_type,
-            footer="create_resource-host_node",
-            param={
-                "res_id": labware_id,
-                "device_id": WORKSTATION_ID,
-                "class_name": "container",
-                "parent": WORKSTATION_ID,
-                "bind_locations": {"x": 0.0, "y": 0.0, "z": 0.0},
-                "liquid_input_slot": [-1],
-                "liquid_type": liquid_type,
-                "liquid_volume": liquid_volume,
-                "slot_on_deck": "",
-            },
-        )
-        resource_last_writer[labware_id] = f"{node_id}:labware"
-
-    last_control_node_id = None
-
-    # 处理协议步骤
-    for step in protocol_steps:
-        node_id = str(uuid.uuid4())
-        G.add_node(node_id, **step)
-
-        # 控制流
-        if last_control_node_id is not None:
-            G.add_edge(last_control_node_id, node_id, source_port="ready", target_port="ready")
-        last_control_node_id = node_id
-
-        # 物料流
-        params = step.get("param", {})
-        input_resources_possible_names = [
-            "vessel",
-            "to_vessel",
-            "from_vessel",
-            "reagent",
-            "solvent",
-            "compound",
-            "sources",
-            "targets",
-        ]
-
-        for target_port in input_resources_possible_names:
-            resource_name = params.get(target_port)
-            if resource_name and resource_name in resource_last_writer:
-                source_node, source_port = resource_last_writer[resource_name].split(":")
-                G.add_edge(source_node, node_id, source_port=source_port, target_port=target_port)
-
-        output_resources = {
-            "vessel_out": params.get("vessel"),
-            "from_vessel_out": params.get("from_vessel"),
-            "to_vessel_out": params.get("to_vessel"),
-            "filtrate_out": params.get("filtrate_vessel"),
-            "reagent": params.get("reagent"),
-            "solvent": params.get("solvent"),
-            "compound": params.get("compound"),
-            "sources_out": params.get("sources"),
-            "targets_out": params.get("targets"),
-        }
-
-        for source_port, resource_name in output_resources.items():
-            if resource_name:
-                resource_last_writer[resource_name] = f"{node_id}:{source_port}"
-
-    return G
-
-
-def draw_protocol_graph(protocol_graph: WorkflowGraph, output_path: str):
-    """
-    (辅助功能) 使用 networkx 和 matplotlib 绘制协议工作流图，用于可视化。
-    """
-    if not protocol_graph:
-        print("Cannot draw graph: Graph object is empty.")
-        return
-
-    G = nx.DiGraph()
-
-    for node_id, attrs in protocol_graph.nodes.items():
-        label = attrs.get("description", attrs.get("template_name", node_id[:8]))
-        G.add_node(node_id, label=label, **attrs)
-
-    for edge in protocol_graph.edges:
-        G.add_edge(edge["source"], edge["target"])
-
-    plt.figure(figsize=(20, 15))
-    try:
-        pos = nx.nx_agraph.graphviz_layout(G, prog="dot")
-    except Exception:
-        pos = nx.shell_layout(G)  # Fallback layout
-
-    node_labels = {node: data["label"] for node, data in G.nodes(data=True)}
-    nx.draw(
-        G,
-        pos,
-        with_labels=False,
-        node_size=2500,
-        node_color="skyblue",
-        node_shape="o",
-        edge_color="gray",
-        width=1.5,
-        arrowsize=15,
-    )
-    nx.draw_networkx_labels(G, pos, labels=node_labels, font_size=8, font_weight="bold")
-
-    plt.title("Chemical Protocol Workflow Graph", size=15)
-    plt.savefig(output_path, dpi=300, bbox_inches="tight")
-    plt.close()
-    print(f"  - Visualization saved to '{output_path}'")
-
-
-COMPASS = {"n", "e", "s", "w", "ne", "nw", "se", "sw", "c"}
-
-
-def _is_compass(port: str) -> bool:
-    return isinstance(port, str) and port.lower() in COMPASS
-
-
-def draw_protocol_graph_with_ports(protocol_graph, output_path: str, rankdir: str = "LR"):
-    """
-    使用 Graphviz 端口语法绘制协议工作流图。
-    - 若边上的 source_port/target_port 是 compass（n/e/s/w/...），直接用 compass。
-    - 否则自动为节点创建 record 形状并定义命名端口 <portname>。
-    最终由 PyGraphviz 渲染并输出到 output_path（后缀决定格式，如 .png/.svg/.pdf）。
-    """
-    if not protocol_graph:
-        print("Cannot draw graph: Graph object is empty.")
-        return
-
-    # 1) 先用 networkx 搭建有向图，保留端口属性
-    G = nx.DiGraph()
-    for node_id, attrs in protocol_graph.nodes.items():
-        label = attrs.get("description", attrs.get("template_name", node_id[:8]))
-        # 保留一个干净的“中心标签”，用于放在 record 的中间槽
-        G.add_node(node_id, _core_label=str(label), **{k: v for k, v in attrs.items() if k not in ("label",)})
-
-    edges_data = []
-    in_ports_by_node = {}  # 收集命名输入端口
-    out_ports_by_node = {}  # 收集命名输出端口
-
-    for edge in protocol_graph.edges:
-        u = edge["source"]
-        v = edge["target"]
-        sp = edge.get("source_handle_key") or edge.get("source_port")
-        tp = edge.get("target_handle_key") or edge.get("target_port")
-
-        # 记录到图里（保留原始端口信息）
-        G.add_edge(u, v, source_handle_key=sp, target_handle_key=tp)
-        edges_data.append((u, v, sp, tp))
-
-        # 如果不是 compass，就按“命名端口”先归类，等会儿给节点造 record
-        if sp and not _is_compass(sp):
-            out_ports_by_node.setdefault(u, set()).add(str(sp))
-        if tp and not _is_compass(tp):
-            in_ports_by_node.setdefault(v, set()).add(str(tp))
-
-    # 2) 转为 AGraph，使用 Graphviz 渲染
-    A = to_agraph(G)
-    A.graph_attr.update(rankdir=rankdir, splines="true", concentrate="false", fontsize="10")
-    A.node_attr.update(
-        shape="box", style="rounded,filled", fillcolor="lightyellow", color="#999999", fontname="Helvetica"
-    )
-    A.edge_attr.update(arrowsize="0.8", color="#666666")
-
-    # 3) 为需要命名端口的节点设置 record 形状与 label
-    #    左列 = 输入端口；中间 = 核心标签；右列 = 输出端口
-    for n in A.nodes():
-        node = A.get_node(n)
-        core = G.nodes[n].get("_core_label", n)
-
-        in_ports = sorted(in_ports_by_node.get(n, []))
-        out_ports = sorted(out_ports_by_node.get(n, []))
-
-        # 如果该节点涉及命名端口，则用 record；否则保留原 box
-        if in_ports or out_ports:
-
-            def port_fields(ports):
-                if not ports:
-                    return " "  # 必须留一个空槽占位
-                # 每个端口一个小格子，<p> name
-                return "|".join(f"<{re.sub(r'[^A-Za-z0-9_:.|-]', '_', p)}> {p}" for p in ports)
-
-            left = port_fields(in_ports)
-            right = port_fields(out_ports)
-
-            # 三栏：左(入) | 中(节点名) | 右(出)
-            record_label = f"{{ {left} | {core} | {right} }}"
-            node.attr.update(shape="record", label=record_label)
-        else:
-            # 没有命名端口：普通盒子，显示核心标签
-            node.attr.update(label=str(core))
-
-    # 4) 给边设置 headport / tailport
-    #    - 若端口为 compass：直接用 compass（e.g., headport="e"）
-    #    - 若端口为命名端口：使用在 record 中定义的 <port> 名（同名即可）
-    for u, v, sp, tp in edges_data:
-        e = A.get_edge(u, v)
-
-        # Graphviz 属性：tail 是源，head 是目标
-        if sp:
-            if _is_compass(sp):
-                e.attr["tailport"] = sp.lower()
-            else:
-                # 与 record label 中 <port> 名一致；特殊字符已在 label 中做了清洗
-                e.attr["tailport"] = re.sub(r"[^A-Za-z0-9_:.|-]", "_", str(sp))
-
-        if tp:
-            if _is_compass(tp):
-                e.attr["headport"] = tp.lower()
-            else:
-                e.attr["headport"] = re.sub(r"[^A-Za-z0-9_:.|-]", "_", str(tp))
-
-        # 可选：若想让边更贴边缘，可设置 constraint/spline 等
-        # e.attr["arrowhead"] = "vee"
-
-    # 5) 输出
-    A.draw(output_path, prog="dot")
-    print(f"  - Port-aware workflow rendered to '{output_path}'")
-
-
-# ---------------- Registry Adapter ----------------
-
-
-class RegistryAdapter:
-    """根据 module 的类名（冒号右侧）反查 registry 的 resource_name（原 device_class），并抽取参数顺序"""
-
-    def __init__(self, device_registry: Dict[str, Any]):
-        self.device_registry = device_registry or {}
-        self.module_class_to_resource = self._build_module_class_index()
-
-    def _build_module_class_index(self) -> Dict[str, str]:
-        idx = {}
-        for resource_name, info in self.device_registry.items():
-            module = info.get("module")
-            if isinstance(module, str) and ":" in module:
-                cls = module.split(":")[-1]
-                idx[cls] = resource_name
-                idx[cls.lower()] = resource_name
-        return idx
-
-    def resolve_resource_by_classname(self, class_name: str) -> Optional[str]:
-        if not class_name:
-            return None
-        return self.module_class_to_resource.get(class_name) or self.module_class_to_resource.get(class_name.lower())
-
-    def get_device_module(self, resource_name: Optional[str]) -> Optional[str]:
-        if not resource_name:
-            return None
-        return self.device_registry.get(resource_name, {}).get("module")
-
-    def get_actions(self, resource_name: Optional[str]) -> Dict[str, Any]:
-        if not resource_name:
-            return {}
-        return (self.device_registry.get(resource_name, {}).get("class", {}).get("action_value_mappings", {})) or {}
-
-    def get_action_schema(self, resource_name: Optional[str], template_name: str) -> Optional[Json]:
-        return (self.get_actions(resource_name).get(template_name) or {}).get("schema")
-
-    def get_action_goal_default(self, resource_name: Optional[str], template_name: str) -> Json:
-        return (self.get_actions(resource_name).get(template_name) or {}).get("goal_default", {}) or {}
-
-    def get_action_input_keys(self, resource_name: Optional[str], template_name: str) -> List[str]:
-        schema = self.get_action_schema(resource_name, template_name) or {}
-        goal = (schema.get("properties") or {}).get("goal") or {}
-        props = goal.get("properties") or {}
-        required = goal.get("required") or []
-        return list(dict.fromkeys(required + list(props.keys())))

unilabos/workflow/convert_from_json.py

@@ -1,356 +0,0 @@
-"""
-JSON 工作流转换模块
-
-提供从多种 JSON 格式转换为统一工作流格式的功能。
-支持的格式：
-1. workflow/reagent 格式
-2. steps_info/labware_info 格式
-"""
-
-import json
-from os import PathLike
-from pathlib import Path
-from typing import Any, Dict, List, Optional, Set, Tuple, Union
-
-from unilabos.workflow.common import WorkflowGraph, build_protocol_graph
-from unilabos.registry.registry import lab_registry
-
-
-def get_action_handles(resource_name: str, template_name: str) -> Dict[str, List[str]]:
-    """
-    从 registry 获取指定设备和动作的 handles 配置
-
-    Args:
-        resource_name: 设备资源名称，如 "liquid_handler.prcxi"
-        template_name: 动作模板名称，如 "transfer_liquid"
-
-    Returns:
-        包含 source 和 target handler_keys 的字典:
-        {"source": ["sources_out", "targets_out", ...], "target": ["sources", "targets", ...]}
-    """
-    result = {"source": [], "target": []}
-
-    device_info = lab_registry.device_type_registry.get(resource_name, {})
-    if not device_info:
-        return result
-
-    action_mappings = device_info.get("class", {}).get("action_value_mappings", {})
-    action_config = action_mappings.get(template_name, {})
-    handles = action_config.get("handles", {})
-
-    if isinstance(handles, dict):
-        # 处理 input handles (作为 target)
-        for handle in handles.get("input", []):
-            handler_key = handle.get("handler_key", "")
-            if handler_key:
-                result["source"].append(handler_key)
-        # 处理 output handles (作为 source)
-        for handle in handles.get("output", []):
-            handler_key = handle.get("handler_key", "")
-            if handler_key:
-                result["target"].append(handler_key)
-
-    return result
-
-
-def validate_workflow_handles(graph: WorkflowGraph) -> Tuple[bool, List[str]]:
-    """
-    校验工作流图中所有边的句柄配置是否正确
-
-    Args:
-        graph: 工作流图对象
-
-    Returns:
-        (is_valid, errors): 是否有效，错误信息列表
-    """
-    errors = []
-    nodes = graph.nodes
-
-    for edge in graph.edges:
-        left_uuid = edge.get("source")
-        right_uuid = edge.get("target")
-        # target_handle_key是target, right的输入节点（入节点）
-        # source_handle_key是source, left的输出节点（出节点）
-        right_source_conn_key = edge.get("target_handle_key", "")
-        left_target_conn_key = edge.get("source_handle_key", "")
-
-        # 获取源节点和目标节点信息
-        left_node = nodes.get(left_uuid, {})
-        right_node = nodes.get(right_uuid, {})
-
-        left_res_name = left_node.get("resource_name", "")
-        left_template_name = left_node.get("template_name", "")
-        right_res_name = right_node.get("resource_name", "")
-        right_template_name = right_node.get("template_name", "")
-
-        # 获取源节点的 output handles
-        left_node_handles = get_action_handles(left_res_name, left_template_name)
-        target_valid_keys = left_node_handles.get("target", [])
-        target_valid_keys.append("ready")
-
-        # 获取目标节点的 input handles
-        right_node_handles = get_action_handles(right_res_name, right_template_name)
-        source_valid_keys = right_node_handles.get("source", [])
-        source_valid_keys.append("ready")
-
-        # 如果节点配置了 output handles，则 source_port 必须有效
-        if not right_source_conn_key:
-            node_name = left_node.get("name", left_uuid[:8])
-            errors.append(f"源节点 '{node_name}' 的 source_handle_key 为空，" f"应设置为: {source_valid_keys}")
-        elif right_source_conn_key not in source_valid_keys:
-            node_name = left_node.get("name", left_uuid[:8])
-            errors.append(
-                f"源节点 '{node_name}' 的 source 端点 '{right_source_conn_key}' 不存在，" f"支持的端点: {source_valid_keys}"
-            )
-
-        # 如果节点配置了 input handles，则 target_port 必须有效
-        if not left_target_conn_key:
-            node_name = right_node.get("name", right_uuid[:8])
-            errors.append(f"目标节点 '{node_name}' 的 target_handle_key 为空，" f"应设置为: {target_valid_keys}")
-        elif left_target_conn_key not in target_valid_keys:
-            node_name = right_node.get("name", right_uuid[:8])
-            errors.append(
-                f"目标节点 '{node_name}' 的 target 端点 '{left_target_conn_key}' 不存在，"
-                f"支持的端点: {target_valid_keys}"
-            )
-
-    return len(errors) == 0, errors
-
-
-# action 到 resource_name 的映射
-ACTION_RESOURCE_MAPPING: Dict[str, str] = {
-    # 生物实验操作
-    "transfer_liquid": "liquid_handler.prcxi",
-    "transfer": "liquid_handler.prcxi",
-    "incubation": "incubator.prcxi",
-    "move_labware": "labware_mover.prcxi",
-    "oscillation": "shaker.prcxi",
-    # 有机化学操作
-    "HeatChillToTemp": "heatchill.chemputer",
-    "StopHeatChill": "heatchill.chemputer",
-    "StartHeatChill": "heatchill.chemputer",
-    "HeatChill": "heatchill.chemputer",
-    "Dissolve": "stirrer.chemputer",
-    "Transfer": "liquid_handler.chemputer",
-    "Evaporate": "rotavap.chemputer",
-    "Recrystallize": "reactor.chemputer",
-    "Filter": "filter.chemputer",
-    "Dry": "dryer.chemputer",
-    "Add": "liquid_handler.chemputer",
-}
-
-
-def normalize_steps(data: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
-    """
-    将不同格式的步骤数据规范化为统一格式
-
-    支持的输入格式：
-    - action + parameters
-    - action + action_args
-    - operation + parameters
-
-    Args:
-        data: 原始步骤数据列表
-
-    Returns:
-        规范化后的步骤列表，格式为 [{"action": str, "parameters": dict, "description": str?, "step_number": int?}, ...]
-    """
-    normalized = []
-    for idx, step in enumerate(data):
-        # 获取动作名称（支持 action 或 operation 字段）
-        action = step.get("action") or step.get("operation")
-        if not action:
-            continue
-
-        # 获取参数（支持 parameters 或 action_args 字段）
-        raw_params = step.get("parameters") or step.get("action_args") or {}
-        params = dict(raw_params)
-
-        # 规范化 source/target -> sources/targets
-        if "source" in raw_params and "sources" not in raw_params:
-            params["sources"] = raw_params["source"]
-        if "target" in raw_params and "targets" not in raw_params:
-            params["targets"] = raw_params["target"]
-
-        # 获取描述（支持 description 或 purpose 字段）
-        description = step.get("description") or step.get("purpose")
-
-        # 获取步骤编号（优先使用原始数据中的 step_number，否则使用索引+1）
-        step_number = step.get("step_number", idx + 1)
-
-        step_dict = {"action": action, "parameters": params, "step_number": step_number}
-        if description:
-            step_dict["description"] = description
-
-        normalized.append(step_dict)
-
-    return normalized
-
-
-def normalize_labware(data: List[Dict[str, Any]]) -> Dict[str, Dict[str, Any]]:
-    """
-    将不同格式的 labware 数据规范化为统一的字典格式
-
-    支持的输入格式：
-    - reagent_name + material_name + positions
-    - name + labware + slot
-
-    Args:
-        data: 原始 labware 数据列表
-
-    Returns:
-        规范化后的 labware 字典，格式为 {name: {"slot": int, "labware": str, "well": list, "type": str, "role": str, "name": str}, ...}
-    """
-    labware = {}
-    for item in data:
-        # 获取 key 名称（优先使用 reagent_name，其次是 material_name 或 name）
-        reagent_name = item.get("reagent_name")
-        key = reagent_name or item.get("material_name") or item.get("name")
-        if not key:
-            continue
-
-        key = str(key)
-
-        # 处理重复 key，自动添加后缀
-        idx = 1
-        original_key = key
-        while key in labware:
-            idx += 1
-            key = f"{original_key}_{idx}"
-
-        labware[key] = {
-            "slot": item.get("positions") or item.get("slot"),
-            "labware": item.get("material_name") or item.get("labware"),
-            "well": item.get("well", []),
-            "type": item.get("type", "reagent"),
-            "role": item.get("role", ""),
-            "name": key,
-        }
-
-    return labware
-
-
-def convert_from_json(
-    data: Union[str, PathLike, Dict[str, Any]],
-    workstation_name: str = "PRCXi",
-    validate: bool = True,
-) -> WorkflowGraph:
-    """
-    从 JSON 数据或文件转换为 WorkflowGraph
-
-    支持的 JSON 格式：
-    1. {"workflow": [...], "reagent": {...}} - 直接格式
-    2. {"steps_info": [...], "labware_info": [...]} - 需要规范化的格式
-
-    Args:
-        data: JSON 文件路径、字典数据、或 JSON 字符串
-        workstation_name: 工作站名称，默认 "PRCXi"
-        validate: 是否校验句柄配置，默认 True
-
-    Returns:
-        WorkflowGraph: 构建好的工作流图
-
-    Raises:
-        ValueError: 不支持的 JSON 格式 或 句柄校验失败
-        FileNotFoundError: 文件不存在
-        json.JSONDecodeError: JSON 解析失败
-    """
-    # 处理输入数据
-    if isinstance(data, (str, PathLike)):
-        path = Path(data)
-        if path.exists():
-            with path.open("r", encoding="utf-8") as fp:
-                json_data = json.load(fp)
-        elif isinstance(data, str):
-            # 尝试作为 JSON 字符串解析
-            json_data = json.loads(data)
-        else:
-            raise FileNotFoundError(f"文件不存在: {data}")
-    elif isinstance(data, dict):
-        json_data = data
-    else:
-        raise TypeError(f"不支持的数据类型: {type(data)}")
-
-    # 根据格式解析数据
-    if "workflow" in json_data and "reagent" in json_data:
-        # 格式1: workflow/reagent（已经是规范格式）
-        protocol_steps = json_data["workflow"]
-        labware_info = json_data["reagent"]
-    elif "steps_info" in json_data and "labware_info" in json_data:
-        # 格式2: steps_info/labware_info（需要规范化）
-        protocol_steps = normalize_steps(json_data["steps_info"])
-        labware_info = normalize_labware(json_data["labware_info"])
-    elif "steps" in json_data and "labware" in json_data:
-        # 格式3: steps/labware（另一种常见格式）
-        protocol_steps = normalize_steps(json_data["steps"])
-        if isinstance(json_data["labware"], list):
-            labware_info = normalize_labware(json_data["labware"])
-        else:
-            labware_info = json_data["labware"]
-    else:
-        raise ValueError(
-            "不支持的 JSON 格式。支持的格式：\n"
-            "1. {'workflow': [...], 'reagent': {...}}\n"
-            "2. {'steps_info': [...], 'labware_info': [...]}\n"
-            "3. {'steps': [...], 'labware': [...]}"
-        )
-
-    # 构建工作流图
-    graph = build_protocol_graph(
-        labware_info=labware_info,
-        protocol_steps=protocol_steps,
-        workstation_name=workstation_name,
-        action_resource_mapping=ACTION_RESOURCE_MAPPING,
-    )
-
-    # 校验句柄配置
-    if validate:
-        is_valid, errors = validate_workflow_handles(graph)
-        if not is_valid:
-            import warnings
-
-            for error in errors:
-                warnings.warn(f"句柄校验警告: {error}")
-
-    return graph
-
-
-def convert_json_to_node_link(
-    data: Union[str, PathLike, Dict[str, Any]],
-    workstation_name: str = "PRCXi",
-) -> Dict[str, Any]:
-    """
-    将 JSON 数据转换为 node-link 格式的字典
-
-    Args:
-        data: JSON 文件路径、字典数据、或 JSON 字符串
-        workstation_name: 工作站名称，默认 "PRCXi"
-
-    Returns:
-        Dict: node-link 格式的工作流数据
-    """
-    graph = convert_from_json(data, workstation_name)
-    return graph.to_node_link_dict()
-
-
-def convert_json_to_workflow_list(
-    data: Union[str, PathLike, Dict[str, Any]],
-    workstation_name: str = "PRCXi",
-) -> List[Dict[str, Any]]:
-    """
-    将 JSON 数据转换为工作流列表格式
-
-    Args:
-        data: JSON 文件路径、字典数据、或 JSON 字符串
-        workstation_name: 工作站名称，默认 "PRCXi"
-
-    Returns:
-        List: 工作流节点列表
-    """
-    graph = convert_from_json(data, workstation_name)
-    return graph.to_dict()
-
-
-# 为了向后兼容，保留下划线前缀的别名
-_normalize_steps = normalize_steps
-_normalize_labware = normalize_labware

unilabos/workflow/from_python_script.py

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

unilabos/workflow/from_xdl.py

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

unilabos/workflow/wf_utils.py

@@ -1,138 +0,0 @@
-"""
-工作流工具模块
-
-提供工作流上传等功能
-"""
-
-import json
-import os
-import uuid
-from typing import Any, Dict, List, Optional
-
-from unilabos.utils.banner_print import print_status
-
-
-def _is_node_link_format(data: Dict[str, Any]) -> bool:
-    """检查数据是否为 node-link 格式"""
-    return "nodes" in data and "edges" in data
-
-
-def _convert_to_node_link(workflow_file: str, workflow_data: Dict[str, Any]) -> Dict[str, Any]:
-    """
-    将非 node-link 格式的工作流数据转换为 node-link 格式
-
-    Args:
-        workflow_file: 工作流文件路径（用于日志）
-        workflow_data: 原始工作流数据
-
-    Returns:
-        node-link 格式的工作流数据
-    """
-    from unilabos.workflow.convert_from_json import convert_json_to_node_link
-
-    print_status(f"检测到非 node-link 格式，正在转换...", "info")
-    node_link_data = convert_json_to_node_link(workflow_data)
-    print_status(f"转换完成", "success")
-    return node_link_data
-
-
-def upload_workflow(
-    workflow_file: str,
-    workflow_name: Optional[str] = None,
-    tags: Optional[List[str]] = None,
-    published: bool = False,
-) -> Dict[str, Any]:
-    """
-    上传工作流到服务器
-
-    支持的输入格式：
-    1. node-link 格式: {"nodes": [...], "edges": [...]}
-    2. workflow/reagent 格式: {"workflow": [...], "reagent": {...}}
-    3. steps_info/labware_info 格式: {"steps_info": [...], "labware_info": [...]}
-    4. steps/labware 格式: {"steps": [...], "labware": [...]}
-
-    Args:
-        workflow_file: 工作流文件路径（JSON格式）
-        workflow_name: 工作流名称，如果不提供则从文件中读取或使用文件名
-        tags: 工作流标签列表，默认为空列表
-        published: 是否发布工作流，默认为False
-
-    Returns:
-        Dict: API响应数据
-    """
-    # 延迟导入，避免在配置文件加载之前初始化 http_client
-    from unilabos.app.web import http_client
-
-    if not os.path.exists(workflow_file):
-        print_status(f"工作流文件不存在: {workflow_file}", "error")
-        return {"code": -1, "message": f"文件不存在: {workflow_file}"}
-
-    # 读取工作流文件
-    try:
-        with open(workflow_file, "r", encoding="utf-8") as f:
-            workflow_data = json.load(f)
-    except json.JSONDecodeError as e:
-        print_status(f"工作流文件JSON解析失败: {e}", "error")
-        return {"code": -1, "message": f"JSON解析失败: {e}"}
-
-    # 自动检测并转换格式
-    if not _is_node_link_format(workflow_data):
-        try:
-            workflow_data = _convert_to_node_link(workflow_file, workflow_data)
-        except Exception as e:
-            print_status(f"工作流格式转换失败: {e}", "error")
-            return {"code": -1, "message": f"格式转换失败: {e}"}
-
-    # 提取工作流数据
-    nodes = workflow_data.get("nodes", [])
-    edges = workflow_data.get("edges", [])
-    workflow_uuid_val = workflow_data.get("workflow_uuid", str(uuid.uuid4()))
-    wf_name_from_file = workflow_data.get("workflow_name", os.path.basename(workflow_file).replace(".json", ""))
-
-    # 确定工作流名称
-    final_name = workflow_name or wf_name_from_file
-
-    print_status(f"正在上传工作流: {final_name}", "info")
-    print_status(f"  - 节点数量: {len(nodes)}", "info")
-    print_status(f"  - 边数量: {len(edges)}", "info")
-    print_status(f"  - 标签: {tags or []}", "info")
-    print_status(f"  - 发布状态: {published}", "info")
-
-    # 调用 http_client 上传
-    result = http_client.workflow_import(
-        name=final_name,
-        workflow_uuid=workflow_uuid_val,
-        workflow_name=final_name,
-        nodes=nodes,
-        edges=edges,
-        tags=tags,
-        published=published,
-    )
-
-    if result.get("code") == 0:
-        data = result.get("data", {})
-        print_status("工作流上传成功！", "success")
-        print_status(f"  - UUID: {data.get('uuid', 'N/A')}", "info")
-        print_status(f"  - 名称: {data.get('name', 'N/A')}", "info")
-    else:
-        print_status(f"工作流上传失败: {result.get('message', '未知错误')}", "error")
-
-    return result
-
-
-def handle_workflow_upload_command(args_dict: Dict[str, Any]) -> None:
-    """
-    处理 workflow_upload 子命令
-
-    Args:
-        args_dict: 命令行参数字典
-    """
-    workflow_file = args_dict.get("workflow_file")
-    workflow_name = args_dict.get("workflow_name")
-    tags = args_dict.get("tags", [])
-    published = args_dict.get("published", False)
-
-    if workflow_file:
-        upload_workflow(workflow_file, workflow_name, tags, published)
-    else:
-        print_status("未指定工作流文件路径，请使用 -f/--workflow_file 参数", "error")