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

package/nodes/symi-knx-bridge.js

@@ -149,11 +149,17 @@ module.exports = function(RED) {
         node.knxStateCache = {};        // KNX设备状态缓存
         node.lastMeshToKnx = {};        // 记录Mesh->KNX发送时间，防止回环
         node.lastKnxToMesh = {};        // 记录KNX->Mesh发送时间，防止回环
+        node.lastKnxAddrSent = {};      // 记录发送到KNX地址的时间，防止自己发的命令又被处理
         
         // 防死循环参数
         const LOOP_PREVENTION_MS = 800;   // 800ms内不处理反向同步，防止回环
         const DEBOUNCE_MS = 100;          // 100ms防抖
         const MAX_QUEUE_SIZE = 100;       // 最大队列大小
+        const COVER_CONTROL_LOCK_MS = 3000;  // 窗帘/调光控制锁定3秒（只忽略过程反馈，不长期锁定）
+        
+        // 控制锁定状态：谁先动作，锁定期间忽略另一方的反馈
+        // { deviceKey: { controller: 'mesh'|'knx', lockUntil: timestamp } }
+        node.controlLock = {};
         
         // 初始化标记
         node.initializing = true;
@@ -292,10 +298,15 @@ module.exports = function(RED) {
             for (const mapping of matchedMappings) {
                 const loopKey = `${mac}_${mapping.meshChannel}`;
                 
-                // 防死循环检查
-                if (node.shouldPreventSync('mesh-to-knx', loopKey)) {
-                    node.log(`[Mesh->KNX] 跳过(防死循环): ${loopKey}`);
-                    continue;
+                // 窗帘设备需要单独处理防死循环（动作和位置分开检查）
+                if (mapping.deviceType === 'cover') {
+                    // 窗帘的防死循环在内部单独处理，这里不跳过
+                } else {
+                    // 其他设备统一防死循环检查
+                    if (node.shouldPreventSync('mesh-to-knx', loopKey)) {
+                        node.log(`[Mesh->KNX] 跳过(防死循环): ${loopKey}`);
+                        continue;
+                    }
                 }
                 
                 // 开关设备
@@ -312,8 +323,23 @@ module.exports = function(RED) {
                         });
                     }
                 }
-                // 调光灯设备（单色、双色、RGB、RGBCW）
+                // 调光灯设备（单色、双色、RGB、RGBCW）- 简化逻辑：谁动谁跟，忽略过程反馈
                 else if (mapping.deviceType.startsWith('light_')) {
+                    if (!eventData.isUserControl) continue;
+                    
+                    const deviceKey = `${macNormalized}_light`;
+                    const now = Date.now();
+                    const lock = node.controlLock[deviceKey];
+                    
+                    // 如果KNX正在控制中，忽略Mesh的反馈
+                    if (lock && lock.controller === 'knx' && now < lock.lockUntil) {
+                        node.debug(`[Mesh->KNX] 调光灯跳过(KNX控制中): ${deviceKey}`);
+                        continue;
+                    }
+                    
+                    // Mesh发起控制，锁定20秒
+                    node.controlLock[deviceKey] = { controller: 'mesh', lockUntil: now + COVER_CONTROL_LOCK_MS };
+                    
                     // 开关状态
                     if (changed.switch !== undefined) {
                         node.log(`[Mesh->KNX] 调光灯开关: ${mapping.name || eventData.device.name} = ${changed.switch}`);
@@ -325,8 +351,8 @@ module.exports = function(RED) {
                             key: loopKey
                         });
                     }
-                    // 亮度
-                    if (changed.brightness !== undefined) {
+                    // 亮度（只在没有开关变化时同步，避免重复）
+                    if (changed.brightness !== undefined && changed.switch === undefined) {
                         node.log(`[Mesh->KNX] 调光灯亮度: ${mapping.name || eventData.device.name} = ${changed.brightness}%`);
                         node.queueCommand({
                             direction: 'mesh-to-knx',
@@ -348,29 +374,50 @@ module.exports = function(RED) {
                         });
                     }
                 }
-                // 窗帘设备
+                // 窗帘设备 - 简化逻辑：谁动谁跟，忽略过程反馈
                 else if (mapping.deviceType === 'cover') {
                     if (!eventData.isUserControl) continue;
                     
-                    if (changed.curtainAction !== undefined || changed.curtainStatus !== undefined) {
-                        const action = changed.curtainAction || state.curtainAction;
+                    const deviceKey = macNormalized;
+                    const now = Date.now();
+                    const lock = node.controlLock[deviceKey];
+                    
+                    // 如果KNX正在控制中，忽略Mesh的反馈（避免回环）
+                    if (lock && lock.controller === 'knx' && now < lock.lockUntil) {
+                        node.debug(`[Mesh->KNX] 窗帘跳过(KNX控制中): ${deviceKey}`);
+                        continue;
+                    }
+                    
+                    // Mesh发起控制，锁定20秒
+                    node.controlLock[deviceKey] = { controller: 'mesh', lockUntil: now + COVER_CONTROL_LOCK_MS };
+                    
+                    // 处理动作（打开/关闭/停止）
+                    if (changed.curtainAction !== undefined) {
+                        const action = changed.curtainAction;
                         node.log(`[Mesh->KNX] 窗帘动作: ${mapping.name || eventData.device.name} action=${action}`);
                         node.queueCommand({
                             direction: 'mesh-to-knx',
                             mapping: mapping,
                             type: 'cover_action',
                             value: action,
-                            key: loopKey
+                            key: `${loopKey}_action`
                         });
+                        
+                        // 停止时解除锁定
+                        if (action === 'stopped') {
+                            delete node.controlLock[deviceKey];
+                        }
                     }
-                    if (changed.curtainPosition !== undefined) {
+                    
+                    // 处理位置变化（只在没有动作变化时同步位置）
+                    if (changed.curtainPosition !== undefined && changed.curtainAction === undefined) {
                         node.log(`[Mesh->KNX] 窗帘位置: ${mapping.name || eventData.device.name} pos=${changed.curtainPosition}%`);
                         node.queueCommand({
                             direction: 'mesh-to-knx',
                             mapping: mapping,
                             type: 'cover_position',
                             value: changed.curtainPosition,
-                            key: loopKey
+                            key: `${loopKey}_position`
                         });
                     }
                 }
@@ -709,10 +756,14 @@ module.exports = function(RED) {
             }
             
             if (knxMsg) {
+                // 记录发送到的KNX地址和时间，防止自己发的命令又被处理
+                const destAddr = knxMsg.knx.destination;
+                node.lastKnxAddrSent[destAddr] = Date.now();
+                
                 // knxUltimate官方格式: https://supergiovane.github.io/node-red-contrib-knx-ultimate/wiki/Device
                 // 必须包含: destination, payload, dpt, event
                 const sendMsg = {
-                    destination: knxMsg.knx.destination,
+                    destination: destAddr,
                     payload: knxMsg.payload,
                     dpt: knxMsg.dpt || knxMsg.knx.dpt,
                     event: "GroupValue_Write"
@@ -897,6 +948,14 @@ module.exports = function(RED) {
                 return;
             }
             
+            // 检查是否是我们自己发出去的命令（防止自己发的命令被监听后又处理）
+            const lastSentTime = node.lastKnxAddrSent[groupAddr] || 0;
+            if (Date.now() - lastSentTime < LOOP_PREVENTION_MS) {
+                node.debug(`[KNX输入] 跳过(自己发的): ${groupAddr}`);
+                done && done();
+                return;
+            }
+            
             // 查找映射
             const mapping = node.findKnxMapping(groupAddr);
             if (!mapping) {
@@ -909,7 +968,7 @@ module.exports = function(RED) {
             const addrFunc = node.getKnxAddrFunction(mapping, groupAddr);
             const loopKey = `${mapping.meshMac}_${mapping.meshChannel}`;
             
-            // 防死循环检查
+            // 防死循环检查（基于设备的双向同步防护）
             if (node.shouldPreventSync('knx-to-mesh', loopKey)) {
                 node.debug(`[KNX->Mesh] 跳过同步(防死循环): ${loopKey}, addr=${groupAddr}`);
                 done && done();
@@ -933,35 +992,55 @@ module.exports = function(RED) {
                     });
                 }
             }
-            // 窗帘设备
+            // 窗帘设备 - 简化逻辑：谁动谁跟，KNX可抢占控制权
             else if (mapping.deviceType === 'cover') {
+                const deviceKey = (mapping.meshMac || '').toLowerCase().replace(/:/g, '');
+                const now = Date.now();
+                
+                // KNX主动发起控制，直接抢占锁定（用户操作优先）
+                node.controlLock[deviceKey] = { controller: 'knx', lockUntil: now + COVER_CONTROL_LOCK_MS };
+                
                 if (addrFunc === 'cmd') {
                     // 上下命令: 0=上(开), 1=下(关)
                     const action = (value === 0 || value === false) ? 'open' : 'close';
+                    node.log(`[KNX->Mesh] 窗帘动作: ${action}`);
                     node.queueCommand({ direction: 'knx-to-mesh', mapping, type: 'cover_action', value: action, key: loopKey, sourceAddr: groupAddr });
                 }
                 else if (addrFunc === 'stop') {
+                    node.log(`[KNX->Mesh] 窗帘停止`);
                     node.queueCommand({ direction: 'knx-to-mesh', mapping, type: 'cover_action', value: 'stop', key: loopKey, sourceAddr: groupAddr });
+                    // 停止时解除锁定
+                    delete node.controlLock[deviceKey];
                 }
                 else if (addrFunc === 'position' || addrFunc === 'status') {
                     const pos = mapping.invertPosition ? (100 - (parseInt(value) || 0)) : (parseInt(value) || 0);
+                    node.log(`[KNX->Mesh] 窗帘位置: ${pos}%`);
                     node.queueCommand({ direction: 'knx-to-mesh', mapping, type: 'cover_position', value: pos, key: loopKey, sourceAddr: groupAddr });
                 }
             }
-            // 调光灯设备
+            // 调光灯设备 - 简化逻辑：谁动谁跟，KNX可抢占控制权
             else if (mapping.deviceType.startsWith('light_')) {
+                const deviceKey = `${(mapping.meshMac || '').toLowerCase().replace(/:/g, '')}_light`;
+                const now = Date.now();
+                
+                // KNX主动发起控制，直接抢占锁定（用户操作优先）
+                node.controlLock[deviceKey] = { controller: 'knx', lockUntil: now + COVER_CONTROL_LOCK_MS };
+                
                 if (addrFunc === 'cmd' || addrFunc === 'status') {
                     // 开关
                     const sw = (value === 1 || value === true);
+                    node.log(`[KNX->Mesh] 调光灯开关: ${sw ? 'ON' : 'OFF'}`);
                     node.queueCommand({ direction: 'knx-to-mesh', mapping, type: 'light_switch', value: sw, key: loopKey, sourceAddr: groupAddr });
                 }
                 else if (addrFunc === 'brightness') {
                     // 亮度 (KNX 0-255 -> Mesh 0-100)
                     const brightness = Math.round((parseInt(value) || 0) * 100 / 255);
+                    node.log(`[KNX->Mesh] 调光灯亮度: ${brightness}%`);
                     node.queueCommand({ direction: 'knx-to-mesh', mapping, type: 'light_brightness', value: brightness, key: loopKey, sourceAddr: groupAddr });
                 }
                 else if (addrFunc === 'colorTemp') {
                     // 色温
+                    node.log(`[KNX->Mesh] 调光灯色温: ${value}`);
                     node.queueCommand({ direction: 'knx-to-mesh', mapping, type: 'light_color_temp', value: parseInt(value) || 50, key: loopKey, sourceAddr: groupAddr });
                 }
             }

package/nodes/symi-mqtt-brand.html

@@ -0,0 +1,75 @@
+<script type="text/javascript">
+    RED.nodes.registerType('symi-mqtt-brand', {
+        category: 'config',
+        defaults: {
+            name: { value: '' },
+            brand: { value: 'hyqw' },
+            mqttBroker: { value: 'mqtt://localhost:1883', required: true },
+            mqttUsername: { value: '' },
+            mqttPassword: { value: '' },
+            projectCode: { value: '', required: true },
+            deviceSn: { value: '', required: true }
+        },
+        label: function() {
+            if (this.name) return this.name;
+            if (this.projectCode && this.deviceSn) {
+                return 'HYQW: ' + this.projectCode;
+            }
+            return '品牌MQTT';
+        },
+        oneditprepare: function() {
+            var node = this;
+            
+            // 品牌切换
+            function updateBrandUI() {
+                var brand = $('#node-config-input-brand').val();
+                if (brand === 'hyqw') {
+                    $('.brand-hyqw-config').show();
+                } else {
+                    $('.brand-hyqw-config').hide();
+                }
+            }
+            $('#node-config-input-brand').on('change', updateBrandUI);
+            updateBrandUI();
+        }
+    });
+</script>
+
+<script type="text/html" data-template-name="symi-mqtt-brand">
+    <div class="form-row">
+        <label for="node-config-input-name"><i class="fa fa-tag"></i> 名称</label>
+        <input type="text" id="node-config-input-name" placeholder="如：花语前湾MQTT">
+    </div>
+
+    <div class="form-row">
+        <label for="node-config-input-brand"><i class="fa fa-plug"></i> 品牌协议</label>
+        <select id="node-config-input-brand">
+            <option value="hyqw">HYQW (花语前湾)</option>
+        </select>
+    </div>
+
+    <div class="form-row">
+        <label for="node-config-input-mqttBroker"><i class="fa fa-server"></i> MQTT地址</label>
+        <input type="text" id="node-config-input-mqttBroker" placeholder="mqtt://192.168.1.100:1883">
+    </div>
+
+    <div class="form-row">
+        <label for="node-config-input-mqttUsername"><i class="fa fa-user"></i> 用户名</label>
+        <input type="text" id="node-config-input-mqttUsername" placeholder="可选">
+    </div>
+
+    <div class="form-row">
+        <label for="node-config-input-mqttPassword"><i class="fa fa-lock"></i> 密码</label>
+        <input type="password" id="node-config-input-mqttPassword" placeholder="可选">
+    </div>
+
+    <div class="form-row brand-hyqw-config">
+        <label for="node-config-input-projectCode"><i class="fa fa-folder"></i> 项目代码</label>
+        <input type="text" id="node-config-input-projectCode" placeholder="如: SH-485-V22">
+    </div>
+
+    <div class="form-row brand-hyqw-config">
+        <label for="node-config-input-deviceSn"><i class="fa fa-barcode"></i> 设备SN</label>
+        <input type="text" id="node-config-input-deviceSn" placeholder="如: FB485V222024110500000377">
+    </div>
+</script>

package/nodes/symi-mqtt-brand.js

@@ -0,0 +1,238 @@
+'use strict';
+
+const mqtt = require('mqtt');
+
+module.exports = function(RED) {
+    // 品牌MQTT配置节点
+    function SymiMqttBrandNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        // 配置参数
+        node.name = config.name || '品牌MQTT';
+        node.brand = config.brand || 'hyqw';
+        node.mqttBroker = config.mqttBroker || 'mqtt://localhost:1883';
+        node.mqttUsername = config.mqttUsername || '';
+        node.mqttPassword = config.mqttPassword || '';
+        node.projectCode = config.projectCode || '';
+        node.deviceSn = config.deviceSn || '';
+
+        // 运行时状态
+        node._client = null;
+        node._connected = false;
+        node._discoveredDevices = 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`;
+        }
+
+        // 限流错误日志
+        function logErrorThrottled(msg) {
+            const now = Date.now();
+            if (now - node._lastErrorLog > 60000) {
+                node._lastErrorLog = now;
+                node.warn(msg);
+            }
+        }
+
+        // 连接MQTT
+        function connect() {
+            if (node._closing || node._client) return;
+
+            const uploadTopic = getUploadTopic();
+            if (!uploadTopic) {
+                node.warn('品牌MQTT配置不完整：缺少项目代码或设备SN');
+                return;
+            }
+
+            const brokerUrl = node.mqttBroker || 'mqtt://localhost:1883';
+            const options = {
+                clientId: `symi_brand_${node.id}_${Date.now()}`,
+                clean: true,
+                connectTimeout: 10000,
+                reconnectPeriod: 0,
+                keepalive: 60
+            };
+
+            if (node.mqttUsername) {
+                options.username = node.mqttUsername;
+                options.password = node.mqttPassword || '';
+            }
+
+            try {
+                node._client = mqtt.connect(brokerUrl, options);
+
+                node._client.on('connect', function() {
+                    node._connected = true;
+                    node._lastErrorLog = 0;
+                    node.log(`品牌MQTT已连接: ${brokerUrl}`);
+                    
+                    // 订阅上报主题
+                    node._client.subscribe(uploadTopic, function(err) {
+                        if (!err) {
+                            node.log(`已订阅: ${uploadTopic}`);
+                        }
+                    });
+
+                    // 通知订阅者
+                    notifySubscribers('connected');
+                });
+
+                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) {
+                        // 静默处理解析错误
+                    }
+                });
+
+                node._client.on('error', function(err) {
+                    logErrorThrottled(`品牌MQTT错误: ${err.message}`);
+                });
+
+                node._client.on('close', function() {
+                    node._connected = false;
+                    notifySubscribers('disconnected');
+                    
+                    if (!node._closing && !node._reconnectTimer) {
+                        node._reconnectTimer = setTimeout(function() {
+                            node._reconnectTimer = null;
+                            if (node._client) {
+                                try { node._client.end(true); } catch(e) {}
+                                node._client = null;
+                            }
+                            connect();
+                        }, 5000);
+                    }
+                });
+
+            } catch (err) {
+                logErrorThrottled(`品牌MQTT连接失败: ${err.message}`);
+            }
+        }
+
+        // 通知订阅者
+        function notifySubscribers(event, data) {
+            node._subscribers.forEach(function(callback) {
+                try {
+                    callback(event, data);
+                } catch (e) {}
+            });
+        }
+
+        // 发布控制命令
+        node.publish = function(st, si, fn, fv) {
+            if (!node._client || !node._connected) return false;
+            
+            const downTopic = getDownTopic();
+            if (!downTopic) return false;
+
+            const payload = JSON.stringify({ payload: { st, si, fn, fv } });
+            node._client.publish(downTopic, payload);
+            return true;
+        };
+
+        // 订阅状态更新
+        node.subscribe = function(callback) {
+            node._subscribers.add(callback);
+            return function() {
+                node._subscribers.delete(callback);
+            };
+        };
+
+        // 获取已发现的设备列表
+        node.getDiscoveredDevices = function() {
+            return Array.from(node._discoveredDevices.values());
+        };
+
+        // 检查是否已连接
+        node.isConnected = function() {
+            return node._connected;
+        };
+
+        // 启动连接
+        if (node.projectCode && node.deviceSn) {
+            setTimeout(connect, 1000);
+        }
+
+        // 清理
+        node.on('close', function(done) {
+            node._closing = true;
+            
+            if (node._reconnectTimer) {
+                clearTimeout(node._reconnectTimer);
+                node._reconnectTimer = null;
+            }
+
+            if (node._client) {
+                try {
+                    node._client.end(true);
+                } catch (e) {}
+                node._client = null;
+            }
+
+            node._subscribers.clear();
+            node._discoveredDevices.clear();
+            done();
+        });
+    }
+
+    RED.nodes.registerType('symi-mqtt-brand', SymiMqttBrandNode);
+
+    // HTTP API - 获取已发现的设备
+    RED.httpAdmin.get('/symi-mqtt-brand/devices/:id', function(req, res) {
+        const node = RED.nodes.getNode(req.params.id);
+        if (node && typeof node.getDiscoveredDevices === 'function') {
+            res.json(node.getDiscoveredDevices());
+        } else {
+            res.json([]);
+        }
+    });
+};