node-red-contrib-symi-mesh 1.2.3

package/lib/serial-client.js

@@ -0,0 +1,286 @@
+/**
+ * Serial Client for Symi Gateway
+ */
+
+const EventEmitter = require('events');
+const { ProtocolHandler } = require('./protocol');
+
+class SerialClient extends EventEmitter {
+    constructor(portPath, baudRate = 115200, logger = console) {
+        super();
+        this.portPath = portPath;
+        this.baudRate = baudRate;
+        this.logger = logger;
+        this.port = null;
+        this.protocolHandler = new ProtocolHandler();
+        this.connected = false;
+        this.commandQueue = [];
+        this.processingQueue = false;
+        this.SerialPort = null;
+        this.reconnectDelay = 5000;
+        this.reconnectTimer = null;
+        this.autoReconnect = true;
+    }
+
+    async connect() {
+        try {
+            if (this.connected) {
+                return Promise.resolve();
+            }
+
+            // 清理之前的端口
+            if (this.port) {
+                try {
+                    if (this.port.isOpen) {
+                        this.port.close();
+                    }
+                    this.port.removeAllListeners();
+                } catch (e) {
+                    // 忽略清理错误
+                }
+                this.port = null;
+            }
+
+            if (!this.SerialPort) {
+                this.SerialPort = require('serialport').SerialPort;
+            }
+
+            this.port = new this.SerialPort({
+                path: this.portPath,
+                baudRate: this.baudRate,
+                dataBits: 8,
+                stopBits: 1,
+                parity: 'none'
+            });
+
+            return new Promise((resolve, reject) => {
+                let resolved = false;
+                let rejected = false;
+
+                const timeout = setTimeout(() => {
+                    if (!resolved && !rejected) {
+                        rejected = true;
+                        this.logger.error('Serial port connection timeout');
+                        if (this.port && this.port.isOpen) {
+                            this.port.close();
+                        }
+                        this.handleDisconnect();
+                        reject(new Error('Serial port connection timeout'));
+                    }
+                }, 10000);
+
+                this.port.on('open', () => {
+                    if (!resolved && !rejected) {
+                        resolved = true;
+                        clearTimeout(timeout);
+                        this.connected = true;
+                        this.logger.log(`Serial port opened: ${this.portPath} at ${this.baudRate} baud`);
+                        this.emit('connected');
+                        
+                        if (!this.processingQueue) {
+                            this.startQueueProcessor();
+                        }
+                        
+                        resolve();
+                    }
+                });
+
+                this.port.on('data', (data) => {
+                    try {
+                        const frames = this.protocolHandler.addData(data);
+                        frames.forEach(frame => {
+                            this.emit('frame', frame);
+                        });
+                    } catch (error) {
+                        this.logger.error('Error parsing frame:', error);
+                    }
+                });
+
+                this.port.on('error', (error) => {
+                    clearTimeout(timeout);
+                    this.logger.error('Serial port error:', error.message);
+                    this.emit('error', error);
+                    
+                    if (!resolved && !rejected) {
+                        rejected = true;
+                        this.handleDisconnect();
+                        reject(error);
+                    }
+                });
+
+                this.port.on('close', () => {
+                    clearTimeout(timeout);
+                    this.logger.log('Serial port closed');
+                    
+                    if (!resolved && !rejected) {
+                        rejected = true;
+                        reject(new Error('Serial port closed during connect'));
+                    }
+                    
+                    this.handleDisconnect();
+                });
+            });
+        } catch (error) {
+            this.logger.error('Failed to open serial port:', error);
+            this.handleDisconnect();
+            throw error;
+        }
+    }
+
+    handleDisconnect() {
+        const wasConnected = this.connected;
+        this.connected = false;
+        
+        // 清理端口
+        if (this.port) {
+            try {
+                if (this.port.isOpen) {
+                    this.port.close();
+                }
+                this.port.removeAllListeners();
+            } catch (e) {
+                // 忽略清理错误
+            }
+            this.port = null;
+        }
+        
+        // 触发断连事件
+        if (wasConnected) {
+            this.emit('disconnected');
+        }
+        
+        // 自动重连
+        if (this.autoReconnect && !this.reconnectTimer) {
+            this.reconnectTimer = setTimeout(() => {
+                this.reconnectTimer = null;
+                this.logger.log('Attempting to reconnect serial port...');
+                this.connect()
+                    .then(() => {
+                        this.logger.log('Serial port reconnected successfully');
+                    })
+                    .catch((error) => {
+                        this.logger.error(`Serial port reconnect failed: ${error.message}`);
+                        // 失败后会自动继续尝试重连（通过handleDisconnect）
+                    });
+            }, this.reconnectDelay);
+        }
+    }
+
+    disconnect() {
+        this.autoReconnect = false;
+        
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        
+        return new Promise((resolve) => {
+            if (this.port && this.port.isOpen) {
+                this.port.close(() => {
+                    this.connected = false;
+                    try {
+                        this.port.removeAllListeners();
+                    } catch (e) {
+                        // 忽略错误
+                    }
+                    this.port = null;
+                    this.commandQueue = [];
+                    this.processingQueue = false;
+                    resolve();
+                });
+            } else {
+                if (this.port) {
+                    try {
+                        this.port.removeAllListeners();
+                    } catch (e) {
+                        // 忽略错误
+                    }
+                    this.port = null;
+                }
+                this.commandQueue = [];
+                this.processingQueue = false;
+                resolve();
+            }
+        });
+    }
+    
+    setAutoReconnect(enabled) {
+        this.autoReconnect = enabled;
+    }
+
+    sendFrame(frame, priority = 1) {
+        return new Promise((resolve, reject) => {
+            if (!this.connected) {
+                reject(new Error('Serial port not connected'));
+                return;
+            }
+
+            const command = { frame, priority, resolve, reject, retries: 0 };
+            
+            if (priority === 0) {
+                this.commandQueue.unshift(command);
+            } else {
+                this.commandQueue.push(command);
+            }
+            
+            if (!this.processingQueue) {
+                this.startQueueProcessor();
+            }
+        });
+    }
+
+    startQueueProcessor() {
+        if (this.processingQueue) return;
+        
+        this.processingQueue = true;
+        this.processQueue();
+    }
+
+    async processQueue() {
+        while (this.commandQueue.length > 0 && this.connected) {
+            const command = this.commandQueue.shift();
+            
+            try {
+                await this.sendFrameDirect(command.frame);
+                command.resolve(true);
+            } catch (error) {
+                command.retries++;
+                if (command.retries < 3) {
+                    this.commandQueue.unshift(command);
+                } else {
+                    command.reject(error);
+                }
+            }
+            
+            await this.sleep(50);
+        }
+        
+        this.processingQueue = false;
+    }
+
+    sendFrameDirect(frame) {
+        return new Promise((resolve, reject) => {
+            if (!this.connected || !this.port) {
+                reject(new Error('Serial port not connected'));
+                return;
+            }
+
+            this.port.write(frame, (error) => {
+                if (error) {
+                    reject(error);
+                } else {
+                    this.port.drain(() => {
+                        resolve();
+                    });
+                }
+            });
+        });
+    }
+
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+}
+
+module.exports = SerialClient;
+

package/lib/tcp-client.js

@@ -0,0 +1,262 @@
+/**
+ * TCP Client for Symi Gateway
+ */
+
+const net = require('net');
+const EventEmitter = require('events');
+const { ProtocolHandler } = require('./protocol');
+
+class TCPClient extends EventEmitter {
+    constructor(host, port, logger = console) {
+        super();
+        this.host = host;
+        this.port = port || 4196;
+        this.logger = logger;
+        this.client = null;
+        this.protocolHandler = new ProtocolHandler();
+        this.connected = false;
+        this.reconnectDelay = 5000;
+        this.reconnectTimer = null;
+        this.autoReconnect = true;
+        this.commandQueue = [];
+        this.processingQueue = false;
+    }
+
+    connect() {
+        return new Promise((resolve, reject) => {
+            if (this.connected) {
+                resolve();
+                return;
+            }
+
+            // 清理之前的客户端
+            if (this.client) {
+                try {
+                    this.client.removeAllListeners();
+                    this.client.destroy();
+                } catch (e) {
+                    // 忽略清理错误
+                }
+            }
+
+            this.client = new net.Socket();
+            this.client.setKeepAlive(true, 30000);
+            
+            let resolved = false;
+            let rejected = false;
+            
+            const timeout = setTimeout(() => {
+                if (!resolved && !rejected) {
+                    rejected = true;
+                    if (this.client) {
+                        this.client.destroy();
+                    }
+                    this.logger.error('Connection timeout');
+                    this.handleDisconnect();
+                    reject(new Error('Connection timeout'));
+                }
+            }, 10000);
+
+            this.client.connect(this.port, this.host, () => {
+                if (!resolved && !rejected) {
+                    resolved = true;
+                    clearTimeout(timeout);
+                    this.connected = true;
+                    this.logger.log(`Connected to gateway at ${this.host}:${this.port}`);
+                    this.emit('connected');
+                    
+                    if (!this.processingQueue) {
+                        this.startQueueProcessor();
+                    }
+                    
+                    resolve();
+                }
+            });
+
+            this.client.on('data', (data) => {
+                try {
+                    // 添加原始数据日志
+                    // const dataHex = data.toString('hex').toUpperCase();
+                    // this.logger.log(`[TCP Raw Data] 收到${data.length}字节: ${dataHex}`);
+                    
+                    const frames = this.protocolHandler.addData(data);
+                    // this.logger.log(`[TCP Parse] 解析出${frames.length}个帧`);
+                    
+                    frames.forEach(frame => {
+                        this.emit('frame', frame);
+                    });
+                } catch (error) {
+                    this.logger.error('Error parsing frame:', error);
+                    this.logger.error('Raw data:', data.toString('hex'));
+                }
+            });
+
+            this.client.on('error', (error) => {
+                clearTimeout(timeout);
+                this.logger.error('TCP client error:', error.message);
+                
+                // 确保错误不会导致uncaught exception
+                this.emit('error', error);
+                
+                if (!resolved && !rejected) {
+                    rejected = true;
+                    this.handleDisconnect();
+                    reject(error);
+                }
+            });
+
+            this.client.on('close', () => {
+                clearTimeout(timeout);
+                this.logger.log('Connection closed');
+                
+                if (!resolved && !rejected) {
+                    rejected = true;
+                    reject(new Error('Connection closed during connect'));
+                }
+                
+                this.handleDisconnect();
+            });
+        });
+    }
+
+    handleDisconnect() {
+        const wasConnected = this.connected;
+        this.connected = false;
+        
+        // 清理客户端
+        if (this.client) {
+            try {
+                this.client.removeAllListeners();
+                this.client.destroy();
+            } catch (e) {
+                // 忽略清理错误
+            }
+            this.client = null;
+        }
+        
+        // 触发断连事件
+        if (wasConnected) {
+            this.emit('disconnected');
+        }
+        
+        // 自动重连
+        if (this.autoReconnect && !this.reconnectTimer) {
+            this.reconnectTimer = setTimeout(() => {
+                this.reconnectTimer = null;
+                this.logger.log('Attempting to reconnect...');
+                this.connect()
+                    .then(() => {
+                        this.logger.log('Reconnected successfully');
+                    })
+                    .catch((error) => {
+                        this.logger.error(`Reconnect failed: ${error.message}`);
+                        // 失败后会自动继续尝试重连（通过handleDisconnect）
+                    });
+            }, this.reconnectDelay);
+        }
+    }
+
+    disconnect() {
+        this.autoReconnect = false;
+        
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        
+        if (this.client) {
+            try {
+                this.client.removeAllListeners();
+                this.client.destroy();
+            } catch (e) {
+                // 忽略错误
+            }
+            this.client = null;
+        }
+        
+        this.connected = false;
+        this.commandQueue = [];
+        this.processingQueue = false;
+    }
+
+    sendFrame(frame, priority = 1) {
+        return new Promise((resolve, reject) => {
+            if (!this.connected) {
+                reject(new Error('Not connected'));
+                return;
+            }
+
+            const command = { frame, priority, resolve, reject, retries: 0 };
+            
+            if (priority === 0) {
+                this.commandQueue.unshift(command);
+            } else {
+                this.commandQueue.push(command);
+            }
+            
+            if (!this.processingQueue) {
+                this.startQueueProcessor();
+            }
+        });
+    }
+
+    startQueueProcessor() {
+        if (this.processingQueue) return;
+        
+        this.processingQueue = true;
+        this.processQueue();
+    }
+
+    async processQueue() {
+        while (this.commandQueue.length > 0 && this.connected) {
+            const command = this.commandQueue.shift();
+            
+            try {
+                await this.sendFrameDirect(command.frame);
+                command.resolve(true);
+            } catch (error) {
+                command.retries++;
+                if (command.retries < 3) {
+                    this.commandQueue.unshift(command);
+                } else {
+                    command.reject(error);
+                }
+            }
+            
+            await this.sleep(50);
+        }
+        
+        this.processingQueue = false;
+    }
+
+    sendFrameDirect(frame) {
+        return new Promise((resolve, reject) => {
+            if (!this.connected || !this.client) {
+                reject(new Error('Not connected'));
+                return;
+            }
+
+            // 添加发送日志
+            const frameHex = frame.toString('hex').toUpperCase();
+            this.logger.log(`[TCP Frame] 发送: ${frameHex}`);
+
+            this.client.write(frame, (error) => {
+                if (error) {
+                    reject(error);
+                } else {
+                    resolve();
+                }
+            });
+        });
+    }
+
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+
+    setAutoReconnect(enabled) {
+        this.autoReconnect = enabled;
+    }
+}
+
+module.exports = TCPClient;