node-red-contrib-symi-mesh 1.2.4 → 1.3.1

package/nodes/symi-cloud-sync.js

@@ -0,0 +1,388 @@
+/**
+ * Symi Cloud Sync Node
+ * 云端数据同步节点 - 获取设备名称和场景信息
+ */
+
+const CloudAPI = require('../lib/cloud-api');
+const { generateSceneButtonConfig } = require('../lib/mqtt-helper');
+
+module.exports = function(RED) {
+    function SymiCloudSyncNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        node.gateway = RED.nodes.getNode(config.gateway);
+        node.mqttConfig = RED.nodes.getNode(config.mqttConfig);
+        node.appId = config.appId;
+        node.appSecret = config.appSecret;
+        node.hotelId = config.hotelId;
+        node.roomNo = config.roomNo;
+        node.roomUuid = config.roomUuid;
+        node.autoSync = config.autoSync !== false;
+        node.selectedDevices = config.selectedDevices || [];
+        node.selectedScenes = config.selectedScenes || [];
+
+        if (!node.gateway) {
+            node.error('未配置网关');
+            node.status({ fill: 'red', shape: 'ring', text: '未配置网关' });
+            return;
+        }
+
+        if (!node.appId || !node.appSecret) {
+            node.warn('未配置云端认证信息');
+            node.status({ fill: 'yellow', shape: 'ring', text: '未配置认证' });
+            return;
+        }
+        
+        node.cloudAPI = new CloudAPI(node.appId, node.appSecret, node);
+        node.syncInProgress = false;
+        
+        node.status({ fill: 'yellow', shape: 'ring', text: '等待同步' });
+        
+        const loadCachedData = () => {
+            const cached = node.context().get('cloudData');
+            if (cached) {
+                node.log(`加载缓存的云端数据: ${cached.devices?.length || 0}个设备, ${cached.scenes?.length || 0}个场景`);
+                return cached;
+            }
+            return null;
+        };
+        
+        const saveCachedData = (data) => {
+            node.context().set('cloudData', data);
+            node.log('云端数据已缓存');
+        };
+        
+        const syncFromCloud = async () => {
+            if (node.syncInProgress) {
+                node.warn('同步正在进行中，跳过');
+                return;
+            }
+            
+            if (!node.hotelId || !node.roomNo) {
+                node.warn('未配置酒店ID或房间号，跳过同步');
+                node.status({ fill: 'yellow', shape: 'ring', text: '未配置房间' });
+                return;
+            }
+            
+            node.syncInProgress = true;
+            node.status({ fill: 'blue', shape: 'dot', text: '同步中...' });
+            
+            try {
+                node.log(`开始从云端获取数据: 酒店ID=${node.hotelId}, 房间号=${node.roomNo}`);
+                
+                const roomInfo = await node.cloudAPI.getRoomInfo({
+                    hotel_id: parseInt(node.hotelId),
+                    room_no: node.roomNo
+                });
+                
+                if (!roomInfo || !roomInfo.device_list) {
+                    throw new Error('云端返回数据格式错误');
+                }
+                
+                const cloudData = {
+                    room_no: roomInfo.room_no,
+                    devices: roomInfo.device_list || [],
+                    scenes: roomInfo.scene_list || [],
+                    lastSync: new Date().toISOString()
+                };
+                
+                node.log(`云端数据获取成功: ${cloudData.devices.length}个设备, ${cloudData.scenes.length}个场景`);
+                
+                saveCachedData(cloudData);
+                
+                applyCloudData(cloudData);
+                
+                node.status({ fill: 'green', shape: 'dot', text: `已同步 ${new Date().toLocaleTimeString()}` });
+                
+            } catch (error) {
+                node.error(`云端同步失败: ${error.message}`);
+                node.status({ fill: 'red', shape: 'ring', text: '同步失败' });
+                
+                const cached = loadCachedData();
+                if (cached) {
+                    node.log('使用缓存的云端数据');
+                    applyCloudData(cached);
+                    node.status({ fill: 'yellow', shape: 'dot', text: '使用缓存' });
+                }
+            } finally {
+                node.syncInProgress = false;
+            }
+        };
+        
+        const applyCloudData = (cloudData) => {
+            if (!cloudData || !cloudData.devices) {
+                node.warn('无可用的云端数据');
+                return;
+            }
+
+            const devices = node.gateway.deviceManager.getAllDevices();
+            let matchedCount = 0;
+            let updatedCount = 0;
+
+            const devicesToSync = node.selectedDevices.length > 0
+                ? cloudData.devices.filter(d => node.selectedDevices.includes(d.mac))
+                : cloudData.devices;
+
+            devicesToSync.forEach(cloudDevice => {
+                // 云端MAC地址是反序存储的，需要反转后匹配
+                const cloudMacRaw = cloudDevice.mac.toLowerCase().replace(/[:-]/g, '');
+                const cloudMacReversed = cloudMacRaw.match(/.{2}/g)?.reverse().join('') || cloudMacRaw;
+
+                const localDevice = devices.find(d => {
+                    const localMac = d.macAddress.toLowerCase().replace(/[:-]/g, '');
+                    return localMac === cloudMacReversed;
+                });
+
+                if (localDevice) {
+                    matchedCount++;
+                    let deviceUpdated = false;
+
+                    // 优先使用nick_name，如果是"未命名"则使用device_name，如果device_name也是"未命名"则保持原有名称
+                    let newName = cloudDevice.nick_name;
+                    if (!newName || newName === '未命名' || newName.trim() === '') {
+                        newName = cloudDevice.device_name;
+                    }
+                    if (!newName || newName === '未命名' || newName.trim() === '') {
+                        newName = localDevice.name; // 保持原有名称（包含设备类型）
+                    }
+
+                    if (localDevice.name !== newName) {
+                        const oldName = localDevice.name;
+                        localDevice.name = newName;
+                        deviceUpdated = true;
+                        node.log(`设备名称已更新: ${oldName} -> ${newName} (MAC: ${cloudDevice.mac})`);
+                    }
+
+                    // 同步按键名称
+                    if (cloudDevice.sub_device && Array.isArray(cloudDevice.sub_device) && cloudDevice.sub_device.length > 0) {
+                        const newSubNames = cloudDevice.sub_device.map(sub => sub.sub_name);
+                        const oldSubNames = localDevice.subDeviceNames || [];
+
+                        node.log(`[按键名称] 设备: ${localDevice.name}, 云端按键数: ${cloudDevice.sub_device.length}, 按键名称: [${newSubNames.join(', ')}]`);
+
+                        // 检查是否有变化
+                        const hasChanged = newSubNames.length !== oldSubNames.length ||
+                                         newSubNames.some((name, idx) => name !== oldSubNames[idx]);
+
+                        if (hasChanged) {
+                            localDevice.subDeviceNames = newSubNames;
+                            deviceUpdated = true;
+                            node.log(`[按键名称] 设备按键名称已更新: ${localDevice.name} -> [${newSubNames.join(', ')}]`);
+                        } else {
+                            node.log(`[按键名称] 设备按键名称无变化: ${localDevice.name}`);
+                        }
+                    } else {
+                        node.log(`[按键名称] 设备无sub_device数据: ${localDevice.name}`);
+                    }
+
+                    if (deviceUpdated) {
+                        updatedCount++;
+                    }
+                } else {
+                    node.log(`云端设备未匹配: ${cloudDevice.device_name} (云端MAC: ${cloudMacRaw} → 反转后: ${cloudMacReversed})`);
+                }
+            });
+
+            node.log(`设备匹配完成: ${matchedCount}/${devicesToSync.length} 匹配, ${updatedCount} 个名称已更新`);
+
+            if (cloudData.scenes && cloudData.scenes.length > 0) {
+                const scenesToSync = node.selectedScenes.length > 0
+                    ? cloudData.scenes.filter(s => node.selectedScenes.includes(s.scene_id))
+                    : cloudData.scenes;
+
+                node.context().set('scenes', scenesToSync);
+                node.log(`场景列表已保存: ${scenesToSync.map(s => s.scene_name).join(', ')}`);
+
+                if (node.mqttConfig && scenesToSync.length > 0) {
+                    publishSceneButtons(scenesToSync);
+                }
+            }
+
+            if (updatedCount > 0 && node.mqttConfig) {
+                setTimeout(() => {
+                    node.log('重新发布MQTT Discovery配置（名称已更新）');
+                    node.mqttConfig.publishAllDiscovery(devices);
+                }, 1000);
+            }
+        };
+
+        const publishSceneButtons = (scenes) => {
+            if (!node.mqttConfig || !node.mqttConfig.mqttClient) {
+                node.warn('MQTT客户端未连接，无法发布场景按钮');
+                return;
+            }
+
+            const mqttClient = node.mqttConfig.mqttClient;
+            const mqttPrefix = node.mqttConfig.mqttPrefix || 'homeassistant';
+
+            const roomNo = node.roomNo || 'unknown';
+            node.log(`开始发布 ${scenes.length} 个场景按钮到Home Assistant`);
+
+            scenes.forEach((scene, index) => {
+                const config = generateSceneButtonConfig(scene, roomNo, mqttPrefix);
+
+                setTimeout(() => {
+                    mqttClient.publish(config.topic, config.payload, { retain: true }, (err) => {
+                        if (err) {
+                            node.error(`发布场景按钮失败: ${scene.scene_name}, ${err.message}`);
+                        } else {
+                            node.debug(`场景按钮已发布: ${scene.scene_name}`);
+                        }
+                    });
+                }, index * 100);
+            });
+
+            // 订阅场景触发主题
+            node.mqttConfig.subscribeSceneTriggers(roomNo);
+        };
+
+        node.gateway.on('device-list-complete', () => {
+            if (node.autoSync) {
+                setTimeout(() => {
+                    node.log('设备列表完成，开始自动同步云端数据');
+                    syncFromCloud();
+                }, 2000);
+            } else {
+                const cached = loadCachedData();
+                if (cached) {
+                    node.log('自动同步已禁用，使用缓存数据');
+                    applyCloudData(cached);
+                }
+            }
+        });
+
+        // 监听场景触发事件
+        if (node.mqttConfig) {
+            node.mqttConfig.on('scene-trigger', (topic, message) => {
+                const roomNo = node.roomNo || 'unknown';
+                if (topic.startsWith(`symi_mesh/room_${roomNo}/scene/`) && topic.endsWith('/trigger')) {
+                    const sceneIdMatch = topic.match(/scene\/(\d+)\/trigger/);
+                    if (sceneIdMatch) {
+                        const sceneId = parseInt(sceneIdMatch[1]);
+                        const scenes = node.context().get('scenes') || [];
+                        const scene = scenes.find(s => s.scene_id === sceneId);
+
+                        if (scene) {
+                            node.log(`[场景控制] 收到场景触发请求: ${scene.scene_name} (ID: ${sceneId})`);
+
+                            if (node.gateway && node.gateway.connected) {
+                                // 构建场景控制帧
+                                const frame = node.gateway.protocolHandler.buildSceneControlFrame(sceneId);
+                                node.log(`[场景控制] 场景控制帧: ${frame.toString('hex').toUpperCase()}`);
+
+                                node.gateway.sendScene(sceneId).then(() => {
+                                    node.log(`[场景控制] ✓ 场景控制命令已发送: ${scene.scene_name} (ID: ${sceneId})`);
+                                }).catch(err => {
+                                    node.error(`[场景控制] ✗ 场景控制命令发送失败: ${err.message}`);
+                                });
+                            } else {
+                                node.error('[场景控制] 网关未连接，无法执行场景');
+                            }
+                        } else {
+                            node.warn(`[场景控制] 场景ID ${sceneId} 未找到`);
+                        }
+                    }
+                }
+            });
+        }
+        
+        node.on('input', async function(msg) {
+            if (msg.payload === 'sync' || msg.payload === true) {
+                node.log('收到手动同步请求');
+                await syncFromCloud();
+            } else if (msg.payload && msg.payload.scene_id !== undefined) {
+                const scenes = node.context().get('scenes') || [];
+                const scene = scenes.find(s => s.scene_id === msg.payload.scene_id);
+                if (scene) {
+                    node.log(`执行场景: ${scene.scene_name} (ID: ${scene.scene_id})`);
+                    msg.payload = { scene_id: scene.scene_id };
+                    node.send(msg);
+                } else {
+                    node.warn(`场景ID ${msg.payload.scene_id} 不存在`);
+                }
+            }
+        });
+        
+        node.on('close', (done) => {
+            node.log('云端同步节点关闭');
+            done();
+        });
+    }
+
+    RED.nodes.registerType('symi-cloud-sync', SymiCloudSyncNode);
+
+    RED.httpAdmin.post('/symi-cloud-sync/test-connection', async (req, res) => {
+        try {
+            const { appId, appSecret } = req.body;
+            if (!appId || !appSecret) {
+                return res.json({ success: false, error: '缺少认证信息' });
+            }
+
+            const api = new CloudAPI(appId, appSecret);
+            await api.getHotelList(1, 1);
+
+            res.json({ success: true });
+        } catch (error) {
+            res.json({ success: false, error: error.message });
+        }
+    });
+
+    RED.httpAdmin.post('/symi-cloud-sync/get-hotels', async (req, res) => {
+        try {
+            const { appId, appSecret } = req.body;
+            if (!appId || !appSecret) {
+                return res.json({ success: false, error: '缺少认证信息' });
+            }
+
+            const api = new CloudAPI(appId, appSecret);
+            const result = await api.getHotelList(1, 100);
+
+            res.json({
+                success: true,
+                hotels: result.data || []
+            });
+        } catch (error) {
+            res.json({ success: false, error: error.message });
+        }
+    });
+
+    RED.httpAdmin.post('/symi-cloud-sync/get-rooms', async (req, res) => {
+        try {
+            const { appId, appSecret, hotelId } = req.body;
+            if (!appId || !appSecret || !hotelId) {
+                return res.json({ success: false, error: '缺少必要参数' });
+            }
+
+            const api = new CloudAPI(appId, appSecret);
+            const result = await api.getRoomList(hotelId, 1, 100);
+
+            res.json({
+                success: true,
+                rooms: result.data || []
+            });
+        } catch (error) {
+            res.json({ success: false, error: error.message });
+        }
+    });
+
+    RED.httpAdmin.post('/symi-cloud-sync/get-room-info', async (req, res) => {
+        try {
+            const { appId, appSecret, roomUuid } = req.body;
+            if (!appId || !appSecret || !roomUuid) {
+                return res.json({ success: false, error: '缺少必要参数' });
+            }
+
+            const api = new CloudAPI(appId, appSecret);
+            const result = await api.getRoomInfo({ room_uuid: roomUuid });
+
+            res.json({
+                success: true,
+                roomInfo: result
+            });
+        } catch (error) {
+            res.json({ success: false, error: error.message });
+        }
+    });
+};
+

package/nodes/symi-device.html

@@ -5,6 +5,7 @@
         defaults: {
             name: { value: '' },
             gateway: { value: '', type: 'symi-gateway', required: true },
+            mqttConfig: { value: '', type: 'symi-mqtt' },
             deviceMac: { value: '', required: true },
             channel: { value: 1 },
             deviceData: { value: '' },
@@ -161,7 +162,12 @@
         <label for="node-input-gateway"><i class="fa fa-server"></i> 网关</label>
         <input type="text" id="node-input-gateway">
     </div>
-    
+
+    <div class="form-row">
+        <label for="node-input-mqttConfig"><i class="fa fa-exchange"></i> MQTT配置</label>
+        <input type="text" id="node-input-mqttConfig">
+    </div>
+
     <div class="form-row">
         <label for="node-input-deviceMac"><i class="fa fa-microchip"></i> 设备</label>
         <select id="node-input-deviceMac" style="width:70%">

package/nodes/symi-gateway.html

@@ -10,8 +10,8 @@
             baudRate: { value: 115200 }
         },
         label: function() {
-            return this.name || (this.connectionType === 'tcp' 
-                ? `Symi Gateway (${this.host}:${this.port})` 
+            return this.name || (this.connectionType === 'tcp'
+                ? `Symi Gateway (${this.host}:${this.port})`
                 : `Symi Gateway (${this.serialPort})`);
         },
         oneditprepare: function() {
@@ -33,7 +33,7 @@
         <label for="node-config-input-name"><i class="fa fa-tag"></i> 名称</label>
         <input type="text" id="node-config-input-name" placeholder="网关名称">
     </div>
-    
+
     <div class="form-row">
         <label for="node-config-input-connectionType"><i class="fa fa-plug"></i> 连接方式</label>
         <select id="node-config-input-connectionType">

package/nodes/symi-gateway.js

@@ -10,21 +10,27 @@ const { ProtocolHandler, parseStatusEvent, OP_RESP_DEVICE_LIST } = require('../l
 module.exports = function(RED) {
     function SymiGatewayNode(config) {
         RED.nodes.createNode(this, config);
-        
+
         this.name = config.name;
         this.connectionType = config.connectionType || 'tcp';
         this.host = config.host;
         this.port = parseInt(config.port) || 4196;
         this.serialPort = config.serialPort;
         this.baudRate = parseInt(config.baudRate) || 115200;
-        
+
         this.client = null;
         this.deviceManager = new DeviceManager(this.context(), this);
         this.protocolHandler = new ProtocolHandler();
         this.connected = false;
         this.deviceListComplete = false;
         this.isQueryingStates = false; // 标记是否正在查询状态
-        
+
+        // 状态事件处理队列 - 确保场景执行后的大量状态更新能被正确处理
+        this.stateEventQueue = [];
+        this.isProcessingStateEvent = false;
+        this.sceneExecutionInProgress = false;  // 场景执行中标志
+        this.sceneExecutionTimer = null;  // 场景执行超时定时器
+
         this.log(`Initializing Symi Gateway: ${this.connectionType === 'tcp' ? `${this.host}:${this.port}` : this.serialPort}`);
         
         // 监听三合一设备检测事件
@@ -113,6 +119,20 @@ module.exports = function(RED) {
             // 初始连接失败，但自动重连会继续尝试
             this.error(`Initial connection failed: ${error.message}, will retry automatically`);
         }
+
+        // 节点关闭时清理资源
+        this.on('close', (done) => {
+            // 清理场景执行定时器
+            if (this.sceneExecutionTimer) {
+                clearTimeout(this.sceneExecutionTimer);
+                this.sceneExecutionTimer = null;
+            }
+
+            // 清空队列
+            this.stateEventQueue = [];
+
+            done();
+        });
     };
 
     SymiGatewayNode.prototype.disconnect = async function() {
@@ -131,16 +151,75 @@ module.exports = function(RED) {
         if (frame.opcode === OP_RESP_DEVICE_LIST && frame.status === 0x00) {
             this.parseDeviceListFrame(frame);
         } else if (frame.isDeviceStatusEvent()) {
+            // 将状态事件加入队列处理
+            this.stateEventQueue.push(frame);
+            this.processStateEventQueue();
+        } else if (frame.opcode === 0xB0) {
+            // 控制命令响应
+            this.debug(`[控制响应] 0xB0: ${frameHex} ${frame.status === 0 ? '(成功)' : '(失败)'}`)
+        } else if (frame.opcode === 0xB4) {
+            // 场景控制响应
+            if (frame.status === 0) {
+                this.log(`[场景控制] 场景控制命令已被网关接受`);
+                // 标记场景执行开始，2秒内的状态事件都认为是场景执行导致的
+                this.sceneExecutionInProgress = true;
+                if (this.sceneExecutionTimer) {
+                    clearTimeout(this.sceneExecutionTimer);
+                }
+                this.sceneExecutionTimer = setTimeout(() => {
+                    this.sceneExecutionInProgress = false;
+                    this.log(`[场景控制] 场景执行完成`);
+                }, 2000);
+            } else {
+                this.error(`[场景控制] 场景控制命令失败: status=${frame.status}`);
+            }
+        } else {
+            // 其他frame类型
+            this.debug(`[其他Frame] ${frameHex}`);
+        }
+    };
+
+    // 处理状态事件队列 - 使用异步队列确保所有事件都被处理
+    SymiGatewayNode.prototype.processStateEventQueue = async function() {
+        if (this.isProcessingStateEvent || this.stateEventQueue.length === 0) {
+            return;
+        }
+
+        this.isProcessingStateEvent = true;
+
+        while (this.stateEventQueue.length > 0) {
+            const frame = this.stateEventQueue.shift();
+
             try {
                 const event = parseStatusEvent(frame);
-                this.debug(`[状态事件] 地址=0x${event.networkAddress.toString(16).toUpperCase()}, 消息类型=0x${event.attrType.toString(16).toUpperCase()}, 参数=[${Array.from(event.parameters).map(p => '0x' + p.toString(16).toUpperCase()).join(', ')}]`);
-                
+
+                // 检查是否是场景执行通知事件
+                if (event.subOpcode === 0x11) {
+                    const sceneId = event.parameters.length > 0 ? event.parameters[0] : 'unknown';
+                    const frameHex = Buffer.concat([
+                        Buffer.from([frame.header, frame.opcode, frame.status, frame.length]),
+                        frame.payload,
+                        Buffer.from([frame.checksum])
+                    ]).toString('hex').toUpperCase();
+                    this.log(`[场景执行] 收到场景执行通知事件: 场景ID=${sceneId}, 设备地址=0x${event.networkAddress.toString(16).toUpperCase()}, 原始帧=${frameHex}`);
+                    continue;
+                }
+
+                // 记录状态事件
+                const logPrefix = this.sceneExecutionInProgress ? '[场景执行]' : '[状态事件]';
+                if (this.sceneExecutionInProgress) {
+                    // 场景执行期间使用log级别，便于查看
+                    this.log(`${logPrefix} 地址=0x${event.networkAddress.toString(16).toUpperCase()}, 消息类型=0x${event.attrType.toString(16).toUpperCase()}, 参数=[${Array.from(event.parameters).map(p => '0x' + p.toString(16).toUpperCase()).join(', ')}]`);
+                } else {
+                    this.debug(`${logPrefix} 地址=0x${event.networkAddress.toString(16).toUpperCase()}, 消息类型=0x${event.attrType.toString(16).toUpperCase()}, 参数=[${Array.from(event.parameters).map(p => '0x' + p.toString(16).toUpperCase()).join(', ')}]`);
+                }
+
                 const device = this.deviceManager.updateDeviceState(
                     event.networkAddress,
                     event.attrType,
                     event.parameters
                 );
-                
+
                 // 只在非查询状态期间才发送state-changed事件到MQTT
                 // 查询状态期间的事件只用于更新设备状态，不触发MQTT发布
                 if (device && !this.isQueryingStates) {
@@ -148,24 +227,26 @@ module.exports = function(RED) {
                         device: device,
                         attrType: event.attrType,
                         parameters: event.parameters,
-                        state: device.state
+                        state: device.state,
+                        isSceneExecution: this.sceneExecutionInProgress  // 标记是否是场景执行导致的状态变化
                     });
                 }
+
+                // 添加小延迟，避免CPU占用过高
+                if (this.stateEventQueue.length > 0) {
+                    await new Promise(resolve => setImmediate(resolve));
+                }
             } catch (error) {
                 this.error(`Error parsing status event: ${error.message}`);
             }
-        } else if (frame.opcode === 0xB0) {
-            // 控制命令响应
-            this.debug(`[控制响应] 0xB0: ${frameHex} ${frame.status === 0 ? '(成功)' : '(失败)'}`)
-        } else {
-            // 其他frame类型
-            this.debug(`[其他Frame] ${frameHex}`);
         }
+
+        this.isProcessingStateEvent = false;
     };
 
     SymiGatewayNode.prototype.parseDeviceListFrame = function(frame) {
         if (frame.payload.length < 16) return;
-        
+
         const maxDevices = frame.payload[0];
         const index = frame.payload[1];
         const macBytes = frame.payload.slice(2, 8);
@@ -209,14 +290,15 @@ module.exports = function(RED) {
     SymiGatewayNode.prototype.queryAllDeviceStates = async function() {
         const devices = this.deviceManager.getAllDevices();
         this.log(`开始查询${devices.length}个设备的初始状态...`);
-        
+
         for (const device of devices) {
             try {
                 let queryAttrs = [];
-                
+
                 // 根据设备类型查询不同属性
                 if ([1, 2, 3].includes(device.deviceType)) {
                     queryAttrs = [0x02]; // 开关状态
+                    this.log(`查询开关设备: ${device.name} (地址=0x${device.networkAddress.toString(16).toUpperCase()}, 路数=${device.channels})`);
                 } else if (device.deviceType === 9) {
                     queryAttrs = [0x02, 0x0E]; // 插卡取电：开关状态、插卡状态
                 } else if (device.deviceType === 4 || device.deviceType === 0x18) {
@@ -367,17 +449,20 @@ module.exports = function(RED) {
                 
                 // 使用状态组合算法
                 const stateValue = this.protocolHandler.buildSwitchState(channels, targetChannel, targetState, currentState);
-                
+
                 let controlParam;
+                let stateValueHex;
                 if (Buffer.isBuffer(stateValue)) {
                     // 6路开关，2字节状态
                     controlParam = stateValue;
+                    stateValueHex = stateValue.toString('hex').toUpperCase();
                 } else {
                     // 1-4路开关，1字节状态
                     controlParam = Buffer.from([stateValue]);
+                    stateValueHex = stateValue.toString(16).toUpperCase();
                 }
-                
-                this.debug(`发送开关控制: 地址0x${networkAddr.toString(16).toUpperCase()}, 第${targetChannel}路${targetState ? '开' : '关'}, 状态值0x${stateValue.toString(16).toUpperCase()}`);
+
+                this.debug(`发送开关控制: 地址0x${networkAddr.toString(16).toUpperCase()}, 第${targetChannel}路${targetState ? '开' : '关'}, 状态值0x${stateValueHex}`);
                 const frame = this.protocolHandler.buildDeviceControlFrame(networkAddr, attrType, controlParam);
                 return await this.client.sendFrame(frame, 1);