# VWED设备处理器使用示例文档 ## 概述 本文档详细说明了在VWED在线脚本中如何使用更新后的设备处理器功能，特别是对VDA5050协议的支持。 **核心特点：** - **消息透传模式**: 消息直接透传，不进行编解码处理，保持原始数据格式 - **内置MQTT服务**: 集成自己的MQTT客户端，自主管理连接和重连 - **多设备类型支持**: 支持vehicle、door、caller、lift、sensor、robot等设备类型 - **多品牌支持**: 支持huarui、seer、quicktron、geek等主流设备品牌 - **注册即运行**: 调用 `VWED.device.register_and_run()` 后立即开始监听MQTT消息 - **自动处理**: 消息到达时自动调用您定义的处理函数 - **自动转发**: 处理完成后自动发送到指定topic - **持续运行**: 一次注册，持续处理消息直到手动停止 - **脚本ID自动关联**: `script_id` 参数由系统在热加载时自动传入，无需用户手动提供 --- ## 1. VDA5050协议小车设备示例 ### 1.1 VDA5050小车注册和处理 ```python #!/usr/bin/env python # -*- coding: utf-8 -*- def boot(): """VDA5050小车处理脚本启动函数""" # 注册华睿小车处理器（消息透传模式） VWED.device.register_and_run( device_id="huarui_agv_001", device_type="vehicle", listen_topics=["vda5050/v2/huarui_agv_001/state", "vda5050/v2/huarui_agv_001/factsheet"], forward_topics=["fleet/huarui_agv_001/status"], handler=vda5050_vehicle_handler, device_brand="huarui", protocol_type="vda5050", # 协议类型 description="华睿小车处理器" ) def vda5050_vehicle_handler(message): """VDA5050小车消息处理器""" device_id = message.device_id payload = message.payload VWED.log.sync_info(f"收到VDA5050小车 {device_id} 消息: {payload}") # 根据消息内容处理（消息透传，保持原始格式） # 可以根据实际消息格式调整解析逻辑 message_type = payload.get('message_type', payload.get('command_type', 'unknown')) if message_type == 'state_response' or 'driving' in payload: # 处理状态响应 driving = payload.get('driving', False) paused = payload.get('paused', False) operating_mode = payload.get('operating_mode', 'unknown') battery_state = payload.get('battery_state', {}) agv_position = payload.get('agv_position', {}) VWED.log.sync_info(f"小车状态 - 运行: {driving}, 暂停: {paused}, 模式: {operating_mode}") VWED.log.sync_info(f"电池状态: {battery_state}") VWED.log.sync_info(f"位置: {agv_position}") # 检查低电量警告 battery_charge = battery_state.get('batteryCharge', 100) if battery_charge < 20: VWED.log.sync_warning(f"小车 {device_id} 电量不足: {battery_charge}%") # 发送低电量警报 alert = { "type": "low_battery_alert", "device_id": device_id, "battery_level": battery_charge, "timestamp": VWED.util.now() } return { "forward": True, "topics": ["fleet/alerts", "fleet/huarui_agv_001/status"], "payload": [alert, payload] } elif message_type == 'factsheet_response' or 'manufacturer' in payload: # 处理设备信息响应 manufacturer = payload.get('manufacturer', '') serial_number = payload.get('serial_number', '') type_spec = payload.get('type_specification', {}) VWED.log.sync_info(f"设备信息 - 制造商: {manufacturer}, 序列号: {serial_number}") # 存储设备信息到缓存 VWED.data.set(f"device_info_{device_id}", { "manufacturer": manufacturer, "serial_number": serial_number, "type_specification": type_spec, "updated_at": VWED.util.now() }) # 默认转发消息 return { "forward": True, "payload": { "device_id": device_id, "original_data": payload, "processed_at": VWED.util.now() } } # VDA5050指令发送示例 def send_vda5050_order_example(): """发送VDA5050订单指令示例""" # 构建订单数据 order_data = { "order_id": f"order_{int(VWED.util.timestamp())}", "nodes": [ { "nodeId": "pickup_station", "sequenceId": 1, "nodePosition": {"x": 10.5, "y": 20.3, "theta": 0.0, "mapId": "warehouse_map"}, "actions": [ { "actionType": "pick", "actionId": "pick_001", "actionDescription": "Pick up cargo", "blockingType": "HARD", "actionParameters": [ {"key": "load_type", "value": "box"}, {"key": "weight", "value": "5"} ] } ] }, { "nodeId": "delivery_station", "sequenceId": 2, "nodePosition": {"x": 30.0, "y": 45.0, "theta": 1.57, "mapId": "warehouse_map"}, "actions": [ { "actionType": "drop", "actionId": "drop_001", "actionDescription": "Drop cargo", "blockingType": "HARD" } ] } ], "edges": [ { "edgeId": "edge_pickup_to_delivery", "sequenceId": 1, "startNodeId": "pickup_station", "endNodeId": "delivery_station", "maxSpeed": 1.5, "actions": [] } ] } # 发送订单 VWED.device.send_order("huarui_agv_001", order_data) VWED.log.sync_info("订单已发送") def send_emergency_stop(): """发送紧急停止指令""" emergency_actions = [ { "actionType": "cancelOrder", "actionId": f"emergency_stop_{int(VWED.util.timestamp())}", "actionDescription": "Emergency stop - cancel current order", "blockingType": "HARD" } ] VWED.device.send_instant_action("huarui_agv_001", emergency_actions) VWED.log.sync_warning("紧急停止指令已发送") def request_vehicle_state(): """请求小车状态""" VWED.device.request_state("huarui_agv_001") VWED.log.sync_info("状态查询请求已发送") ``` ### 1.2 门设备即时动作示例 ```python def boot(): """门设备VDA5050即时动作处理""" # 注册门设备处理器 VWED.device.register_and_run( device_id="door_001", device_type="door", listen_topics=["door/door_001/status"], forward_topics=["facility/door_001/events"], handler=door_instant_action_handler, device_brand="standard", protocol_type="vda5050", description="门设备处理器" ) def door_instant_action_handler(message): """门设备即时动作处理器""" device_id = message.device_id payload = message.payload VWED.log.sync_info(f"收到门设备 {device_id} 消息: {payload}") door_status = payload.get('door_status', 'unknown') if door_status == 'access_requested': # 处理门禁访问请求 card_id = payload.get('card_id') # 验证访问权限 if is_authorized_card(card_id): # 发送开门指令 open_actions = [ { "actionType": "open", "actionId": f"open_{int(VWED.util.timestamp())}", "actionDescription": f"Open door for card {card_id}", "blockingType": "SOFT", "actionParameters": [ {"key": "duration", "value": "5"}, # 开门5秒 {"key": "card_id", "value": card_id} ] } ] VWED.device.send_instant_action("door_001", open_actions, "door/door_001/control") VWED.log.sync_info(f"已授权开门: {card_id}") return { "forward": True, "payload": { "event": "access_granted", "card_id": card_id, "timestamp": VWED.util.now() } } else: VWED.log.sync_warning(f"未授权访问被拒绝: {card_id}") return { "forward": True, "payload": { "event": "access_denied", "card_id": card_id, "reason": "unauthorized", "timestamp": VWED.util.now() } } return {"forward": True, "payload": payload} def is_authorized_card(card_id): """检查卡片是否有权限""" authorized_cards = VWED.data.get("authorized_cards", ["CARD001", "CARD002", "CARD003"]) return card_id in authorized_cards ``` ### 1.3 通用设备即时动作示例 ```python def boot(): """传感器设备即时动作处理""" # 注册传感器设备 VWED.device.register_and_run( device_id="temp_sensor_001", device_type="sensor", listen_topics=["sensors/temperature/001/data"], forward_topics=["environmental/alerts"], handler=sensor_instant_action_handler, device_brand="standard", protocol_type="vda5050", description="温度传感器处理器" ) def sensor_instant_action_handler(message): """传感器即时动作处理器""" device_id = message.device_id payload = message.payload temperature = payload.get('temperature', 0) VWED.log.sync_info(f"传感器 {device_id} 温度: {temperature}°C") if temperature > 35: # 温度过高，发送冷却指令 cooling_actions = [ { "actionType": "cooling_control", "actionId": f"cool_{int(VWED.util.timestamp())}", "actionDescription": "Activate cooling system", "blockingType": "SOFT", "actionParameters": [ {"key": "target_temp", "value": "25"}, {"key": "priority", "value": "high"} ] } ] VWED.device.send_instant_action("temp_sensor_001", cooling_actions, "hvac/control") return { "forward": True, "payload": { "alert_type": "temperature_high", "temperature": temperature, "action_taken": "cooling_activated", "timestamp": VWED.util.now() } } return {"forward": False} # 正常温度不转发 ``` --- ## 2. 传统协议小车设备示例 ### 1.1 基本小车命令处理 ```python #!/usr/bin/env python # -*- coding: utf-8 -*- def boot(): """脚本启动函数""" # 注册并运行AGV设备处理器 VWED.device.register_and_run( device_id="agv_001", device_type="vehicle", listen_topics=["factory/agv/command"], forward_topics=["factory/agv/execute"], handler=agv_command_processor, device_brand="standard", protocol_type="vda5050", description="AGV命令处理器 - 添加安全检查" ) def agv_command_processor(message): """AGV命令处理逻辑 - 消息到达时自动执行""" # 记录接收到的消息 VWED.log.sync_info(f"收到AGV命令: {message.payload}") command = message.payload.get("command") if command == "move": # 添加安全检查逻辑 x = message.payload.get("x", 0) y = message.payload.get("y", 0) speed = message.payload.get("speed", 100) # 限制最大速度 safe_speed = min(speed, 50) # 检查坐标范围 if x < 0 or x > 1000 or y < 0 or y > 800: VWED.log.sync_warning(f"AGV坐标超出安全范围: x={x}, y={y}") return { "forward": False, # 不转发 "response": { "status": "error", "message": "坐标超出安全范围" }, "response_topic": "factory/agv/response" } # 构建安全的移动命令 safe_command = { "command": "move_safe", "x": x, "y": y, "speed": safe_speed, "safety_check": True, "timestamp": VWED.util.now(), "processed_by": "agv_001_processor" } VWED.log.sync_info(f"AGV安全命令已生成: 速度限制 {speed} -> {safe_speed}") return { "forward": True, "payload": safe_command } elif command == "stop": # 紧急停止 - 直接转发 emergency_stop = { "command": "emergency_stop", "reason": message.payload.get("reason", "manual_stop"), "timestamp": VWED.util.now() } return { "forward": True, "payload": emergency_stop } else: # 未知命令 - 记录并拒绝 VWED.log.sync_warning(f"未知AGV命令: {command}") return { "forward": False, "response": { "status": "error", "message": f"不支持的命令: {command}" }, "response_topic": "factory/agv/response" } ``` **MQTT消息流转示例:** ``` 输入topic: factory/agv/command 输入消息: {"command": "move", "x": 100, "y": 200, "speed": 80} 处理后输出topic: factory/agv/execute 输出消息: {"command": "move_safe", "x": 100, "y": 200, "speed": 50, "safety_check": true, "timestamp": "2024-01-01T12:00:00", "processed_by": "agv_001_processor"} ``` ### 1.2 多AGV协调处理 ```python def boot(): """多AGV统一处理""" # 注册AGV车队控制器 VWED.device.register_and_run( device_id="agv_fleet_controller", device_type="vehicle", listen_topics=["factory/agv/+/command"], # 监听所有AGV命令 forward_topics=["factory/agv/coordination"], handler=agv_fleet_coordinator, device_brand="standard", protocol_type="vda5050", description="AGV车队协调器" ) def agv_fleet_coordinator(message): """AGV车队协调逻辑""" # 解析AGV ID topic_parts = message.topic.split("/") agv_id = topic_parts[2] if len(topic_parts) > 2 else "unknown" command = message.payload.get("command") if command == "move": # 检查路径冲突 x = message.payload.get("x") y = message.payload.get("y") # 获取其他AGV位置（从缓存中） other_agvs = VWED.data.get("agv_positions", {}) # 简单的冲突检测 conflict_detected = False for other_id, other_pos in other_agvs.items(): if other_id != agv_id: distance = ((x - other_pos["x"])**2 + (y - other_pos["y"])**2)**0.5 if distance < 50: # 50cm安全距离 conflict_detected = True break if conflict_detected: # 发送等待指令 wait_command = { "command": "wait", "reason": "path_conflict", "retry_after": 3, # 3秒后重试 "timestamp": VWED.util.now() } VWED.log.sync_warning(f"AGV {agv_id} 路径冲突，指令等待") return { "forward": True, "topics": [f"factory/agv/{agv_id}/execute"], "payload": wait_command } else: # 更新AGV位置缓存 other_agvs[agv_id] = {"x": x, "y": y, "timestamp": VWED.util.now()} VWED.data.set("agv_positions", other_agvs) # 转发原始命令 return { "forward": True, "topics": [f"factory/agv/{agv_id}/execute"], "payload": message.payload } # 默认转发 return { "forward": True, "topics": [f"factory/agv/{agv_id}/execute"], "payload": message.payload } ``` --- ## 2. 门禁(Door)设备处理示例 ### 2.1 基本门禁控制 ```python def boot(): """门禁系统处理器""" VWED.device.register_and_run( device_id="door_main_entrance", device_type="door", listen_topics=["building/door/access_request"], forward_topics=["building/door/control"], handler=door_access_controller, device_brand="standard", protocol_type="vda5050", description="主入口门禁控制器" ) def door_access_controller(message): """门禁访问控制逻辑""" # 获取访问请求信息 card_id = message.payload.get("card_id") door_id = message.payload.get("door_id", "main_entrance") request_time = message.payload.get("timestamp", VWED.util.now()) VWED.log.sync_info(f"门禁访问请求: 卡号={card_id}, 门={door_id}") # 权限验证逻辑 if not card_id: return { "forward": False, "response": {"status": "error", "message": "缺少卡号"}, "response_topic": "building/door/response" } # 检查黑名单 blacklist = VWED.data.get("door_blacklist", []) if card_id in blacklist: VWED.log.sync_warning(f"黑名单卡号访问被拒绝: {card_id}") return { "forward": False, "response": { "status": "denied", "reason": "blacklist", "card_id": card_id, "timestamp": request_time }, "response_topic": "building/door/response" } # 检查白名单 whitelist = VWED.data.get("door_whitelist", [ "CARD001", "CARD002", "CARD003" # 默认白名单 ]) if card_id in whitelist: # 授权开门 open_command = { "action": "open", "door_id": door_id, "card_id": card_id, "authorized_by": "door_main_entrance", "open_duration": 5, # 开门5秒 "timestamp": request_time } # 记录访问日志 access_log = VWED.data.get("door_access_log", []) access_log.append({ "card_id": card_id, "door_id": door_id, "status": "granted", "timestamp": request_time }) # 只保留最近100条记录 if len(access_log) > 100: access_log = access_log[-100:] VWED.data.set("door_access_log", access_log) VWED.log.sync_info(f"门禁访问已授权: {card_id}") return { "forward": True, "payload": open_command } else: # 未授权卡号 VWED.log.sync_warning(f"未授权卡号访问被拒绝: {card_id}") return { "forward": False, "response": { "status": "denied", "reason": "unauthorized", "card_id": card_id, "timestamp": request_time }, "response_topic": "building/door/response" } ``` ### 2.2 门禁状态监控 ```python def boot(): """门禁状态监控""" # 监控门禁状态 VWED.device.register_and_run( device_id="door_status_monitor", device_type="door", listen_topics=["building/door/+/status"], forward_topics=["building/security/alerts"], handler=door_status_monitor, device_brand="standard", protocol_type="vda5050", description="门禁状态监控器" ) def door_status_monitor(message): """门禁状态监控逻辑""" # 解析门ID topic_parts = message.topic.split("/") door_id = topic_parts[2] if len(topic_parts) > 2 else "unknown" status = message.payload.get("status") timestamp = message.payload.get("timestamp", VWED.util.now()) # 更新门状态缓存 door_states = VWED.data.get("door_states", {}) door_states[door_id] = { "status": status, "timestamp": timestamp, "last_update": VWED.util.now() } VWED.data.set("door_states", door_states) # 异常状态检测 if status == "forced_open": # 门被强制打开 - 发送安全警报 alert = { "type": "security_alert", "level": "high", "door_id": door_id, "event": "forced_open", "message": f"门 {door_id} 被强制打开", "timestamp": timestamp, "requires_action": True } VWED.log.sync_error(f"安全警报: 门 {door_id} 被强制打开") return { "forward": True, "payload": alert } elif status == "open_timeout": # 门打开超时 - 发送提醒 alert = { "type": "maintenance_alert", "level": "medium", "door_id": door_id, "event": "open_timeout", "message": f"门 {door_id} 打开时间过长", "timestamp": timestamp, "requires_action": False } VWED.log.sync_warning(f"维护提醒: 门 {door_id} 打开时间过长") return { "forward": True, "payload": alert } # 正常状态 - 不转发 return {"forward": False} ``` --- ## 3. 呼叫器(Caller)设备处理示例 ### 3.1 基本呼叫处理 ```python def boot(): """呼叫器处理系统""" VWED.device.register_and_run( device_id="caller_lobby_01", device_type="caller", listen_topics=["building/caller/signal"], forward_topics=["building/caller/response", "building/notification/broadcast"], handler=caller_signal_processor, device_brand="standard", protocol_type="vda5050", description="大厅呼叫器信号处理器" ) def caller_signal_processor(message): """呼叫器信号处理逻辑""" caller_id = message.payload.get("caller_id") signal_type = message.payload.get("signal_type") location = message.payload.get("location", "unknown") priority = message.payload.get("priority", "normal") VWED.log.sync_info(f"收到呼叫信号: {caller_id} - {signal_type} ({priority})") # 根据信号类型处理 if signal_type == "emergency": # 紧急呼叫 - 立即响应 emergency_response = { "type": "emergency_response", "caller_id": caller_id, "location": location, "status": "received", "response_time": "immediate", "assigned_staff": "security_team", "message": "紧急响应团队已派遣", "timestamp": VWED.util.now() } # 广播紧急通知 emergency_broadcast = { "type": "emergency_broadcast", "level": "critical", "message": f"紧急呼叫: {location} ({caller_id})", "location": location, "caller_id": caller_id, "timestamp": VWED.util.now() } VWED.log.sync_error(f"紧急呼叫处理: {caller_id} 位置: {location}") return { "forward": True, "topics": ["building/caller/response", "building/notification/broadcast"], "payload": [emergency_response, emergency_broadcast] } elif signal_type == "service": # 服务请求 - 分配服务人员 service_response = { "type": "service_response", "caller_id": caller_id, "location": location, "status": "queued", "estimated_time": "5-10 minutes", "queue_position": get_queue_position(location), "message": "服务请求已接收，请稍候", "timestamp": VWED.util.now() } VWED.log.sync_info(f"服务请求处理: {caller_id}") return { "forward": True, "topics": ["building/caller/response"], "payload": service_response } elif signal_type == "information": # 信息查询 - 提供自动回复 info_response = { "type": "information_response", "caller_id": caller_id, "location": location, "status": "completed", "information": get_location_info(location), "timestamp": VWED.util.now() } return { "forward": True, "topics": ["building/caller/response"], "payload": info_response } else: # 未知信号类型 error_response = { "type": "error_response", "caller_id": caller_id, "status": "error", "message": f"不支持的信号类型: {signal_type}", "timestamp": VWED.util.now() } return { "forward": True, "topics": ["building/caller/response"], "payload": error_response } def get_queue_position(location): """获取队列位置""" queue = VWED.data.get(f"service_queue_{location}", []) return len(queue) + 1 def get_location_info(location): """获取位置信息""" location_data = { "lobby": "大厅 - 营业时间: 8:00-18:00, 电话: 123-456-7890", "elevator": "电梯区域 - 共6部电梯, 楼层: B1-F20", "parking": "停车场 - 地下3层, 收费标准: 5元/小时" } return location_data.get(location, "暂无相关信息") ``` ### 3.2 呼叫器多级响应 ```python def boot(): """多级呼叫响应系统""" VWED.device.register_and_run( device_id="caller_escalation_manager", device_type="caller", listen_topics=["building/caller/+/urgent"], forward_topics=["building/staff/notification"], handler=caller_escalation_handler, device_brand="standard", protocol_type="vda5050", description="呼叫升级管理器" ) def caller_escalation_handler(message): """呼叫升级处理逻辑""" # 解析呼叫器ID topic_parts = message.topic.split("/") caller_id = topic_parts[2] if len(topic_parts) > 2 else "unknown" urgency_level = message.payload.get("urgency", "medium") repeat_count = message.payload.get("repeat_count", 1) last_response_time = message.payload.get("last_response_time") # 升级逻辑 if repeat_count >= 3: # 第3次重复呼叫 - 升级到管理层 escalation = { "type": "management_escalation", "caller_id": caller_id, "urgency": "high", "repeat_count": repeat_count, "reason": "multiple_unattended_calls", "notify_roles": ["supervisor", "manager"], "message": f"呼叫器 {caller_id} 连续{repeat_count}次呼叫未响应", "timestamp": VWED.util.now() } VWED.log.sync_warning(f"呼叫升级到管理层: {caller_id} ({repeat_count}次)") return { "forward": True, "payload": escalation } elif repeat_count == 2: # 第2次重复呼叫 - 通知高级员工 notification = { "type": "senior_staff_notification", "caller_id": caller_id, "urgency": "medium", "repeat_count": repeat_count, "notify_roles": ["senior_staff"], "message": f"呼叫器 {caller_id} 重复呼叫，请优先处理", "timestamp": VWED.util.now() } return { "forward": True, "payload": notification } else: # 首次呼叫 - 正常通知 notification = { "type": "normal_notification", "caller_id": caller_id, "urgency": urgency_level, "notify_roles": ["staff"], "message": f"呼叫器 {caller_id} 请求服务", "timestamp": VWED.util.now() } return { "forward": True, "payload": notification } ``` --- ## 4. 综合设备处理示例 ### 4.1 智能楼宇综合管理 ```python def boot(): """智能楼宇综合管理系统""" # 环境监控 VWED.device.register_and_run( device_id="environmental_monitor", device_type="sensor", listen_topics=["building/sensors/+/data"], forward_topics=["building/hvac/control", "building/alerts"], handler=environmental_processor, description="环境监控处理器" ) # 电梯调度 VWED.device.register_and_run( device_id="elevator_scheduler", device_type="lift", listen_topics=["building/elevator/call"], forward_topics=["building/elevator/+/command"], handler=elevator_scheduler, description="电梯调度器" ) # 安全系统集成 VWED.device.register_and_run( device_id="security_integrator", device_type="custom", listen_topics=["building/security/+/event"], forward_topics=["building/security/response"], handler=security_event_processor, description="安全系统集成器" ) def environmental_processor(message): """环境数据处理""" # 解析传感器ID topic_parts = message.topic.split("/") sensor_id = topic_parts[2] if len(topic_parts) > 2 else "unknown" temperature = message.payload.get("temperature") humidity = message.payload.get("humidity") air_quality = message.payload.get("air_quality") controls = [] alerts = [] # 温度控制 if temperature is not None: if temperature > 26: controls.append({ "device": "hvac", "action": "cool", "target_temp": 24, "reason": f"温度过高: {temperature}°C" }) elif temperature < 20: controls.append({ "device": "hvac", "action": "heat", "target_temp": 22, "reason": f"温度过低: {temperature}°C" }) # 湿度控制 if humidity is not None: if humidity > 70: controls.append({ "device": "dehumidifier", "action": "on", "target_humidity": 60, "reason": f"湿度过高: {humidity}%" }) # 空气质量监控 if air_quality is not None and air_quality < 50: alerts.append({ "type": "air_quality_alert", "level": "medium", "sensor_id": sensor_id, "value": air_quality, "message": "空气质量较差，建议开启新风系统" }) # 返回控制指令和警报 responses = [] if controls: responses.append(("building/hvac/control", {"controls": controls, "timestamp": VWED.util.now()})) if alerts: responses.append(("building/alerts", {"alerts": alerts, "timestamp": VWED.util.now()})) if responses: return { "forward": True, "topics": [topic for topic, _ in responses], "payload": [payload for _, payload in responses] } return {"forward": False} def elevator_scheduler(message): """电梯调度逻辑""" floor_from = message.payload.get("from_floor") floor_to = message.payload.get("to_floor") priority = message.payload.get("priority", "normal") # 获取电梯状态 elevator_status = VWED.data.get("elevator_status", { "elevator_1": {"current_floor": 1, "status": "idle"}, "elevator_2": {"current_floor": 10, "status": "busy"}, "elevator_3": {"current_floor": 5, "status": "idle"} }) # 选择最佳电梯 best_elevator = None min_distance = float('inf') for elevator_id, status in elevator_status.items(): if status["status"] == "idle": distance = abs(status["current_floor"] - floor_from) if distance < min_distance: min_distance = distance best_elevator = elevator_id if best_elevator: # 分配电梯 command = { "elevator_id": best_elevator, "action": "goto", "from_floor": floor_from, "to_floor": floor_to, "priority": priority, "estimated_time": min_distance * 3, # 假设每层3秒 "timestamp": VWED.util.now() } # 更新电梯状态 elevator_status[best_elevator]["status"] = "busy" VWED.data.set("elevator_status", elevator_status) return { "forward": True, "topics": [f"building/elevator/{best_elevator}/command"], "payload": command } else: # 无空闲电梯 - 加入队列 queue = VWED.data.get("elevator_queue", []) queue.append({ "from_floor": floor_from, "to_floor": floor_to, "priority": priority, "request_time": VWED.util.now() }) VWED.data.set("elevator_queue", queue) return { "forward": False, "response": { "status": "queued", "position": len(queue), "estimated_wait": len(queue) * 30 # 每个请求30秒 }, "response_topic": "building/elevator/response" } def security_event_processor(message): """安全事件处理""" event_type = message.payload.get("event_type") location = message.payload.get("location") severity = message.payload.get("severity", "medium") if event_type == "intrusion_detected": # 入侵检测 - 立即响应 response = { "action": "lockdown", "location": location, "alert_level": "high", "notify_security": True, "timestamp": VWED.util.now() } return { "forward": True, "payload": response } elif event_type == "fire_alarm": # 火警 - 疏散程序 response = { "action": "evacuation", "location": location, "alert_level": "critical", "notify_fire_dept": True, "timestamp": VWED.util.now() } return { "forward": True, "payload": response } # 其他事件正常处理 return { "forward": True, "payload": message.payload } ``` --- ## 5. 设备处理器管理功能 ### 5.1 设备状态监控 ```python def boot(): """设备管理和监控""" # 注册设备状态监控 VWED.device.register_and_run( device_id="device_status_monitor", device_type="custom", listen_topics=["system/device/+/heartbeat"], forward_topics=["system/alerts"], handler=device_heartbeat_monitor, description="设备心跳监控器" ) # 定时检查设备状态 VWED.timer.interval( seconds=60, # 每分钟检查一次 handler=check_device_status ) def device_heartbeat_monitor(message): """设备心跳监控""" device_id = message.payload.get("device_id") status = message.payload.get("status") timestamp = message.payload.get("timestamp", VWED.util.now()) # 更新设备心跳记录 heartbeats = VWED.data.get("device_heartbeats", {}) heartbeats[device_id] = { "status": status, "last_heartbeat": timestamp, "updated_at": VWED.util.now() } VWED.data.set("device_heartbeats", heartbeats) # 如果设备状态异常，发送警报 if status in ["error", "offline", "malfunction"]: alert = { "type": "device_alert", "device_id": device_id, "status": status, "message": f"设备 {device_id} 状态异常: {status}", "timestamp": timestamp, "requires_attention": True } return { "forward": True, "payload": alert } return {"forward": False} def check_device_status(): """定时检查设备状态""" current_time = VWED.util.timestamp() heartbeats = VWED.data.get("device_heartbeats", {}) for device_id, info in heartbeats.items(): last_heartbeat = info.get("last_heartbeat") if last_heartbeat: # 检查是否超过5分钟没有心跳 if current_time - last_heartbeat > 300: # 5分钟 VWED.log.sync_warning(f"设备 {device_id} 心跳超时") # 发送超时警报 VWED.device.sync_publish_message( topic="system/alerts", payload={ "type": "device_timeout", "device_id": device_id, "last_seen": last_heartbeat, "timeout_duration": current_time - last_heartbeat, "timestamp": VWED.util.now() } ) ``` ### 5.2 设备处理器动态管理 ```python def boot(): """动态设备管理""" # 设备管理控制器 VWED.device.register_and_run( device_id="device_manager", device_type="custom", listen_topics=["system/device/control"], forward_topics=["system/device/response"], handler=device_management_handler, description="设备动态管理控制器" ) def device_management_handler(message): """设备管理控制处理""" action = message.payload.get("action") device_id = message.payload.get("device_id") if action == "status": # 获取设备状态 status = VWED.device.get_handler_status(device_id) return { "forward": True, "payload": { "action": "status_response", "device_id": device_id, "status": status, "timestamp": VWED.util.now() } } elif action == "stop": # 停止设备处理器 try: VWED.device.stop_handler(device_id) return { "forward": True, "payload": { "action": "stop_response", "device_id": device_id, "status": "stopped", "timestamp": VWED.util.now() } } except Exception as e: return { "forward": True, "payload": { "action": "stop_response", "device_id": device_id, "status": "error", "error": str(e), "timestamp": VWED.util.now() } } elif action == "restart": # 重启设备处理器 try: VWED.device.restart_handler(device_id) return { "forward": True, "payload": { "action": "restart_response", "device_id": device_id, "status": "restarted", "timestamp": VWED.util.now() } } except Exception as e: return { "forward": True, "payload": { "action": "restart_response", "device_id": device_id, "status": "error", "error": str(e), "timestamp": VWED.util.now() } } elif action == "list": # 获取所有设备列表 handlers = VWED.device.get_running_handlers() return { "forward": True, "payload": { "action": "list_response", "handlers": handlers, "timestamp": VWED.util.now() } } else: return { "forward": True, "payload": { "action": "error_response", "message": f"不支持的操作: {action}", "timestamp": VWED.util.now() } } ``` --- ## 6. 调试和故障排除 ### 6.1 设备处理器调试 ```python def boot(): """设备处理器调试模式""" # 启用调试模式 debug_mode = True if debug_mode: # 注册调试设备处理器 VWED.device.register_and_run( device_id="debug_processor", device_type="custom", listen_topics=["debug/+/+"], # 监听所有调试消息 forward_topics=[], handler=debug_message_handler, description="调试消息处理器" ) def debug_message_handler(message): """调试消息处理""" # 详细记录消息信息 VWED.log.sync_info(f"调试消息 - Topic: {message.topic}") VWED.log.sync_info(f"调试消息 - Payload: {message.payload}") VWED.log.sync_info(f"调试消息 - Device: {message.device_id}") VWED.log.sync_info(f"调试消息 - Type: {message.device_type}") VWED.log.sync_info(f"调试消息 - Timestamp: {message.timestamp}") # 保存调试日志 debug_logs = VWED.data.get("debug_logs", []) debug_logs.append({ "topic": message.topic, "payload": message.payload, "device_id": message.device_id, "device_type": message.device_type.value if hasattr(message.device_type, 'value') else str(message.device_type), "timestamp": message.timestamp, "processed_at": VWED.util.now() }) # 只保留最近50条调试日志 if len(debug_logs) > 50: debug_logs = debug_logs[-50:] VWED.data.set("debug_logs", debug_logs) # 不转发调试消息 return {"forward": False} def get_debug_statistics(): """获取调试统计信息""" handlers = VWED.device.get_running_handlers() debug_logs = VWED.data.get("debug_logs", []) return { "total_handlers": handlers.get("device_count", 0), "running_handlers": handlers.get("running_devices", 0), "debug_log_count": len(debug_logs), "last_debug_time": debug_logs[-1]["processed_at"] if debug_logs else None } ``` --- ## 总结 本文档提供了VWED设备处理器的完整使用示例，包括： ### 主要功能 1. **设备类型支持** - 小车、门禁、呼叫器、电梯、传感器等 2. **注册即运行** - 一次注册，持续监听和处理MQTT消息 3. **自动转发** - 处理完成后自动发送到指定topic 4. **动态管理** - 支持运行时启停、重启设备处理器 5. **状态监控** - 实时监控设备状态和处理统计 ### 关键特点 - **分离式设计** - 注册和处理逻辑分离，保持代码清晰 - **消息驱动** - MQTT消息自动触发处理，无需手动调用 - **错误处理** - 完善的异常处理和重试机制 - **扩展性强** - 支持自定义设备类型和处理逻辑 - **易于调试** - 详细的日志记录和调试功能 ### 使用建议 1. 根据实际设备类型选择合适的device_type 2. 合理设置listen_topics和forward_topics 3. 在处理函数中添加充分的错误处理 4. 使用VWED.log记录关键操作日志 5. 利用VWED.data缓存必要的状态信息 通过这些示例，您可以快速掌握VWED设备处理器的使用方法，实现复杂的设备逻辑处理和MQTT消息转发。