node-red-contrib-symi-mesh 1.6.7 → 1.6.9

package/nodes/symi-knx-ha-bridge.js

@@ -0,0 +1,524 @@
+/**
+ * Symi KNX-HA Bridge Node - KNX与Home Assistant实体双向同步桥接
+ * 版本: 1.6.9
+ */
+
+module.exports = function(RED) {
+    
+    function SymiKNXHABridgeNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        node.name = config.name || 'KNX-HA Bridge';
+        node.haServer = RED.nodes.getNode(config.haServer);
+        
+        let knxEntities = [];
+        try {
+            knxEntities = JSON.parse(config.knxEntities || '[]');
+        } catch (e) {
+            node.error('KNX实体配置解析失败: ' + e.message);
+        }
+
+        try {
+            const rawMappings = JSON.parse(config.mappings || '[]');
+            node.mappings = rawMappings.map(m => {
+                const knxEntity = knxEntities.find(e => e.id === m.knxEntityId) || {};
+                
+                return {
+                    knxEntityId: m.knxEntityId,
+                    haEntityId: m.haEntityId,
+                    knxName: knxEntity.name || '',
+                    knxType: knxEntity.type || 'switch',
+                    knxAddrCmd: knxEntity.cmdAddr || '',
+                    knxAddrStatus: knxEntity.statusAddr || '',
+                    knxAddrExt1: knxEntity.ext1 || '',
+                    knxAddrExt2: knxEntity.ext2 || '',
+                    knxAddrExt3: knxEntity.ext3 || '',
+                    invertPosition: knxEntity.invert || false,
+                    allKnxAddrs: [
+                        knxEntity.cmdAddr,
+                        knxEntity.statusAddr,
+                        knxEntity.ext1,
+                        knxEntity.ext2,
+                        knxEntity.ext3
+                    ].filter(addr => addr && addr.length > 0)
+                };
+            }).filter(m => m.knxEntityId && m.haEntityId);
+            
+            if (node.mappings.length > 0) {
+                node.mappings.forEach((m, i) => {
+                    node.log(`[映射${i+1}] KNX ${m.knxName}[${m.knxAddrCmd}] <-> HA ${m.haEntityId}`);
+                });
+            }
+        } catch (e) {
+            node.mappings = [];
+            node.error('映射配置解析失败: ' + e.message);
+        }
+
+        node.commandQueue = [];
+        node.processing = false;
+        node.knxStateCache = {};
+        node.haStateCache = {};
+        node.lastKnxToHa = {};
+        node.lastHaToKnx = {};
+        node.dimmingTimers = {};
+        node.coverTimers = {};
+        
+        const LOOP_PREVENTION_MS = 800;
+        const DEBOUNCE_MS = 100;
+        const MAX_QUEUE_SIZE = 100;
+        const DIMMING_DEBOUNCE_MS = 300;
+        const COVER_DEBOUNCE_MS = 500;
+        
+        node.initializing = true;
+        node.initTimer = setTimeout(() => {
+            node.initializing = false;
+            node.log('[KNX-HA Bridge] 初始化完成，开始同步');
+        }, 5000);
+
+        node.log(`[KNX-HA Bridge] haServer: ${!!node.haServer}, credentials: ${!!node.haServer?.credentials}`);
+        
+        if (node.mappings.length === 0) {
+            node.status({ fill: 'grey', shape: 'ring', text: '未配置映射' });
+        } else {
+            node.status({ fill: 'green', shape: 'dot', text: `${node.mappings.length}个映射已激活` });
+        }
+
+        node.findKnxMapping = function(groupAddr) {
+            return node.mappings.find(m => m.allKnxAddrs.includes(groupAddr));
+        };
+
+        node.findHaMapping = function(entityId) {
+            return node.mappings.find(m => m.haEntityId === entityId);
+        };
+
+        node.getKnxAddrFunction = function(mapping, groupAddr) {
+            if (groupAddr === mapping.knxAddrCmd) return 'cmd';
+            if (groupAddr === mapping.knxAddrStatus) return 'status';
+            if (groupAddr === mapping.knxAddrExt1) return 'ext1';
+            if (groupAddr === mapping.knxAddrExt2) return 'ext2';
+            if (groupAddr === mapping.knxAddrExt3) return 'ext3';
+            return 'unknown';
+        };
+
+        node.shouldPreventSync = function(direction, key) {
+            const now = Date.now();
+            if (direction === 'knx-to-ha') {
+                const lastHaTime = node.lastHaToKnx[key] || 0;
+                return (now - lastHaTime) < LOOP_PREVENTION_MS;
+            } else {
+                const lastKnxTime = node.lastKnxToHa[key] || 0;
+                return (now - lastKnxTime) < LOOP_PREVENTION_MS;
+            }
+        };
+
+        node.recordSyncTime = function(direction, key) {
+            const now = Date.now();
+            if (direction === 'knx-to-ha') {
+                node.lastKnxToHa[key] = now;
+            } else {
+                node.lastHaToKnx[key] = now;
+            }
+        };
+
+        node.sleep = function(ms) {
+            return new Promise(resolve => setTimeout(resolve, ms));
+        };
+
+        // 输入处理：支持KNX和HA两种消息
+        node.on('input', function(msg) {
+            if (node.initializing) return;
+            
+            // 处理来自HA server-state-changed节点的消息
+            if (msg.data && msg.data.entity_id && msg.data.new_state && msg.data.old_state) {
+                const entityId = msg.data.entity_id;
+                const mapping = node.findHaMapping(entityId);
+                
+                if (!mapping) {
+                    node.debug(`[HA输入] 实体 ${entityId} 无映射配置`);
+                    return;
+                }
+                
+                const loopKey = `${mapping.knxEntityId}_${mapping.haEntityId}`;
+                
+                if (node.shouldPreventSync('ha-to-knx', loopKey)) {
+                    node.debug(`[HA->KNX] 跳过(防死循环): ${entityId}`);
+                    return;
+                }
+                
+                const newState = msg.data.new_state;
+                const oldState = msg.data.old_state;
+                
+                if (oldState.state === newState.state) return;
+                
+                node.log(`[HA->KNX] ${entityId} 状态变化: ${oldState.state} -> ${newState.state}`);
+                
+                const domain = entityId.split('.')[0];
+                node.queueCommand({
+                    direction: 'ha-to-knx',
+                    mapping: mapping,
+                    type: domain === 'switch' ? 'switch' : 'light_switch',
+                    value: newState.state === 'on',
+                    key: loopKey
+                });
+                return;
+            }
+            
+            // 处理来自KNX的消息
+            if (!msg.knx || !msg.knx.destination) {
+                return;
+            }
+            
+            const groupAddr = msg.knx.destination;
+            const mapping = node.findKnxMapping(groupAddr);
+            
+            if (!mapping) {
+                node.debug(`[KNX输入] 组地址 ${groupAddr} 无映射配置`);
+                return;
+            }
+            
+            const loopKey = `${mapping.knxEntityId}_${mapping.haEntityId}`;
+            
+            if (node.shouldPreventSync('knx-to-ha', loopKey)) {
+                node.log(`[KNX->HA] 跳过(防死循环): ${groupAddr}`);
+                return;
+            }
+            
+            node.log(`[KNX输入] ${groupAddr} = ${msg.payload}, 映射到 ${mapping.haEntityId}`);
+            
+            const addrFunc = node.getKnxAddrFunction(mapping, groupAddr);
+            const knxType = mapping.knxType;
+            
+            if (knxType === 'switch') {
+                if (addrFunc === 'cmd' || addrFunc === 'status') {
+                    node.queueCommand({
+                        direction: 'knx-to-ha',
+                        mapping: mapping,
+                        type: 'switch',
+                        value: msg.payload === true || msg.payload === 1,
+                        key: loopKey
+                    });
+                }
+            }
+            else if (knxType.startsWith('light_')) {
+                if (addrFunc === 'cmd') {
+                    node.queueCommand({
+                        direction: 'knx-to-ha',
+                        mapping: mapping,
+                        type: 'light_switch',
+                        value: msg.payload === true || msg.payload === 1,
+                        key: loopKey
+                    });
+                } else if (addrFunc === 'ext1') {
+                    const timerKey = `${mapping.haEntityId}_brightness`;
+                    if (node.dimmingTimers[timerKey]) {
+                        clearTimeout(node.dimmingTimers[timerKey]);
+                    }
+                    node.dimmingTimers[timerKey] = setTimeout(() => {
+                        node.queueCommand({
+                            direction: 'knx-to-ha',
+                            mapping: mapping,
+                            type: 'light_brightness',
+                            value: Math.round(msg.payload * 100 / 255),
+                            key: loopKey
+                        });
+                        delete node.dimmingTimers[timerKey];
+                    }, DIMMING_DEBOUNCE_MS);
+                }
+            }
+            else if (knxType === 'cover') {
+                if (addrFunc === 'cmd') {
+                    node.queueCommand({
+                        direction: 'knx-to-ha',
+                        mapping: mapping,
+                        type: 'cover_action',
+                        value: msg.payload ? 'closing' : 'opening',
+                        key: loopKey
+                    });
+                } else if (addrFunc === 'status') {
+                    const timerKey = `${mapping.haEntityId}_position`;
+                    if (node.coverTimers[timerKey]) {
+                        clearTimeout(node.coverTimers[timerKey]);
+                    }
+                    node.coverTimers[timerKey] = setTimeout(() => {
+                        const pos = mapping.invertPosition ? (100 - msg.payload) : msg.payload;
+                        node.queueCommand({
+                            direction: 'knx-to-ha',
+                            mapping: mapping,
+                            type: 'cover_position',
+                            value: pos,
+                            key: loopKey
+                        });
+                        delete node.coverTimers[timerKey];
+                    }, COVER_DEBOUNCE_MS);
+                }
+            }
+            else if (knxType === 'climate') {
+                if (addrFunc === 'cmd') {
+                    node.queueCommand({
+                        direction: 'knx-to-ha',
+                        mapping: mapping,
+                        type: 'climate_switch',
+                        value: msg.payload === true || msg.payload === 1,
+                        key: loopKey
+                    });
+                }
+            }
+        });
+
+        node.queueCommand = function(cmd) {
+            if (node.commandQueue.length >= MAX_QUEUE_SIZE) {
+                node.commandQueue.shift();
+            }
+            
+            const existing = node.commandQueue.find(c =>
+                c.direction === cmd.direction &&
+                c.mapping.knxEntityId === cmd.mapping.knxEntityId &&
+                c.type === cmd.type &&
+                Date.now() - (c.timestamp || 0) < DEBOUNCE_MS
+            );
+            
+            if (existing) {
+                existing.value = cmd.value;
+                return;
+            }
+            
+            cmd.timestamp = Date.now();
+            node.commandQueue.push(cmd);
+            node.processQueue();
+        };
+
+        node.processQueue = async function() {
+            if (node.processing || node.commandQueue.length === 0) return;
+            
+            node.processing = true;
+            
+            try {
+                while (node.commandQueue.length > 0) {
+                    const cmd = node.commandQueue.shift();
+                    try {
+                        if (cmd.direction === 'knx-to-ha') {
+                            await node.syncKnxToHa(cmd);
+                        } else if (cmd.direction === 'ha-to-knx') {
+                            await node.syncHaToKnx(cmd);
+                        }
+                        await node.sleep(50);
+                    } catch (err) {
+                        node.error(`同步失败: ${err.message}`);
+                    }
+                }
+            } finally {
+                node.processing = false;
+            }
+        };
+
+        // KNX -> HA 同步
+        node.syncKnxToHa = async function(cmd) {
+            const { mapping, type, value, key } = cmd;
+            node.recordSyncTime('knx-to-ha', key);
+            
+            if (!node.haServer || !node.haServer.credentials) {
+                node.warn('[KNX->HA] HA服务器未配置');
+                return;
+            }
+            
+            try {
+                const axios = require('axios');
+                const baseURL = node.haServer.credentials.host || 'http://localhost:8123';
+                const token = node.haServer.credentials.access_token;
+                
+                if (!token) {
+                    node.warn('[KNX->HA] HA访问令牌未配置');
+                    return;
+                }
+                
+                const domain = mapping.haEntityId.split('.')[0];
+                let service = '';
+                let serviceData = { entity_id: mapping.haEntityId };
+                
+                if (type === 'switch') {
+                    service = value ? 'turn_on' : 'turn_off';
+                }
+                else if (type === 'light_switch') {
+                    service = value ? 'turn_on' : 'turn_off';
+                }
+                else if (type === 'light_brightness') {
+                    service = 'turn_on';
+                    serviceData.brightness = Math.round(value * 255 / 100);
+                }
+                else if (type === 'cover_action') {
+                    service = value === 'opening' ? 'open_cover' : 'close_cover';
+                }
+                else if (type === 'cover_position') {
+                    service = 'set_cover_position';
+                    serviceData.position = value;
+                }
+                else if (type === 'climate_switch') {
+                    service = value ? 'turn_on' : 'turn_off';
+                }
+                
+                if (service) {
+                    await axios.post(`${baseURL}/api/services/${domain}/${service}`, serviceData, {
+                        headers: {
+                            'Authorization': `Bearer ${token}`,
+                            'Content-Type': 'application/json'
+                        },
+                        timeout: 5000
+                    });
+                    
+                    node.log(`[KNX->HA] ${mapping.haEntityId} ${service}`);
+                    
+                    node.send([null, { 
+                        payload: { 
+                            type: 'knx-to-ha', 
+                            entity: mapping.haEntityId,
+                            service: service
+                        } 
+                    }]);
+                }
+            } catch (err) {
+                node.error(`[KNX->HA] 调用HA服务失败: ${err.message}`);
+            }
+        };
+
+
+        // HA -> KNX 同步
+        node.syncHaToKnx = async function(cmd) {
+            const { mapping, type, value, key } = cmd;
+            node.recordSyncTime('ha-to-knx', key);
+            
+            let knxMsg = null;
+            
+            if (type === 'switch') {
+                knxMsg = {
+                    destination: mapping.knxAddrCmd,
+                    payload: value,
+                    dpt: '1.001',
+                    event: "GroupValue_Write"
+                };
+            }
+            else if (type === 'light_switch') {
+                knxMsg = {
+                    destination: mapping.knxAddrCmd,
+                    payload: value,
+                    dpt: '1.001',
+                    event: "GroupValue_Write"
+                };
+            }
+            else if (type === 'light_brightness') {
+                knxMsg = {
+                    destination: mapping.knxAddrExt1 || mapping.knxAddrStatus,
+                    payload: Math.round(value * 255 / 100),
+                    dpt: '5.001',
+                    event: "GroupValue_Write"
+                };
+            }
+            else if (type === 'cover_action') {
+                knxMsg = {
+                    destination: mapping.knxAddrCmd,
+                    payload: value === 'closing',
+                    dpt: '1.008',
+                    event: "GroupValue_Write"
+                };
+            }
+            else if (type === 'cover_position') {
+                const pos = mapping.invertPosition ? (100 - value) : value;
+                knxMsg = {
+                    destination: mapping.knxAddrStatus || mapping.knxAddrExt1,
+                    payload: pos,
+                    dpt: '5.001',
+                    event: "GroupValue_Write"
+                };
+            }
+            
+            if (knxMsg) {
+                node.log(`[HA->KNX] ${knxMsg.destination} = ${value}`);
+                node.send([knxMsg, null]);
+            }
+        };
+
+        node.on('close', function(done) {
+            if (node.initTimer) clearTimeout(node.initTimer);
+            
+            // 清理HA事件监听
+            if (node.haEventHandlers) {
+                node.haEventHandlers.forEach(({ eventName, handler, ha }) => {
+                    if (ha && ha.eventBus) {
+                        ha.eventBus.removeListener(eventName, handler);
+                    }
+                });
+                node.haEventHandlers = [];
+            }
+            
+            Object.values(node.dimmingTimers).forEach(timer => clearTimeout(timer));
+            Object.values(node.coverTimers).forEach(timer => clearTimeout(timer));
+            
+            node.commandQueue = [];
+            node.knxStateCache = {};
+            node.haStateCache = {};
+            node.lastKnxToHa = {};
+            node.lastHaToKnx = {};
+            node.dimmingTimers = {};
+            node.coverTimers = {};
+            
+            done();
+        });
+    }
+
+    RED.nodes.registerType('symi-knx-ha-bridge', SymiKNXHABridgeNode);
+
+    // HTTP API: 加载HA实体 - 直接使用HA REST API
+    RED.httpAdmin.get('/symi-knx-ha-bridge/ha-entities/:id', async function(req, res) {
+        try {
+            const serverNode = RED.nodes.getNode(req.params.id);
+            
+            if (!serverNode || !serverNode.credentials) {
+                return res.json([]);
+            }
+            
+            const axios = require('axios');
+            const baseURL = serverNode.credentials.host || 'http://localhost:8123';
+            const token = serverNode.credentials.access_token;
+            
+            RED.log.info('[KNX-HA Bridge] baseURL: ' + baseURL);
+            RED.log.info('[KNX-HA Bridge] token length: ' + (token ? token.length : 0));
+            
+            if (!token) {
+                RED.log.warn('[KNX-HA Bridge] HA访问令牌未配置');
+                return res.json([]);
+            }
+            
+            RED.log.info('[KNX-HA Bridge] 使用REST API加载HA实体: ' + baseURL);
+            
+            const response = await axios.get(`${baseURL}/api/states`, {
+                headers: {
+                    'Authorization': `Bearer ${token}`,
+                    'Content-Type': 'application/json'
+                },
+                timeout: 10000
+            });
+            
+            const entities = [];
+            if (response.data && Array.isArray(response.data)) {
+                response.data.forEach(state => {
+                    if (!state || !state.entity_id) return;
+                    
+                    const domain = state.entity_id.split('.')[0];
+                    if (['switch', 'light', 'cover', 'climate', 'fan'].includes(domain)) {
+                        entities.push({
+                            entity_id: state.entity_id,
+                            name: (state.attributes && state.attributes.friendly_name) || state.entity_id,
+                            type: domain
+                        });
+                    }
+                });
+            }
+            
+            RED.log.info('[KNX-HA Bridge] 成功加载 ' + entities.length + ' 个HA实体');
+            res.json(entities);
+        } catch (err) {
+            RED.log.error('[KNX-HA Bridge] 加载HA实体失败: ' + err.message);
+            res.json([]);
+        }
+    });
+};

package/package.json

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