node-red-contrib-symi-mesh 1.7.2 → 1.7.3

package/nodes/symi-mqtt-sync.js

@@ -0,0 +1,473 @@
+/**
+ * MQTT同步节点 - 实现第三方MQTT品牌设备与Mesh设备的双向同步
+ * 
+ * 架构设计:
+ * - 使用symi-mqtt配置节点共享MQTT连接（与Mesh网关MQTT一致）
+ * - 品牌协议可扩展（HYQW、涂鸦等，后续添加）
+ * - 自动发现 + 手动映射
+ * - 双向状态同步，2秒防抖防死循环
+ * - 错误日志频率限制，避免网络故障时日志爆炸
+ */
+
+module.exports = function(RED) {
+    const mqtt = require('mqtt');
+
+    // ===== 常量定义 =====
+    const SYNC_DEBOUNCE_MS = 2000;
+    const RECONNECT_INTERVAL = 5000;
+    const MAX_DISCOVERED = 200;
+    const CLEANUP_INTERVAL = 60000;
+    const ERROR_LOG_INTERVAL = 60000;  // 错误日志最小间隔60秒
+
+    // ===== 品牌协议定义 (可扩展) =====
+    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: (deviceType, deviceId, fn, fv) => {
+                return JSON.stringify({ payload: { st: deviceType, si: deviceId, fn, fv } });
+            },
+            deviceTypes: {
+                8: { name: '灯具', meshType: 'light' },
+                12: { name: '空调', meshType: 'climate' },
+                14: { name: '窗帘', meshType: 'cover' },
+                16: { name: '地暖', meshType: 'climate' },
+                36: { name: '新风', meshType: 'fan' }
+            }
+        }
+        // 后续可扩展其他品牌: tuya, custom 等
+    };
+
+    // 通用映射
+    const AC_MODE_MAP = { 0: 'cool', 1: 'heat', 2: 'fan_only', 3: 'dry' };
+    const AC_MODE_REVERSE = { cool: 0, heat: 1, fan_only: 2, dry: 3 };
+    const FAN_SPEED_MAP = { 0: 'auto', 1: 'low', 2: 'medium', 3: 'high' };
+    const FAN_SPEED_REVERSE = { auto: 0, low: 1, medium: 2, high: 3 };
+
+    // ===== 节点注册 =====
+    function SymiMqttSyncNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        // 基础配置
+        node.name = config.name || 'MQTT同步';
+        node.mqttConfigId = config.mqttConfig;
+        node.brandMqttConfigId = config.brandMqttConfig;
+        node.autoDiscover = config.autoDiscover !== false;
+
+        // 获取symi-mqtt配置节点（Mesh网关MQTT）
+        node._mqttConfig = null;
+        node._gateway = null;
+        if (node.mqttConfigId) {
+            node._mqttConfig = RED.nodes.getNode(node.mqttConfigId);
+            if (node._mqttConfig) {
+                node._gateway = node._mqttConfig.gateway;
+            }
+        }
+
+        // 获取品牌MQTT配置节点
+        node._brandMqttConfig = null;
+        if (node.brandMqttConfigId) {
+            node._brandMqttConfig = RED.nodes.getNode(node.brandMqttConfigId);
+        }
+
+        // 从品牌MQTT配置节点获取参数
+        node.brand = node._brandMqttConfig ? node._brandMqttConfig.brand : 'hyqw';
+        node.projectCode = node._brandMqttConfig ? node._brandMqttConfig.projectCode : '';
+        node.deviceSn = node._brandMqttConfig ? node._brandMqttConfig.deviceSn : '';
+        node.brandMqttBroker = node._brandMqttConfig ? node._brandMqttConfig.mqttBroker : '';
+        node.brandMqttUsername = node._brandMqttConfig ? node._brandMqttConfig.mqttUsername : '';
+        node.brandMqttPassword = node._brandMqttConfig ? node._brandMqttConfig.mqttPassword : '';
+
+        // 获取品牌协议处理器
+        node._brandProtocol = BRAND_PROTOCOLS[node.brand] || BRAND_PROTOCOLS.hyqw;
+        
+        // 解析映射配置
+        try {
+            node.mappings = JSON.parse(config.mappings || '[]');
+        } catch (e) {
+            node.mappings = [];
+        }
+
+        // 运行时状态
+        node._mqttClient = null;
+        node._connected = false;
+        node._reconnectTimer = null;
+        node._syncTimestamps = new Map();
+        node._deviceStates = new Map();
+        node._discoveredDevices = new Map();
+        node._cleanupTimer = null;
+        node._closing = false;
+        node._lastErrorLog = 0;  // 错误日志限流
+
+        if (!node._mqttConfig) {
+            node.status({ fill: 'red', shape: 'ring', text: '未选择Mesh MQTT' });
+            return;
+        }
+
+        if (!node._gateway) {
+            node.status({ fill: 'red', shape: 'ring', text: 'Mesh网关未连接' });
+            return;
+        }
+
+        if (!node._brandMqttConfig) {
+            node.status({ fill: 'red', shape: 'ring', text: '未选择品牌MQTT' });
+            return;
+        }
+
+        // 初始化
+        node.status({ fill: 'yellow', shape: 'ring', text: '初始化...' });
+
+        // 延迟启动
+        setTimeout(() => {
+            if (!node._closing) {
+                connectMqtt();
+                setupGatewayListeners();
+                startCleanupTimer();
+            }
+        }, 2000);
+
+        // ===== 限流错误日志 =====
+        function logErrorThrottled(msg) {
+            const now = Date.now();
+            if (now - node._lastErrorLog > ERROR_LOG_INTERVAL) {
+                node._lastErrorLog = now;
+                node.warn(msg);
+            }
+        }
+
+        // ===== MQTT连接 =====
+        function connectMqtt() {
+            if (node._closing || node._mqttClient) return;
+            
+            const uploadTopic = node._brandProtocol.getUploadTopic(node);
+            if (!uploadTopic) {
+                node.status({ fill: 'red', shape: 'ring', text: '品牌配置不完整' });
+                return;
+            }
+
+            // 使用品牌MQTT服务配置（独立连接）
+            const mqttBroker = node.brandMqttBroker || 'mqtt://localhost:1883';
+            const mqttUsername = node.brandMqttUsername || '';
+            const mqttPassword = node.brandMqttPassword || '';
+
+            const options = {
+                clientId: `symi_mqtt_sync_${node.id}_${Date.now()}`,
+                clean: true,
+                connectTimeout: 10000,
+                reconnectPeriod: 0,
+                keepalive: 60
+            };
+
+            if (mqttUsername) {
+                options.username = mqttUsername;
+                options.password = mqttPassword;
+            }
+
+            try {
+                node._mqttClient = mqtt.connect(mqttBroker, options);
+
+                node._mqttClient.on('connect', () => {
+                    node._connected = true;
+                    node._mqttClient.subscribe(uploadTopic, { qos: 0 }, (err) => {
+                        if (!err) {
+                            updateStatusWithCount();
+                        }
+                    });
+                });
+
+                node._mqttClient.on('message', handleMqttMessage);
+
+                node._mqttClient.on('error', (err) => {
+                    node._connected = false;
+                    logErrorThrottled(`MQTT错误: ${err.message}`);
+                    scheduleReconnect();
+                });
+
+                node._mqttClient.on('close', () => {
+                    node._connected = false;
+                    if (!node._closing) {
+                        node.status({ fill: 'red', shape: 'ring', text: '已断开' });
+                        scheduleReconnect();
+                    }
+                });
+
+            } catch (err) {
+                logErrorThrottled(`MQTT连接失败: ${err.message}`);
+                scheduleReconnect();
+            }
+        }
+
+        function scheduleReconnect() {
+            if (node._closing || node._reconnectTimer) return;
+            node._reconnectTimer = setTimeout(() => {
+                node._reconnectTimer = null;
+                if (node._mqttClient) {
+                    try { node._mqttClient.end(true); } catch (e) {}
+                    node._mqttClient = null;
+                }
+                connectMqtt();
+            }, RECONNECT_INTERVAL);
+        }
+
+        // ===== MQTT消息处理 =====
+        function handleMqttMessage(topic, message) {
+            if (node._closing) return;
+
+            try {
+                const parsed = node._brandProtocol.parseMessage(message);
+                if (!parsed) return;
+
+                const { deviceType, deviceId, fn, fv } = parsed;
+                const deviceKey = `${deviceType}_${deviceId}`;
+
+                // 自动发现
+                if (node.autoDiscover && !node._discoveredDevices.has(deviceKey)) {
+                    if (node._discoveredDevices.size < MAX_DISCOVERED) {
+                        const typeInfo = node._brandProtocol.deviceTypes[deviceType];
+                        node._discoveredDevices.set(deviceKey, {
+                            deviceType, deviceId,
+                            typeName: typeInfo ? typeInfo.name : `类型${deviceType}`,
+                            meshType: typeInfo ? typeInfo.meshType : 'unknown',
+                            lastSeen: Date.now()
+                        });
+                        updateStatusWithCount();
+                    }
+                }
+
+                // 更新设备状态缓存
+                if (!node._deviceStates.has(deviceKey)) {
+                    node._deviceStates.set(deviceKey, {});
+                }
+                node._deviceStates.get(deviceKey)[fn] = fv;
+
+                // 同步到Mesh
+                syncToMesh(deviceType, deviceId, fn, fv);
+            } catch (e) {
+                // 静默
+            }
+        }
+
+        // ===== 同步到Mesh =====
+        function syncToMesh(deviceType, deviceId, fn, fv) {
+            if (!node._gateway?.deviceManager) return;
+
+            const mapping = node.mappings.find(m => 
+                parseInt(m.brandDeviceType) === deviceType && parseInt(m.brandDeviceId) === deviceId
+            );
+            if (!mapping || !mapping.meshMac) return;
+
+            // 防死循环
+            const syncKey = `mqtt_${deviceType}_${deviceId}_${fn}`;
+            const lastSync = node._syncTimestamps.get(syncKey) || 0;
+            if (Date.now() - lastSync < SYNC_DEBOUNCE_MS) return;
+
+            const meshMac = mapping.meshMac;
+            const meshChannel = parseInt(mapping.meshChannel) || 1;
+            const device = node._gateway.deviceManager.getDeviceByMac(meshMac);
+            if (!device) return;
+
+            node._syncTimestamps.set(syncKey, Date.now());
+            node._syncTimestamps.set(`mesh_${meshMac}_${meshChannel}`, Date.now());
+
+            const typeInfo = node._brandProtocol.deviceTypes[deviceType];
+            if (!typeInfo) return;
+
+            let property = '', value = null;
+            try {
+                if (fn === 1) {
+                    property = 'switch'; value = fv === 1;
+                    node._gateway.deviceManager.controlDevice(meshMac, meshChannel, 'switch', fv === 1);
+                } else if (fn === 2) {
+                    property = typeInfo.meshType === 'light' ? 'brightness' : 
+                               typeInfo.meshType === 'cover' ? 'position' : 'temperature';
+                    value = fv;
+                    node._gateway.deviceManager.controlDevice(meshMac, meshChannel, property, fv);
+                } else if (fn === 3) {
+                    if (typeInfo.meshType === 'climate') {
+                        const mode = AC_MODE_MAP[fv];
+                        if (mode) {
+                            property = 'mode'; value = mode;
+                            node._gateway.deviceManager.controlDevice(meshMac, meshChannel, 'mode', mode);
+                        }
+                    } else if (typeInfo.meshType === 'fan') {
+                        const speed = FAN_SPEED_MAP[fv];
+                        if (speed) {
+                            property = 'fanSpeed'; value = speed;
+                            node._gateway.deviceManager.controlDevice(meshMac, meshChannel, 'fanSpeed', speed);
+                        }
+                    }
+                } else if (fn === 4 && typeInfo.meshType === 'climate') {
+                    const speed = FAN_SPEED_MAP[fv];
+                    if (speed) {
+                        property = 'fanSpeed'; value = speed;
+                        node._gateway.deviceManager.controlDevice(meshMac, meshChannel, 'fanSpeed', speed);
+                    }
+                }
+                
+                // 输出到debug
+                if (property) {
+                    node.send({
+                        topic: 'mqtt-sync/brand-to-mesh',
+                        payload: {
+                            direction: 'Brand→Mesh',
+                            brandType: deviceType, brandId: deviceId, fn, fv,
+                            meshMac, meshChannel, property, value,
+                            timestamp: Date.now()
+                        }
+                    });
+                }
+            } catch (e) {}
+        }
+
+        // ===== 同步到MQTT =====
+        function syncToMqtt(meshMac, channel, property, value) {
+            if (!node._connected || !node._mqttClient) return;
+
+            const mapping = node.mappings.find(m => 
+                m.meshMac?.toLowerCase() === meshMac?.toLowerCase() && 
+                parseInt(m.meshChannel) === channel
+            );
+            if (!mapping) return;
+
+            const deviceType = parseInt(mapping.brandDeviceType);
+            const deviceId = parseInt(mapping.brandDeviceId);
+            const typeInfo = node._brandProtocol.deviceTypes[deviceType];
+            if (!typeInfo) return;
+
+            // 防死循环
+            const syncKey = `mesh_${meshMac}_${channel}`;
+            const lastSync = node._syncTimestamps.get(syncKey) || 0;
+            if (Date.now() - lastSync < SYNC_DEBOUNCE_MS) return;
+            node._syncTimestamps.set(syncKey, Date.now());
+
+            let fn, fv;
+            if (property === 'switch' || property === 'on' || property === 'isOn') {
+                fn = 1; fv = value ? 1 : 0;
+            } else if (property === 'brightness' || property === 'temperature' || property === 'position') {
+                fn = 2; fv = parseInt(value) || 0;
+            } else if (property === 'mode' || property === 'hvacMode') {
+                fn = 3; fv = AC_MODE_REVERSE[value] ?? 0;
+            } else if (property === 'fanSpeed' || property === 'fanMode') {
+                fn = typeInfo.meshType === 'climate' ? 4 : 3;
+                fv = FAN_SPEED_REVERSE[value] ?? 0;
+            } else {
+                return;
+            }
+
+            const topic = node._brandProtocol.getDownTopic(node);
+            const payload = node._brandProtocol.buildMessage(deviceType, deviceId, fn, fv);
+
+            try {
+                node._mqttClient.publish(topic, payload, { qos: 0 });
+                node._syncTimestamps.set(`mqtt_${deviceType}_${deviceId}_${fn}`, Date.now());
+                
+                // 输出到debug
+                node.send({
+                    topic: 'mqtt-sync/mesh-to-brand',
+                    payload: {
+                        direction: 'Mesh→Brand',
+                        meshMac, channel, property, value,
+                        brandType: deviceType, brandId: deviceId, fn, fv,
+                        timestamp: Date.now()
+                    }
+                });
+            } catch (e) {}
+        }
+
+        // ===== 网关事件监听 =====
+        function setupGatewayListeners() {
+            if (!node._gateway?.deviceManager) return;
+
+            const handleStateChange = (event) => {
+                if (node._closing) return;
+                const { mac, channel, changes } = event;
+                if (!mac || !changes) return;
+                for (const [prop, val] of Object.entries(changes)) {
+                    syncToMqtt(mac, channel || 1, prop, val);
+                }
+            };
+
+            node._gateway.deviceManager.on('device-state-changed', handleStateChange);
+            node._stateChangeHandler = handleStateChange;
+        }
+
+        // ===== 状态显示 =====
+        function updateStatusWithCount() {
+            if (node._closing) return;
+            const mapCount = node.mappings.length;
+            const discCount = node._discoveredDevices.size;
+            if (node._connected) {
+                node.status({ fill: 'green', shape: 'dot', text: `已连接 映射:${mapCount} 发现:${discCount}` });
+            }
+        }
+
+        // ===== 定期清理 =====
+        function startCleanupTimer() {
+            node._cleanupTimer = setInterval(() => {
+                if (node._closing) return;
+                const now = Date.now();
+                for (const [key, ts] of node._syncTimestamps) {
+                    if (now - ts > 60000) node._syncTimestamps.delete(key);
+                }
+                if (node._discoveredDevices.size > MAX_DISCOVERED) {
+                    const sorted = [...node._discoveredDevices.entries()].sort((a, b) => a[1].lastSeen - b[1].lastSeen);
+                    sorted.slice(0, sorted.length - MAX_DISCOVERED).forEach(([key]) => node._discoveredDevices.delete(key));
+                }
+            }, CLEANUP_INTERVAL);
+        }
+
+        // ===== 输入处理 =====
+        node.on('input', (msg) => {
+            if (node._closing) return;
+            if (msg.topic === 'refresh' || msg.payload?.action === 'refresh') {
+                updateStatusWithCount();
+            }
+        });
+
+        // ===== 节点关闭 =====
+        node.on('close', (done) => {
+            node._closing = true;
+            if (node._reconnectTimer) { clearTimeout(node._reconnectTimer); node._reconnectTimer = null; }
+            if (node._cleanupTimer) { clearInterval(node._cleanupTimer); node._cleanupTimer = null; }
+            if (node._gateway?.deviceManager && node._stateChangeHandler) {
+                node._gateway.deviceManager.removeListener('device-state-changed', node._stateChangeHandler);
+            }
+            if (node._mqttClient) { try { node._mqttClient.end(true); } catch (e) {} node._mqttClient = null; }
+            node._syncTimestamps.clear();
+            node._deviceStates.clear();
+            node._discoveredDevices.clear();
+            done();
+        });
+    }
+
+    // ===== HTTP API =====
+    RED.httpAdmin.get('/symi-mqtt-sync/discovered/:nodeId', (req, res) => {
+        const targetNode = RED.nodes.getNode(req.params.nodeId);
+        if (targetNode && targetNode._discoveredDevices) {
+            res.json(Array.from(targetNode._discoveredDevices.entries()).map(([key, info]) => ({ key, ...info })));
+        } else {
+            res.json([]);
+        }
+    });
+
+    RED.httpAdmin.get('/symi-mqtt-sync/brands', (req, res) => {
+        const brands = Object.entries(BRAND_PROTOCOLS).map(([id, proto]) => ({
+            id, name: proto.name, needsProjectConfig: proto.needsProjectConfig
+        }));
+        res.json(brands);
+    });
+
+    RED.nodes.registerType('symi-mqtt-sync', SymiMqttSyncNode);
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-symi-mesh",
-  "version": "1.7.2",
+  "version": "1.7.3",
   "description": "Node-RED节点集合，用于通过TCP/串口连接Symi蓝牙Mesh网关，支持Home Assistant MQTT Discovery自动发现和云端数据同步",
   "main": "nodes/symi-gateway.js",
   "scripts": {
@@ -37,7 +37,9 @@
       "rs485-debug": "nodes/rs485-debug.js",
       "symi-knx-bridge": "nodes/symi-knx-bridge.js",
       "symi-knx-ha-bridge": "nodes/symi-knx-ha-bridge.js",
-      "symi-rs485-sync": "nodes/symi-rs485-sync.js"
+      "symi-rs485-sync": "nodes/symi-rs485-sync.js",
+      "symi-mqtt-sync": "nodes/symi-mqtt-sync.js",
+      "symi-mqtt-brand": "nodes/symi-mqtt-brand.js"
     }
   },
   "dependencies": {