""" Bioyond工作站实现 Bioyond Workstation Implementation 集成Bioyond物料管理的工作站示例 """ import traceback from typing import Dict, Any, List, Optional, Union import json from unilabos.devices.workstation.workstation_base import WorkstationBase, ResourceSynchronizer from unilabos.devices.workstation.bioyond_studio.bioyond_rpc import BioyondV1RPC from unilabos.registry.placeholder_type import ResourceSlot, DeviceSlot from unilabos.resources.warehouse import WareHouse from unilabos.utils.log import logger from unilabos.resources.graphio import resource_bioyond_to_plr from unilabos.ros.nodes.base_device_node import ROS2DeviceNode, BaseROS2DeviceNode from unilabos.ros.nodes.presets.workstation import ROS2WorkstationNode from pylabrobot.resources.resource import Resource as ResourcePLR from unilabos.devices.workstation.bioyond_studio.config import ( API_CONFIG, WORKFLOW_MAPPINGS, MATERIAL_TYPE_MAPPINGS, STATION_TYPES, DEFAULT_STATION_CONFIG ) class BioyondResourceSynchronizer(ResourceSynchronizer): """Bioyond资源同步器 负责与Bioyond系统进行物料数据的同步 """ def __init__(self, workstation: 'BioyondWorkstation'): super().__init__(workstation) self.bioyond_api_client = None self.sync_interval = 60 # 默认60秒同步一次 self.last_sync_time = 0 self.initialize() def initialize(self) -> bool: """初始化Bioyond资源同步器""" try: self.bioyond_api_client = self.workstation.hardware_interface if self.bioyond_api_client is None: logger.error("Bioyond API客户端未初始化") return False # 设置同步间隔 self.sync_interval = self.workstation.bioyond_config.get("sync_interval", 600) logger.info("Bioyond资源同步器初始化完成") return True except Exception as e: logger.error(f"Bioyond资源同步器初始化失败: {e}") return False def sync_from_external(self) -> bool: """从Bioyond系统同步物料数据""" try: if self.bioyond_api_client is None: logger.error("Bioyond API客户端未初始化") return False bioyond_data = self.bioyond_api_client.stock_material('{"typeMode": 2, "includeDetail": true}') if not bioyond_data: logger.warning("从Bioyond获取的物料数据为空") return False # 转换为UniLab格式 unilab_resources = resource_bioyond_to_plr(bioyond_data, type_mapping=self.workstation.bioyond_config["material_type_mappings"], deck=self.workstation.deck) logger.info(f"从Bioyond同步了 {len(unilab_resources)} 个资源") return True except Exception as e: logger.error(f"从Bioyond同步物料数据失败: {e}") traceback.print_exc() return False def sync_to_external(self, resource: Any) -> bool: """将本地物料数据变更同步到Bioyond系统""" try: if self.bioyond_api_client is None: logger.error("Bioyond API客户端未初始化") return False # 调用入库、出库操作 # bioyond_format_data = self._convert_resource_to_bioyond_format(resource) # success = await self.bioyond_api_client.update_material(bioyond_format_data) # # if success except: pass def handle_external_change(self, change_info: Dict[str, Any]) -> bool: """处理Bioyond系统的变更通知""" try: # 这里可以实现对Bioyond变更的处理逻辑 logger.info(f"处理Bioyond变更通知: {change_info}") return True except Exception as e: logger.error(f"处理Bioyond变更通知失败: {e}") return False class BioyondWorkstation(WorkstationBase): """Bioyond工作站 集成Bioyond物料管理的工作站实现 """ def __init__( self, bioyond_config: Optional[Dict[str, Any]] = None, deck: Optional[Any] = None, station_config: Optional[Dict[str, Any]] = None, *args, **kwargs, ): # 初始化父类 super().__init__( # 桌子 deck=deck, *args, **kwargs, ) # 检查 deck 是否为 None，防止 AttributeError if self.deck is None: logger.error("❌ Deck 配置为空，请检查配置文件中的 deck 参数") raise ValueError("Deck 配置不能为空，请在配置文件中添加正确的 deck 配置") # 初始化 warehouses 属性 self.deck.warehouses = {} for resource in self.deck.children: if isinstance(resource, WareHouse): self.deck.warehouses[resource.name] = resource # 配置站点类型 self._configure_station_type(station_config) # 创建通信模块 self._create_communication_module(bioyond_config) self.resource_synchronizer = BioyondResourceSynchronizer(self) self.resource_synchronizer.sync_from_external() # TODO: self._ros_node里面拿属性 logger.info(f"Bioyond工作站初始化完成") def post_init(self, ros_node: ROS2WorkstationNode): self._ros_node = ros_node #self.deck = create_a_coin_cell_deck() ROS2DeviceNode.run_async_func(self._ros_node.update_resource, True, **{ "resources": [self.deck] }) def transfer_resource_to_another(self, resource_a: ResourceSlot, device_id: DeviceSlot, resource_b: ResourceSlot): ROS2DeviceNode.run_async_func(self._ros_node.transfer_resource_to_another, True, **{ "plr_resources": [resource_a], "target_device_id": device_id, "target_resource_uuid": getattr(resource_b, "unilabos_uuid", None), }) def _configure_station_type(self, station_config: Optional[Dict[str, Any]] = None) -> None: """配置站点类型和功能模块 Args: station_config (Optional[Dict[str, Any]]): 站点配置，如果为None则使用默认配置 """ # 合并默认配置和用户配置 self.station_config = {**DEFAULT_STATION_CONFIG} if station_config: self.station_config.update(station_config) # 设置站点属性 self.station_type = self.station_config["station_type"] self.enable_reaction_station = self.station_config["enable_reaction_station"] self.enable_dispensing_station = self.station_config["enable_dispensing_station"] self.station_name = self.station_config["station_name"] self.station_description = self.station_config["description"] # 根据站点类型调整功能启用状态 if self.station_type == STATION_TYPES["REACTION"]: self.enable_reaction_station = True self.enable_dispensing_station = False self.station_description = "Bioyond反应站" logger.info("🧪 配置为反应站模式") elif self.station_type == STATION_TYPES["DISPENSING"]: self.enable_reaction_station = False self.enable_dispensing_station = True self.station_description = "Bioyond配液站" logger.info("🧫 配置为配液站模式") elif self.station_type == STATION_TYPES["HYBRID"]: self.enable_reaction_station = True self.enable_dispensing_station = True self.station_description = "Bioyond混合工作站" logger.info("🔬 配置为混合工作站模式") logger.info(f"站点配置: {self.station_name} - {self.station_description}") logger.info(f"反应站功能: {'✅ 启用' if self.enable_reaction_station else '❌ 禁用'}") logger.info(f"配液站功能: {'✅ 启用' if self.enable_dispensing_station else '❌ 禁用'}") def _create_communication_module(self, config: Optional[Dict[str, Any]] = None) -> None: """创建Bioyond通信模块""" self.bioyond_config = config or { **API_CONFIG, "workflow_mappings": WORKFLOW_MAPPINGS, "material_type_mappings": MATERIAL_TYPE_MAPPINGS } # 根据站点配置有条件地初始化接口 self.hardware_interface = None self.dispensing_interface = None if self.enable_reaction_station: # 反应站接口 self.hardware_interface = BioyondV1RPC(self.bioyond_config) logger.info("✅ 反应站接口已初始化") else: logger.info("⏭️ 反应站接口已跳过") if self.enable_dispensing_station: # 配液站接口 - 使用统一的BioyondV1RPC类 self.dispensing_interface = BioyondV1RPC(self.bioyond_config) logger.info("✅ 配液站接口已初始化") else: logger.info("⏭️ 配液站接口已跳过") return None def _check_interface_availability(self, interface_type: str) -> bool: """检查指定接口是否可用 Args: interface_type (str): 接口类型，'reaction' 或 'dispensing' Returns: bool: 接口是否可用 Raises: RuntimeError: 当接口不可用时抛出异常 """ if interface_type == "reaction": if not self.enable_reaction_station or self.hardware_interface is None: raise RuntimeError( f"❌ 反应站接口不可用！当前站点类型: {self.station_type}, " f"反应站功能: {'启用' if self.enable_reaction_station else '禁用'}" ) return True elif interface_type == "dispensing": if not self.enable_dispensing_station or self.dispensing_interface is None: raise RuntimeError( f"❌ 配液站接口不可用！当前站点类型: {self.station_type}, " f"配液站功能: {'启用' if self.enable_dispensing_station else '禁用'}" ) return True else: raise ValueError(f"未知的接口类型: {interface_type}") def get_station_info(self) -> Dict[str, Any]: """获取站点信息 Returns: Dict[str, Any]: 站点配置和状态信息 """ return { "station_name": self.station_name, "station_type": self.station_type, "station_description": self.station_description, "enable_reaction_station": self.enable_reaction_station, "enable_dispensing_station": self.enable_dispensing_station, "reaction_interface_available": self.hardware_interface is not None, "dispensing_interface_available": self.dispensing_interface is not None, "supported_station_types": list(STATION_TYPES.values()) } @property def bioyond_status(self) -> Dict[str, Any]: """获取 Bioyond 系统状态信息 这个属性被 ROS 节点用来发布设备状态 Returns: Dict[str, Any]: Bioyond 系统的状态信息 """ try: # 获取基础站点信息 station_info = self.get_station_info() # 获取接口状态 interface_status = { "reaction_interface_connected": False, "dispensing_interface_connected": False, "last_sync_time": getattr(self.resource_synchronizer, 'last_sync_time', 0), "sync_interval": getattr(self.resource_synchronizer, 'sync_interval', 60) } # 检查反应站接口状态 if self.hardware_interface is not None: try: # 尝试获取调度器状态来验证连接 scheduler_status = self.get_scheduler_status() interface_status["reaction_interface_connected"] = scheduler_status.get("status") == "success" except Exception: interface_status["reaction_interface_connected"] = False # 检查配液站接口状态 if self.dispensing_interface is not None: try: # 配液站接口也使用相同的连接检查方式 interface_status["dispensing_interface_connected"] = True except Exception: interface_status["dispensing_interface_connected"] = False # 获取资源同步状态 sync_status = { "last_sync_success": True, # 默认值，可以根据实际同步结果更新 "total_resources": len(getattr(self.deck, 'children', [])), "warehouse_count": len(getattr(self.deck, 'warehouses', {})) } return { "station_info": station_info, "interface_status": interface_status, "sync_status": sync_status, "timestamp": __import__('time').time(), "status": "online" if (interface_status["reaction_interface_connected"] or interface_status["dispensing_interface_connected"]) else "offline" } except Exception as e: logger.error(f"获取 Bioyond 状态失败: {e}") # 返回基础状态信息，避免完全失败 return { "station_info": { "station_name": getattr(self, 'station_name', 'BioyondWorkstation'), "station_type": getattr(self, 'station_type', 'unknown'), "enable_reaction_station": getattr(self, 'enable_reaction_station', False), "enable_dispensing_station": getattr(self, 'enable_dispensing_station', False) }, "interface_status": { "reaction_interface_connected": False, "dispensing_interface_connected": False, "last_sync_time": 0, "sync_interval": 60 }, "sync_status": { "last_sync_success": False, "total_resources": 0, "warehouse_count": 0 }, "timestamp": __import__('time').time(), "status": "error", "error_message": str(e) } def _register_supported_workflows(self): """注册Bioyond支持的工作流""" from unilabos.devices.workstation.workstation_base import WorkflowInfo # Bioyond物料同步工作流 self.supported_workflows["bioyond_sync"] = WorkflowInfo( name="bioyond_sync", description="从Bioyond系统同步物料", parameters={ "sync_type": {"type": "string", "default": "full", "options": ["full", "incremental"]}, "force_sync": {"type": "boolean", "default": False} } ) # Bioyond物料更新工作流 self.supported_workflows["bioyond_update"] = WorkflowInfo( name="bioyond_update", description="将本地物料变更同步到Bioyond", parameters={ "material_ids": {"type": "list", "default": []}, "sync_all": {"type": "boolean", "default": True} } ) logger.info(f"注册了 {len(self.supported_workflows)} 个Bioyond工作流") async def execute_bioyond_sync_workflow(self, parameters: Dict[str, Any]) -> Dict[str, Any]: """执行Bioyond同步工作流""" try: sync_type = parameters.get("sync_type", "full") force_sync = parameters.get("force_sync", False) logger.info(f"开始执行Bioyond同步工作流: {sync_type}") # 获取物料管理模块 material_manager = self.material_management if sync_type == "full": # 全量同步 success = await material_manager.sync_from_bioyond() else: # 增量同步（这里可以实现增量同步逻辑） success = await material_manager.sync_from_bioyond() if success: result = { "status": "success", "message": f"Bioyond同步完成: {sync_type}", "synced_resources": len(material_manager.plr_resources) } else: result = { "status": "failed", "message": "Bioyond同步失败" } logger.info(f"Bioyond同步工作流执行完成: {result['status']}") return result except Exception as e: logger.error(f"Bioyond同步工作流执行失败: {e}") return { "status": "error", "message": str(e) } # ==================== 工作流合并与参数设置 API ==================== def merge_workflow_with_parameters( self, name: str, workflows: List[Dict[str, Any]], **kwargs ) -> Dict[str, Any]: """合并工作流并设置参数 API 合并子工作流时传入实验参数，新建实验时如果没有传参数，则使用此处传入的参数作为默认值 Args: name (str): 拼接后的长工作流名称 workflows (List[Dict[str, Any]]): 待合并的子工作流列表，每个元素包含： - id (str): 子工作流 ID (UUID) - stepParameters (Dict, 可选): 步骤参数配置 **kwargs: 其他参数 Returns: Dict[str, Any]: 操作结果，包含 code、message 和 timestamp Example: workflows = [ { "id": "3fa85f64-5717-4562-b3fc-2c963f66afa6" }, { "id": "3fa85f64-5717-4562-b3fc-2c963f66afa6", "stepParameters": { "5a30bee1-7de2-45de-a89f-a25c78e4404b": { "反应模块-开始搅拌": [ { "key": "temperature", "value": "25" } ], "通量-配置": [ { "key": "cutoff", "value": "9999" }, { "key": "assignMaterialName", "value": "3a1bf167-e862-f269-3749-a1c70cbbe6a6" } ] } } } ] result = workstation.merge_workflow_with_parameters( name="拼接后的长工作流的名称", workflows=workflows ) """ try: # 检查反应站接口是否可用 self._check_interface_availability("reaction") logger.info(f"开始合并工作流: {name}, 包含 {len(workflows)} 个子工作流") # 基本参数验证 if not name: raise ValueError("工作流名称不能为空") if not workflows or len(workflows) == 0: raise ValueError("工作流列表不能为空") # 使用 RPC 层进行详细的参数验证 validation_result = self.hardware_interface.validate_workflow_parameters(workflows) if not validation_result.get("valid", False): raise ValueError(f"工作流参数验证失败: {validation_result.get('message', '未知错误')}") # 构造请求数据 request_data = { "name": name, "workflows": workflows } # 转换为 JSON 字符串 json_str = json.dumps(request_data, ensure_ascii=False) logger.info(f"发送工作流合并请求: {json_str}") # 调用底层 API（需要在 bioyond_rpc.py 中实现） result = self.hardware_interface.merge_workflow_with_parameters(json_str) if result.get("code") == 1: success_msg = f"工作流合并成功: {name}" logger.info(success_msg) return { "success": True, "code": result.get("code"), "message": result.get("message", ""), "timestamp": result.get("timestamp", 0), "action": "merge_workflow_with_parameters", "workflow_name": name, "workflow_count": len(workflows) } else: error_msg = f"工作流合并失败: {result.get('message', '未知错误')}" logger.error(error_msg) return { "success": False, "code": result.get("code", 0), "message": result.get("message", error_msg), "timestamp": result.get("timestamp", 0), "action": "merge_workflow_with_parameters" } except Exception as e: error_msg = f"工作流合并操作异常: {str(e)}" logger.error(error_msg) traceback.print_exc() return { "success": False, "code": 0, "message": error_msg, "action": "merge_workflow_with_parameters" } def validate_workflow_parameters(self, workflows: List[Dict[str, Any]]) -> Dict[str, Any]: """验证工作流参数格式 Args: workflows (List[Dict[str, Any]]): 工作流列表 Returns: Dict[str, Any]: 验证结果 """ # 委托给 RPC 层进行参数验证 return self.hardware_interface.validate_workflow_parameters(workflows) def get_workflow_parameter_template(self) -> Dict[str, Any]: """获取工作流参数模板 Returns: Dict[str, Any]: 参数模板和说明 """ # 委托给 RPC 层获取参数模板 return self.hardware_interface.get_workflow_parameter_template() # ==================== 反应站动作函数 ==================== # 基于 bioyond_rpc.py 中的反应站方法实现 def reactor_taken_out(self, order_id: str = "", preintake_id: str = "", **kwargs) -> Dict[str, Any]: """反应器取出操作 - 调用底层 order_takeout API 从反应站中取出反应器，通过订单ID和预取样ID进行精确控制 Args: order_id (str): 订单ID，用于标识要取出的订单 preintake_id (str): 预取样ID，用于标识具体的取样任务 Returns: Dict[str, Any]: 操作结果，包含 code 和 return_info """ try: logger.info(f"执行反应器取出操作: 订单ID={order_id}, 预取样ID={preintake_id}") # 构造 JSON 参数 params = { "order_id": order_id, "preintake_id": preintake_id } json_str = json.dumps(params) # 调用底层 order_takeout API result_code = self.hardware_interface.order_takeout(json_str) if result_code == 1: success_msg = f"反应器取出操作成功完成，订单ID: {order_id}" logger.info(success_msg) return { "success": True, "code": result_code, "return_info": success_msg, "action": "reactor_taken_out" } else: error_msg = f"反应器取出操作失败，返回代码: {result_code}" logger.error(error_msg) return { "success": False, "code": result_code, "return_info": error_msg, "action": "reactor_taken_out" } except Exception as e: error_msg = f"反应器取出操作异常: {str(e)}" logger.error(error_msg) return { "success": False, "code": 0, "return_info": error_msg, "action": "reactor_taken_out" } def reactor_taken_in(self, **kwargs) -> Dict[str, Any]: """反应器放入操作 将反应器放入反应站 Returns: Dict[str, Any]: 操作结果 """ try: logger.info("执行反应器放入操作") # 调用 bioyond_rpc.py 中的反应站方法 result = self.hardware_interface.reactor_taken_in() return { "success": True, "message": "反应器放入操作完成", "result": result, "action": "reactor_taken_in" } except Exception as e: logger.error(f"反应器放入操作失败: {e}") return { "success": False, "error": str(e), "action": "reactor_taken_in" } def solid_feeding_vials(self, material_name: str = "", volume: str = "", **kwargs) -> Dict[str, Any]: """固体进料到小瓶 Args: material_name (str): 物料名称 volume (str): 进料体积 **kwargs: 其他参数 Returns: Dict[str, Any]: 操作结果 """ try: logger.info(f"执行固体进料操作: 物料={material_name}, 体积={volume}") # 参数验证 if not material_name: raise ValueError("物料名称不能为空") # 调用 bioyond_rpc.py 中的反应站方法 result = self.hardware_interface.solid_feeding_vials( assign_material_name=material_name, volume=volume, **kwargs ) return { "success": True, "message": f"固体进料操作完成: {material_name}", "result": result, "action": "solid_feeding_vials", "parameters": { "material_name": material_name, "volume": volume } } except Exception as e: logger.error(f"固体进料操作失败: {e}") return { "success": False, "error": str(e), "action": "solid_feeding_vials", "parameters": { "material_name": material_name, "volume": volume } } def liquid_feeding_vials_non_titration(self, material_name: str = "", volume: str = "", **kwargs) -> Dict[str, Any]: """非滴定液体进料到小瓶 Args: material_name (str): 物料名称 volume (str): 进料体积 **kwargs: 其他参数 Returns: Dict[str, Any]: 操作结果 """ try: logger.info(f"执行非滴定液体进料操作: 物料={material_name}, 体积={volume}") # 参数验证 if not material_name: raise ValueError("物料名称不能为空") if not volume: raise ValueError("进料体积不能为空") # 调用 bioyond_rpc.py 中的反应站方法 result = self.hardware_interface.liquid_feeding_vials_non_titration( assign_material_name=material_name, volume=volume, **kwargs ) return { "success": True, "message": f"非滴定液体进料操作完成: {material_name}", "result": result, "action": "liquid_feeding_vials_non_titration", "parameters": { "material_name": material_name, "volume": volume } } except Exception as e: logger.error(f"非滴定液体进料操作失败: {e}") return { "success": False, "error": str(e), "action": "liquid_feeding_vials_non_titration", "parameters": { "material_name": material_name, "volume": volume } } def liquid_feeding_solvents(self, material_name: str = "", volume: str = "", **kwargs) -> Dict[str, Any]: """溶剂进料操作 Args: material_name (str): 溶剂名称 volume (str): 进料体积 **kwargs: 其他参数 Returns: Dict[str, Any]: 操作结果 """ try: logger.info(f"执行溶剂进料操作: 溶剂={material_name}, 体积={volume}") # 参数验证 if not material_name: raise ValueError("溶剂名称不能为空") if not volume: raise ValueError("进料体积不能为空") # 调用 bioyond_rpc.py 中的反应站方法 result = self.hardware_interface.liquid_feeding_solvents( assign_material_name=material_name, volume=volume, **kwargs ) return { "success": True, "message": f"溶剂进料操作完成: {material_name}", "result": result, "action": "liquid_feeding_solvents", "parameters": { "material_name": material_name, "volume": volume } } except Exception as e: logger.error(f"溶剂进料操作失败: {e}") return { "success": False, "error": str(e), "action": "liquid_feeding_solvents", "parameters": { "material_name": material_name, "volume": volume } } def liquid_feeding_titration(self, material_name: str = "", volume: str = "", titration_type: str = "1", time: str = "120", torque_variation: str = "2", **kwargs) -> Dict[str, Any]: """滴定液体进料操作 Args: material_name (str): 物料名称 volume (str): 进料体积 titration_type (str): 滴定类型，默认为"1" time (str): 滴定时间，默认为"120"秒 torque_variation (str): 扭矩变化，默认为"2" **kwargs: 其他参数 Returns: Dict[str, Any]: 操作结果 """ try: logger.info(f"执行滴定液体进料操作: 物料={material_name}, 体积={volume}, 类型={titration_type}") # 参数验证 if not material_name: raise ValueError("物料名称不能为空") if not volume: raise ValueError("进料体积不能为空") # 调用 bioyond_rpc.py 中的反应站方法 result = self.hardware_interface.liquid_feeding_titration( assign_material_name=material_name, volume=volume, titration_type=titration_type, time=time, torque_variation=torque_variation, **kwargs ) return { "success": True, "message": f"滴定液体进料操作完成: {material_name}", "result": result, "action": "liquid_feeding_titration", "parameters": { "material_name": material_name, "volume": volume, "titration_type": titration_type, "time": time, "torque_variation": torque_variation } } except Exception as e: logger.error(f"滴定液体进料操作失败: {e}") return { "success": False, "error": str(e), "action": "liquid_feeding_titration", "parameters": { "material_name": material_name, "volume": volume, "titration_type": titration_type, "time": time, "torque_variation": torque_variation } } def liquid_feeding_beaker(self, material_name: str = "", volume: str = "", **kwargs) -> Dict[str, Any]: """烧杯液体进料操作 Args: material_name (str): 物料名称 volume (str): 进料体积 **kwargs: 其他参数 Returns: Dict[str, Any]: 操作结果 """ try: logger.info(f"执行烧杯液体进料操作: 物料={material_name}, 体积={volume}") # 参数验证 if not material_name: raise ValueError("物料名称不能为空") if not volume: raise ValueError("进料体积不能为空") # 调用 bioyond_rpc.py 中的反应站方法 result = self.hardware_interface.liquid_feeding_beaker( assign_material_name=material_name, volume=volume, **kwargs ) return { "success": True, "message": f"烧杯液体进料操作完成: {material_name}", "result": result, "action": "liquid_feeding_beaker", "parameters": { "material_name": material_name, "volume": volume } } except Exception as e: logger.error(f"烧杯液体进料操作失败: {e}") return { "success": False, "error": str(e), "action": "liquid_feeding_beaker", "parameters": { "material_name": material_name, "volume": volume } } # ==================== 配液站动作函数 ==================== # 基于 dispensing_station_bioyong.py 中的配液站方法实现 def create_order(self, order_data: Union[str, Dict[str, Any]]) -> Dict[str, Any]: """创建配液任务订单 Args: order_data (Union[str, Dict[str, Any]]): 订单数据，可以是JSON字符串或字典 Returns: Dict[str, Any]: 操作结果 """ try: logger.info("创建配液任务订单") # 处理输入数据 if isinstance(order_data, str): order_json = order_data else: order_json = json.dumps(order_data) # 调用配液站接口 result = self.dispensing_interface.create_order(order_json) return { "success": True, "message": "配液任务订单创建完成", "result": result, "action": "create_order" } except Exception as e: logger.error(f"创建配液任务订单失败: {e}") return { "success": False, "error": str(e), "action": "create_order" } def order_query(self, query_data: Union[str, Dict[str, Any]]) -> Dict[str, Any]: """查询配液任务状态 Args: query_data (Union[str, Dict[str, Any]]): 查询数据，可以是JSON字符串或字典 Returns: Dict[str, Any]: 查询结果 """ try: logger.info("查询配液任务状态") # 处理输入数据 if isinstance(query_data, str): query_json = query_data else: query_json = json.dumps(query_data) # 调用配液站接口 result = self.dispensing_interface.order_query(query_json) return { "success": True, "message": "配液任务状态查询完成", "result": result, "action": "order_query" } except Exception as e: logger.error(f"查询配液任务状态失败: {e}") return { "success": False, "error": str(e), "action": "order_query" } def dispensing_material_inbound(self, material_data: Union[str, Dict[str, Any]]) -> Dict[str, Any]: """配液站物料入库 Args: material_data (Union[str, Dict[str, Any]]): 物料数据，可以是JSON字符串或字典 Returns: Dict[str, Any]: 操作结果 """ try: # 检查配液站接口是否可用 self._check_interface_availability("dispensing") logger.info("执行配液站物料入库操作") # 处理输入数据 if isinstance(material_data, str): material_json = material_data else: material_json = json.dumps(material_data) # 调用配液站接口 result = self.dispensing_interface.material_inbound(material_json) return { "success": True, "message": "配液站物料入库完成", "result": result, "action": "dispensing_material_inbound" } except Exception as e: logger.error(f"配液站物料入库失败: {e}") return { "success": False, "error": str(e), "action": "dispensing_material_inbound" } def dispensing_material_outbound(self, material_data: Union[str, Dict[str, Any]]) -> Dict[str, Any]: """配液站物料出库 Args: material_data (Union[str, Dict[str, Any]]): 物料数据，可以是JSON字符串或字典 Returns: Dict[str, Any]: 操作结果 """ try: # 检查配液站接口是否可用 self._check_interface_availability("dispensing") logger.info("执行配液站物料出库操作") # 处理输入数据 if isinstance(material_data, str): material_json = material_data else: material_json = json.dumps(material_data) # 调用配液站接口 result = self.dispensing_interface.material_outbound(material_json) return { "success": True, "message": "配液站物料出库完成", "result": result, "action": "dispensing_material_outbound" } except Exception as e: logger.error(f"配液站物料出库失败: {e}") return { "success": False, "error": str(e), "action": "dispensing_material_outbound" } def delete_material(self, material_data: Union[str, Dict[str, Any]]) -> Dict[str, Any]: """删除物料 Args: material_data (Union[str, Dict[str, Any]]): 物料数据，可以是JSON字符串或字典 Returns: Dict[str, Any]: 操作结果 """ try: logger.info("执行删除物料操作") # 处理输入数据 if isinstance(material_data, str): material_json = material_data else: material_json = json.dumps(material_data) # 调用配液站接口 result = self.dispensing_interface.delete_material(material_json) return { "success": True, "message": "删除物料操作完成", "result": result, "action": "delete_material" } except Exception as e: logger.error(f"删除物料操作失败: {e}") return { "success": False, "error": str(e), "action": "delete_material" } def sample_waste_removal(self, waste_data: Union[str, Dict[str, Any]]) -> Dict[str, Any]: """样品废料移除 Args: waste_data (Union[str, Dict[str, Any]]): 废料数据，可以是JSON字符串或字典 Returns: Dict[str, Any]: 操作结果 """ try: # 检查配液站接口是否可用 self._check_interface_availability("dispensing") logger.info("执行样品废料移除操作") # 处理输入数据 if isinstance(waste_data, str): waste_json = waste_data else: waste_json = json.dumps(waste_data) # 调用配液站接口 result = self.dispensing_interface.sample_waste_removal(waste_json) return { "success": True, "message": "样品废料移除操作完成", "result": result, "action": "sample_waste_removal" } except Exception as e: logger.error(f"样品废料移除操作失败: {e}") return { "success": False, "error": str(e), "action": "sample_waste_removal" } def create_resource(self, resource_data: Union[str, Dict[str, Any]]) -> Dict[str, Any]: """创建资源（样品板等） Args: resource_data (Union[str, Dict[str, Any]]): 资源数据，可以是JSON字符串或字典 Returns: Dict[str, Any]: 操作结果 """ try: # 检查配液站接口是否可用 self._check_interface_availability("dispensing") logger.info("执行创建资源操作") # 处理输入数据 if isinstance(resource_data, str): resource_json = resource_data else: resource_json = json.dumps(resource_data) # 调用配液站接口 result = self.dispensing_interface.create_resource(resource_json) return { "success": True, "message": "创建资源操作完成", "result": result, "action": "create_resource" } except Exception as e: logger.error(f"创建资源操作失败: {e}") return { "success": False, "error": str(e), "action": "create_resource" } def create_90_10_vial_feeding_task(self, task_data: Union[str, Dict[str, Any]]) -> Dict[str, Any]: """创建90/10比例进料任务 Args: task_data (Union[str, Dict[str, Any]]): 任务数据，可以是JSON字符串或字典 Returns: Dict[str, Any]: 操作结果 """ try: # 检查配液站接口是否可用 self._check_interface_availability("dispensing") logger.info("创建90/10比例进料任务") # 处理输入数据 if isinstance(task_data, str): task_params = json.loads(task_data) else: task_params = task_data # 调用配液站接口，传递具体参数而不是JSON字符串 result = self.dispensing_interface.create_90_10_vial_feeding_task( order_name=task_params.get("order_name"), speed=task_params.get("speed"), temperature=task_params.get("temperature"), delay_time=task_params.get("delay_time"), percent_90_1_assign_material_name=task_params.get("percent_90_1_assign_material_name"), percent_90_1_target_weigh=task_params.get("percent_90_1_target_weigh"), percent_90_2_assign_material_name=task_params.get("percent_90_2_assign_material_name"), percent_90_2_target_weigh=task_params.get("percent_90_2_target_weigh"), percent_90_3_assign_material_name=task_params.get("percent_90_3_assign_material_name"), percent_90_3_target_weigh=task_params.get("percent_90_3_target_weigh"), percent_10_1_assign_material_name=task_params.get("percent_10_1_assign_material_name"), percent_10_1_target_weigh=task_params.get("percent_10_1_target_weigh"), percent_10_1_volume=task_params.get("percent_10_1_volume"), percent_10_1_liquid_material_name=task_params.get("percent_10_1_liquid_material_name"), percent_10_2_assign_material_name=task_params.get("percent_10_2_assign_material_name"), percent_10_2_target_weigh=task_params.get("percent_10_2_target_weigh"), percent_10_2_volume=task_params.get("percent_10_2_volume"), percent_10_2_liquid_material_name=task_params.get("percent_10_2_liquid_material_name"), percent_10_3_assign_material_name=task_params.get("percent_10_3_assign_material_name"), percent_10_3_target_weigh=task_params.get("percent_10_3_target_weigh"), percent_10_3_volume=task_params.get("percent_10_3_volume"), percent_10_3_liquid_material_name=task_params.get("percent_10_3_liquid_material_name"), hold_m_name=task_params.get("hold_m_name") ) return { "success": True, "message": "90/10比例进料任务创建完成", "result": result, "action": "create_90_10_vial_feeding_task" } except Exception as e: logger.error(f"创建90/10比例进料任务失败: {e}") return { "success": False, "error": str(e), "action": "create_90_10_vial_feeding_task" } def create_diamine_solution_task(self, solution_data: Union[str, Dict[str, Any]]) -> Dict[str, Any]: """创建二胺溶液配制任务 Args: solution_data (Union[str, Dict[str, Any]]): 溶液数据，可以是JSON字符串或字典 Returns: Dict[str, Any]: 操作结果 """ try: # 检查配液站接口是否可用 self._check_interface_availability("dispensing") logger.info("创建二胺溶液配制任务") # 处理输入数据 if isinstance(solution_data, str): solution_params = json.loads(solution_data) else: solution_params = solution_data # 调用配液站接口，传递具体参数而不是JSON字符串 result = self.dispensing_interface.create_diamine_solution_task( order_name=solution_params.get("order_name"), material_name=solution_params.get("material_name"), target_weigh=solution_params.get("target_weigh"), volume=solution_params.get("volume"), liquid_material_name=solution_params.get("liquid_material_name", "NMP"), speed=solution_params.get("speed"), temperature=solution_params.get("temperature"), delay_time=solution_params.get("delay_time"), hold_m_name=solution_params.get("hold_m_name") ) return { "success": True, "message": "二胺溶液配制任务创建完成", "result": result, "action": "create_diamine_solution_task" } except Exception as e: logger.error(f"创建二胺溶液配制任务失败: {e}") return { "success": False, "error": str(e), "action": "create_diamine_solution_task" } def create_batch_90_10_vial_feeding_task(self, batch_data: Union[str, Dict[str, Any]]) -> Dict[str, Any]: """ 创建批量90%10%小瓶投料任务 Args: batch_data: 批量90%10%小瓶投料任务数据，可以是JSON字符串或字典 包含batch_name、tasks列表和global_settings Returns: Dict[str, Any]: 批量任务创建结果 """ try: # 检查配液站接口是否可用 if not self._check_interface_availability("dispensing"): return { "success": False, "error": "配液站接口不可用", "action": "create_batch_90_10_vial_feeding_task" } # 解析输入数据 if isinstance(batch_data, str): batch_params = json.loads(batch_data) else: batch_params = batch_data logger.info(f"创建批量90%10%小瓶投料任务: {batch_params.get('batch_name', '未命名批量90%10%小瓶投料任务')}") # 调用配液站接口的批量90%10%小瓶投料方法 result = self.dispensing_interface.create_batch_90_10_vial_feeding_task( json.dumps(batch_params) if isinstance(batch_params, dict) else batch_data ) return { "success": True, "result": result, "action": "create_batch_90_10_vial_feeding_task" } except json.JSONDecodeError as e: logger.error(f"批量90%10%小瓶投料任务数据解析失败: {e}") return { "success": False, "error": f"JSON解析失败: {str(e)}", "action": "create_batch_90_10_vial_feeding_task" } except Exception as e: logger.error(f"创建批量90%10%小瓶投料任务失败: {e}") return { "success": False, "error": str(e), "action": "create_batch_90_10_vial_feeding_task" } def create_batch_diamine_solution_task(self, batch_data: Union[str, Dict[str, Any]]) -> Dict[str, Any]: """ 创建批量二胺溶液配制任务 Args: batch_data: 批量二胺溶液配制任务数据，可以是JSON字符串或字典 包含batch_name、tasks列表和global_settings Returns: Dict[str, Any]: 批量任务创建结果 """ try: # 检查配液站接口是否可用 if not self._check_interface_availability("dispensing"): return { "success": False, "error": "配液站接口不可用", "action": "create_batch_diamine_solution_task" } # 解析输入数据 if isinstance(batch_data, str): batch_params = json.loads(batch_data) else: batch_params = batch_data logger.info(f"创建批量二胺溶液配制任务: {batch_params.get('batch_name', '未命名批量二胺溶液配制任务')}") # 调用配液站接口的批量二胺溶液配制方法 result = self.dispensing_interface.create_batch_diamine_solution_task( json.dumps(batch_params) if isinstance(batch_params, dict) else batch_data ) return { "success": True, "result": result, "action": "create_batch_diamine_solution_task" } except json.JSONDecodeError as e: logger.error(f"批量二胺溶液配制任务数据解析失败: {e}") return { "success": False, "error": f"JSON解析失败: {str(e)}", "action": "create_batch_diamine_solution_task" } except Exception as e: logger.error(f"创建批量二胺溶液配制任务失败: {e}") return { "success": False, "error": str(e), "action": "create_batch_diamine_solution_task" } # ==================== 反应站动作接口 ==================== def reaction_station_drip_back(self, volume: str, assign_material_name: str, time: str, torque_variation: str) -> Dict[str, Any]: """反应站滴回操作 Args: volume (str): 投料体积 assign_material_name (str): 溶剂名称 time (str): 观察时间（单位min） torque_variation (str): 是否观察1否2是 Returns: Dict[str, Any]: 操作结果 """ try: # 检查反应站接口是否可用 self._check_interface_availability("reaction") logger.info(f"执行反应站滴回操作: 体积={volume}, 溶剂={assign_material_name}") # 调用硬件接口的滴回方法 result = self.hardware_interface.reactor_taken_out( volume=volume, assign_material_name=assign_material_name, time=time, torque_variation=torque_variation ) return { "success": True, "return_info": "滴回操作完成", "result": result, "action": "reaction_station_drip_back" } except Exception as e: logger.error(f"反应站滴回操作失败: {e}") return { "success": False, "return_info": f"滴回操作失败: {str(e)}", "action": "reaction_station_drip_back" } def reaction_station_liquid_feed(self, titration_type: str, volume: str, assign_material_name: str, time: str, torque_variation: str) -> Dict[str, Any]: """反应站液体投料操作 Args: titration_type (str): 滴定类型1否2是 volume (str): 投料体积 assign_material_name (str): 溶剂名称 time (str): 观察时间（单位min） torque_variation (str): 是否观察1否2是 Returns: Dict[str, Any]: 操作结果 """ try: # 检查反应站接口是否可用 self._check_interface_availability("reaction") logger.info(f"执行反应站液体投料: 类型={titration_type}, 体积={volume}, 溶剂={assign_material_name}") # 根据滴定类型选择相应的方法 if titration_type == "2": # 滴定 result = self.hardware_interface.liquid_feeding_titration( volume=volume, assign_material_name=assign_material_name, time=time, torque_variation=torque_variation ) else: # 非滴定 result = self.hardware_interface.liquid_feeding_vials_non_titration( volume=volume, assign_material_name=assign_material_name, time=time, torque_variation=torque_variation ) return { "success": True, "return_info": "液体投料操作完成", "result": result, "action": "reaction_station_liquid_feed" } except Exception as e: logger.error(f"反应站液体投料操作失败: {e}") return { "success": False, "return_info": f"液体投料操作失败: {str(e)}", "action": "reaction_station_liquid_feed" } def reaction_station_solid_feed_vial(self, assign_material_name: str, material_id: str, time: str, torque_variation: str) -> Dict[str, Any]: """反应站固体投料-小瓶操作 Args: assign_material_name (str): 固体名称_粉末加样模块-投料 material_id (str): 固体投料类型_粉末加样模块-投料 time (str): 观察时间_反应模块-观察搅拌结果 torque_variation (str): 是否观察1否2是_反应模块-观察搅拌结果 Returns: Dict[str, Any]: 操作结果 """ try: # 检查反应站接口是否可用 self._check_interface_availability("reaction") logger.info(f"执行反应站固体投料: 固体={assign_material_name}, ID={material_id}") # 调用硬件接口的固体投料方法 result = self.hardware_interface.solid_feeding_vials( assign_material_name=assign_material_name, material_id=material_id, time=time, torque_variation=torque_variation ) return { "success": True, "return_info": "固体投料操作完成", "result": result, "action": "reaction_station_solid_feed_vial" } except Exception as e: logger.error(f"反应站固体投料操作失败: {e}") return { "success": False, "return_info": f"固体投料操作失败: {str(e)}", "action": "reaction_station_solid_feed_vial" } def reaction_station_take_in(self, cutoff: str, temperature: str, assign_material_name: str) -> Dict[str, Any]: """反应站取入操作 Args: cutoff (str): 截止参数 temperature (str): 温度 assign_material_name (str): 物料名称 Returns: Dict[str, Any]: 操作结果 """ try: # 检查反应站接口是否可用 self._check_interface_availability("reaction") logger.info(f"执行反应站取入操作: 温度={temperature}, 物料={assign_material_name}") # 调用硬件接口的取入方法 result = self.hardware_interface.reactor_taken_in( cutoff=cutoff, temperature=temperature, assign_material_name=assign_material_name ) return { "success": True, "return_info": "取入操作完成", "result": result, "action": "reaction_station_take_in" } except Exception as e: logger.error(f"反应站取入操作失败: {e}") return { "success": False, "return_info": f"取入操作失败: {str(e)}", "action": "reaction_station_take_in" } def reaction_station_reactor_taken_out(self, order_id: str = "", preintake_id: str = "") -> Dict[str, Any]: """反应站反应器取出操作 Args: order_id (str): 订单ID，用于标识要取出的订单 preintake_id (str): 预取样ID，用于标识具体的取样任务 Returns: Dict[str, Any]: 操作结果 """ try: # 检查反应站接口是否可用 self._check_interface_availability("reaction") logger.info(f"执行反应站反应器取出操作: 订单ID={order_id}, 预取样ID={preintake_id}") # 调用更新后的反应器取出方法 result = self.reactor_taken_out(order_id=order_id, preintake_id=preintake_id) # 更新 action 字段以区分调用来源 result["action"] = "reaction_station_reactor_taken_out" return result except Exception as e: logger.error(f"反应站反应器取出操作失败: {e}") return { "success": False, "code": 0, "return_info": f"反应器取出操作失败: {str(e)}", "action": "reaction_station_reactor_taken_out" } def reaction_station_process_execute(self, workflow_name: str, task_name: str) -> Dict[str, Any]: """反应站流程执行操作 Args: workflow_name (str): 工作流名称 task_name (str): 任务名称 Returns: Dict[str, Any]: 操作结果 """ try: # 检查反应站接口是否可用 self._check_interface_availability("reaction") logger.info(f"执行反应站流程: 工作流={workflow_name}, 任务={task_name}") # 这里可以根据具体的工作流和任务名称调用相应的方法 # 暂时使用通用的执行方法 result = { "workflow_name": workflow_name, "task_name": task_name, "status": "executed" } return { "success": True, "return_info": "流程执行完成", "result": result, "action": "reaction_station_process_execute" } except Exception as e: logger.error(f"反应站流程执行失败: {e}") return { "success": False, "return_info": f"流程执行失败: {str(e)}", "action": "reaction_station_process_execute" } # ==================== 物料管理动作函数 ==================== def material_inbound(self, material_id: str, location_name: str) -> Dict[str, Any]: """物料入库操作 将物料添加到指定位置 Args: material_id (str): 物料ID location_name (str): 位置名称 Returns: Dict[str, Any]: 操作结果，包含状态和消息 """ try: logger.info(f"开始执行物料入库操作: 物料ID={material_id}, 位置={location_name}") result = self.hardware_interface.material_inbound( material_id=material_id, location_name=location_name ) if result: logger.info("物料入库操作成功") return { "status": "success", "message": f"物料入库成功，物料ID: {material_id}", "data": result } else: logger.error("物料入库操作失败") return { "status": "failed", "message": "物料入库失败" } except Exception as e: logger.error(f"物料入库操作异常: {e}") return { "status": "error", "message": f"物料入库操作异常: {str(e)}" } def material_outbound(self, material_id: str, location_name: str, quantity: int) -> Dict[str, Any]: """物料出库操作 从指定位置取出物料 Args: material_id (str): 物料ID location_name (str): 位置名称 quantity (int): 数量 Returns: Dict[str, Any]: 操作结果，包含状态和消息 """ try: logger.info(f"开始执行物料出库操作: 物料ID={material_id}, 位置={location_name}, 数量={quantity}") result = self.hardware_interface.material_outbound( material_id=material_id, location_name=location_name, quantity=quantity ) if result: logger.info("物料出库操作成功") return { "status": "success", "message": f"物料出库成功，物料ID: {material_id}", "data": result } else: logger.error("物料出库操作失败") return { "status": "failed", "message": "物料出库失败" } except Exception as e: logger.error(f"物料出库操作异常: {e}") return { "status": "error", "message": f"物料出库操作异常: {str(e)}" } # ============ 工作流控制函数 ============ def create_order(self, workflow_name: str, task_name: str, parameters: Dict[str, Any] = None) -> Dict[str, Any]: """创建工作流订单 创建并提交工作流执行订单 Args: workflow_name (str): 工作流名称 task_name (str): 任务名称 parameters (Dict[str, Any]): 工作流参数 Returns: Dict[str, Any]: 操作结果，包含状态和订单信息 """ try: logger.info(f"开始创建工作流订单: 工作流={workflow_name}, 任务={task_name}") # 使用 BioyondV1RPC 的工作流处理方法 result = self.hardware_interface.process_and_execute_workflow( workflow_name=workflow_name, task_name=task_name ) if result and result.get("status") == "success": logger.info("工作流订单创建成功") return { "status": "success", "message": f"工作流订单创建成功: {workflow_name}", "data": result } else: logger.error("工作流订单创建失败") return { "status": "failed", "message": "工作流订单创建失败", "data": result } except Exception as e: logger.error(f"创建工作流订单异常: {e}") return { "status": "error", "message": f"创建工作流订单异常: {str(e)}" } def get_scheduler_status(self) -> Dict[str, Any]: """获取调度器状态 Returns: Dict[str, Any]: 调度器状态信息 """ try: logger.info("获取调度器状态") result = self.hardware_interface.scheduler_status() return { "status": "success", "message": "调度器状态获取成功", "data": result } except Exception as e: logger.error(f"获取调度器状态异常: {e}") return { "status": "error", "message": f"获取调度器状态异常: {str(e)}" } def start_scheduler(self) -> Dict[str, Any]: """启动调度器 Returns: Dict[str, Any]: 操作结果 """ try: logger.info("启动调度器") result = self.hardware_interface.scheduler_start() if result == 1: # 成功返回1 logger.info("调度器启动成功") return { "status": "success", "message": "调度器启动成功" } else: logger.error("调度器启动失败") return { "status": "failed", "message": "调度器启动失败" } except Exception as e: logger.error(f"启动调度器异常: {e}") return { "status": "error", "message": f"启动调度器异常: {str(e)}" } def stop_scheduler(self) -> Dict[str, Any]: """停止调度器 Returns: Dict[str, Any]: 操作结果 """ try: logger.info("停止调度器") result = self.hardware_interface.scheduler_stop() if result == 1: # 成功返回1 logger.info("调度器停止成功") return { "status": "success", "message": "调度器停止成功" } else: logger.error("调度器停止失败") return { "status": "failed", "message": "调度器停止失败" } except Exception as e: logger.error(f"停止调度器异常: {e}") return { "status": "error", "message": f"停止调度器异常: {str(e)}" } # ============ 其他操作函数 ============ def drip_back(self, assign_material_name: str = "Reactor", time: str = "0", torque_variation: str = "1", temperature: float = 25.00) -> Dict[str, Any]: """滴回操作 执行滴回操作，通常用于反应后的物料回收 Args: assign_material_name (str): 指定的物料名称，默认为 "Reactor" time (str): 操作时间，默认为 "0" torque_variation (str): 扭矩变化，默认为 "1" temperature (float): 温度设置，默认为 25.00°C Returns: Dict[str, Any]: 操作结果，包含状态和消息 """ try: logger.info(f"开始执行滴回操作: 物料={assign_material_name}, 温度={temperature}°C") # 根据配置文件中的映射，滴回操作可能对应特定的工作流 workflow_name = self.config.get("workflow_mappings", {}).get("Drip_back") if workflow_name: result = self.hardware_interface.process_and_execute_workflow( workflow_name=workflow_name, task_name="drip_back_task" ) else: # 如果没有特定的工作流映射，使用通用的液体操作 logger.warning("未找到滴回操作的工作流映射，使用默认处理") result = {"status": "success", "message": "滴回操作完成"} if result and result.get("status") == "success": logger.info("滴回操作成功") return { "status": "success", "message": f"滴回操作成功，物料: {assign_material_name}", "data": result } else: logger.error("滴回操作失败") return { "status": "failed", "message": "滴回操作失败" } except Exception as e: logger.error(f"滴回操作异常: {e}") return { "status": "error", "message": f"滴回操作异常: {str(e)}" } def get_device_list(self) -> Dict[str, Any]: """获取设备列表 Returns: Dict[str, Any]: 设备列表信息 """ try: logger.info("获取设备列表") result = self.hardware_interface.device_list() return { "status": "success", "message": "设备列表获取成功", "data": result } except Exception as e: logger.error(f"获取设备列表异常: {e}") return { "status": "error", "message": f"获取设备列表异常: {str(e)}" } def device_operation(self, device_id: str, operation: str, parameters: Dict[str, Any] = None) -> Dict[str, Any]: """设备操作 对指定设备执行操作 Args: device_id (str): 设备ID operation (str): 操作类型 parameters (Dict[str, Any]): 操作参数 Returns: Dict[str, Any]: 操作结果 """ try: logger.info(f"执行设备操作: 设备ID={device_id}, 操作={operation}") result = self.hardware_interface.device_operation( device_id=device_id, operation=operation, parameters=parameters or {} ) if result: logger.info("设备操作成功") return { "status": "success", "message": f"设备操作成功: {operation}", "data": result } else: logger.error("设备操作失败") return { "status": "failed", "message": "设备操作失败" } except Exception as e: logger.error(f"设备操作异常: {e}") return { "status": "error", "message": f"设备操作异常: {str(e)}" } def add_material(self, material_data: Dict[str, Any]) -> Dict[str, Any]: """添加物料 向系统中添加新的物料信息 Args: material_data (Dict[str, Any]): 物料数据 Returns: Dict[str, Any]: 操作结果 """ try: logger.info(f"添加物料: {material_data.get('name', 'Unknown')}") result = self.hardware_interface.add_material(material_data) if result: logger.info("物料添加成功") return { "status": "success", "message": "物料添加成功", "data": result } else: logger.error("物料添加失败") return { "status": "failed", "message": "物料添加失败" } except Exception as e: logger.error(f"添加物料异常: {e}") return { "status": "error", "message": f"添加物料异常: {str(e)}" } def stock_material(self, material_id: str, location: str, quantity: int) -> Dict[str, Any]: """库存物料 更新物料库存信息 Args: material_id (str): 物料ID location (str): 位置 quantity (int): 数量 Returns: Dict[str, Any]: 操作结果 """ try: logger.info(f"更新物料库存: 物料ID={material_id}, 位置={location}, 数量={quantity}") result = self.hardware_interface.stock_material( material_id=material_id, location=location, quantity=quantity ) if result: logger.info("物料库存更新成功") return { "status": "success", "message": "物料库存更新成功", "data": result } else: logger.error("物料库存更新失败") return { "status": "failed", "message": "物料库存更新失败" } except Exception as e: logger.error(f"物料库存更新异常: {e}") return { "status": "error", "message": f"物料库存更新异常: {str(e)}" } # ============ 工作站状态管理 ============ def get_workstation_status(self) -> Dict[str, Any]: """获取工作站状态 Returns: Dict[str, Any]: 工作站状态信息 """ try: # 获取基础状态信息 base_status = { "is_busy": self.is_busy, "workflow_status": self.workflow_status, "workflow_runtime": self.workflow_runtime } # 获取调度器状态 scheduler_status = self.get_scheduler_status() # 获取设备列表 device_list = self.get_device_list() return { "status": "success", "message": "工作站状态获取成功", "data": { "base_status": base_status, "scheduler_status": scheduler_status.get("data"), "device_list": device_list.get("data"), "config": { "api_host": self.config.get("api_host"), "workflow_mappings": self.config.get("workflow_mappings", {}), "material_type_mappings": self.config.get("material_type_mappings", {}) } } } except Exception as e: logger.error(f"获取工作站状态异常: {e}") return { "status": "error", "message": f"获取工作站状态异常: {str(e)}" } def get_bioyond_status(self) -> Dict[str, Any]: """获取完整的 Bioyond 状态信息 这个方法提供了比 bioyond_status 属性更详细的状态信息， 包括错误处理和格式化的响应结构 Returns: Dict[str, Any]: 格式化的 Bioyond 状态响应 """ try: # 获取 bioyond_status 属性的数据 status_data = self.bioyond_status return { "status": "success", "message": "Bioyond 状态获取成功", "data": status_data } except Exception as e: logger.error(f"获取 Bioyond 状态异常: {e}") return { "status": "error", "message": f"获取 Bioyond 状态异常: {str(e)}", "data": { "station_info": { "station_name": getattr(self, 'station_name', 'BioyondWorkstation'), "station_type": getattr(self, 'station_type', 'unknown'), "enable_reaction_station": getattr(self, 'enable_reaction_station', False), "enable_dispensing_station": getattr(self, 'enable_dispensing_station', False) }, "interface_status": { "reaction_interface_connected": False, "dispensing_interface_connected": False, "last_sync_time": 0, "sync_interval": 60 }, "sync_status": { "last_sync_success": False, "total_resources": 0, "warehouse_count": 0 }, "timestamp": __import__('time').time(), "status": "error", "error_message": str(e) } } def reset_workstation(self) -> Dict[str, Any]: """重置工作站 重置工作站到初始状态 Returns: Dict[str, Any]: 操作结果 """ try: logger.info("开始重置工作站") # 停止当前工作流（如果有） if self.is_busy: self.stop_workflow() # 停止调度器 self.stop_scheduler() # 重新启动调度器 start_result = self.start_scheduler() if start_result.get("status") == "success": logger.info("工作站重置成功") return { "status": "success", "message": "工作站重置成功" } else: logger.error("工作站重置失败") return { "status": "failed", "message": "工作站重置失败" } except Exception as e: logger.error(f"工作站重置异常: {e}") return { "status": "error", "message": f"工作站重置异常: {str(e)}" } async def execute_bioyond_update_workflow(self, parameters: Dict[str, Any]) -> Dict[str, Any]: """执行Bioyond更新工作流""" try: material_ids = parameters.get("material_ids", []) sync_all = parameters.get("sync_all", True) logger.info(f"开始执行Bioyond更新工作流: sync_all={sync_all}") # 获取物料管理模块 material_manager = self.material_management if sync_all: # 同步所有物料 success_count = 0 for resource in material_manager.plr_resources.values(): success = await material_manager.sync_to_bioyond(resource) if success: success_count += 1 else: # 同步指定物料 success_count = 0 for material_id in material_ids: resource = material_manager.find_material_by_id(material_id) if resource: success = await material_manager.sync_to_bioyond(resource) if success: success_count += 1 result = { "status": "success", "message": f"Bioyond更新完成", "updated_resources": success_count, "total_resources": len(material_ids) if not sync_all else len(material_manager.plr_resources) } logger.info(f"Bioyond更新工作流执行完成: {result['status']}") return result except Exception as e: logger.error(f"Bioyond更新工作流执行失败: {e}") return { "status": "error", "message": str(e) } def load_bioyond_data_from_file(self, file_path: str) -> bool: """从文件加载Bioyond数据（用于测试）""" try: with open(file_path, 'r', encoding='utf-8') as f: bioyond_data = json.load(f) # 获取物料管理模块 material_manager = self.material_management # 转换为UniLab格式 if isinstance(bioyond_data, dict) and "data" in bioyond_data: unilab_resources = material_manager.resource_bioyond_container_to_ulab(bioyond_data) else: unilab_resources = material_manager.resource_bioyond_to_ulab(bioyond_data) # 分配到Deck import asyncio asyncio.create_task(material_manager._assign_resources_to_deck(unilab_resources)) logger.info(f"从文件 {file_path} 加载了 {len(unilab_resources)} 个Bioyond资源") return True except Exception as e: logger.error(f"从文件加载Bioyond数据失败: {e}") return False # 使用示例 def create_bioyond_workstation_example(): """创建Bioyond工作站示例""" # 配置参数 device_id = "bioyond_workstation_001" # 子资源配置 children = { "plate_1": { "name": "plate_1", "type": "plate", "position": {"x": 100, "y": 100, "z": 0}, "config": { "size_x": 127.76, "size_y": 85.48, "size_z": 14.35, "model": "Generic 96 Well Plate" } } } # Bioyond配置 bioyond_config = { "base_url": "http://bioyond.example.com/api", "api_key": "your_api_key_here", "sync_interval": 60, # 60秒同步一次 "timeout": 30 } # Deck配置 deck_config = { "size_x": 1000.0, "size_y": 1000.0, "size_z": 100.0, "model": "BioyondDeck" } # 创建工作站 workstation = BioyondWorkstation( station_resource=deck_config, bioyond_config=bioyond_config, deck_config=deck_config, ) return workstation if __name__ == "__main__": # 创建示例工作站 #workstation = create_bioyond_workstation_example() # 从文件加载测试数据 #workstation.load_bioyond_data_from_file("bioyond_test_yibin.json") # 获取状态 #status = workstation.get_bioyond_status() #print("Bioyond工作站状态:", status) # 创建测试数据 - 使用resource_bioyond_container_to_ulab函数期望的格式 # 读取 bioyond_resources_unilab_output3 copy.json 文件 from unilabos.resources.graphio import resource_ulab_to_plr, convert_resources_to_type from Bioyond_wuliao import * from typing import List from pylabrobot.resources import Resource as PLRResource import json from pylabrobot.resources.deck import Deck from pylabrobot.resources.coordinate import Coordinate with open("./bioyond_test_yibin3_unilab_result_corr.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(f"转换结果长度: {len(ulab_resources) if ulab_resources else 0}") deck = Deck(size_x=2000, size_y=653.5, size_z=900) Stack0 = Stack(name="Stack0", location=Coordinate(0, 100, 0)) Stack1 = Stack(name="Stack1", location=Coordinate(100, 100, 0)) Stack2 = Stack(name="Stack2", location=Coordinate(200, 100, 0)) Stack3 = Stack(name="Stack3", location=Coordinate(300, 100, 0)) Stack4 = Stack(name="Stack4", location=Coordinate(400, 100, 0)) Stack5 = Stack(name="Stack5", location=Coordinate(500, 100, 0)) deck.assign_child_resource(Stack1, Stack1.location) deck.assign_child_resource(Stack2, Stack2.location) deck.assign_child_resource(Stack3, Stack3.location) deck.assign_child_resource(Stack4, Stack4.location) deck.assign_child_resource(Stack5, Stack5.location) Stack0.assign_child_resource(ulab_resources[0], Stack0.location) Stack1.assign_child_resource(ulab_resources[1], Stack1.location) Stack2.assign_child_resource(ulab_resources[2], Stack2.location) Stack3.assign_child_resource(ulab_resources[3], Stack3.location) Stack4.assign_child_resource(ulab_resources[4], Stack4.location) Stack5.assign_child_resource(ulab_resources[5], Stack5.location) from unilabos.resources.graphio import convert_resources_from_type from unilabos.app.web.client import http_client resources = convert_resources_from_type([deck], [PLRResource]) print(resources) http_client.remote_addr = "https://uni-lab.bohrium.com/api/v1" #http_client.auth = "9F05593C" http_client.auth = "ED634D1C" http_client.resource_add(resources, database_process_later=False)