open_pub/Uni-Lab-OS
1
0
Fork 0
mirror of https://github.com/dptech-corp/Uni-Lab-OS.git synced 2025-12-17 13:01:12 +00:00
Code Issues Packages Projects Releases Wiki Activity

refactor: ProtocolNode→WorkstationNode

Browse Source
This commit is contained in:
Junhan Chang
2025-08-25 22:09:37 +08:00
parent ae3c1100ae
commit 5ec8a57a1f
19 changed files with 1089 additions and 365 deletions
Download Patch File Download Diff File Expand all files Collapse all files

347
unilabos/ros/nodes/presets/protocol_node.py
View File

@@ -28,9 +28,9 @@ from unilabos.utils.log import error
from unilabos.utils.type_check import serialize_result_info
class ROS2ProtocolNode(BaseROS2DeviceNode):
class ROS2WorkstationNode(BaseROS2DeviceNode):
"""
ROS2ProtocolNode代表管理ROS2环境中设备通信和动作的协议节点。
ROS2WorkstationNode代表管理ROS2环境中设备通信和动作的协议节点。
它初始化设备节点，处理动作客户端，并基于指定的协议执行工作流。
它还物理上代表一组协同工作的设备，如带夹持器的机械臂，带传送带的CNC机器等。
"""
@@ -43,7 +43,8 @@ class ROS2ProtocolNode(BaseROS2DeviceNode):
children: dict,
protocol_type: Union[str, list[str]],
resource_tracker: DeviceNodeResourceTracker,
workstation_config: dict = None, # 新增：工作站配置
workstation_config: dict = {},
workstation_instance: object = None,
*args,
**kwargs,
):
@@ -55,10 +56,12 @@ class ROS2ProtocolNode(BaseROS2DeviceNode):
self.communication_interfaces = self.workstation_config.get('communication_interfaces', {}) # 从工作站配置获取通信接口
# 新增：获取工作站实例（如果存在）
self.workstation_instance = self.workstation_config.get('workstation_instance')
self.workstation_instance = workstation_instance
self._busy = False
self.sub_devices = {}
self.communication_devices = {}
self.logical_devices = {}
self._goals = {}
self._protocol_servers = {}
self._action_clients = {}
@@ -72,73 +75,38 @@ class ROS2ProtocolNode(BaseROS2DeviceNode):
device_id=device_id,
status_types={},
action_value_mappings=self.protocol_action_mappings,
hardware_interface={},
hardware_interface={"name": "hardware_interface", "write": "send_command", "read": "read_data", "extra_info": []},
print_publish=False,
resource_tracker=resource_tracker,
)
# 初始化子设备
self.communication_node_id_to_instance = {}
self._initialize_child_devices()
# 设置硬件接口代理
self._setup_hardware_proxies()
# 新增：如果有工作站实例，建立双向引用
if self.workstation_instance:
self.workstation_instance._protocol_node = self
self._setup_workstation_method_proxies()
self.lab_logger().info(f"ROS2ProtocolNode {device_id} 与工作站实例 {type(self.workstation_instance).__name__} 关联")
self.lab_logger().info(f"ROS2ProtocolNode {device_id} initialized with protocols: {self.protocol_names}")
def _setup_workstation_method_proxies(self):
"""设置工作站方法代理"""
if not self.workstation_instance:
return
# 代理工作站的核心方法
workstation_methods = [
'start_workflow', 'stop_workflow', 'workflow_status', 'is_busy',
'process_material_change_report', 'process_step_finish_report',
'process_sample_finish_report', 'process_order_finish_report',
'handle_external_error'
]
for method_name in workstation_methods:
if hasattr(self.workstation_instance, method_name):
# 创建代理方法
setattr(self, method_name, getattr(self.workstation_instance, method_name))
self.lab_logger().debug(f"代理工作站方法: {method_name}")
# ============ 工作站方法代理 ============
def get_workstation_status(self) -> Dict[str, Any]:
"""获取工作站状态"""
if self.workstation_instance:
return {
'workflow_status': str(self.workstation_instance.workflow_status.value),
'is_busy': self.workstation_instance.is_busy,
'workflow_runtime': self.workstation_instance.workflow_runtime,
'error_count': self.workstation_instance.error_count,
'last_error': self.workstation_instance.last_error
}
return {'status': 'no_workstation_instance'}
def delegate_to_workstation(self, method_name: str, *args, **kwargs):
"""委托方法调用给工作站实例"""
if self.workstation_instance and hasattr(self.workstation_instance, method_name):
method = getattr(self.workstation_instance, method_name)
return method(*args, **kwargs)
if isinstance(getattr(driver_instance, "hardware_interface", None), str):
self.logical_devices[device_id] = driver_instance
else:
self.lab_logger().warning(f"工作站实例不存在或没有方法: {method_name}")
return None
self.communication_devices[device_id] = driver_instance
# 设置硬件接口代理
for device_id, device_node in self.logical_devices.items():
if device_node and hasattr(device_node, 'ros_node_instance'):
self._setup_device_hardware_proxy(device_id, device_node)
# 新增：如果有工作站实例，建立双向引用和硬件接口设置
if self.workstation_instance:
self._setup_workstation_integration()
def _setup_workstation_integration(self):
"""设置工作站集成 - 统一设备处理模式"""
# 1. 建立协议节点引用
self.workstation_instance.set_protocol_node(self)
self.lab_logger().info(f"ROS2WorkstationNode {self.device_id} 与工作站实例 {type(self.workstation_instance).__name__} 集成完成")
def _initialize_child_devices(self):
"""初始化子设备 - 重构为更清晰的方法"""
# 设备分类字典 - 统一管理
self.communication_devices = {}
self.logical_devices = {}
for device_id, device_config in self.children.items():
if device_config.get("type", "device") != "device":
@@ -157,7 +125,6 @@ class ROS2ProtocolNode(BaseROS2DeviceNode):
# 兼容旧的ID匹配方式和新的配置方式
if device_type == "communication" or "serial_" in device_id or "io_" in device_id:
self.communication_node_id_to_instance[device_id] = d # 保持向后兼容
self.communication_devices[device_id] = d # 新的统一方式
self.lab_logger().info(f"通信设备 {device_id} 初始化并分类成功")
elif device_type == "logical":
@@ -171,91 +138,100 @@ class ROS2ProtocolNode(BaseROS2DeviceNode):
except Exception as ex:
self.lab_logger().error(f"[Protocol Node] Failed to initialize device {device_id}: {ex}\n{traceback.format_exc()}")
def _setup_hardware_proxies(self):
"""设置硬件接口代理 - 重构为独立方法，支持工作站配置"""
# 1. 传统的协议节点硬件代理设置
for device_id, device_config in self.children.items():
if device_config.get("type", "device") != "device":
continue
# 设置硬件接口代理
if device_id not in self.sub_devices:
self.lab_logger().error(f"[Protocol Node] {device_id} 还没有正确初始化，跳过...")
continue
d = self.sub_devices[device_id]
if d:
self._setup_device_hardware_proxy(device_id, d)
def _setup_device_hardware_proxy(self, device_id: str, device: ROS2DeviceNode):
"""统一的设备硬件接口代理设置方法
# 2. 工作站配置的通信接口代理设置
if hasattr(self, 'communication_interfaces') and self.communication_interfaces:
self._setup_workstation_communication_interfaces()
self.lab_logger().info(f"ROS2ProtocolNode {self.device_id} initialized with protocols: {self.protocol_names}")
def _setup_workstation_communication_interfaces(self):
"""设置工作站特定的通信接口代理"""
for logical_device_id, logical_device in self.logical_devices.items():
# 检查是否有配置的通信接口
interface_config = getattr(self, 'communication_interfaces', {}).get(logical_device_id)
if not interface_config:
continue
comm_device = self.communication_devices.get(interface_config.device_id)
if not comm_device:
self.lab_logger().error(f"通信设备 {interface_config.device_id} 不存在")
continue
# 设置工作站级别的通信代理
self._setup_workstation_hardware_proxy(
logical_device,
comm_device,
interface_config
)
def _setup_workstation_hardware_proxy(self, logical_device, comm_device, interface_config):
"""为逻辑设备设置工作站级通信代理"""
try:
# 获取通信设备的读写方法
read_func = getattr(comm_device.driver_instance, interface_config.read_method, None)
write_func = getattr(comm_device.driver_instance, interface_config.write_method, None)
if read_func:
setattr(logical_device.driver_instance, 'comm_read', read_func)
if write_func:
setattr(logical_device.driver_instance, 'comm_write', write_func)
# 设置通信配置
setattr(logical_device.driver_instance, 'comm_config', interface_config.config)
setattr(logical_device.driver_instance, 'comm_protocol', interface_config.protocol_type)
self.lab_logger().info(f"为逻辑设备 {logical_device.device_id} 设置工作站通信代理 -> {comm_device.device_id}")
except Exception as e:
self.lab_logger().error(f"设置工作站通信代理失败: {e}")
def _setup_device_hardware_proxy(self, device_id: str, device):
"""为单个设备设置硬件接口代理"""
Args:
device_id: 设备ID
device: 设备实例
"""
hardware_interface = device.ros_node_instance._hardware_interface
if (
if not self._validate_hardware_interface(device, hardware_interface):
return
# 获取硬件接口名称
interface_name = getattr(device.driver_instance, hardware_interface["name"])
# 情况1: 如果interface_name是字符串，说明需要转发到其他设备
if isinstance(interface_name, str):
# 查找目标设备
communication_device = self.communication_devices.get(device_id, None)
if not communication_device:
self.lab_logger().error(f"转发目标设备 {device_id} 不存在")
return
read_method = hardware_interface.get("read", None)
write_method = hardware_interface.get("write", None)
# 设置传统硬件代理
communicate_hardware_info = communication_device.ros_node_instance._hardware_interface
self._setup_hardware_proxy(device, communication_device, read_method, write_method)
self.lab_logger().info(
f"传统通信代理：为子设备{device.device_id} "
f"添加了{read_method}方法(来源：{communication_device.device_id} {communicate_hardware_info['read']}) "
f"添加了{write_method}方法(来源：{communication_device.device_id} {communicate_hardware_info['write']})"
)
self.lab_logger().info(f"字符串转发代理：设备 {device.device_id} -> {device_id}")
# 情况2: 如果设备有communication_interface配置，设置协议代理
elif hasattr(self, 'communication_interfaces') and device_id in self.communication_interfaces:
interface_config = self._get_communication_interface_config(device_id)
protocol_type = interface_config.get('protocol_type', 'modbus')
self._setup_communication_proxy(device, interface_config, protocol_type)
# 情况3: 其他情况，使用默认处理
else:
self.lab_logger().debug(f"设备 {device_id} 使用默认硬件接口处理")
def _get_communication_interface_config(self, device_id: str) -> dict:
"""获取设备的通信接口配置"""
# 优先从工作站配置获取
if hasattr(self, 'communication_interfaces') and device_id in self.communication_interfaces:
return self.communication_interfaces[device_id]
# 从设备自身配置获取
device_node = self.logical_devices[device_id]
if device_node and hasattr(device_node.driver_instance, 'communication_interface'):
return getattr(device_node.driver_instance, 'communication_interface')
return {}
def _validate_hardware_interface(self, device: ROS2DeviceNode, hardware_interface: dict) -> bool:
"""验证硬件接口配置"""
return (
hasattr(device.driver_instance, hardware_interface["name"])
and hasattr(device.driver_instance, hardware_interface["write"])
and (hardware_interface["read"] is None or hasattr(device.driver_instance, hardware_interface["read"]))
):
name = getattr(device.driver_instance, hardware_interface["name"])
read = hardware_interface.get("read", None)
write = hardware_interface.get("write", None)
)
# 如果硬件接口是字符串，通过通信设备提供
if isinstance(name, str) and name in self.sub_devices:
communicate_device = self.sub_devices[name]
communicate_hardware_info = communicate_device.ros_node_instance._hardware_interface
self._setup_hardware_proxy(device, self.sub_devices[name], read, write)
self.lab_logger().info(
f"\n通信代理：为子设备{device_id}\n "
f"添加了{read}方法(来源：{name} {communicate_hardware_info['write']}) \n "
f"添加了{write}方法(来源：{name} {communicate_hardware_info['read']})"
)
def _setup_communication_proxy(self, logical_device: ROS2DeviceNode, interface_config, protocol_type):
"""为逻辑设备设置通信代理 - 统一方法"""
try:
# 获取通信设备
comm_device_id = interface_config.get('device_id')
comm_device = self.communication_devices.get(comm_device_id)
if not comm_device:
self.lab_logger().error(f"通信设备 {comm_device_id} 不存在")
return
# 根据协议类型设置不同的代理方法
if protocol_type == 'modbus':
self._setup_modbus_proxy(logical_device, comm_device, interface_config)
elif protocol_type == 'opcua':
self._setup_opcua_proxy(logical_device, comm_device, interface_config)
elif protocol_type == 'http':
self._setup_http_proxy(logical_device, comm_device, interface_config)
elif protocol_type == 'serial':
self._setup_serial_proxy(logical_device, comm_device, interface_config)
else:
self.lab_logger().warning(f"不支持的协议类型: {protocol_type}")
return
self.lab_logger().info(f"通信代理：为逻辑设备 {logical_device.device_id} 设置{protocol_type}通信代理 -> {comm_device_id}")
except Exception as e:
self.lab_logger().error(f"设置通信代理失败: {e}")
def _setup_protocol_names(self, protocol_type):
# 处理协议类型
@@ -493,6 +469,99 @@ class ROS2ProtocolNode(BaseROS2DeviceNode):
"""还没有改过的部分"""
def _setup_modbus_proxy(self, logical_device: ROS2DeviceNode, comm_device: ROS2DeviceNode, interface_config):
"""设置Modbus通信代理"""
config = interface_config.get('config', {})
# 设置Modbus读写方法
def modbus_read(address, count=1, function_code=3):
"""Modbus读取方法"""
return comm_device.driver_instance.read_holding_registers(
address=address,
count=count,
slave_id=config.get('slave_id', 1)
)
def modbus_write(address, value, function_code=6):
"""Modbus写入方法"""
if isinstance(value, (list, tuple)):
return comm_device.driver_instance.write_multiple_registers(
address=address,
values=value,
slave_id=config.get('slave_id', 1)
)
else:
return comm_device.driver_instance.write_single_register(
address=address,
value=value,
slave_id=config.get('slave_id', 1)
)
# 绑定方法到逻辑设备
setattr(logical_device.driver_instance, 'comm_read', modbus_read)
setattr(logical_device.driver_instance, 'comm_write', modbus_write)
setattr(logical_device.driver_instance, 'comm_config', config)
setattr(logical_device.driver_instance, 'comm_protocol', 'modbus')
def _setup_opcua_proxy(self, logical_device: ROS2DeviceNode, comm_device: ROS2DeviceNode, interface_config):
"""设置OPC UA通信代理"""
config = interface_config.get('config', {})
def opcua_read(node_id):
"""OPC UA读取方法"""
return comm_device.driver_instance.read_node_value(node_id)
def opcua_write(node_id, value):
"""OPC UA写入方法"""
return comm_device.driver_instance.write_node_value(node_id, value)
# 绑定方法到逻辑设备
setattr(logical_device.driver_instance, 'comm_read', opcua_read)
setattr(logical_device.driver_instance, 'comm_write', opcua_write)
setattr(logical_device.driver_instance, 'comm_config', config)
setattr(logical_device.driver_instance, 'comm_protocol', 'opcua')
def _setup_http_proxy(self, logical_device: ROS2DeviceNode, comm_device: ROS2DeviceNode, interface_config):
"""设置HTTP/RPC通信代理"""
config = interface_config.get('config', {})
base_url = config.get('base_url', 'http://localhost:8080')
def http_read(endpoint, params=None):
"""HTTP GET请求"""
url = f"{base_url.rstrip('/')}/{endpoint.lstrip('/')}"
return comm_device.driver_instance.get_request(url, params=params)
def http_write(endpoint, data):
"""HTTP POST请求"""
url = f"{base_url.rstrip('/')}/{endpoint.lstrip('/')}"
return comm_device.driver_instance.post_request(url, data=data)
# 绑定方法到逻辑设备
setattr(logical_device.driver_instance, 'comm_read', http_read)
setattr(logical_device.driver_instance, 'comm_write', http_write)
setattr(logical_device.driver_instance, 'comm_config', config)
setattr(logical_device.driver_instance, 'comm_protocol', 'http')
def _setup_serial_proxy(self, logical_device: ROS2DeviceNode, comm_device: ROS2DeviceNode, interface_config):
"""设置串口通信代理"""
config = interface_config.get('config', {})
def serial_read(timeout=1.0):
"""串口读取方法"""
return comm_device.driver_instance.read_data(timeout=timeout)
def serial_write(data):
"""串口写入方法"""
if isinstance(data, str):
data = data.encode('utf-8')
return comm_device.driver_instance.write_data(data)
# 绑定方法到逻辑设备
setattr(logical_device.driver_instance, 'comm_read', serial_read)
setattr(logical_device.driver_instance, 'comm_write', serial_write)
setattr(logical_device.driver_instance, 'comm_config', config)
setattr(logical_device.driver_instance, 'comm_protocol', 'serial')
def _setup_hardware_proxy(
self, device: ROS2DeviceNode, communication_device: ROS2DeviceNode, read_method, write_method
):