1036 lines
41 KiB
Python
1036 lines
41 KiB
Python
#!/usr/bin/env python
|
||
# -*- coding: utf-8 -*-
|
||
|
||
"""
|
||
设备处理服务模块
|
||
基于VDA5050协议的设备管理框架，支持MQTT通信
|
||
消息直接透传，不进行编解码处理
|
||
"""
|
||
|
||
import asyncio
|
||
import json
|
||
import time
|
||
import socket
|
||
import threading
|
||
from datetime import datetime
|
||
from typing import Dict, Any, Optional, Callable, List, Union
|
||
from dataclasses import dataclass, asdict
|
||
from enum import Enum
|
||
from utils.logger import get_logger
|
||
from .mqtt_service import MQTTService
|
||
from .async_mqtt_service import AsyncMQTTService
|
||
|
||
logger = get_logger("services.device_handler")
|
||
|
||
|
||
class DeviceType(Enum):
|
||
"""设备类型枚举"""
|
||
VEHICLE = "vehicle" # 小车
|
||
DOOR = "door" # 门
|
||
CALLER = "caller" # 呼叫器
|
||
LIFT = "lift" # 电梯
|
||
CONVEYOR = "conveyor" # 输送带
|
||
SENSOR = "sensor" # 传感器
|
||
ROBOT = "robot" # 机器人
|
||
CAMERA = "camera" # 摄像头
|
||
SCANNER = "scanner" # 扫描器
|
||
CUSTOM = "custom" # 自定义设备
|
||
|
||
|
||
class VDA5050CommandType(Enum):
|
||
"""VDA5050协议指令类型"""
|
||
ORDER = "order" # 订单指令（仅小车）
|
||
STATE = "state" # 状态查询（仅小车）
|
||
FACTSHEET = "factsheet" # 设备信息（仅小车）
|
||
INSTANT_ACTIONS = "instantActions" # 即时动作（所有设备）
|
||
CONNECTION = "connection" # 连接管理
|
||
VISUALIZATION = "visualization" # 可视化
|
||
|
||
|
||
class ProtocolType(Enum):
|
||
"""协议类型"""
|
||
VDA5050 = "vda5050" # VDA5050协议（默认）
|
||
TCP = "tcp" # TCP协议
|
||
|
||
|
||
class DeviceBrand(Enum):
|
||
"""设备品牌枚举"""
|
||
HUARUI = "huarui" # 华睿
|
||
SEER = "seer" # 仙工
|
||
QUICKTRON = "quicktron" # 快仓
|
||
GEEK = "geek" # 极智嘉
|
||
MUSHINY = "mushiny" # 木蚁
|
||
FLASHHOLD = "flashhold" # 闪电匣
|
||
HIKROBOT = "hikrobot" # 海康机器人
|
||
STANDARD = "standard" # 标准协议
|
||
CUSTOM = "custom" # 自定义品牌
|
||
|
||
|
||
class DeviceProtocol:
|
||
"""设备协议定义基类"""
|
||
|
||
def __init__(self, brand: DeviceBrand, device_type: DeviceType,
|
||
protocol_type: ProtocolType = ProtocolType.VDA5050):
|
||
self.brand = brand
|
||
self.device_type = device_type
|
||
self.protocol_type = protocol_type
|
||
|
||
def encode_command(self, command_type: str, command: Dict[str, Any]) -> Dict[str, Any]:
|
||
"""将VDA5050标准指令编码为设备特定格式"""
|
||
raise NotImplementedError("子类必须实现encode_command方法")
|
||
|
||
def decode_response(self, message_type: str, response: Dict[str, Any]) -> Dict[str, Any]:
|
||
"""将设备响应解码为VDA5050标准格式"""
|
||
raise NotImplementedError("子类必须实现decode_response方法")
|
||
|
||
def validate_command(self, command_type: str, command: Dict[str, Any]) -> bool:
|
||
"""验证指令格式是否正确"""
|
||
return True
|
||
|
||
def get_supported_command_types(self) -> List[str]:
|
||
"""获取支持的VDA5050指令类型列表"""
|
||
if self.device_type == DeviceType.VEHICLE:
|
||
return [
|
||
VDA5050CommandType.ORDER.value,
|
||
VDA5050CommandType.STATE.value,
|
||
VDA5050CommandType.FACTSHEET.value,
|
||
VDA5050CommandType.INSTANT_ACTIONS.value
|
||
]
|
||
else:
|
||
# 其他设备只支持即时动作
|
||
return [VDA5050CommandType.INSTANT_ACTIONS.value]
|
||
|
||
|
||
class VDA5050Protocol(DeviceProtocol):
|
||
"""VDA5050协议实现（标准协议）"""
|
||
|
||
def __init__(self, brand: DeviceBrand = DeviceBrand.STANDARD, device_type: DeviceType = DeviceType.VEHICLE):
|
||
super().__init__(brand, device_type, ProtocolType.VDA5050)
|
||
|
||
def encode_command(self, command_type: str, command: Dict[str, Any]) -> Dict[str, Any]:
|
||
"""VDA5050标准指令编码"""
|
||
if command_type == VDA5050CommandType.ORDER.value:
|
||
return self._encode_order(command)
|
||
elif command_type == VDA5050CommandType.INSTANT_ACTIONS.value:
|
||
return self._encode_instant_actions(command)
|
||
elif command_type == VDA5050CommandType.STATE.value:
|
||
return self._encode_state_request(command)
|
||
elif command_type == VDA5050CommandType.FACTSHEET.value:
|
||
return self._encode_factsheet_request(command)
|
||
else:
|
||
return command
|
||
|
||
def decode_response(self, message_type: str, response: Dict[str, Any]) -> Dict[str, Any]:
|
||
"""VDA5050标准响应解码"""
|
||
if message_type == VDA5050CommandType.STATE.value:
|
||
return self._decode_state_response(response)
|
||
elif message_type == VDA5050CommandType.FACTSHEET.value:
|
||
return self._decode_factsheet_response(response)
|
||
else:
|
||
return response
|
||
|
||
def _encode_order(self, command: Dict[str, Any]) -> Dict[str, Any]:
|
||
"""编码VDA5050订单指令"""
|
||
return {
|
||
"headerId": command.get("header_id", f"order_{int(time.time())}"),
|
||
"timestamp": command.get("timestamp", datetime.now().isoformat()),
|
||
"version": command.get("version", "2.0.0"),
|
||
"manufacturer": self.brand.value,
|
||
"serialNumber": command.get("serial_number", ""),
|
||
"orderId": command.get("order_id", f"order_{int(time.time())}"),
|
||
"orderUpdateId": command.get("order_update_id", 0),
|
||
"zoneSetId": command.get("zone_set_id", ""),
|
||
"nodes": command.get("nodes", []),
|
||
"edges": command.get("edges", [])
|
||
}
|
||
|
||
def _encode_instant_actions(self, command: Dict[str, Any]) -> Dict[str, Any]:
|
||
"""编码VDA5050即时动作指令"""
|
||
actions = command.get("actions", [])
|
||
|
||
# 标准化动作格式
|
||
formatted_actions = []
|
||
for action in actions:
|
||
if isinstance(action, str):
|
||
# 简单字符串转换为标准VDA5050动作格式
|
||
formatted_actions.append({
|
||
"actionType": action,
|
||
"actionId": f"{action}_{int(time.time())}",
|
||
"actionDescription": f"{self.device_type.value} {action} action",
|
||
"blockingType": "SOFT"
|
||
})
|
||
else:
|
||
formatted_actions.append(action)
|
||
|
||
return {
|
||
"headerId": command.get("header_id", f"instant_{int(time.time())}"),
|
||
"timestamp": command.get("timestamp", datetime.now().isoformat()),
|
||
"version": command.get("version", "2.0.0"),
|
||
"manufacturer": self.brand.value,
|
||
"serialNumber": command.get("serial_number", ""),
|
||
"instantActions": formatted_actions
|
||
}
|
||
|
||
def _encode_state_request(self, command: Dict[str, Any]) -> Dict[str, Any]:
|
||
"""编码VDA5050状态请求"""
|
||
return {
|
||
"requestId": command.get("request_id", f"state_{int(time.time())}"),
|
||
"timestamp": command.get("timestamp", datetime.now().isoformat())
|
||
}
|
||
|
||
def _encode_factsheet_request(self, command: Dict[str, Any]) -> Dict[str, Any]:
|
||
"""编码VDA5050设备信息请求"""
|
||
return {
|
||
"requestId": command.get("request_id", f"factsheet_{int(time.time())}"),
|
||
"timestamp": command.get("timestamp", datetime.now().isoformat())
|
||
}
|
||
|
||
def _decode_state_response(self, response: Dict[str, Any]) -> Dict[str, Any]:
|
||
"""解码VDA5050状态响应"""
|
||
return {
|
||
"command_type": "state_response",
|
||
"order_id": response.get("orderId", ""),
|
||
"order_update_id": response.get("orderUpdateId", 0),
|
||
"last_node_id": response.get("lastNodeId", ""),
|
||
"last_node_sequence_id": response.get("lastNodeSequenceId", 0),
|
||
"driving": response.get("driving", False),
|
||
"paused": response.get("paused", False),
|
||
"new_base_request": response.get("newBaseRequest", False),
|
||
"distance_since_last_node": response.get("distanceSinceLastNode", 0.0),
|
||
"operating_mode": response.get("operatingMode", ""),
|
||
"node_states": response.get("nodeStates", []),
|
||
"edge_states": response.get("edgeStates", []),
|
||
"agv_position": response.get("agvPosition", {}),
|
||
"velocity": response.get("velocity", {}),
|
||
"loads": response.get("loads", []),
|
||
"action_states": response.get("actionStates", []),
|
||
"battery_state": response.get("batteryState", {}),
|
||
"safety_state": response.get("safetyState", {}),
|
||
"information": response.get("information", []),
|
||
"errors": response.get("errors", []),
|
||
"timestamp": response.get("timestamp", "")
|
||
}
|
||
|
||
def _decode_factsheet_response(self, response: Dict[str, Any]) -> Dict[str, Any]:
|
||
"""解码VDA5050设备信息响应"""
|
||
return {
|
||
"command_type": "factsheet_response",
|
||
"manufacturer": response.get("manufacturer", ""),
|
||
"serial_number": response.get("serialNumber", ""),
|
||
"type_specification": response.get("typeSpecification", {}),
|
||
"physical_parameters": response.get("physicalParameters", {}),
|
||
"protocol_limits": response.get("protocolLimits", {}),
|
||
"protocol_features": response.get("protocolFeatures", {}),
|
||
"agv_geometry": response.get("agvGeometry", {}),
|
||
"load_specification": response.get("loadSpecification", {}),
|
||
"timestamp": response.get("timestamp", "")
|
||
}
|
||
|
||
|
||
class TCPProtocol(DeviceProtocol):
|
||
"""TCP协议实现（VDA5050通过TCP传输）"""
|
||
|
||
def __init__(self, brand: DeviceBrand = DeviceBrand.STANDARD, device_type: DeviceType = DeviceType.VEHICLE):
|
||
super().__init__(brand, device_type, ProtocolType.TCP)
|
||
self.vda_protocol = VDA5050Protocol(brand, device_type)
|
||
|
||
def encode_command(self, command_type: str, command: Dict[str, Any]) -> Dict[str, Any]:
|
||
"""TCP协议编码（基于VDA5050）"""
|
||
# 先通过VDA5050协议编码
|
||
vda_data = self.vda_protocol.encode_command(command_type, command)
|
||
|
||
# 添加TCP传输包装
|
||
tcp_packet = {
|
||
"protocol": "vda5050",
|
||
"transport": "tcp",
|
||
"timestamp": datetime.now().isoformat(),
|
||
"data": vda_data
|
||
}
|
||
|
||
return tcp_packet
|
||
|
||
def decode_response(self, message_type: str, response: Dict[str, Any]) -> Dict[str, Any]:
|
||
"""TCP协议解码（基于VDA5050）"""
|
||
# 如果是TCP包装格式，提取VDA5050数据
|
||
if "data" in response and response.get("protocol") == "vda5050":
|
||
vda_data = response["data"]
|
||
return self.vda_protocol.decode_response(message_type, vda_data)
|
||
else:
|
||
# 直接作为VDA5050数据处理
|
||
return self.vda_protocol.decode_response(message_type, response)
|
||
|
||
|
||
class DeviceProtocolRegistry:
|
||
"""设备协议注册中心"""
|
||
|
||
def __init__(self):
|
||
self.protocols: Dict[str, DeviceProtocol] = {}
|
||
self._register_builtin_protocols()
|
||
|
||
def _register_builtin_protocols(self):
|
||
"""注册内置协议"""
|
||
# 默认VDA5050协议（适用于所有设备）
|
||
default_vda5050 = VDA5050Protocol()
|
||
self.register_protocol("vda5050", default_vda5050)
|
||
|
||
# 各品牌VDA5050协议
|
||
for brand in [DeviceBrand.HUARUI, DeviceBrand.SEER, DeviceBrand.QUICKTRON,
|
||
DeviceBrand.GEEK, DeviceBrand.MUSHINY, DeviceBrand.FLASHHOLD,
|
||
DeviceBrand.HIKROBOT]:
|
||
# 小车VDA5050协议
|
||
vehicle_protocol = VDA5050Protocol(brand, DeviceType.VEHICLE)
|
||
self.register_protocol(f"{brand.value}_vda5050", vehicle_protocol)
|
||
|
||
# TCP协议（基于VDA5050）
|
||
tcp_protocol = TCPProtocol(brand, DeviceType.VEHICLE)
|
||
self.register_protocol(f"{brand.value}_tcp", tcp_protocol)
|
||
|
||
# 非小车设备的VDA5050协议（即时动作）
|
||
for device_type in [DeviceType.DOOR, DeviceType.CALLER, DeviceType.LIFT,
|
||
DeviceType.CONVEYOR, DeviceType.SENSOR, DeviceType.CAMERA,
|
||
DeviceType.SCANNER, DeviceType.ROBOT, DeviceType.CUSTOM]:
|
||
vda_protocol = VDA5050Protocol(DeviceBrand.STANDARD, device_type)
|
||
self.register_protocol(f"{device_type.value}_vda5050", vda_protocol)
|
||
|
||
tcp_protocol = TCPProtocol(DeviceBrand.STANDARD, device_type)
|
||
self.register_protocol(f"{device_type.value}_tcp", tcp_protocol)
|
||
|
||
def register_protocol(self, protocol_key: str, protocol: DeviceProtocol):
|
||
"""注册设备协议"""
|
||
self.protocols[protocol_key] = protocol
|
||
logger.info(f"注册设备协议: {protocol_key} ({protocol.brand.value}_{protocol.device_type.value})")
|
||
|
||
def get_protocol(self, protocol_key: str) -> Optional[DeviceProtocol]:
|
||
"""获取设备协议"""
|
||
return self.protocols.get(protocol_key)
|
||
|
||
def get_protocol_by_brand_type(self, brand: Union[str, DeviceBrand],
|
||
device_type: Union[str, DeviceType]) -> Optional[DeviceProtocol]:
|
||
"""根据品牌和设备类型获取协议"""
|
||
if isinstance(brand, str):
|
||
brand = DeviceBrand(brand)
|
||
if isinstance(device_type, str):
|
||
device_type = DeviceType(device_type)
|
||
|
||
for protocol in self.protocols.values():
|
||
if protocol.brand == brand and protocol.device_type == device_type:
|
||
return protocol
|
||
return None
|
||
|
||
def list_protocols(self) -> Dict[str, Dict[str, str]]:
|
||
"""列出所有协议"""
|
||
return {
|
||
key: {
|
||
"brand": protocol.brand.value,
|
||
"device_type": protocol.device_type.value,
|
||
"supported_commands": protocol.get_supported_commands()
|
||
}
|
||
for key, protocol in self.protocols.items()
|
||
}
|
||
|
||
def register_custom_protocol(self, protocol_key: str, brand: str, device_type: str,
|
||
encode_func: Callable = None, decode_func: Callable = None):
|
||
"""注册自定义协议（基于VDA5050）"""
|
||
|
||
# 解析设备类型
|
||
try:
|
||
device_enum = DeviceType(device_type)
|
||
except ValueError:
|
||
device_enum = DeviceType.CUSTOM
|
||
|
||
# 解析品牌
|
||
try:
|
||
brand_enum = DeviceBrand(brand)
|
||
except ValueError:
|
||
brand_enum = DeviceBrand.CUSTOM
|
||
|
||
# 创建基于VDA5050的自定义协议
|
||
custom_protocol = VDA5050Protocol(brand_enum, device_enum)
|
||
|
||
# 如果提供了自定义编解码函数，包装协议
|
||
if encode_func or decode_func:
|
||
original_encode = custom_protocol.encode_command
|
||
original_decode = custom_protocol.decode_response
|
||
|
||
def custom_encode(command_type: str, command: Dict[str, Any]) -> Dict[str, Any]:
|
||
vda_result = original_encode(command_type, command)
|
||
if encode_func:
|
||
return encode_func(command_type, vda_result)
|
||
return vda_result
|
||
|
||
def custom_decode(message_type: str, response: Dict[str, Any]) -> Dict[str, Any]:
|
||
if decode_func:
|
||
processed_response = decode_func(message_type, response)
|
||
return original_decode(message_type, processed_response)
|
||
return original_decode(message_type, response)
|
||
|
||
custom_protocol.encode_command = custom_encode
|
||
custom_protocol.decode_response = custom_decode
|
||
|
||
self.register_protocol(protocol_key, custom_protocol)
|
||
|
||
|
||
# 全局协议注册中心
|
||
_global_protocol_registry = DeviceProtocolRegistry()
|
||
|
||
|
||
def get_protocol_registry() -> DeviceProtocolRegistry:
|
||
"""获取全局协议注册中心"""
|
||
return _global_protocol_registry
|
||
|
||
|
||
class MessagePriority(Enum):
|
||
"""消息优先级"""
|
||
LOW = 1
|
||
NORMAL = 2
|
||
HIGH = 3
|
||
CRITICAL = 4
|
||
|
||
|
||
@dataclass
|
||
class DeviceMessage:
|
||
"""设备消息数据结构"""
|
||
device_id: str
|
||
device_type: DeviceType
|
||
topic: str
|
||
payload: Dict[str, Any]
|
||
timestamp: float
|
||
priority: MessagePriority = MessagePriority.NORMAL
|
||
source_topic: Optional[str] = None
|
||
target_topics: Optional[List[str]] = None
|
||
processed: bool = False
|
||
retry_count: int = 0
|
||
max_retries: int = 3
|
||
|
||
def to_dict(self) -> Dict[str, Any]:
|
||
"""转换为字典格式"""
|
||
data = asdict(self)
|
||
data['device_type'] = self.device_type.value
|
||
data['priority'] = self.priority.value
|
||
return data
|
||
|
||
@classmethod
|
||
def from_dict(cls, data: Dict[str, Any]) -> 'DeviceMessage':
|
||
"""从字典创建消息对象"""
|
||
data['device_type'] = DeviceType(data['device_type'])
|
||
data['priority'] = MessagePriority(data['priority'])
|
||
return cls(**data)
|
||
|
||
|
||
@dataclass
|
||
class DeviceHandlerConfig:
|
||
"""设备处理器配置"""
|
||
device_id: str
|
||
device_type: DeviceType
|
||
listen_topics: List[str]
|
||
forward_topics: List[str]
|
||
handler_function: str
|
||
script_id: str
|
||
device_brand: Optional[DeviceBrand] = DeviceBrand.STANDARD # 设备品牌（默认标准）
|
||
protocol_type: ProtocolType = ProtocolType.VDA5050 # 协议类型（默认VDA5050）
|
||
# auto_encode: bool = True # 编解码功能已移除，消息直接透传
|
||
enabled: bool = True
|
||
auto_retry: bool = True
|
||
timeout_seconds: int = 30
|
||
batch_size: int = 1
|
||
description: str = ""
|
||
metadata: Dict[str, Any] = None
|
||
|
||
def __post_init__(self):
|
||
if self.metadata is None:
|
||
self.metadata = {}
|
||
|
||
# 已移除: protocol_key 方法，不再需要协议标识
|
||
|
||
|
||
|
||
class DeviceHandlerRegistry:
|
||
"""设备处理器注册中心"""
|
||
|
||
def __init__(self, use_async_mqtt: bool =True):
|
||
self.device_handlers: Dict[str, DeviceHandlerConfig] = {}
|
||
self.message_processors: Dict[str, Callable] = {}
|
||
self.topic_mappings: Dict[str, List[str]] = {} # topic -> device_ids
|
||
self.active_devices: Dict[str, Dict[str, Any]] = {}
|
||
self.message_queue: asyncio.Queue = asyncio.Queue()
|
||
self.processing_stats: Dict[str, Dict[str, Any]] = {}
|
||
|
||
# 选择MQTT服务类型
|
||
self.use_async_mqtt = use_async_mqtt
|
||
if use_async_mqtt:
|
||
self.mqtt_service = AsyncMQTTService()
|
||
logger.info("使用异步MQTT服务")
|
||
else:
|
||
self.mqtt_service = MQTTService()
|
||
logger.info("使用同步MQTT服务")
|
||
# self.protocol_registry = get_protocol_registry() # 已移除协议注册中心
|
||
|
||
def register_device_handler(self, config: DeviceHandlerConfig, processor: Callable):
|
||
"""注册并运行设备处理器"""
|
||
device_id = config.device_id
|
||
|
||
# 注册设备配置
|
||
self.device_handlers[device_id] = config
|
||
self.message_processors[device_id] = processor
|
||
|
||
# 建立topic映射
|
||
for topic in config.listen_topics:
|
||
if topic not in self.topic_mappings:
|
||
self.topic_mappings[topic] = []
|
||
if device_id not in self.topic_mappings[topic]:
|
||
self.topic_mappings[topic].append(device_id)
|
||
|
||
# 初始化统计信息
|
||
self.processing_stats[device_id] = {
|
||
"total_messages": 0,
|
||
"success_count": 0,
|
||
"error_count": 0,
|
||
"last_processed": None,
|
||
"average_processing_time_ms": None,
|
||
"registered_at": datetime.now().isoformat(),
|
||
"status": "running"
|
||
}
|
||
|
||
# 标记设备为活跃
|
||
self.active_devices[device_id] = {
|
||
"config": config,
|
||
"status": "running",
|
||
"last_heartbeat": time.time(),
|
||
"message_count": 0
|
||
}
|
||
|
||
brand_info = f" 品牌: {config.device_brand.value}" if config.device_brand else ""
|
||
# protocol_info = f" 协议: {config.protocol_key}" if config.protocol_key else "" # 已移除协议信息
|
||
|
||
logger.info(f"注册并运行设备处理器: {device_id} ({config.device_type.value}{brand_info})")
|
||
logger.info(f"监听topics: {config.listen_topics}")
|
||
logger.info(f"转发topics: {config.forward_topics}")
|
||
logger.info("消息透传模式: 已启用")
|
||
|
||
# 如果MQTT服务已连接，立即订阅topics
|
||
if self.mqtt_service.connected:
|
||
if self.use_async_mqtt:
|
||
# 异步MQTT需要在异步上下文中订阅
|
||
asyncio.create_task(self._subscribe_topics_async(config.listen_topics))
|
||
else:
|
||
self._subscribe_topics(config.listen_topics)
|
||
|
||
def unregister_device_handler(self, device_id: str):
|
||
"""停止并注销设备处理器"""
|
||
if device_id in self.device_handlers:
|
||
config = self.device_handlers[device_id]
|
||
|
||
# 只在MQTT连接时才尝试取消订阅topics（_unsubscribe_topics已内置连接检查）
|
||
self._unsubscribe_topics(config.listen_topics, device_id)
|
||
|
||
# 清理topic映射
|
||
for topic in config.listen_topics:
|
||
if topic in self.topic_mappings:
|
||
if device_id in self.topic_mappings[topic]:
|
||
self.topic_mappings[topic].remove(device_id)
|
||
if not self.topic_mappings[topic]:
|
||
del self.topic_mappings[topic]
|
||
|
||
# 清理注册信息
|
||
del self.device_handlers[device_id]
|
||
del self.message_processors[device_id]
|
||
if device_id in self.active_devices:
|
||
del self.active_devices[device_id]
|
||
if device_id in self.processing_stats:
|
||
del self.processing_stats[device_id]
|
||
|
||
logger.info(f"停止并注销设备处理器: {device_id}")
|
||
|
||
def _subscribe_topics(self, topics: List[str]):
|
||
"""订阅MQTT topics（同步版本）"""
|
||
for topic in topics:
|
||
# 为每个topic添加消息处理器
|
||
self.mqtt_service.add_message_handler(topic, self._handle_mqtt_message)
|
||
self.mqtt_service.subscribe(topic)
|
||
|
||
async def _subscribe_topics_async(self, topics: List[str]):
|
||
"""订阅MQTT topics（异步版本）"""
|
||
for topic in topics:
|
||
# 为每个topic添加消息处理器
|
||
self.mqtt_service.add_message_handler(topic, self._handle_mqtt_message_async)
|
||
await self.mqtt_service.subscribe(topic)
|
||
|
||
def _unsubscribe_topics(self, topics: List[str], device_id: str):
|
||
"""取消订阅MQTT topics"""
|
||
# 检查MQTT连接状态，避免在断开连接时产生警告
|
||
if not self.mqtt_service.connected:
|
||
logger.debug(f"MQTT未连接，跳过取消订阅: {topics}")
|
||
return
|
||
|
||
for topic in topics:
|
||
# 检查是否还有其他设备在监听这个topic
|
||
other_devices = [d for d in self.topic_mappings.get(topic, []) if d != device_id]
|
||
if not other_devices:
|
||
if self.use_async_mqtt:
|
||
# 异步MQTT需要创建任务来取消订阅
|
||
asyncio.create_task(self.mqtt_service.unsubscribe(topic))
|
||
else:
|
||
self.mqtt_service.unsubscribe(topic)
|
||
|
||
def get_handlers_for_topic(self, topic: str) -> List[str]:
|
||
"""获取处理指定topic的设备ID列表"""
|
||
return self.topic_mappings.get(topic, [])
|
||
|
||
def get_device_config(self, device_id: str) -> Optional[DeviceHandlerConfig]:
|
||
"""获取设备配置"""
|
||
return self.device_handlers.get(device_id)
|
||
|
||
def get_device_processor(self, device_id: str) -> Optional[Callable]:
|
||
"""获取设备处理器"""
|
||
return self.message_processors.get(device_id)
|
||
|
||
def _handle_mqtt_message(self, topic: str, payload: str):
|
||
"""处理MQTT消息"""
|
||
try:
|
||
# 获取当前事件循环，如果没有则创建新的
|
||
try:
|
||
loop = asyncio.get_running_loop()
|
||
# 在当前循环中创建任务
|
||
asyncio.create_task(self.handle_mqtt_message(topic, payload))
|
||
except RuntimeError:
|
||
# 没有运行中的事件循环，使用线程安全的方式
|
||
def run_async():
|
||
# 在新线程中运行异步处理
|
||
asyncio.run(self.handle_mqtt_message(topic, payload))
|
||
|
||
# 创建并启动线程
|
||
thread = threading.Thread(target=run_async, daemon=True)
|
||
thread.start()
|
||
except Exception as e:
|
||
logger.error(f"处理MQTT消息异常: {e}", exc_info=True)
|
||
|
||
async def _handle_mqtt_message_async(self, topic: str, payload: str):
|
||
"""处理MQTT消息（异步版本）"""
|
||
await self.handle_mqtt_message(topic, payload)
|
||
|
||
async def handle_mqtt_message(self, topic: str, payload: Union[str, bytes, Dict[str, Any]]):
|
||
"""处理MQTT消息"""
|
||
try:
|
||
# 解析payload
|
||
if isinstance(payload, (str, bytes)):
|
||
payload_data = json.loads(payload)
|
||
else:
|
||
payload_data = payload
|
||
|
||
# 获取处理该topic的设备列表
|
||
device_ids = self.get_handlers_for_topic(topic)
|
||
|
||
for device_id in device_ids:
|
||
config = self.get_device_config(device_id)
|
||
if config and config.enabled:
|
||
decoded_payload = payload_data
|
||
|
||
# 创建设备消息
|
||
message = DeviceMessage(
|
||
device_id=device_id,
|
||
device_type=config.device_type,
|
||
topic=topic,
|
||
payload=decoded_payload,
|
||
timestamp=time.time(),
|
||
source_topic=topic,
|
||
target_topics=config.forward_topics
|
||
)
|
||
|
||
# 立即处理消息
|
||
await self._process_device_message(message)
|
||
|
||
except json.JSONDecodeError as e:
|
||
logger.error(f"MQTT消息JSON解析失败: {e}, topic: {topic}, payload: {payload}")
|
||
except Exception as e:
|
||
logger.error(f"处理MQTT消息失败: {e}", exc_info=True)
|
||
|
||
async def _process_device_message(self, message: DeviceMessage):
|
||
"""处理单个设备消息"""
|
||
device_id = message.device_id
|
||
config = self.device_handlers.get(device_id)
|
||
processor = self.message_processors.get(device_id)
|
||
|
||
if not config or not processor:
|
||
logger.warning(f"未找到设备处理器: {device_id}")
|
||
return
|
||
|
||
if not config.enabled:
|
||
logger.debug(f"设备处理器已禁用: {device_id}")
|
||
return
|
||
|
||
start_time = time.time()
|
||
try:
|
||
# 更新统计信息
|
||
stats = self.processing_stats[device_id]
|
||
stats["total_messages"] += 1
|
||
|
||
# 执行处理器
|
||
if asyncio.iscoroutinefunction(processor):
|
||
result = await processor(message)
|
||
else:
|
||
result = processor(message)
|
||
|
||
# 处理成功
|
||
stats["success_count"] += 1
|
||
stats["last_processed"] = datetime.now().isoformat()
|
||
message.processed = True
|
||
|
||
# 更新设备心跳
|
||
if device_id in self.active_devices:
|
||
self.active_devices[device_id]["last_heartbeat"] = time.time()
|
||
self.active_devices[device_id]["message_count"] += 1
|
||
|
||
# 计算平均处理时间
|
||
processing_time_ms = int((time.time() - start_time) * 1000)
|
||
if stats["average_processing_time_ms"] is None:
|
||
stats["average_processing_time_ms"] = processing_time_ms
|
||
else:
|
||
total_time = (stats["average_processing_time_ms"] *
|
||
(stats["success_count"] - 1) + processing_time_ms)
|
||
stats["average_processing_time_ms"] = int(total_time / stats["success_count"])
|
||
|
||
# 处理转发逻辑
|
||
if result and isinstance(result, dict):
|
||
await self._handle_message_result(message, result)
|
||
|
||
logger.debug(f"设备消息处理成功: {device_id}, 耗时: {processing_time_ms}ms")
|
||
|
||
except Exception as e:
|
||
# 处理失败
|
||
stats["error_count"] += 1
|
||
logger.error(f"设备消息处理失败: {device_id}, 错误: {e}", exc_info=True)
|
||
|
||
async def _handle_message_result(self, original_message: DeviceMessage, result: Dict[str, Any]):
|
||
"""处理消息处理结果"""
|
||
try:
|
||
config = self.device_handlers.get(original_message.device_id)
|
||
if not config:
|
||
return
|
||
|
||
# 检查是否需要转发
|
||
if result.get("forward", True):
|
||
# 确定转发的payload
|
||
forward_payload = result.get("payload", original_message.payload)
|
||
|
||
# 直接使用转发payload，不进行编码
|
||
encoded_payload = forward_payload
|
||
|
||
# 确定转发的topics
|
||
forward_topics = result.get("topics", original_message.target_topics)
|
||
if isinstance(forward_topics, str):
|
||
forward_topics = [forward_topics]
|
||
|
||
# 转发到所有目标topics
|
||
if forward_topics:
|
||
for topic in forward_topics:
|
||
self._publish_mqtt_message(topic, encoded_payload)
|
||
logger.debug(f"消息已转发: {original_message.device_id} -> {topic}")
|
||
|
||
# 处理自定义响应
|
||
if "response" in result:
|
||
response_topic = result.get("response_topic")
|
||
response_payload = result["response"]
|
||
|
||
# 直接使用响应payload，不进行编码
|
||
|
||
if response_topic:
|
||
self._publish_mqtt_message(response_topic, response_payload)
|
||
logger.debug(f"响应已发送: {original_message.device_id} -> {response_topic}")
|
||
|
||
except Exception as e:
|
||
logger.error(f"处理消息结果失败: {e}", exc_info=True)
|
||
|
||
def _publish_mqtt_message(self, topic: str, payload: Any):
|
||
"""发布MQTT消息"""
|
||
if self.use_async_mqtt:
|
||
# 对于异步MQTT，创建异步任务
|
||
asyncio.create_task(self.mqtt_service.publish(topic, payload))
|
||
else:
|
||
self.mqtt_service.publish(topic, payload)
|
||
|
||
async def start_mqtt_service(self):
|
||
"""启动内部MQTT服务"""
|
||
try:
|
||
if self.use_async_mqtt:
|
||
success = await self.mqtt_service.connect()
|
||
else:
|
||
success = self.mqtt_service.connect()
|
||
|
||
if success:
|
||
logger.info("内部MQTT服务已启动")
|
||
|
||
# 为已注册的设备订阅topics
|
||
all_topics = set()
|
||
for config in self.device_handlers.values():
|
||
all_topics.update(config.listen_topics)
|
||
|
||
if all_topics:
|
||
if self.use_async_mqtt:
|
||
await self._subscribe_topics_async(list(all_topics))
|
||
else:
|
||
self._subscribe_topics(list(all_topics))
|
||
return True
|
||
else:
|
||
logger.error("启动内部MQTT服务失败")
|
||
return False
|
||
except Exception as e:
|
||
logger.error(f"启动MQTT服务异常: {e}", exc_info=True)
|
||
return False
|
||
|
||
async def stop_mqtt_service(self):
|
||
"""停止内部MQTT服务"""
|
||
try:
|
||
if self.use_async_mqtt:
|
||
await self.mqtt_service.disconnect()
|
||
else:
|
||
self.mqtt_service.disconnect()
|
||
logger.info("内部MQTT服务已停止")
|
||
except Exception as e:
|
||
logger.error(f"停止MQTT服务异常: {e}", exc_info=True)
|
||
|
||
def get_device_statistics(self, device_id: str = None) -> Dict[str, Any]:
|
||
"""获取设备统计信息"""
|
||
if device_id:
|
||
stats = self.processing_stats.get(device_id, {}).copy()
|
||
if device_id in self.active_devices:
|
||
stats.update({
|
||
"device_status": self.active_devices[device_id]["status"],
|
||
"last_heartbeat": self.active_devices[device_id]["last_heartbeat"],
|
||
"message_count": self.active_devices[device_id]["message_count"]
|
||
})
|
||
return stats
|
||
else:
|
||
return {
|
||
"device_count": len(self.device_handlers),
|
||
"running_devices": len([d for d in self.active_devices.values()
|
||
if d["status"] == "running"]),
|
||
"total_topics": len(self.topic_mappings),
|
||
"devices": {device_id: self.get_device_statistics(device_id)
|
||
for device_id in self.device_handlers.keys()}
|
||
}
|
||
|
||
def clear_script_device_registrations(self, script_id: str):
|
||
"""清理指定脚本的所有设备注册"""
|
||
devices_to_remove = []
|
||
for device_id, config in self.device_handlers.items():
|
||
if config.script_id == script_id:
|
||
devices_to_remove.append(device_id)
|
||
|
||
for device_id in devices_to_remove:
|
||
self.unregister_device_handler(device_id)
|
||
|
||
logger.info(f"已清理脚本 {script_id} 的 {len(devices_to_remove)} 个设备注册")
|
||
|
||
|
||
# 全局设备处理器注册中心
|
||
_global_device_registry = DeviceHandlerRegistry()
|
||
|
||
|
||
def get_device_registry() -> DeviceHandlerRegistry:
|
||
"""获取全局设备注册中心实例"""
|
||
return _global_device_registry
|
||
|
||
|
||
class DeviceHandlerService:
|
||
"""设备处理器服务"""
|
||
|
||
def __init__(self):
|
||
self.registry = get_device_registry()
|
||
|
||
async def start_service(self):
|
||
"""启动设备处理服务"""
|
||
if await self.registry.start_mqtt_service():
|
||
logger.info("设备处理服务已启动，MQTT服务已连接")
|
||
else:
|
||
logger.warning("设备处理服务已启动，但MQTT连接失败")
|
||
|
||
async def stop_service(self):
|
||
"""停止设备处理服务"""
|
||
# 先清理所有设备注册（这会取消订阅topics）
|
||
device_ids = list(self.registry.device_handlers.keys())
|
||
for device_id in device_ids:
|
||
self.registry.unregister_device_handler(device_id)
|
||
|
||
# 最后停止MQTT服务
|
||
await self.registry.stop_mqtt_service()
|
||
|
||
logger.info("设备处理服务已停止")
|
||
|
||
def register_and_run(self, device_id: str, device_type: Union[str, DeviceType],
|
||
listen_topics: List[str], forward_topics: List[str],
|
||
handler: Callable, script_id: str, description: str = "",
|
||
device_brand: Union[str, DeviceBrand] = DeviceBrand.STANDARD,
|
||
protocol_type: Union[str, ProtocolType] = ProtocolType.VDA5050,
|
||
protocol_key: str = "vda5050", # 兼容性参数，默认值
|
||
**kwargs):
|
||
"""注册并运行设备处理器（消息直接透传）
|
||
|
||
Args:
|
||
device_id: 设备ID
|
||
device_type: 设备类型
|
||
listen_topics: 监听的MQTT topics
|
||
forward_topics: 转发的MQTT topics
|
||
handler: 消息处理器函数
|
||
script_id: 脚本ID
|
||
description: 描述信息
|
||
device_brand: 设备品牌（默认standard）
|
||
protocol_type: 协议类型（vda5050或tcp，默认vda5050）
|
||
protocol_key: 协议标识（已弃用，兼容性参数）
|
||
**kwargs: 其他配置参数
|
||
"""
|
||
|
||
# 确保device_type是DeviceType枚举
|
||
if isinstance(device_type, str):
|
||
device_type = DeviceType(device_type)
|
||
|
||
# 处理设备品牌
|
||
if isinstance(device_brand, str):
|
||
try:
|
||
device_brand = DeviceBrand(device_brand)
|
||
except ValueError:
|
||
logger.warning(f"未知的设备品牌: {device_brand}, 使用STANDARD品牌")
|
||
device_brand = DeviceBrand.STANDARD
|
||
|
||
# 处理协议类型
|
||
if isinstance(protocol_type, str):
|
||
try:
|
||
protocol_type = ProtocolType(protocol_type)
|
||
except ValueError:
|
||
logger.warning(f"未知的协议类型: {protocol_type}, 使用VDA5050协议")
|
||
protocol_type = ProtocolType.VDA5050
|
||
|
||
# 过滤掉已弃用的兼容性参数
|
||
if protocol_key != "vda5050" and protocol_key:
|
||
logger.warning(f"protocol_key参数已弃用，使用默认VDA5050协议: {protocol_key}")
|
||
|
||
# 过滤kwargs中的兼容性参数（包括可能传入的auto_encode）
|
||
filtered_kwargs = {k: v for k, v in kwargs.items()
|
||
if k not in ['protocol_key', 'auto_encode']}
|
||
|
||
config = DeviceHandlerConfig(
|
||
device_id=device_id,
|
||
device_type=device_type,
|
||
listen_topics=listen_topics,
|
||
forward_topics=forward_topics,
|
||
handler_function=handler.__name__,
|
||
script_id=script_id,
|
||
description=description,
|
||
device_brand=device_brand,
|
||
protocol_type=protocol_type,
|
||
**filtered_kwargs
|
||
)
|
||
|
||
self.registry.register_device_handler(config, handler)
|
||
|
||
def stop_handler(self, device_id: str):
|
||
"""停止指定设备处理器"""
|
||
self.registry.unregister_device_handler(device_id)
|
||
|
||
def get_running_handlers(self) -> Dict[str, Any]:
|
||
"""获取所有正在运行的设备处理器"""
|
||
return self.registry.get_device_statistics()
|
||
|
||
def get_handler_status(self, device_id: str) -> Dict[str, Any]:
|
||
"""获取设备处理器状态"""
|
||
return self.registry.get_device_statistics(device_id)
|
||
|
||
async def publish_message(self, topic: str, payload: Any):
|
||
"""主动发布MQTT消息
|
||
|
||
Args:
|
||
topic: MQTT主题
|
||
payload: 消息载荷
|
||
"""
|
||
self.registry._publish_mqtt_message(topic, payload)
|
||
|
||
def send_order(self, device_id: str, order_data: Dict[str, Any], topic: str = None) -> None:
|
||
"""发送订单消息
|
||
|
||
Args:
|
||
device_id: 设备ID
|
||
order_data: 订单数据
|
||
topic: 发布主题（可选，默认使用vda5050格式）
|
||
"""
|
||
import asyncio
|
||
|
||
if not topic:
|
||
topic = f"vda5050/{device_id}/order"
|
||
|
||
asyncio.create_task(
|
||
self.publish_message(topic, order_data)
|
||
)
|
||
|
||
def send_instant_action(self, device_id: str, actions: Union[List[str], List[Dict[str, Any]]],
|
||
topic: str = None) -> None:
|
||
"""发送即时动作消息
|
||
|
||
Args:
|
||
device_id: 设备ID
|
||
actions: 动作列表
|
||
topic: 发布主题（可选，默认使用vda5050格式）
|
||
"""
|
||
import asyncio
|
||
|
||
if not topic:
|
||
topic = f"vda5050/{device_id}/instantActions"
|
||
|
||
action_data = {"actions": actions}
|
||
asyncio.create_task(
|
||
self.publish_message(topic, action_data)
|
||
)
|
||
|
||
def request_state(self, device_id: str, topic: str = None) -> None:
|
||
"""请求设备状态
|
||
|
||
Args:
|
||
device_id: 设备ID
|
||
topic: 发布主题（可选，默认使用vda5050格式）
|
||
"""
|
||
import asyncio
|
||
|
||
if not topic:
|
||
topic = f"vda5050/{device_id}/state"
|
||
|
||
state_request = {"request_type": "state"}
|
||
asyncio.create_task(
|
||
self.publish_message(topic, state_request)
|
||
)
|
||
|
||
def request_factsheet(self, device_id: str, topic: str = None) -> None:
|
||
"""请求设备信息
|
||
|
||
Args:
|
||
device_id: 设备ID
|
||
topic: 发布主题（可选，默认使用vda5050格式）
|
||
"""
|
||
import asyncio
|
||
|
||
if not topic:
|
||
topic = f"vda5050/{device_id}/factsheet"
|
||
|
||
factsheet_request = {"request_type": "factsheet"}
|
||
asyncio.create_task(
|
||
self.publish_message(topic, factsheet_request)
|
||
)
|
||
|
||
# 保持兼容性的别名方法
|
||
def send_vda5050_order(self, device_id: str, order_data: Dict[str, Any], topic: str = None) -> None:
|
||
"""发送VDA5050订单指令（兼容性方法）"""
|
||
self.send_order(device_id, order_data, topic)
|
||
|
||
def send_vda5050_instant_action(self, device_id: str, actions: List[Dict[str, Any]], topic: str = None) -> None:
|
||
"""发送VDA5050即时动作指令（兼容性方法）"""
|
||
self.send_instant_action(device_id, actions, topic)
|
||
|
||
def request_vda5050_state(self, device_id: str, topic: str = None) -> None:
|
||
"""请求VDA5050状态（兼容性方法）"""
|
||
self.request_state(device_id, topic)
|
||
|
||
|
||
# 全局设备处理服务实例
|
||
_global_device_service = DeviceHandlerService()
|
||
|
||
|
||
def get_device_service() -> DeviceHandlerService:
|
||
"""获取全局设备处理服务实例"""
|
||
return _global_device_service |