868 lines
31 KiB
Python
868 lines
31 KiB
Python
#!/usr/bin/env python
|
||
# -*- coding: utf-8 -*-
|
||
|
||
"""
|
||
VWED统一对象模块系统
|
||
提供脚本中可使用的VWED.api、VWED.function等统一接口
|
||
"""
|
||
|
||
import asyncio
|
||
from typing import Dict, Any, Optional, Callable, List, Union
|
||
from .script_registry_service import get_global_registry
|
||
from .script_websocket_service import get_websocket_manager
|
||
from .device_handler_service import get_device_service, DeviceType, DeviceBrand, get_protocol_registry
|
||
from utils.logger import get_logger
|
||
|
||
logger = get_logger("services.script_vwed_objects")
|
||
|
||
|
||
class VWEDApiModule:
|
||
"""VWED.api 模块 - API接口注册"""
|
||
|
||
def __init__(self, script_id: str):
|
||
self.script_id = script_id
|
||
self.registry = get_global_registry()
|
||
|
||
def register_route(self, path: str, method: str = "GET", handler: Callable = None,
|
||
description: str = "", params: Dict = None,
|
||
parameters: Dict = None, response_schema: Dict = None):
|
||
"""分离式API接口注册（用户要求的新格式）
|
||
|
||
使用方式：
|
||
VWED.api.register_route(
|
||
path="/calculate",
|
||
method="POST",
|
||
handler=calculate_handler,
|
||
description="数学计算接口",
|
||
params={"a": 0, "b": 0, "operation": "add"} # 简化的参数定义
|
||
)
|
||
"""
|
||
# 验证HTTP方法
|
||
valid_methods = ["GET", "POST", "PUT", "DELETE"]
|
||
if method.upper() not in valid_methods:
|
||
raise ValueError(f"method参数错误：'{method}' 不是有效的HTTP请求方式。支持的方式有：{', '.join(valid_methods)}")
|
||
|
||
if handler is None:
|
||
raise ValueError("handler参数不能为空")
|
||
|
||
self.registry.register_api_route(
|
||
path=path,
|
||
method=method.upper(),
|
||
handler=handler,
|
||
script_id=self.script_id,
|
||
description=description,
|
||
params=params, # 传递简化的参数格式
|
||
parameters=parameters,
|
||
response_schema=response_schema
|
||
)
|
||
return handler
|
||
|
||
|
||
class VWEDFunctionModule:
|
||
"""VWED.function 模块 - 自定义函数注册"""
|
||
|
||
def __init__(self, script_id: str):
|
||
self.script_id = script_id
|
||
self.registry = get_global_registry()
|
||
|
||
def register(self, name: str, handler: Callable = None, description: str = "",
|
||
params: Dict = None, parameters: List[Dict] = None,
|
||
return_schema: Dict = None, tags: List[str] = None):
|
||
"""分离式自定义函数注册
|
||
|
||
使用方式：
|
||
VWED.function.register(
|
||
name="simple_add",
|
||
handler=simple_add,
|
||
description="简单加法函数",
|
||
params={"a": 0, "b": 0} # 简化的参数定义
|
||
)
|
||
"""
|
||
if handler is None:
|
||
raise ValueError("handler参数不能为空")
|
||
|
||
self.registry.register_function(
|
||
name=name,
|
||
handler=handler,
|
||
script_id=self.script_id,
|
||
description=description,
|
||
params=params, # 传递简化的参数格式
|
||
parameters=parameters,
|
||
return_schema=return_schema,
|
||
tags=tags
|
||
)
|
||
return handler
|
||
|
||
|
||
class VWEDEventModule:
|
||
"""VWED.event 模块 - 事件系统"""
|
||
|
||
def __init__(self, script_id: str):
|
||
self.script_id = script_id
|
||
self.registry = get_global_registry()
|
||
|
||
def listen(self, event_name: str, handler: Callable, priority: int = 1):
|
||
"""注册事件监听器
|
||
|
||
分离式模式：
|
||
VWED.event.listen(
|
||
event_name="user_login",
|
||
handler=on_user_login
|
||
)
|
||
"""
|
||
def decorator(func: Callable):
|
||
self.registry.register_event_listener(
|
||
event_name=event_name,
|
||
handler=func,
|
||
script_id=self.script_id,
|
||
priority=priority
|
||
)
|
||
return func
|
||
|
||
return decorator(handler)
|
||
|
||
|
||
async def emit(self, event_name: str, data: Dict[str, Any]):
|
||
"""触发事件"""
|
||
await self.registry.emit_event(event_name, data)
|
||
|
||
def on(self, event_name: str, priority: int = 1):
|
||
"""listen的别名"""
|
||
return self.listen(event_name, priority=priority)
|
||
|
||
|
||
class VWEDTimerModule:
|
||
"""VWED.timer 模块 - 定时任务"""
|
||
|
||
def __init__(self, script_id: str):
|
||
self.script_id = script_id
|
||
self.registry = get_global_registry()
|
||
|
||
def interval(self, seconds: int, handler: Callable, repeat: bool = True, delay: int = 0):
|
||
"""注册定时任务
|
||
分离式模式：
|
||
VWED.timer.interval(
|
||
seconds=60,
|
||
handler=system_monitor
|
||
)
|
||
"""
|
||
def decorator(func: Callable):
|
||
timer_id = f"{self.script_id}_{func.__name__}_{id(func)}"
|
||
self.registry.register_timer(
|
||
timer_id=timer_id,
|
||
interval=seconds,
|
||
handler=func,
|
||
script_id=self.script_id,
|
||
repeat=repeat,
|
||
delay=delay
|
||
)
|
||
return func
|
||
|
||
# if handler is not None:
|
||
# 分离式调用模式
|
||
return decorator(handler)
|
||
# else:
|
||
# # 装饰器模式
|
||
# return decorator
|
||
|
||
def once(self, delay: int = 0, handler: Callable = None):
|
||
"""注册一次性定时任务
|
||
分离式模式：
|
||
VWED.timer.once(
|
||
delay=10,
|
||
handler=initialization_task
|
||
)
|
||
"""
|
||
return self.interval(0, handler=handler, repeat=False, delay=delay)
|
||
|
||
# def every(self, seconds: int):
|
||
# """interval的别名"""
|
||
# return self.interval(seconds)
|
||
|
||
|
||
class VWEDLogModule:
|
||
"""VWED.log 模块 - 日志系统"""
|
||
|
||
def __init__(self, script_id: str):
|
||
self.script_id = script_id
|
||
self.websocket_manager = get_websocket_manager()
|
||
|
||
async def info(self, message: str, **kwargs):
|
||
"""输出信息日志"""
|
||
await self.websocket_manager.broadcast_script_log(
|
||
self.script_id, "INFO", message, **kwargs
|
||
)
|
||
|
||
async def warning(self, message: str, **kwargs):
|
||
"""输出警告日志"""
|
||
await self.websocket_manager.broadcast_script_log(
|
||
self.script_id, "WARNING", message, **kwargs
|
||
)
|
||
|
||
async def error(self, message: str, **kwargs):
|
||
"""输出错误日志"""
|
||
await self.websocket_manager.broadcast_script_log(
|
||
self.script_id, "ERROR", message, **kwargs
|
||
)
|
||
|
||
async def debug(self, message: str, **kwargs):
|
||
"""输出调试日志"""
|
||
await self.websocket_manager.broadcast_script_log(
|
||
self.script_id, "DEBUG", message, **kwargs
|
||
)
|
||
|
||
def sync_info(self, message: str, **kwargs):
|
||
"""同步方式输出信息日志"""
|
||
asyncio.create_task(self.info(message, **kwargs))
|
||
|
||
def sync_warning(self, message: str, **kwargs):
|
||
"""同步方式输出警告日志"""
|
||
asyncio.create_task(self.warning(message, **kwargs))
|
||
|
||
def sync_error(self, message: str, **kwargs):
|
||
"""同步方式输出错误日志"""
|
||
asyncio.create_task(self.error(message, **kwargs))
|
||
|
||
def sync_debug(self, message: str, **kwargs):
|
||
"""同步方式输出调试日志"""
|
||
asyncio.create_task(self.debug(message, **kwargs))
|
||
|
||
|
||
class VWEDTaskModule:
|
||
"""VWED.task 模块 - 任务系统集成"""
|
||
|
||
def __init__(self, script_id: str):
|
||
self.script_id = script_id
|
||
self.logger = get_logger(f"script.{script_id}.task")
|
||
|
||
async def create_task(
|
||
self,
|
||
label: str,
|
||
task_type: int = 1,
|
||
remark: Optional[str] = None,
|
||
period: Optional[int] = None,
|
||
delay: Optional[int] = 3000,
|
||
release_sites: Optional[bool] = True,
|
||
tenant_id: str = "default",
|
||
map_id: Optional[str] = None,
|
||
auto_get_token: bool = True
|
||
) -> Dict[str, Any]:
|
||
"""创建VWED任务
|
||
|
||
Args:
|
||
label: 任务名称
|
||
task_type: 任务类型，1-普通任务，2-定时任务
|
||
remark: 任务备注
|
||
period: 周期时间（毫秒），定时任务必填
|
||
delay: 延迟时间（毫秒），默认3000
|
||
release_sites: 是否释放站点，默认true
|
||
tenant_id: 租户ID，默认"default"
|
||
map_id: 相关地图ID
|
||
auto_get_token: 是否自动获取登录token，默认true
|
||
|
||
Returns:
|
||
Dict[str, Any]: 创建结果
|
||
"""
|
||
try:
|
||
from services.task_service import TaskService, TaskNameExistsError
|
||
from data.session import get_db
|
||
|
||
# 获取登录token
|
||
token = None
|
||
if auto_get_token:
|
||
try:
|
||
from services.sync_service import refresh_token_if_needed
|
||
token = await refresh_token_if_needed()
|
||
if token:
|
||
self.logger.info(f"脚本 {self.script_id} 成功获取到登录token")
|
||
else:
|
||
self.logger.warning(f"脚本 {self.script_id} 获取登录token失败，继续使用空token")
|
||
except Exception as e:
|
||
self.logger.warning(f"脚本 {self.script_id} 获取token异常: {str(e)}，继续使用空token")
|
||
|
||
# 获取数据库会话
|
||
db = next(get_db())
|
||
|
||
try:
|
||
# 调用TaskService.create_task方法
|
||
result = TaskService.create_task(
|
||
db=db,
|
||
label=label,
|
||
task_type=task_type,
|
||
remark=remark,
|
||
period=period,
|
||
delay=delay,
|
||
release_sites=release_sites,
|
||
token=token, # 使用获取到的token
|
||
tenant_id=tenant_id,
|
||
map_id=map_id
|
||
)
|
||
|
||
self.logger.info(f"脚本 {self.script_id} 成功创建任务: {label} (ID: {result['id']})")
|
||
return {
|
||
"success": True,
|
||
"message": "任务创建成功",
|
||
"data": result
|
||
}
|
||
|
||
except TaskNameExistsError as e:
|
||
self.logger.warning(f"脚本 {self.script_id} 创建任务失败: {str(e)}")
|
||
return {
|
||
"success": False,
|
||
"message": f"任务名称已存在: {str(e)}",
|
||
"error_type": "name_exists"
|
||
}
|
||
except Exception as e:
|
||
self.logger.error(f"脚本 {self.script_id} 创建任务失败: {str(e)}")
|
||
return {
|
||
"success": False,
|
||
"message": f"创建任务失败: {str(e)}",
|
||
"error_type": "create_error"
|
||
}
|
||
finally:
|
||
db.close()
|
||
|
||
except Exception as e:
|
||
self.logger.error(f"脚本 {self.script_id} 任务创建异常: {str(e)}")
|
||
return {
|
||
"success": False,
|
||
"message": f"任务创建异常: {str(e)}",
|
||
"error_type": "system_error"
|
||
}
|
||
|
||
async def execute_task(
|
||
self,
|
||
task_id: str,
|
||
parameters: Optional[List[Dict[str, Any]]] = None,
|
||
source_system: str = "script",
|
||
source_device: Optional[str] = None,
|
||
auto_get_token: bool = True
|
||
) -> Dict[str, Any]:
|
||
"""执行VWED任务
|
||
|
||
Args:
|
||
task_id: 任务ID
|
||
parameters: 任务输入参数列表
|
||
source_system: 来源系统，默认"script"
|
||
source_device: 来源设备标识
|
||
auto_get_token: 是否自动获取登录token，默认true
|
||
|
||
Returns:
|
||
Dict[str, Any]: 执行结果
|
||
"""
|
||
try:
|
||
from services.task_edit_service import TaskEditService
|
||
from routes.model.task_edit_model import TaskEditRunRequest, TaskInputParam
|
||
from data.enum.task_record_enum import SourceType
|
||
|
||
# 获取登录token
|
||
token = None
|
||
if auto_get_token:
|
||
try:
|
||
from services.sync_service import refresh_token_if_needed
|
||
token = await refresh_token_if_needed()
|
||
if token:
|
||
self.logger.info(f"脚本 {self.script_id} 成功获取到登录token")
|
||
else:
|
||
self.logger.warning(f"脚本 {self.script_id} 获取登录token失败，继续使用空token")
|
||
except Exception as e:
|
||
self.logger.warning(f"脚本 {self.script_id} 获取token异常: {str(e)}，继续使用空token")
|
||
|
||
# 构建运行请求
|
||
input_params = []
|
||
if parameters:
|
||
for param in parameters:
|
||
if isinstance(param, dict) and "name" in param and "defaultValue" in param:
|
||
input_params.append(TaskInputParam(
|
||
name=param["name"],
|
||
defaultValue=param["defaultValue"]
|
||
))
|
||
|
||
run_request = TaskEditRunRequest(
|
||
taskId=task_id,
|
||
params=input_params,
|
||
source_type=SourceType.SYSTEM_SCHEDULING,
|
||
source_system=source_system,
|
||
source_device=source_device or f"script_{self.script_id}"
|
||
)
|
||
|
||
# 调用TaskEditService.run_task方法
|
||
result = await TaskEditService.run_task(
|
||
run_request=run_request,
|
||
client_ip="127.0.0.1", # 本地脚本调用
|
||
client_info=f"{{\"script_id\": \"{self.script_id}\", \"source\": \"VWED.task.execute_task\"}}",
|
||
tf_api_token=token # 使用获取到的token
|
||
)
|
||
|
||
if result and result.get("success"):
|
||
self.logger.info(f"脚本 {self.script_id} 成功启动任务: {task_id}")
|
||
return {
|
||
"success": True,
|
||
"message": "任务启动成功",
|
||
"data": result
|
||
}
|
||
else:
|
||
error_msg = result.get("message", "任务启动失败") if result else "任务启动失败"
|
||
self.logger.error(f"脚本 {self.script_id} 启动任务失败: {error_msg}")
|
||
return {
|
||
"success": False,
|
||
"message": error_msg,
|
||
"error_type": "execute_error"
|
||
}
|
||
|
||
except Exception as e:
|
||
self.logger.error(f"脚本 {self.script_id} 执行任务异常: {str(e)}")
|
||
return {
|
||
"success": False,
|
||
"message": f"执行任务异常: {str(e)}",
|
||
"error_type": "system_error"
|
||
}
|
||
|
||
async def get_task_status(self, task_record_id: str) -> Dict[str, Any]:
|
||
"""获取任务执行状态
|
||
|
||
Args:
|
||
task_record_id: 任务记录ID（不是任务定义ID）
|
||
|
||
Returns:
|
||
Dict[str, Any]: 任务状态信息
|
||
"""
|
||
try:
|
||
from data.session import get_async_session
|
||
from data.models.taskrecord import VWEDTaskRecord
|
||
from sqlalchemy import select
|
||
|
||
async with get_async_session() as session:
|
||
result = await session.execute(
|
||
select(VWEDTaskRecord).where(VWEDTaskRecord.id == task_record_id)
|
||
)
|
||
task_record = result.scalar_one_or_none()
|
||
|
||
if not task_record:
|
||
return {
|
||
"success": False,
|
||
"message": "任务记录不存在",
|
||
"error_type": "not_found"
|
||
}
|
||
|
||
# 构建状态信息
|
||
status_info = {
|
||
"task_record_id": task_record.id,
|
||
"task_def_id": task_record.task_def_id,
|
||
"status": task_record.status,
|
||
"progress": task_record.progress,
|
||
"start_time": task_record.start_time.isoformat() if task_record.start_time else None,
|
||
"end_time": task_record.end_time.isoformat() if task_record.end_time else None,
|
||
"error_message": task_record.error_message,
|
||
"variables": task_record.variables
|
||
}
|
||
|
||
self.logger.info(f"脚本 {self.script_id} 获取任务状态: {task_record_id}")
|
||
return {
|
||
"success": True,
|
||
"message": "获取任务状态成功",
|
||
"data": status_info
|
||
}
|
||
|
||
except Exception as e:
|
||
self.logger.error(f"脚本 {self.script_id} 获取任务状态异常: {str(e)}")
|
||
return {
|
||
"success": False,
|
||
"message": f"获取任务状态异常: {str(e)}",
|
||
"error_type": "system_error"
|
||
}
|
||
|
||
|
||
class VWEDDataModule:
|
||
"""VWED.data 模块 - 数据存储和缓存"""
|
||
|
||
def __init__(self, script_id: str):
|
||
self.script_id = script_id
|
||
self._storage: Dict[str, Any] = {}
|
||
|
||
def get(self, key: str, default=None):
|
||
"""获取数据"""
|
||
return self._storage.get(key, default)
|
||
|
||
def set(self, key: str, value: Any):
|
||
"""设置数据"""
|
||
self._storage[key] = value
|
||
|
||
def delete(self, key: str):
|
||
"""删除数据"""
|
||
if key in self._storage:
|
||
del self._storage[key]
|
||
|
||
def clear(self):
|
||
"""清空所有数据"""
|
||
self._storage.clear()
|
||
|
||
def keys(self):
|
||
"""获取所有键"""
|
||
return list(self._storage.keys())
|
||
|
||
def has(self, key: str) -> bool:
|
||
"""检查键是否存在"""
|
||
return key in self._storage
|
||
|
||
|
||
class VWEDUtilModule:
|
||
"""VWED.util 模块 - 工具函数"""
|
||
|
||
def __init__(self, script_id: str):
|
||
self.script_id = script_id
|
||
|
||
def sleep(self, seconds: float):
|
||
"""同步睡眠"""
|
||
import time
|
||
time.sleep(seconds)
|
||
|
||
async def async_sleep(self, seconds: float):
|
||
"""异步睡眠"""
|
||
await asyncio.sleep(seconds)
|
||
|
||
def now(self) -> str:
|
||
"""获取当前时间"""
|
||
from datetime import datetime
|
||
return datetime.now().isoformat()
|
||
|
||
def timestamp(self) -> float:
|
||
"""获取当前时间戳"""
|
||
import time
|
||
return time.time()
|
||
|
||
def uuid(self) -> str:
|
||
"""生成UUID"""
|
||
import uuid
|
||
return str(uuid.uuid4())
|
||
|
||
|
||
class VWEDDeviceModule:
|
||
"""VWED.device 模块 - 设备处理器注册并运行"""
|
||
|
||
def __init__(self, script_id: str):
|
||
self.script_id = script_id
|
||
self.device_service = get_device_service()
|
||
self.registry = get_global_registry()
|
||
self.logger = get_logger(f"script.{script_id}.device")
|
||
|
||
def register_and_run(self, device_id: str, device_type: Union[str, DeviceType],
|
||
listen_topics: List[str], forward_topics: List[str] = None,
|
||
handler: Callable = None, description: str = "",
|
||
device_brand: str = None, protocol_key: str = None,
|
||
auto_encode: bool = True, **kwargs):
|
||
"""注册并运行设备处理器
|
||
|
||
注册完成后立即：
|
||
1. 订阅指定的MQTT topics
|
||
2. 开始监听消息
|
||
3. 消息到达时自动调用处理函数
|
||
4. 自动转发处理结果
|
||
5. 支持设备品牌特定的协议编码/解码
|
||
|
||
使用方式：
|
||
# 基础用法
|
||
VWED.device.register_and_run(
|
||
device_id="agv_001",
|
||
device_type="vehicle",
|
||
listen_topics=["factory/agv/command"],
|
||
forward_topics=["factory/agv/execute"],
|
||
handler=agv_processor,
|
||
description="AGV命令处理器"
|
||
)
|
||
|
||
# 支持品牌特定协议
|
||
VWED.device.register_and_run(
|
||
device_id="huarui_agv_001",
|
||
device_type="vehicle",
|
||
device_brand="huarui", # 华睿品牌
|
||
listen_topics=["huarui/agv/status"],
|
||
forward_topics=["huarui/agv/command"],
|
||
handler=huarui_agv_processor,
|
||
auto_encode=True, # 自动进行华睿协议编码/解码
|
||
description="华睿AGV处理器"
|
||
)
|
||
|
||
# 自定义协议
|
||
VWED.device.register_and_run(
|
||
device_id="custom_device_001",
|
||
device_type="custom",
|
||
protocol_key="my_custom_protocol", # 使用预注册的自定义协议
|
||
listen_topics=["custom/device/data"],
|
||
forward_topics=["custom/device/control"],
|
||
handler=custom_device_processor,
|
||
description="自定义设备处理器"
|
||
)
|
||
|
||
Args:
|
||
device_id: 设备唯一标识
|
||
device_type: 设备类型 (vehicle, door, caller, sensor等)
|
||
listen_topics: 监听的MQTT主题列表
|
||
forward_topics: 转发的MQTT主题列表
|
||
handler: 消息处理函数
|
||
description: 设备描述信息
|
||
device_brand: 设备品牌 (huarui, seer, quicktron等)
|
||
protocol_key: 自定义协议标识
|
||
auto_encode: 是否自动进行协议编码/解码
|
||
**kwargs: 其他配置参数
|
||
"""
|
||
if handler is None:
|
||
raise ValueError("handler参数不能为空")
|
||
|
||
if not listen_topics:
|
||
raise ValueError("listen_topics参数不能为空")
|
||
|
||
# 确保device_type是字符串格式
|
||
if isinstance(device_type, DeviceType):
|
||
device_type = device_type.value
|
||
|
||
# 验证设备类型
|
||
valid_types = [dt.value for dt in DeviceType]
|
||
if device_type not in valid_types:
|
||
raise ValueError(f"device_type参数错误：'{device_type}' 不是有效的设备类型。支持的类型有：{', '.join(valid_types)}")
|
||
|
||
# 设置默认转发topics
|
||
if forward_topics is None:
|
||
forward_topics = []
|
||
|
||
# 调用设备服务注册
|
||
self.device_service.register_and_run(
|
||
device_id=device_id,
|
||
device_type=device_type,
|
||
listen_topics=listen_topics,
|
||
forward_topics=forward_topics,
|
||
handler=handler,
|
||
script_id=self.script_id,
|
||
description=description,
|
||
device_brand=device_brand,
|
||
protocol_key=protocol_key,
|
||
auto_encode=auto_encode,
|
||
**kwargs
|
||
)
|
||
|
||
# 同时在注册中心记录
|
||
self.registry.register_device_handler(
|
||
device_id=device_id,
|
||
device_type=device_type,
|
||
listen_topics=listen_topics,
|
||
forward_topics=forward_topics,
|
||
handler=handler,
|
||
script_id=self.script_id,
|
||
description=description,
|
||
device_brand=device_brand,
|
||
protocol_key=protocol_key,
|
||
auto_encode=auto_encode,
|
||
**kwargs
|
||
)
|
||
|
||
brand_info = f" (品牌: {device_brand})" if device_brand else ""
|
||
protocol_info = f" (协议: {protocol_key})" if protocol_key else ""
|
||
self.logger.info(f"设备处理器已注册并运行: {device_id} ({device_type}{brand_info}{protocol_info})")
|
||
return handler
|
||
|
||
def stop_handler(self, device_id: str):
|
||
"""停止指定设备处理器的运行"""
|
||
self.device_service.stop_handler(device_id)
|
||
self.logger.info(f"设备处理器已停止: {device_id}")
|
||
|
||
def restart_handler(self, device_id: str):
|
||
"""重启设备处理器"""
|
||
# 获取设备配置
|
||
handler_info = self.registry.get_device_handler(device_id)
|
||
if not handler_info:
|
||
raise ValueError(f"设备处理器不存在: {device_id}")
|
||
|
||
# 先停止
|
||
self.stop_handler(device_id)
|
||
|
||
# 重新注册并运行
|
||
self.register_and_run(
|
||
device_id=handler_info["device_id"],
|
||
device_type=handler_info["device_type"],
|
||
listen_topics=handler_info["listen_topics"],
|
||
forward_topics=handler_info["forward_topics"],
|
||
handler=handler_info["handler"],
|
||
description=handler_info["description"]
|
||
)
|
||
|
||
self.logger.info(f"设备处理器已重启: {device_id}")
|
||
|
||
def get_running_handlers(self) -> Dict[str, Any]:
|
||
"""获取所有正在运行的设备处理器"""
|
||
return self.device_service.get_running_handlers()
|
||
|
||
def get_handler_status(self, device_id: str) -> Dict[str, Any]:
|
||
"""获取设备处理器状态"""
|
||
return self.device_service.get_handler_status(device_id)
|
||
|
||
async def publish_message(self, topic: str, payload: Any):
|
||
"""主动发布MQTT消息
|
||
|
||
使用方式：
|
||
await VWED.device.publish_message(
|
||
topic="factory/agv/command",
|
||
payload={"action": "move", "x": 100, "y": 200}
|
||
)
|
||
"""
|
||
await self.device_service.publish_message(topic, payload)
|
||
self.logger.info(f"MQTT消息已发布: {topic}")
|
||
|
||
def sync_publish_message(self, topic: str, payload: Any):
|
||
"""同步方式发布MQTT消息"""
|
||
asyncio.create_task(self.publish_message(topic, payload))
|
||
|
||
def subscribe_topic(self, topic: str, handler: Callable):
|
||
"""订阅额外的MQTT topic
|
||
|
||
注意：这是临时订阅，建议使用register_and_run进行完整的设备注册
|
||
"""
|
||
# 创建临时设备ID
|
||
temp_device_id = f"temp_{self.script_id}_{topic.replace('/', '_')}"
|
||
|
||
self.register_and_run(
|
||
device_id=temp_device_id,
|
||
device_type="custom",
|
||
listen_topics=[topic],
|
||
forward_topics=[],
|
||
handler=handler,
|
||
description=f"临时订阅topic: {topic}"
|
||
)
|
||
|
||
return temp_device_id
|
||
|
||
def unsubscribe_topic(self, device_id: str):
|
||
"""取消订阅topic（通过停止设备处理器）"""
|
||
self.stop_handler(device_id)
|
||
|
||
def get_device_types(self) -> List[str]:
|
||
"""获取支持的设备类型列表"""
|
||
return [dt.value for dt in DeviceType]
|
||
|
||
def get_device_brands(self) -> List[str]:
|
||
"""获取支持的设备品牌列表"""
|
||
return [db.value for db in DeviceBrand]
|
||
|
||
def get_protocols(self) -> Dict[str, Dict[str, Any]]:
|
||
"""获取所有可用的协议"""
|
||
protocol_registry = get_protocol_registry()
|
||
return protocol_registry.list_protocols()
|
||
|
||
def register_custom_protocol(self, protocol_key: str, brand: str, device_type: str,
|
||
encode_func: Callable, decode_func: Callable,
|
||
supported_commands: List[str] = None):
|
||
"""注册自定义设备协议
|
||
|
||
使用方式：
|
||
def my_encode(command):
|
||
# 自定义编码逻辑
|
||
return {"custom_format": command}
|
||
|
||
def my_decode(response):
|
||
# 自定义解码逻辑
|
||
return {"decoded": response}
|
||
|
||
VWED.device.register_custom_protocol(
|
||
protocol_key="my_brand_vehicle",
|
||
brand="my_brand",
|
||
device_type="vehicle",
|
||
encode_func=my_encode,
|
||
decode_func=my_decode,
|
||
supported_commands=["move", "stop"]
|
||
)
|
||
"""
|
||
protocol_registry = get_protocol_registry()
|
||
protocol_registry.register_custom_protocol(
|
||
protocol_key, brand, device_type,
|
||
encode_func, decode_func, supported_commands
|
||
)
|
||
|
||
self.logger.info(f"自定义协议已注册: {protocol_key} ({brand}_{device_type})")
|
||
|
||
def test_protocol_encoding(self, protocol_key: str, test_command: Dict[str, Any]) -> Dict[str, Any]:
|
||
"""测试协议编码功能
|
||
|
||
使用方式：
|
||
result = VWED.device.test_protocol_encoding(
|
||
protocol_key="huarui_vehicle",
|
||
test_command={"action": "move", "x": 100, "y": 200}
|
||
)
|
||
"""
|
||
protocol_registry = get_protocol_registry()
|
||
protocol = protocol_registry.get_protocol(protocol_key)
|
||
|
||
if not protocol:
|
||
return {
|
||
"success": False,
|
||
"error": f"协议不存在: {protocol_key}"
|
||
}
|
||
|
||
try:
|
||
encoded = protocol.encode_command(test_command)
|
||
return {
|
||
"success": True,
|
||
"original": test_command,
|
||
"encoded": encoded,
|
||
"protocol": protocol_key
|
||
}
|
||
except Exception as e:
|
||
return {
|
||
"success": False,
|
||
"error": f"编码失败: {str(e)}",
|
||
"protocol": protocol_key
|
||
}
|
||
|
||
def create_message_filter(self, conditions: Dict[str, Any]) -> Callable:
|
||
"""创建消息过滤器
|
||
|
||
使用方式：
|
||
filter_func = VWED.device.create_message_filter({
|
||
"device_type": "vehicle",
|
||
"action": "move"
|
||
})
|
||
|
||
def my_handler(message):
|
||
if filter_func(message):
|
||
# 处理符合条件的消息
|
||
pass
|
||
"""
|
||
def filter_func(message):
|
||
payload = message.payload if hasattr(message, 'payload') else message
|
||
|
||
for key, expected_value in conditions.items():
|
||
if key == "device_type":
|
||
actual_value = message.device_type.value if hasattr(message, 'device_type') else None
|
||
else:
|
||
actual_value = payload.get(key)
|
||
|
||
if actual_value != expected_value:
|
||
return False
|
||
return True
|
||
|
||
return filter_func
|
||
|
||
|
||
class VWEDObject:
|
||
"""VWED统一对象 - 脚本中的全局VWED变量"""
|
||
|
||
def __init__(self, script_id: str):
|
||
self.script_id = script_id
|
||
|
||
# 初始化各模块
|
||
self.api = VWEDApiModule(script_id)
|
||
self.function = VWEDFunctionModule(script_id)
|
||
self.event = VWEDEventModule(script_id)
|
||
self.timer = VWEDTimerModule(script_id)
|
||
self.log = VWEDLogModule(script_id)
|
||
self.task = VWEDTaskModule(script_id)
|
||
self.data = VWEDDataModule(script_id)
|
||
self.util = VWEDUtilModule(script_id)
|
||
self.device = VWEDDeviceModule(script_id)
|
||
|
||
def get_script_id(self) -> str:
|
||
"""获取当前脚本ID"""
|
||
return self.script_id
|
||
|
||
|
||
def create_vwed_object(script_id: str) -> VWEDObject:
|
||
"""创建VWED对象实例"""
|
||
return VWEDObject(script_id) |