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

package/nodes/symi-mqtt.js

@@ -33,43 +33,160 @@ module.exports = function(RED) {
         
         node.connectMQTT();
         
-        node.gateway.on('device-list-complete', (devices) => {
+        // 存储事件处理函数引用，便于关闭时移除
+        node._handlers = {};
+        
+        node._handlers.deviceListComplete = (devices) => {
             if (node.mqttClient && node.mqttClient.connected) {
+                // 延迟3秒等待云端同步完成后再发布Discovery
                 setTimeout(() => {
                     node.log(`网关设备列表同步完成，发布${devices.length}个设备到MQTT`);
                     node.publishAllDiscovery(devices);
-                }, 500);
+                }, 3000);
             } else {
                 node.warn('设备列表已完成但MQTT未连接，等待MQTT连接后发布');
             }
-        });
+        };
+        node.gateway.on('device-list-complete', node._handlers.deviceListComplete);
         
-        node.gateway.on('gateway-connected', () => {
+        node._handlers.gatewayConnected = () => {
             node.log('网关已连接，等待设备发现完成');
-        });
+        };
+        node.gateway.on('gateway-connected', node._handlers.gatewayConnected);
         
-        node.gateway.on('gateway-disconnected', () => {
+        node._handlers.gatewayDisconnected = () => {
             node.log('网关已断开');
-        });
+        };
+        node.gateway.on('gateway-disconnected', node._handlers.gatewayDisconnected);
         
-        node.gateway.on('device-state-changed', (eventData) => {
+        node._handlers.deviceStateChanged = (eventData) => {
             if (node.mqttClient && node.mqttClient.connected) {
                 node.publishDeviceState(eventData);
             }
-        });
-        
-        
-        node.on('close', (done) => {
+        };
+        node.gateway.on('device-state-changed', node._handlers.deviceStateChanged);
+
+        // 监听设备状态同步完成事件，处理三合一设备的MQTT发布
+        node._handlers.deviceStatesSynced = (devices) => {
             if (node.mqttClient && node.mqttClient.connected) {
-                const devices = node.gateway.deviceManager.getAllDevices();
+                // 检查是否有新确认的三合一设备需要发布
                 devices.forEach(device => {
-                    const macClean = device.macAddress.replace(/:/g, '').toLowerCase();
-                    node.mqttClient.publish(`symi_mesh/${macClean}/availability`, 'offline', { retain: true });
+                    if (device.isThreeInOne) {
+                        const macClean = device.macAddress.replace(/:/g, '').toLowerCase();
+                        if (!node.publishedDevices.has(macClean)) {
+                            node.log(`[三合一] 发布三合一设备 ${device.name} 到MQTT`);
+                            
+                            // 发布availability
+                            node.mqttClient.publish(`symi_mesh/${macClean}/availability`, 'online', { retain: true });
+                            
+                            // 发布Discovery配置
+                            const configs = generateDiscoveryConfig(device, node.mqttPrefix, node);
+                            configs.forEach((config, index) => {
+                                setTimeout(() => {
+                                    node.mqttClient.publish(config.topic, config.payload, { retain: true });
+                                }, index * 50);
+                            });
+                            
+                            // 订阅command topics
+                            const topics = generateStateTopics(device);
+                            const deviceMacForSub = device.macAddress; // 捕获当前设备MAC，避免闭包问题
+                            node.log(`[三合一] 订阅${topics.command.length}个command topics`);
+                            topics.command.forEach(topic => {
+                                if (!node.subscriptions.has(topic)) {
+                                    node.log(`[三合一] 订阅: ${topic}`);
+                                    node.mqttClient.subscribe(topic, (err) => {
+                                        if (!err) {
+                                            node.subscriptions.set(topic, deviceMacForSub);
+                                            node.log(`[三合一] 订阅成功: ${topic}`);
+                                        } else {
+                                            node.error(`[三合一] 订阅失败: ${topic}`);
+                                        }
+                                    });
+                                }
+                            });
+                            
+                            node.publishedDevices.add(macClean);
+                            
+                            // 发布初始状态
+                            setTimeout(() => {
+                                publishInitialDeviceState(device, node);
+                            }, 500);
+                        }
+                    }
                 });
-                
-                setTimeout(() => {
-                    node.mqttClient.end(false, {}, done);
-                }, 200);
+            }
+        };
+        node.gateway.on('device-states-synced', node._handlers.deviceStatesSynced);
+
+        // 监听温控器确认事件，确认后立即发布Discovery
+        node._handlers.thermostatConfirmed = (device) => {
+            if (node.mqttClient && node.mqttClient.connected) {
+                node.log(`温控器${device.name}已确认，发布Discovery配置`);
+                const macClean = device.macAddress.replace(/:/g, '').toLowerCase();
+
+                // 发布availability
+                node.mqttClient.publish(`symi_mesh/${macClean}/availability`, 'online', { retain: true });
+
+                // 发布Discovery配置
+                const configs = generateDiscoveryConfig(device, node.mqttPrefix, node);
+                configs.forEach(config => {
+                    node.mqttClient.publish(config.topic, config.payload, { retain: config.retain });
+                });
+
+                // 订阅command topics
+                const topics = generateStateTopics(device);
+                const deviceMacForSub = device.macAddress; // 捕获当前设备MAC，避免闭包问题
+                topics.command.forEach(topic => {
+                    if (!node.subscriptions.has(topic)) {
+                        node.mqttClient.subscribe(topic, (err) => {
+                            if (!err) {
+                                node.subscriptions.set(topic, deviceMacForSub);
+                                node.debug(`订阅topic: ${topic} -> ${deviceMacForSub}`);
+                            } else {
+                                node.error(`订阅失败: ${topic}, ${err.message}`);
+                            }
+                        });
+                    }
+                });
+
+                // 标记为已发布
+                node.publishedDevices.add(macClean);
+
+                // 发布初始状态
+                publishInitialDeviceState(device, node);
+            }
+        };
+        node.gateway.on('thermostat-confirmed', node._handlers.thermostatConfirmed);
+
+        node.on('close', (done) => {
+            // 移除gateway事件监听器，防止内存泄漏
+            if (node.gateway && node._handlers) {
+                node.gateway.removeListener('device-list-complete', node._handlers.deviceListComplete);
+                node.gateway.removeListener('gateway-connected', node._handlers.gatewayConnected);
+                node.gateway.removeListener('gateway-disconnected', node._handlers.gatewayDisconnected);
+                node.gateway.removeListener('device-state-changed', node._handlers.deviceStateChanged);
+                node.gateway.removeListener('device-states-synced', node._handlers.deviceStatesSynced);
+                node.gateway.removeListener('thermostat-confirmed', node._handlers.thermostatConfirmed);
+            }
+            
+            // 清理MQTT资源
+            if (node.mqttClient) {
+                // 移除所有监听器
+                node.mqttClient.removeAllListeners();
+
+                if (node.mqttClient.connected) {
+                    const devices = node.gateway.deviceManager.getAllDevices();
+                    devices.forEach(device => {
+                        const macClean = device.macAddress.replace(/:/g, '').toLowerCase();
+                        node.mqttClient.publish(`symi_mesh/${macClean}/availability`, 'offline', { retain: true });
+                    });
+
+                    setTimeout(() => {
+                        node.mqttClient.end(false, {}, done);
+                    }, 200);
+                } else {
+                    done();
+                }
             } else {
                 done();
             }
@@ -94,7 +211,7 @@ module.exports = function(RED) {
             node.mqttClient = mqtt.connect(node.mqttBroker, options);
             
             node.mqttClient.on('message', (topic, message) => {
-                node.debug(`[MQTT消息] topic=${topic}, message=${message.toString()}`);
+                node.log(`[MQTT消息] topic=${topic}, message=${message.toString()}`);
                 node.handleMQTTMessage(topic, message);
             });
             
@@ -121,10 +238,13 @@ module.exports = function(RED) {
             });
             
             node.mqttClient.on('error', (error) => {
-                node.error(`MQTT错误: ${error.message}`);
+                // 只记录非连接错误，避免重连时大量日志
+                if (error.code !== 'ECONNREFUSED' && error.code !== 'ENOTFOUND') {
+                    node.error(`MQTT错误: ${error.message}`);
+                }
                 node.status({ fill: 'red', shape: 'ring', text: '错误' });
             });
-            
+
             node.mqttClient.on('offline', () => {
                 node.status({ fill: 'yellow', shape: 'ring', text: '离线' });
             });
@@ -135,46 +255,56 @@ module.exports = function(RED) {
         }
     };
 
-    SymiMQTTNode.prototype.publishAllDiscovery = function(devices) {
+    SymiMQTTNode.prototype.publishAllDiscovery = function(devices, forceUpdate = false) {
         const node = this;
-        
-        const supportedTypes = [1, 2, 3, 4, 5, 8, 9, 10, 0x18];
-        
+
+        const supportedTypes = [1, 2, 3, 4, 5, 8, 9, 10, 0x18, 39];
+
         devices.forEach(device => {
             const macClean = device.macAddress.replace(/:/g, '').toLowerCase();
-            
+
             // 跳过正在检测中的设备（等待三合一识别完成）
             if (device.needsThreeInOneCheck) {
-                node.log(`设备${device.name}正在检测类型，跳过发布（等待识别完成）`);
+                node.debug(`设备${device.name}正在检测类型，跳过发布（等待识别完成）`);
                 return; // 不添加到publishedDevices，等识别完成后再发布
             }
-            
+
             // 跳过温控器类型但未确认的设备（防止在识别过程中被提前发布）
             if (device.deviceType === 10 && !device.isThreeInOne && !device.thermostatConfirmed) {
-                node.log(`温控器${device.name}尚未确认类型，跳过发布`);
+                node.debug(`温控器${device.name}尚未确认类型，跳过发布（等待确认后自动发布）`);
                 return;
             }
-            
+
             // 三合一设备通过isThreeInOne标记识别，不依赖deviceType
             if (!supportedTypes.includes(device.deviceType) && !device.isThreeInOne) {
                 node.log(`跳过非支持设备: ${device.name} (type=${device.deviceType})`);
                 return;
             }
-            
-            if (node.publishedDevices.has(macClean)) {
-                node.log(`设备已发布，跳过: ${device.name}`);
+
+            // 如果不是强制更新，且设备已发布，则跳过
+            if (!forceUpdate && node.publishedDevices.has(macClean)) {
+                node.debug(`设备已发布，跳过: ${device.name}`);
                 return;
             }
+
+            // 如果是强制更新，先从已发布列表中移除，以便重新发布
+            if (forceUpdate && node.publishedDevices.has(macClean)) {
+                node.log(`强制更新设备配置: ${device.name}`);
+                node.publishedDevices.delete(macClean);
+            }
             
-            const configs = generateDiscoveryConfig(device, node.mqttPrefix);
+            const configs = generateDiscoveryConfig(device, node.mqttPrefix, node);
             const topics = generateStateTopics(device);
             
-            node.log(`发布设备 ${device.name} (${configs.length}个实体)`);
+            node.debug(`发布设备 ${device.name} (${configs.length}个实体)`);
             
             // 先立即发布availability: online，确保HA认为设备可用
+            node.log(`[MQTT] 发布 ${device.name} availability: online`);
             node.mqttClient.publish(`symi_mesh/${macClean}/availability`, 'online', { retain: true }, (err) => {
                 if (err) {
                     node.error(`发布availability失败: ${err.message}`);
+                } else {
+                    node.log(`[MQTT] ${device.name} availability已发布`);
                 }
             });
             
@@ -189,14 +319,16 @@ module.exports = function(RED) {
                 }, index * 50 + 100);
             });
             
+            const deviceMacForSub = device.macAddress; // 捕获当前设备MAC，避免闭包问题
             topics.command.forEach(topic => {
                 if (!node.subscriptions.has(topic)) {
+                    node.log(`[MQTT] 订阅: ${topic}`);
                     node.mqttClient.subscribe(topic, (err) => {
                         if (!err) {
-                            node.subscriptions.set(topic, device.macAddress);
-                            node.debug(`订阅topic: ${topic} → ${device.macAddress}`);
+                            node.subscriptions.set(topic, deviceMacForSub);
+                            node.log(`[MQTT] 订阅成功: ${topic}`);
                         } else {
-                            node.error(`订阅失败: ${topic}, ${err.message}`);
+                            node.error(`[MQTT] 订阅失败: ${topic}, ${err.message}`);
                         }
                     });
                 }
@@ -310,7 +442,7 @@ module.exports = function(RED) {
             node.mqttClient.publish(`symi_mesh/${macClean}/floor_heating/current_temp`, '20', { retain: true });
         }
         
-        node.log(`发布设备 ${device.name} 初始状态`);
+        node.debug(`发布设备 ${device.name} 初始状态`);
     }
 
     SymiMQTTNode.prototype.publishDeviceState = function(eventData) {
@@ -409,6 +541,7 @@ module.exports = function(RED) {
                     node.debug(`发布开关状态: ${switchState}`);
                 } else {
                     // 发布每个继电器的状态
+                    node.debug(`[状态发布] ${device.name} (${device.channels}路) attrType=0x${attrType.toString(16).toUpperCase()}, state=${JSON.stringify(state)}`);
                     for (let i = 1; i <= device.channels; i++) {
                         const value = state[`switch_${i}`];
                         if (value !== undefined) {
@@ -417,7 +550,9 @@ module.exports = function(RED) {
                                 topic: `symi_mesh/${macClean}/switch_${i}/state`,
                                 payload: switchState
                             });
-                            node.debug(`发布开关路${i}: ${switchState}`);
+                            node.debug(`[状态发布] ${device.name} 第${i}路: ${switchState} (value=${value})`);
+                        } else {
+                            node.warn(`[状态发布] ${device.name} 第${i}路状态未定义`);
                         }
                     }
                 }
@@ -869,7 +1004,10 @@ module.exports = function(RED) {
         if (publishes.length > 0 && node.mqttClient && node.mqttClient.connected) {
             publishes.forEach(p => {
                 node.mqttClient.publish(p.topic, p.payload, { retain: true });
+                node.debug(`[MQTT发布] ${p.topic} = ${p.payload}`);
             });
+        } else if (publishes.length > 0) {
+            node.warn(`[MQTT发布失败] MQTT未连接，无法发布${publishes.length}条消息`);
         }
     };
 
@@ -877,7 +1015,8 @@ module.exports = function(RED) {
         const node = this;
 
         // 检查是否是场景触发消息
-        if (topic.match(/symi_mesh\/room_\w+\/scene\/\d+\/trigger/)) {
+        if (topic.match(/symi_mesh\/room_.+\/scene\/\d+\/trigger/)) {
+            node.log(`[场景触发] 收到MQTT消息: ${topic}`);
             node.emit('scene-trigger', topic, message);
             return;
         }
@@ -885,13 +1024,18 @@ module.exports = function(RED) {
         const deviceMac = node.subscriptions.get(topic);
 
         if (!deviceMac) {
-            node.warn(`未找到topic订阅: ${topic}`);
+            // 输出当前所有订阅，帮助调试
+            node.warn(`[MQTT] 未找到topic订阅: ${topic}`);
+            node.debug(`[MQTT] 当前订阅列表 (${node.subscriptions.size}个):`);
+            node.subscriptions.forEach((mac, t) => {
+                node.debug(`  ${t} -> ${mac}`);
+            });
             return;
         }
 
         const device = node.gateway.getDevice(deviceMac);
         if (!device) {
-            node.warn(`设备未找到: ${deviceMac}`);
+            node.warn(`[MQTT] 设备未找到: MAC=${deviceMac}, topic=${topic}`);
             return;
         }
         
@@ -901,11 +1045,51 @@ module.exports = function(RED) {
         const commands = node.parseMQTTCommand(topic, payload, device);
 
         if (commands && commands.length > 0) {
-            node.log(`[MQTT解析] 解析出${commands.length}个命令:`);
+            node.debug(`[MQTT解析] 解析出${commands.length}个命令:`);
             commands.forEach((cmd, idx) => {
                 node.log(`  命令${idx + 1}: attrType=0x${cmd.attrType.toString(16).toUpperCase()}, param=[${Array.from(cmd.param).map(p => '0x' + p.toString(16).toUpperCase()).join(', ')}]`);
             });
 
+            // 检查是否是开关控制命令，且该按键绑定了场景
+            const isSwitch = (device.deviceType === 1 || device.deviceType === 2) && commands[0].attrType === 0x02;
+            if (isSwitch && device.subDeviceConfigs && device.subDeviceConfigs.length > 0) {
+                // 解析出是哪个按键
+                const match = topic.match(/switch_(\d+)\/set/);
+                const channel = match ? parseInt(match[1]) : 1;
+
+                // 检查该按键是否绑定场景
+                const sceneInfo = device.getButtonSceneId(channel);
+                if (sceneInfo) {
+                    // 该按键绑定了场景，应该触发场景而不是直接控制继电器
+                    node.log(`[MQTT场景] 按键${channel}(${sceneInfo.name})绑定了场景，触发场景而非控制继电器`);
+
+                    (async () => {
+                        try {
+                            // 根据按键类型决定触发哪个场景
+                            let sceneId = sceneInfo.sceneId;
+
+                            if (sceneInfo.type === 'dual_control' || sceneInfo.type === 'master_control') {
+                                // 双控/总控：根据目标状态选择场景
+                                const targetState = (payload === 'ON');
+                                const config = device.subDeviceConfigs[channel - 1];
+                                sceneId = targetState ? config.on_scene_id : config.off_scene_id;
+                                node.log(`[MQTT场景] ${sceneInfo.type === 'dual_control' ? '双控' : '总控'}按键，目标状态=${targetState ? '开' : '关'}，触发场景${sceneId}`);
+                            } else {
+                                // 场景按键：直接触发场景
+                                node.log(`[MQTT场景] 场景按键，触发场景${sceneId}`);
+                            }
+
+                            await node.gateway.sendScene(sceneId);
+                            node.log(`[MQTT场景] 场景${sceneId}(${sceneInfo.name})控制命令已发送`);
+                        } catch(err) {
+                            node.error(`[MQTT场景] 场景触发失败: ${err.message}`);
+                        }
+                    })();
+
+                    return; // 不执行后续的继电器控制
+                }
+            }
+
             // 使用for循环而不是forEach以正确处理async
             (async () => {
                 for (const command of commands) {
@@ -913,13 +1097,13 @@ module.exports = function(RED) {
                     node.log(`[MQTT发送] → 网关: addr=0x${device.networkAddress.toString(16).toUpperCase()}, attr=0x${command.attrType.toString(16).toUpperCase()}, param=[${paramHex}]`);
                     try {
                         await node.gateway.sendControl(device.networkAddress, command.attrType, command.param);
-                        node.log(`[MQTT发送] ✓ 成功: ${device.name}`);
-                        
+                        node.debug(`[MQTT发送] 成功: ${device.name}`);
+
                         // 立即发布状态更新（optimistic update）
                         node.publishCommandFeedback(device, command, payload, topic);
-                        
+
                     } catch(err) {
-                        node.error(`[MQTT发送] ✗ 失败: ${err.message}`);
+                        node.error(`[MQTT发送] 失败: ${err.message}`);
                     }
                 }
             })();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-symi-mesh",
-  "version": "1.3.1",
+  "version": "1.6.1",
   "description": "Node-RED节点集合，用于通过TCP/串口连接Symi蓝牙Mesh网关，支持Home Assistant MQTT Discovery自动发现和云端数据同步",
   "main": "index.js",
   "scripts": {
@@ -31,16 +31,19 @@
       "symi-gateway": "nodes/symi-gateway.js",
       "symi-device": "nodes/symi-device.js",
       "symi-mqtt": "nodes/symi-mqtt.js",
-      "symi-cloud-sync": "nodes/symi-cloud-sync.js"
+      "symi-cloud-sync": "nodes/symi-cloud-sync.js",
+      "symi-485-config": "nodes/symi-485-config.js",
+      "symi-rs485-bridge": "nodes/symi-485-bridge.js",
+      "rs485-debug": "nodes/rs485-debug.js"
     }
   },
   "dependencies": {
-    "axios": "^1.13.2",
+    "axios": "^1.7.9",
     "mqtt": "^5.3.0",
     "serialport": "^12.0.0"
   },
   "engines": {
-    "node": ">=14.0.0"
+    "node": ">=18.0.0"
   },
   "files": [
     "lib/",