node-red-contrib-symi-mesh 1.7.5 → 1.7.8

package/nodes/symi-mqtt-brand.js

@@ -1,8 +1,74 @@
 'use strict';
 
+/**
+ * 品牌MQTT配置节点 - 支持HYQW等第三方MQTT协议
+ * v1.7.8 增强版：完整HYQW协议支持，可扩展架构
+ */
+
 const mqtt = require('mqtt');
 
 module.exports = function(RED) {
+    // 品牌协议定义
+    const BRAND_PROTOCOLS = {
+        hyqw: {
+            name: 'HYQW (花语前湾)',
+            needsProjectConfig: true,
+            getUploadTopic: (cfg) => cfg.projectCode && cfg.deviceSn 
+                ? `FMQ/${cfg.projectCode}/${cfg.deviceSn}/UPLOAD/2002` : null,
+            getDownTopic: (cfg) => cfg.projectCode && cfg.deviceSn 
+                ? `FMQ/${cfg.projectCode}/${cfg.deviceSn}/DOWN/2001` : null,
+            parseMessage: (payload) => {
+                try {
+                    const data = JSON.parse(payload.toString());
+                    if (!data.payload) return null;
+                    const { st, si, fn, fv } = data.payload;
+                    if (st === undefined || si === undefined || fn === undefined || fv === undefined) return null;
+                    return { deviceType: st, deviceId: si, fn, fv };
+                } catch (e) { return null; }
+            },
+            buildMessage: (st, si, fn, fv) => {
+                return JSON.stringify({ payload: { st, si, fn, fv } });
+            },
+            deviceTypes: {
+                8: { name: '灯具', meshType: 'light', channels: 8 },
+                12: { name: '空调', meshType: 'climate', channels: 1 },
+                14: { name: '窗帘', meshType: 'cover', channels: 1 },
+                16: { name: '地暖', meshType: 'climate', channels: 1 },
+                36: { name: '新风', meshType: 'fan', channels: 1 }
+            },
+            // 功能码定义
+            functionCodes: {
+                8: { // 灯具
+                    1: { name: '开关', meshProp: 'switch', valueMap: { 0: false, 1: true }, reverseMap: { false: 0, true: 1 } },
+                    2: { name: '亮度', meshProp: 'brightness', range: [0, 100] }
+                },
+                12: { // 空调
+                    1: { name: '开关', meshProp: 'switch', valueMap: { 0: false, 1: true }, reverseMap: { false: 0, true: 1 } },
+                    2: { name: '温度', meshProp: 'targetTemp', range: [18, 29] },
+                    3: { name: '模式', meshProp: 'climateMode', valueMap: { 0: 'cool', 1: 'heat', 2: 'fan_only', 3: 'dry' }, 
+                         reverseMap: { cool: 0, heat: 1, fan_only: 2, dry: 3 } },
+                    4: { name: '风速', meshProp: 'fanMode', valueMap: { 0: 'auto', 1: 'low', 2: 'medium', 3: 'high' },
+                         reverseMap: { auto: 0, low: 1, medium: 2, high: 3 } }
+                },
+                14: { // 窗帘
+                    1: { name: '动作', meshProp: 'curtainAction', valueMap: { 0: 'close', 1: 'open', 2: 'stop' },
+                         reverseMap: { close: 0, open: 1, stop: 2 } },
+                    2: { name: '位置', meshProp: 'curtainPosition', range: [0, 100] }
+                },
+                16: { // 地暖
+                    1: { name: '开关', meshProp: 'floorHeatingSwitch', valueMap: { 0: false, 1: true }, reverseMap: { false: 0, true: 1 } },
+                    2: { name: '温度', meshProp: 'floorHeatingTemp', range: [5, 35] }
+                },
+                36: { // 新风
+                    1: { name: '开关', meshProp: 'freshAirSwitch', valueMap: { 0: false, 1: true }, reverseMap: { false: 0, true: 1 } },
+                    3: { name: '风速', meshProp: 'freshAirSpeed', valueMap: { 0: 'auto', 1: 'low', 2: 'medium', 3: 'high' },
+                         reverseMap: { auto: 0, low: 1, medium: 2, high: 3 } }
+                }
+            }
+        }
+        // 后续可扩展其他品牌: tuya, custom 等
+    };
+
     // 品牌MQTT配置节点
     function SymiMqttBrandNode(config) {
         RED.nodes.createNode(this, config);
@@ -17,34 +83,19 @@ module.exports = function(RED) {
         node.projectCode = config.projectCode || '';
         node.deviceSn = config.deviceSn || '';
 
+        // 获取协议处理器
+        node._protocol = BRAND_PROTOCOLS[node.brand] || BRAND_PROTOCOLS.hyqw;
+
         // 运行时状态
         node._client = null;
         node._connected = false;
         node._discoveredDevices = new Map();
+        node._deviceStates = new Map();
         node._subscribers = new Set();
         node._closing = false;
         node._reconnectTimer = null;
         node._lastErrorLog = 0;
-
-        // 设备类型定义
-        const DEVICE_TYPES = {
-            8: { name: '灯具', type: 'light' },
-            12: { name: '空调', type: 'climate' },
-            14: { name: '窗帘', type: 'cover' },
-            16: { name: '地暖', type: 'climate' },
-            36: { name: '新风', type: 'fan' }
-        };
-
-        // 获取MQTT主题
-        function getUploadTopic() {
-            if (!node.projectCode || !node.deviceSn) return null;
-            return `FMQ/${node.projectCode}/${node.deviceSn}/UPLOAD/2002`;
-        }
-
-        function getDownTopic() {
-            if (!node.projectCode || !node.deviceSn) return null;
-            return `FMQ/${node.projectCode}/${node.deviceSn}/DOWN/2001`;
-        }
+        node._cleanupTimer = null;
 
         // 限流错误日志
         function logErrorThrottled(msg) {
@@ -55,6 +106,15 @@ module.exports = function(RED) {
             }
         }
 
+        // 获取MQTT主题
+        function getUploadTopic() {
+            return node._protocol.getUploadTopic(node);
+        }
+
+        function getDownTopic() {
+            return node._protocol.getDownTopic(node);
+        }
+
         // 连接MQTT
         function connect() {
             if (node._closing || node._client) return;
@@ -88,49 +148,20 @@ module.exports = function(RED) {
                     node.log(`品牌MQTT已连接: ${brokerUrl}`);
                     
                     // 订阅上报主题
-                    node._client.subscribe(uploadTopic, function(err) {
+                    node._client.subscribe(uploadTopic, { qos: 0 }, function(err) {
                         if (!err) {
                             node.log(`已订阅: ${uploadTopic}`);
+                        } else {
+                            node.error(`订阅失败: ${err.message}`);
                         }
                     });
 
                     // 通知订阅者
-                    notifySubscribers('connected');
+                    notifySubscribers('connected', { broker: brokerUrl });
                 });
 
                 node._client.on('message', function(topic, payload) {
-                    try {
-                        const data = JSON.parse(payload.toString());
-                        if (data.payload) {
-                            const { st, si, fn, fv } = data.payload;
-                            if (st !== undefined && si !== undefined) {
-                                // 发现设备
-                                const deviceKey = `${st}_${si}`;
-                                const deviceType = DEVICE_TYPES[st] || { name: `类型${st}`, type: 'unknown' };
-                                
-                                if (!node._discoveredDevices.has(deviceKey)) {
-                                    node._discoveredDevices.set(deviceKey, {
-                                        deviceType: st,
-                                        deviceId: si,
-                                        typeName: deviceType.name,
-                                        meshType: deviceType.type,
-                                        lastSeen: Date.now(),
-                                        lastState: { fn, fv }
-                                    });
-                                    node.log(`发现品牌设备: ${deviceType.name} ID:${si}`);
-                                } else {
-                                    const dev = node._discoveredDevices.get(deviceKey);
-                                    dev.lastSeen = Date.now();
-                                    dev.lastState = { fn, fv };
-                                }
-
-                                // 通知订阅者状态更新
-                                notifySubscribers('state', { st, si, fn, fv });
-                            }
-                        }
-                    } catch (e) {
-                        // 静默处理解析错误
-                    }
+                    handleMessage(topic, payload);
                 });
 
                 node._client.on('error', function(err) {
@@ -138,8 +169,12 @@ module.exports = function(RED) {
                 });
 
                 node._client.on('close', function() {
+                    const wasConnected = node._connected;
                     node._connected = false;
-                    notifySubscribers('disconnected');
+                    
+                    if (wasConnected) {
+                        notifySubscribers('disconnected');
+                    }
                     
                     if (!node._closing && !node._reconnectTimer) {
                         node._reconnectTimer = setTimeout(function() {
@@ -158,6 +193,65 @@ module.exports = function(RED) {
             }
         }
 
+        // 处理接收到的消息
+        function handleMessage(topic, payload) {
+            try {
+                const parsed = node._protocol.parseMessage(payload);
+                if (!parsed) return;
+
+                const { deviceType, deviceId, fn, fv } = parsed;
+                const deviceKey = `${deviceType}_${deviceId}`;
+                const deviceTypeInfo = node._protocol.deviceTypes[deviceType];
+                
+                // 发现设备
+                if (!node._discoveredDevices.has(deviceKey)) {
+                    node._discoveredDevices.set(deviceKey, {
+                        deviceType,
+                        deviceId,
+                        typeName: deviceTypeInfo ? deviceTypeInfo.name : `类型${deviceType}`,
+                        meshType: deviceTypeInfo ? deviceTypeInfo.meshType : 'unknown',
+                        channels: deviceTypeInfo ? deviceTypeInfo.channels : 1,
+                        lastSeen: Date.now(),
+                        lastState: {}
+                    });
+                    node.log(`发现品牌设备: ${deviceTypeInfo ? deviceTypeInfo.name : '未知'} ID:${deviceId}`);
+                }
+
+                // 更新设备状态
+                const device = node._discoveredDevices.get(deviceKey);
+                device.lastSeen = Date.now();
+                device.lastState[fn] = fv;
+
+                // 更新状态缓存
+                if (!node._deviceStates.has(deviceKey)) {
+                    node._deviceStates.set(deviceKey, {});
+                }
+                node._deviceStates.get(deviceKey)[fn] = fv;
+
+                // 转换为Mesh属性
+                const fnConfig = node._protocol.functionCodes[deviceType]?.[fn];
+                let meshProp = null, meshValue = null;
+                
+                if (fnConfig) {
+                    meshProp = fnConfig.meshProp;
+                    if (fnConfig.valueMap) {
+                        meshValue = fnConfig.valueMap[fv];
+                    } else {
+                        meshValue = fv;
+                    }
+                }
+
+                // 通知订阅者状态更新
+                notifySubscribers('state', { 
+                    deviceType, deviceId, fn, fv,
+                    meshProp, meshValue,
+                    deviceKey
+                });
+            } catch (e) {
+                // 静默处理解析错误
+            }
+        }
+
         // 通知订阅者
         function notifySubscribers(event, data) {
             node._subscribers.forEach(function(callback) {
@@ -169,16 +263,44 @@ module.exports = function(RED) {
 
         // 发布控制命令
         node.publish = function(st, si, fn, fv) {
-            if (!node._client || !node._connected) return false;
+            if (!node._client || !node._connected) {
+                node.warn('品牌MQTT未连接，无法发送命令');
+                return false;
+            }
             
             const downTopic = getDownTopic();
             if (!downTopic) return false;
 
-            const payload = JSON.stringify({ payload: { st, si, fn, fv } });
-            node._client.publish(downTopic, payload);
+            const payload = node._protocol.buildMessage(st, si, fn, fv);
+            node._client.publish(downTopic, payload, { qos: 0 });
+            node.debug(`发送品牌命令: st=${st}, si=${si}, fn=${fn}, fv=${fv}`);
             return true;
         };
 
+        // 根据Mesh属性发送命令
+        node.publishByMeshProp = function(deviceType, deviceId, meshProp, meshValue) {
+            const fnConfigs = node._protocol.functionCodes[deviceType];
+            if (!fnConfigs) return false;
+
+            for (const [fn, config] of Object.entries(fnConfigs)) {
+                if (config.meshProp === meshProp) {
+                    let fv;
+                    if (config.reverseMap) {
+                        fv = config.reverseMap[meshValue];
+                        if (fv === undefined) fv = meshValue ? 1 : 0;
+                    } else {
+                        fv = parseInt(meshValue) || 0;
+                        // 范围限制
+                        if (config.range) {
+                            fv = Math.max(config.range[0], Math.min(config.range[1], fv));
+                        }
+                    }
+                    return node.publish(deviceType, deviceId, parseInt(fn), fv);
+                }
+            }
+            return false;
+        };
+
         // 订阅状态更新
         node.subscribe = function(callback) {
             node._subscribers.add(callback);
@@ -192,14 +314,55 @@ module.exports = function(RED) {
             return Array.from(node._discoveredDevices.values());
         };
 
+        // 获取设备状态
+        node.getDeviceState = function(deviceType, deviceId) {
+            const key = `${deviceType}_${deviceId}`;
+            return node._deviceStates.get(key) || {};
+        };
+
         // 检查是否已连接
         node.isConnected = function() {
             return node._connected;
         };
 
+        // 获取协议信息
+        node.getProtocol = function() {
+            return node._protocol;
+        };
+
+        // 定期清理过期设备（超过1小时未更新）
+        function startCleanupTimer() {
+            node._cleanupTimer = setInterval(function() {
+                const now = Date.now();
+                const expireTime = 3600000; // 1小时
+                
+                for (const [key, device] of node._discoveredDevices) {
+                    if (now - device.lastSeen > expireTime) {
+                        node._discoveredDevices.delete(key);
+                        node._deviceStates.delete(key);
+                    }
+                }
+                
+                // 限制设备数量
+                if (node._discoveredDevices.size > 200) {
+                    const sorted = [...node._discoveredDevices.entries()]
+                        .sort((a, b) => a[1].lastSeen - b[1].lastSeen);
+                    sorted.slice(0, sorted.length - 200).forEach(([key]) => {
+                        node._discoveredDevices.delete(key);
+                        node._deviceStates.delete(key);
+                    });
+                }
+            }, 60000);
+        }
+
         // 启动连接
         if (node.projectCode && node.deviceSn) {
-            setTimeout(connect, 1000);
+            setTimeout(function() {
+                if (!node._closing) {
+                    connect();
+                    startCleanupTimer();
+                }
+            }, 1000);
         }
 
         // 清理
@@ -211,6 +374,11 @@ module.exports = function(RED) {
                 node._reconnectTimer = null;
             }
 
+            if (node._cleanupTimer) {
+                clearInterval(node._cleanupTimer);
+                node._cleanupTimer = null;
+            }
+
             if (node._client) {
                 try {
                     node._client.end(true);
@@ -220,6 +388,7 @@ module.exports = function(RED) {
 
             node._subscribers.clear();
             node._discoveredDevices.clear();
+            node._deviceStates.clear();
             done();
         });
     }
@@ -235,4 +404,19 @@ module.exports = function(RED) {
             res.json([]);
         }
     });
+
+    // HTTP API - 获取支持的品牌列表
+    RED.httpAdmin.get('/symi-mqtt-brand/brands', function(req, res) {
+        const brands = Object.entries(BRAND_PROTOCOLS).map(([id, proto]) => ({
+            id,
+            name: proto.name,
+            needsProjectConfig: proto.needsProjectConfig,
+            deviceTypes: Object.entries(proto.deviceTypes).map(([type, info]) => ({
+                type: parseInt(type),
+                name: info.name,
+                meshType: info.meshType
+            }))
+        }));
+        res.json(brands);
+    });
 };