node-red-contrib-symi-modbus 2.6.6 → 2.6.7

package/nodes/modbus-slave-switch.js

@@ -123,6 +123,13 @@ module.exports = function(RED) {
 
         // 节点关闭标志（用于静默关闭期间的警告）
         node.isClosing = false;
+
+        // 根据按钮编号计算deviceAddr和channel（用于LED反馈）
+        // Symi协议公式：按键编号 = deviceAddr * 4 - 4 + channel
+        // 反推公式：deviceAddr = floor((buttonNumber - 1) / 4) + 1, channel = ((buttonNumber - 1) % 4) + 1
+        // 这样即使没有物理按键事件，也能正确发送LED反馈
+        node.buttonDeviceAddr = Math.floor((node.config.buttonNumber - 1) / 4) + 1;
+        node.buttonChannel = ((node.config.buttonNumber - 1) % 4) + 1;
         
         // MQTT主题（映射到继电器设备）
         node.stateTopic = `${node.config.mqttBaseTopic}/${node.config.targetSlaveAddress}/${node.config.targetCoilNumber}/state`;
@@ -224,6 +231,9 @@ module.exports = function(RED) {
                 // 监听物理开关面板的按键事件
                 node.startListeningButtonEvents();
 
+                // 监听主站的状态变化事件（用于LED反馈）
+                node.startListeningStateChanges();
+
             } catch (err) {
                 node.error(`RS-485连接失败: ${err.message}`);
                 node.isRs485Connected = false;
@@ -247,6 +257,50 @@ module.exports = function(RED) {
             }
         };
 
+        // 监听主站的状态变化事件（用于LED反馈）
+        node.startListeningStateChanges = function() {
+            // 定义状态变化监听器
+            node.stateChangeListener = (data) => {
+                if (!data || typeof data !== 'object') {
+                    return;
+                }
+
+                const slave = parseInt(data.slave);
+                const coil = parseInt(data.coil);
+                const value = Boolean(data.value);
+
+                // 检查是否是我们关注的从站和线圈
+                if (slave === node.config.targetSlaveAddress && coil === node.config.targetCoilNumber) {
+                    node.log(`收到状态变化事件：从站${slave} 线圈${coil} = ${value ? 'ON' : 'OFF'}`);
+
+                    // 更新当前状态
+                    node.currentState = value;
+                    node.lastStateChange.timestamp = Date.now();
+                    node.lastStateChange.value = value;
+
+                    // 更新节点状态显示
+                    node.updateStatus();
+
+                    // 发送LED反馈到物理开关面板
+                    node.sendCommandToPanel(value);
+
+                    // 输出状态消息
+                    node.send({
+                        payload: value,
+                        topic: `switch_${node.config.switchId}_btn${node.config.buttonNumber}`,
+                        switchId: node.config.switchId,
+                        button: node.config.buttonNumber,
+                        targetSlave: node.config.targetSlaveAddress,
+                        targetCoil: node.config.targetCoilNumber
+                    });
+                }
+            };
+
+            // 注册内部事件监听器
+            RED.events.on('modbus:coilStateChanged', node.stateChangeListener);
+            node.log('已注册状态变化监听器（用于LED反馈）');
+        };
+
         // 处理RS-485接收到的数据
         node.handleRs485Data = function(data) {
             try {
@@ -277,9 +331,20 @@ module.exports = function(RED) {
                 // buttonNumber对应实际按键编号（1-8）
                 if (buttonEvent.raw.localAddr === node.config.switchId && actualButtonNumber === node.config.buttonNumber) {
                     // 保存原始的deviceAddr和channel，用于LED反馈
+                    const oldDeviceAddr = node.buttonDeviceAddr;
+                    const oldChannel = node.buttonChannel;
                     node.buttonDeviceAddr = buttonEvent.deviceAddr;
                     node.buttonChannel = buttonEvent.channel;
-                    const isSceneMode = node.config.buttonType === 'scene' || buttonEvent.deviceType === 0x07;
+
+                    // 输出调试日志，对比计算值和实际值
+                    if (oldDeviceAddr !== buttonEvent.deviceAddr || oldChannel !== buttonEvent.channel) {
+                        node.log(`按键事件更新LED反馈地址：计算值(设备${oldDeviceAddr} 通道${oldChannel}) → 实际值(设备${buttonEvent.deviceAddr} 通道${buttonEvent.channel})`);
+                    }
+
+                    // 判断按钮类型：优先使用协议解析结果，其次使用配置
+                    const isSceneMode = buttonEvent.isSceneMode ||
+                                       node.config.buttonType === 'scene' ||
+                                       buttonEvent.deviceType === 0x07;
 
                     // 全局防抖：防止多个节点重复处理同一个按键
                     const debounceKey = `${node.config.switchId}-${node.config.buttonNumber}`;
@@ -293,12 +358,11 @@ module.exports = function(RED) {
                     globalDebounceCache.set(debounceKey, now);
 
                     if (isSceneMode) {
-                        node.debug(`场景触发: 面板${node.config.switchId} 按键${node.config.buttonNumber}`);
+                        node.debug(`场景触发: 面板${node.config.switchId} 按键${node.config.buttonNumber} (opInfo=0x${buttonEvent.opInfo.toString(16).toUpperCase()})`);
                         // 场景模式：切换状态（每次触发时翻转）
                         node.currentState = !node.currentState;
                         node.sendMqttCommand(node.currentState);
                     } else {
-
                         // 开关模式：根据状态发送ON/OFF
                         node.debug(`开关${buttonEvent.state ? 'ON' : 'OFF'}: 面板${node.config.switchId} 按键${node.config.buttonNumber}`);
                         node.sendMqttCommand(buttonEvent.state);
@@ -310,10 +374,10 @@ module.exports = function(RED) {
             }
         };
         
-        // 发送命令到继电器（支持两种模式：MQTT模式和本地模式）
+        // 发送命令到继电器（支持两种模式：MQTT模式和内部事件模式）
         node.sendMqttCommand = function(state) {
             // 模式1：MQTT模式（通过MQTT发送命令，由主站节点统一处理）
-            if (node.mqttClient && node.mqttClient.connected) {
+            if (node.config.enableMqtt && node.mqttClient && node.mqttClient.connected) {
                 // 直接发送MQTT命令（不使用队列，立即发送）
                 // 主站节点会处理去重和防抖
                 const commandTopic = `${node.config.mqttBaseTopic}/${node.config.targetSlaveAddress}/${node.config.targetCoilNumber}/set`;
@@ -322,26 +386,26 @@ module.exports = function(RED) {
                 node.mqttClient.publish(commandTopic, payload, { qos: 1 }, (err) => {
                     if (err) {
                         node.error(`MQTT发送失败: ${err.message}`);
+                    } else {
+                        node.debug(`MQTT模式：发送命令到${commandTopic} = ${payload}`);
                     }
-                    // 成功时不输出日志，减少总线负担
                 });
                 return;
             }
 
-            // 模式2：本地模式（通过Node-RED消息输出，直接连线到主站节点）
-            // 当MQTT未连接时，通过节点输出发送控制命令
-            const msg = {
-                payload: {
-                    cmd: "writeCoil",
-                    slave: node.config.targetSlaveAddress,
-                    coil: node.config.targetCoilNumber,
-                    value: state
-                },
-                topic: `modbus/write/${node.config.targetSlaveAddress}/${node.config.targetCoilNumber}`
-            };
-            
-            node.send(msg);
-            node.debug(`本地模式：发送控制命令到从站${node.config.targetSlaveAddress} 线圈${node.config.targetCoilNumber} = ${state ? 'ON' : 'OFF'}`);
+            // 模式2：内部事件模式（通过RED内部事件系统，免连线通信）
+            // 当MQTT未启用或未连接时，通过内部事件发送控制命令
+            // 主站节点会监听这些事件并执行写入操作
+            RED.events.emit('modbus:writeCoil', {
+                slave: node.config.targetSlaveAddress,
+                coil: node.config.targetCoilNumber,
+                value: state,
+                source: 'slave-switch',
+                nodeId: node.id
+            });
+
+            // 输出日志确认发送
+            node.log(`内部事件模式：发送命令到从站${node.config.targetSlaveAddress} 线圈${node.config.targetCoilNumber} = ${state ? 'ON' : 'OFF'}`);
         };
         
         // 处理命令队列（防止多个按键同时按下造成冲突）
@@ -454,10 +518,10 @@ module.exports = function(RED) {
                 const state = item.state;
                 
                 try {
-                    // 使用保存的原始deviceAddr和channel（从按键事件中获取）
-                    // 如果没有保存，则根据按键编号反推（兼容旧版本）
-                    const deviceAddr = node.buttonDeviceAddr || (Math.floor((node.config.buttonNumber - 1) / 4) + 1);
-                    const channel = node.buttonChannel || (((node.config.buttonNumber - 1) % 4) + 1);
+                    // 使用初始化时计算的deviceAddr和channel
+                    // 当物理按键按下时，会更新为实际的deviceAddr和channel
+                    const deviceAddr = node.buttonDeviceAddr;
+                    const channel = node.buttonChannel;
 
                     // 根据按钮类型选择协议类型
                     // 开关模式：使用SET协议（0x03），面板LED需要接收SET指令
@@ -486,8 +550,11 @@ module.exports = function(RED) {
                         node.serialPortConfig.write(command, (err) => {
                             if (err) {
                                 node.error(`LED反馈失败: ${err.message}`);
+                            } else {
+                                // 输出调试日志，确认LED反馈已发送（包含协议帧十六进制）
+                                const hexStr = command.toString('hex').toUpperCase().match(/.{1,2}/g).join(' ');
+                                node.log(`LED反馈已发送：面板${node.config.switchId} 按钮${node.config.buttonNumber} 设备${deviceAddr} 通道${channel} = ${state ? 'ON' : 'OFF'} (${node.config.buttonType === 'scene' ? 'REPORT' : 'SET'}) [${hexStr}]`);
                             }
-                            // 成功时不输出日志，减少总线负担
                         });
                     } else {
                         node.warn('RS-485连接未配置');
@@ -551,8 +618,8 @@ module.exports = function(RED) {
         node.connectMqtt = function() {
             // 检查是否启用MQTT
             if (!node.config.enableMqtt) {
-                node.log('MQTT未启用 - 使用本地模式（通过Node-RED连线控制）');
-                node.log('提示：将此节点连线到主站节点，即可实现本地控制');
+                node.log('MQTT未启用 - 使用内部事件模式（免连线通信）');
+                node.log('提示：物理开关面板按键会通过内部事件自动发送到主站节点');
                 return;
             }
             
@@ -827,6 +894,13 @@ module.exports = function(RED) {
                 }
                 node.serialDataListener = null;
             }
+
+            // 移除状态变化监听器
+            if (node.stateChangeListener) {
+                RED.events.removeListener('modbus:coilStateChanged', node.stateChangeListener);
+                node.stateChangeListener = null;
+                node.log('状态变化监听器已移除');
+            }
             
             // 关闭MQTT连接
             if (node.mqttClient) {

package/nodes/serial-port-config.js

@@ -32,6 +32,10 @@ module.exports = function(RED) {
         // 数据监听器列表（每个从站开关节点注册一个）
         node.dataListeners = [];
 
+        // 写入队列（防止多个节点同时写入冲突）
+        node.writeQueue = [];
+        node.isWriting = false;
+
         // 打开TCP连接
         node.openTcpConnection = function() {
             if (node.connection && !node.connection.destroyed) {
@@ -47,8 +51,8 @@ module.exports = function(RED) {
 
             try {
                 node.connection = new net.Socket();
-                node.connection.setKeepAlive(true, 30000);  // 启用TCP Keep-Alive，30秒间隔
-                node.connection.setTimeout(60000);  // 60秒超时
+                node.connection.setKeepAlive(true, 10000);  // 启用TCP Keep-Alive，10秒间隔
+                node.connection.setTimeout(0);  // 禁用超时（永不超时）
 
                 node.connection.connect(node.tcpPort, node.tcpHost, () => {
                     node.log(`TCP连接已建立: ${node.tcpHost}:${node.tcpPort}`);
@@ -56,6 +60,8 @@ module.exports = function(RED) {
                 });
 
                 // 监听数据（分发给所有注册的监听器）
+                // 注意：不在这里做协议解析，直接广播原始数据
+                // 让各个监听器（modbus-master、modbus-slave-switch等）自己决定如何处理
                 node.connection.on('data', (data) => {
                     // 广播给所有监听器
                     node.dataListeners.forEach(listener => {
@@ -84,21 +90,21 @@ module.exports = function(RED) {
                 // 监听关闭（统一的重连入口）
                 node.connection.on('close', (hadError) => {
                     node.log(`TCP连接已关闭${hadError ? '（有错误）' : ''}`);
-                    
+
                     // 清理连接对象
                     if (node.connection) {
                         node.connection.removeAllListeners();
                         node.connection.destroy();
                         node.connection = null;
                     }
-                    
+
                     // 自动重连（如果不是主动关闭且有监听器在使用）
                     if (!node.isClosing && node.dataListeners.length > 0) {
                         const delay = Math.min(5000 * Math.pow(2, node.reconnectAttempts), 60000);  // 指数退避，最大60秒
                         node.reconnectAttempts++;
-                        
+
                         node.log(`${delay/1000}秒后尝试重新连接TCP（第${node.reconnectAttempts}次）...`);
-                        
+
                         node.reconnectTimer = setTimeout(() => {
                             node.reconnectTimer = null;
                             node.openTcpConnection();
@@ -296,54 +302,111 @@ module.exports = function(RED) {
             }
         };
 
-        // 写入数据
+        // 写入数据（带队列机制，防止并发冲突）
         node.write = function(data, callback) {
-            if (!node.connection) {
-                const err = new Error('连接未建立');
-                if (callback) callback(err);
+            // 加入写入队列
+            node.writeQueue.push({ data, callback });
+
+            // 启动队列处理
+            node.processWriteQueue();
+        };
+
+        // 处理写入队列（串行执行，避免并发冲突）
+        node.processWriteQueue = async function() {
+            if (node.isWriting || node.writeQueue.length === 0) {
                 return;
             }
 
-            if (node.connectionType === 'tcp') {
-                if (node.connection.destroyed) {
-                    const err = new Error('TCP连接已断开');
-                    if (callback) callback(err);
-                    return;
-                }
-                node.connection.write(data, (err) => {
-                    if (err) {
-                        node.error(`TCP写入失败: ${err.message}`);
+            node.isWriting = true;
+
+            while (node.writeQueue.length > 0) {
+                const item = node.writeQueue.shift();
+                const { data, callback } = item;
+
+                try {
+                    if (!node.connection) {
+                        const err = new Error('连接未建立');
+                        if (callback) callback(err);
+                        continue;
                     }
-                    if (callback) callback(err);
-                });
-            } else {
-                if (!node.connection.isOpen) {
-                    const err = new Error('串口未打开');
-                    if (callback) callback(err);
-                    return;
-                }
-                node.connection.write(data, (err) => {
-                    if (err) {
-                        node.error(`串口写入失败: ${err.message}`);
+
+                    if (node.connectionType === 'tcp') {
+                        if (node.connection.destroyed) {
+                            const err = new Error('TCP连接已断开');
+                            if (callback) callback(err);
+                            continue;
+                        }
+
+                        // TCP写入（异步）
+                        await new Promise((resolve, reject) => {
+                            node.connection.write(data, (err) => {
+                                if (err) {
+                                    node.error(`TCP写入失败: ${err.message}`);
+                                    if (callback) callback(err);
+                                    reject(err);
+                                } else {
+                                    if (callback) callback(null);
+                                    resolve();
+                                }
+                            });
+                        });
+
+                        // TCP写入间隔（20ms，避免网关处理不过来）
+                        if (node.writeQueue.length > 0) {
+                            await new Promise(resolve => setTimeout(resolve, 20));
+                        }
+                    } else {
+                        if (!node.connection.isOpen) {
+                            const err = new Error('串口未打开');
+                            if (callback) callback(err);
+                            continue;
+                        }
+
+                        // 串口写入（异步）
+                        await new Promise((resolve, reject) => {
+                            node.connection.write(data, (err) => {
+                                if (err) {
+                                    node.error(`串口写入失败: ${err.message}`);
+                                    if (callback) callback(err);
+                                    reject(err);
+                                } else {
+                                    if (callback) callback(null);
+                                    resolve();
+                                }
+                            });
+                        });
+
+                        // 串口写入间隔（10ms，串口速度较快）
+                        if (node.writeQueue.length > 0) {
+                            await new Promise(resolve => setTimeout(resolve, 10));
+                        }
                     }
-                    if (callback) callback(err);
-                });
+                } catch (err) {
+                    // 写入失败，继续处理下一个
+                    node.warn(`写入失败（已跳过）: ${err.message}`);
+                }
             }
+
+            node.isWriting = false;
         };
 
         // 节点关闭时清理
         node.on('close', function(done) {
             node.isClosing = true;  // 标记正在关闭，防止自动重连
-            
+
             // 清除重连定时器
             if (node.reconnectTimer) {
                 clearTimeout(node.reconnectTimer);
                 node.reconnectTimer = null;
             }
-            
+
             // 清空所有监听器
             node.dataListeners = [];
 
+            // 清空写入队列
+            node.writeQueue = [];
+            node.isWriting = false;
+
             // 关闭连接
             if (node.connection) {
                 if (node.connectionType === 'tcp') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-symi-modbus",
-  "version": "2.6.6",
+  "version": "2.6.7",
   "description": "Node-RED Modbus节点，支持TCP/串口通信、串口自动搜索、多设备轮询、可选MQTT集成（支持纯本地模式和MQTT模式）、Home Assistant自动发现和物理开关面板双向同步，工控机长期稳定运行",
   "main": "nodes/modbus-master.js",
   "scripts": {