ts-communication 1.0.0 → 1.1.0

package/dist/core/DeviceSerialPort.js

@@ -0,0 +1,283 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceSerialPort = void 0;
+const Core_1 = require("./Core");
+const CommunicationLock_1 = require("./CommunicationLock");
+/**
+ * 串口设备基类
+ * Base class for serial port devices
+ */
+class DeviceSerialPort {
+    // 串口配置
+    PortName = '';
+    BaudRate = 9600;
+    DataBits = 8;
+    StopBits = 1;
+    Parity = 'none';
+    // 超时设置
+    ReceiveTimeOut = 5000;
+    ConnectTimeOut = 5000;
+    // 字节转换器
+    ByteTransform = new Core_1.ByteTransform();
+    // 连接ID
+    ConnectionId = '';
+    // 通信锁和请求队列
+    communicationLock;
+    requestQueue;
+    // 是否启用通信锁（默认启用）
+    EnableCommunicationLock = true;
+    // 串口对象
+    serial;
+    isOpen = false;
+    // 接收空数据计数（用于某些协议判断帧结束）
+    ReceiveEmptyDataCount = 0;
+    constructor() {
+        this.communicationLock = new CommunicationLock_1.CommunicationLockSimple();
+        this.requestQueue = new CommunicationLock_1.RequestQueue();
+    }
+    /**
+     * 打包命令（在发送前添加协议头、CRC等）
+     * 子类可以重写此方法
+     */
+    PackCommandWithHeader(command) {
+        return command;
+    }
+    /**
+     * 解包响应（验证CRC、去除协议头等）
+     * 子类可以重写此方法
+     */
+    UnpackResponseContent(send, response) {
+        return Core_1.OperateResult.CreateSuccessResult(response);
+    }
+    /**
+     * 初始化串口配置
+     */
+    SerialPortInni(portName, baudRate = 9600, dataBits = 8, stopBits = 1, parity = 'none') {
+        this.PortName = portName;
+        this.BaudRate = baudRate;
+        this.DataBits = dataBits;
+        this.StopBits = stopBits;
+        this.Parity = parity;
+        this.ConnectionId = `Serial:${portName}`;
+        return this;
+    }
+    /**
+     * 打开串口
+     */
+    async Open() {
+        if (this.isOpen && this.serial) {
+            return Core_1.OperateResult.CreateSuccessResult();
+        }
+        try {
+            // 动态导入 serialport
+            const mod = await import('serialport');
+            const SerialPort = mod.SerialPort;
+            this.serial = new SerialPort({
+                path: this.PortName,
+                baudRate: this.BaudRate,
+                dataBits: this.DataBits,
+                stopBits: this.StopBits,
+                parity: this.Parity,
+                autoOpen: false
+            });
+            // 打开串口
+            return new Promise((resolve) => {
+                const timer = setTimeout(() => {
+                    resolve(new Core_1.OperateResult('Serial port open timeout', -1));
+                }, this.ConnectTimeOut);
+                this.serial.open((err) => {
+                    clearTimeout(timer);
+                    if (err) {
+                        resolve(new Core_1.OperateResult(`Unable to open serial port: ${err.message}`, -1));
+                    }
+                    else {
+                        this.isOpen = true;
+                        resolve(Core_1.OperateResult.CreateSuccessResult());
+                    }
+                });
+            });
+        }
+        catch (e) {
+            return new Core_1.OperateResult(`Unable to load serialport module: ${e.message}. Please install: npm install serialport`, -1);
+        }
+    }
+    /**
+     * 关闭串口
+     */
+    async Close() {
+        if (!this.serial || !this.isOpen) {
+            return Core_1.OperateResult.CreateSuccessResult();
+        }
+        return new Promise((resolve) => {
+            this.serial.close((err) => {
+                if (err) {
+                    resolve(new Core_1.OperateResult(`Unable to close serial port: ${err.message}`, -1));
+                }
+                else {
+                    this.isOpen = false;
+                    this.serial = undefined;
+                    resolve(Core_1.OperateResult.CreateSuccessResult());
+                }
+            });
+        });
+    }
+    /**
+     * 发送请求并接收响应
+     */
+    async ReadFromCoreServer(send, hasResponseData = true, usePackAndUnpack = true) {
+        // 加入请求队列
+        return this.requestQueue.enqueue(async () => {
+            // 进入通信锁
+            if (this.EnableCommunicationLock) {
+                const lockResult = await this.communicationLock.EnterLock(this.ConnectTimeOut);
+                if (!lockResult.IsSuccess) {
+                    return Core_1.OperateResult.CreateFailedResult(lockResult);
+                }
+            }
+            try {
+                // 确保串口已打开
+                const openResult = await this.Open();
+                if (!openResult.IsSuccess) {
+                    return Core_1.OperateResult.CreateFailedResult(openResult);
+                }
+                // 打包命令
+                const sendData = usePackAndUnpack ? this.PackCommandWithHeader(send) : send;
+                // 如果不需要响应数据，直接发送并返回
+                if (!hasResponseData) {
+                    return new Promise((resolve) => {
+                        this.serial.write(sendData, (err) => {
+                            if (err) {
+                                resolve(new Core_1.OperateResult(`Serial write error: ${err.message}`, -1));
+                            }
+                            else {
+                                resolve(Core_1.OperateResult.CreateSuccessResult(Buffer.alloc(0)));
+                            }
+                        });
+                    });
+                }
+                // 获取消息解析器
+                const message = this.GetNewNetMessage();
+                if (message) {
+                    return await this.readWithMessage(sendData, send, message, usePackAndUnpack);
+                }
+                // 如果没有消息解析器，返回错误
+                return new Core_1.OperateResult('No message parser available', -1);
+            }
+            finally {
+                // 离开通信锁
+                if (this.EnableCommunicationLock) {
+                    this.communicationLock.LeaveLock();
+                }
+            }
+        });
+    }
+    /**
+     * 使用 INetMessage 解析器读取数据
+     */
+    async readWithMessage(sendData, originalSend, message, usePackAndUnpack) {
+        return new Promise((resolve) => {
+            let receiveBuffer = Buffer.alloc(0);
+            let done = false;
+            let emptyCount = 0;
+            message.SendBytes = sendData;
+            const finish = (result) => {
+                if (done)
+                    return;
+                done = true;
+                clearTimeout(timer);
+                this.serial.removeListener('data', onData);
+                resolve(result);
+            };
+            const onData = (chunk) => {
+                if (chunk.length === 0) {
+                    emptyCount++;
+                    if (this.ReceiveEmptyDataCount > 0 && emptyCount >= this.ReceiveEmptyDataCount) {
+                        // 连续接收到空数据，认为帧结束
+                        if (receiveBuffer.length > 0) {
+                            const unpackResult = usePackAndUnpack
+                                ? this.UnpackResponseContent(originalSend, receiveBuffer)
+                                : Core_1.OperateResult.CreateSuccessResult(receiveBuffer);
+                            finish(unpackResult);
+                        }
+                    }
+                    return;
+                }
+                emptyCount = 0;
+                receiveBuffer = Buffer.concat([receiveBuffer, chunk]);
+                try {
+                    // 第一步：接收头部
+                    if (message.HeadBytes.length < message.ProtocolHeadBytesLength) {
+                        // 检查并跳过无效前缀
+                        const uselessLength = message.PependedUselesByteLength(receiveBuffer);
+                        if (uselessLength > 0) {
+                            receiveBuffer = receiveBuffer.subarray(uselessLength);
+                        }
+                        const headLength = message.ProtocolHeadBytesLength;
+                        if (headLength > 0 && receiveBuffer.length >= headLength) {
+                            message.HeadBytes = receiveBuffer.subarray(0, headLength);
+                            receiveBuffer = receiveBuffer.subarray(headLength);
+                            // 检查头部合法性
+                            if (!message.CheckHeadBytesLegal()) {
+                                finish(new Core_1.OperateResult('Invalid message head', -3));
+                                return;
+                            }
+                        }
+                        else if (headLength < 0) {
+                            // 动态长度消息（如 Modbus ASCII），需要特殊处理
+                            // 继续接收直到遇到结束符
+                        }
+                        else {
+                            return; // 继续等待
+                        }
+                    }
+                    // 第二步：获取内容长度
+                    const contentLength = message.GetContentLengthByHeadBytes();
+                    if (contentLength < 0) {
+                        // 对于动态长度消息，继续等待
+                        return;
+                    }
+                    // 第三步：接收内容
+                    if (receiveBuffer.length >= contentLength) {
+                        message.ContentBytes = receiveBuffer.subarray(0, contentLength);
+                        const fullMessage = Buffer.concat([message.HeadBytes, message.ContentBytes]);
+                        // 检查消息匹配
+                        const matchResult = message.CheckMessageMatch(sendData, fullMessage);
+                        if (matchResult === 0) {
+                            finish(new Core_1.OperateResult('Message match failed', -4));
+                        }
+                        else if (matchResult === 1) {
+                            // 解包响应
+                            const unpackResult = usePackAndUnpack
+                                ? this.UnpackResponseContent(originalSend, fullMessage)
+                                : Core_1.OperateResult.CreateSuccessResult(message.ContentBytes);
+                            finish(unpackResult);
+                        }
+                        // matchResult === -1 继续等待
+                    }
+                }
+                catch (e) {
+                    finish(new Core_1.OperateResult(`Parse error: ${e.message}`, -5));
+                }
+            };
+            const timer = setTimeout(() => {
+                finish(new Core_1.OperateResult('Receive timeout', -2));
+            }, this.ReceiveTimeOut);
+            this.serial.on('data', onData);
+            // 发送数据
+            this.serial.write(sendData, (err) => {
+                if (err) {
+                    finish(new Core_1.OperateResult(`Serial write error: ${err.message}`, -1));
+                }
+            });
+        });
+    }
+    /**
+     * 释放资源
+     */
+    async Dispose() {
+        await this.Close();
+        this.communicationLock.dispose();
+        this.requestQueue.clear();
+    }
+}
+exports.DeviceSerialPort = DeviceSerialPort;

package/dist/core/DeviceUdpNet.d.ts

@@ -0,0 +1,56 @@
+import { OperateResult, ByteTransform } from './Core';
+import { ICommunicationLock, RequestQueue } from './CommunicationLock';
+import { INetMessage } from './INetMessage';
+/**
+ * UDP 设备基类
+ * Base class for UDP devices
+ */
+export declare abstract class DeviceUdpNet {
+    IpAddress: string;
+    Port: number;
+    LocalPort: number;
+    ConnectTimeOut: number;
+    ReceiveTimeOut: number;
+    ByteTransform: ByteTransform;
+    ConnectionId: string;
+    protected communicationLock: ICommunicationLock;
+    protected requestQueue: RequestQueue;
+    EnableCommunicationLock: boolean;
+    private socket?;
+    private isOpen;
+    constructor(ipAddress?: string, port?: number);
+    /**
+     * 获取当前协议的消息解析器
+     * 子类应该重写此方法以提供特定协议的消息解析器
+     */
+    protected GetNewNetMessage(): INetMessage | undefined;
+    /**
+     * 打开 UDP socket
+     */
+    ConnectServer(): Promise<OperateResult<void>>;
+    /**
+     * 关闭 UDP socket
+     */
+    ConnectClose(): Promise<OperateResult<void>>;
+    /**
+     * 发送请求并接收响应
+     */
+    protected request(frame: Buffer, parser?: (data: Buffer) => Buffer): Promise<OperateResult<Buffer>>;
+    /**
+     * 使用 INetMessage 解析器发送请求
+     */
+    private requestWithMessage;
+    /**
+     * 简单的请求响应（不使用 INetMessage）
+     */
+    private requestSimple;
+    /**
+     * 批量发送请求（自动合并结果）
+     */
+    protected ReadFromCoreServer(commands: Buffer[]): Promise<OperateResult<Buffer>>;
+    protected fromResult<T>(result: OperateResult<Buffer>, fn: (data: Buffer) => T): OperateResult<T>;
+    /**
+     * 释放资源
+     */
+    Dispose(): Promise<void>;
+}

package/dist/core/DeviceUdpNet.js

@@ -0,0 +1,307 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceUdpNet = void 0;
+const dgram = __importStar(require("node:dgram"));
+const Core_1 = require("./Core");
+const CommunicationLock_1 = require("./CommunicationLock");
+/**
+ * UDP 设备基类
+ * Base class for UDP devices
+ */
+class DeviceUdpNet {
+    IpAddress = '127.0.0.1';
+    Port = 5000;
+    LocalPort = 0; // 0 表示随机端口
+    ConnectTimeOut = 5000;
+    ReceiveTimeOut = 5000;
+    ByteTransform = new Core_1.ByteTransform();
+    ConnectionId = '';
+    // 通信锁和请求队列
+    communicationLock;
+    requestQueue;
+    // 是否启用通信锁（默认启用）
+    EnableCommunicationLock = true;
+    // UDP socket
+    socket;
+    isOpen = false;
+    constructor(ipAddress, port) {
+        if (ipAddress !== undefined)
+            this.IpAddress = ipAddress;
+        if (port !== undefined)
+            this.Port = port;
+        this.ConnectionId = `UDP:${this.IpAddress}:${this.Port}`;
+        // 初始化通信锁和队列
+        this.communicationLock = new CommunicationLock_1.CommunicationLockSimple();
+        this.requestQueue = new CommunicationLock_1.RequestQueue();
+    }
+    /**
+     * 获取当前协议的消息解析器
+     * 子类应该重写此方法以提供特定协议的消息解析器
+     */
+    GetNewNetMessage() {
+        return undefined;
+    }
+    /**
+     * 打开 UDP socket
+     */
+    async ConnectServer() {
+        if (this.isOpen && this.socket) {
+            return Core_1.OperateResult.CreateSuccessResult();
+        }
+        return new Promise((resolve) => {
+            try {
+                this.socket = dgram.createSocket('udp4');
+                const timer = setTimeout(() => {
+                    resolve(new Core_1.OperateResult('UDP socket bind timeout', -1));
+                }, this.ConnectTimeOut);
+                this.socket.once('listening', () => {
+                    clearTimeout(timer);
+                    this.isOpen = true;
+                    resolve(Core_1.OperateResult.CreateSuccessResult());
+                });
+                this.socket.once('error', (err) => {
+                    clearTimeout(timer);
+                    resolve(new Core_1.OperateResult(`UDP socket error: ${err.message}`, -1));
+                });
+                // 绑定本地端口（0 表示随机）
+                this.socket.bind(this.LocalPort);
+            }
+            catch (e) {
+                resolve(new Core_1.OperateResult(`Unable to create UDP socket: ${e.message}`, -1));
+            }
+        });
+    }
+    /**
+     * 关闭 UDP socket
+     */
+    async ConnectClose() {
+        if (!this.socket || !this.isOpen) {
+            return Core_1.OperateResult.CreateSuccessResult();
+        }
+        return new Promise((resolve) => {
+            this.socket.close(() => {
+                this.isOpen = false;
+                this.socket = undefined;
+                resolve(Core_1.OperateResult.CreateSuccessResult());
+            });
+        });
+    }
+    /**
+     * 发送请求并接收响应
+     */
+    async request(frame, parser) {
+        // 加入请求队列
+        return this.requestQueue.enqueue(async () => {
+            // 进入通信锁
+            if (this.EnableCommunicationLock) {
+                const lockResult = await this.communicationLock.EnterLock(this.ConnectTimeOut);
+                if (!lockResult.IsSuccess) {
+                    return Core_1.OperateResult.CreateFailedResult(lockResult);
+                }
+            }
+            try {
+                const connected = await this.ConnectServer();
+                if (!connected.IsSuccess) {
+                    return Core_1.OperateResult.CreateFailedResult(connected);
+                }
+                // 如果有消息解析器，使用它
+                const message = this.GetNewNetMessage();
+                if (message && !parser) {
+                    return await this.requestWithMessage(frame, message);
+                }
+                // 否则使用传统的 parser 方式
+                return await this.requestSimple(frame, parser || ((data) => data));
+            }
+            finally {
+                // 离开通信锁
+                if (this.EnableCommunicationLock) {
+                    this.communicationLock.LeaveLock();
+                }
+            }
+        });
+    }
+    /**
+     * 使用 INetMessage 解析器发送请求
+     */
+    async requestWithMessage(frame, message) {
+        return new Promise((resolve) => {
+            const socket = this.socket;
+            let receiveBuffer = Buffer.alloc(0);
+            let done = false;
+            message.SendBytes = frame;
+            const finish = (result) => {
+                if (done)
+                    return;
+                done = true;
+                clearTimeout(timer);
+                socket.removeListener('message', onMessage);
+                resolve(result);
+            };
+            const onMessage = (msg, rinfo) => {
+                // 验证响应来自目标服务器
+                if (rinfo.address !== this.IpAddress || rinfo.port !== this.Port) {
+                    return; // 忽略来自其他地址的消息
+                }
+                receiveBuffer = Buffer.concat([receiveBuffer, msg]);
+                try {
+                    // 第一步：接收头部
+                    if (message.HeadBytes.length < message.ProtocolHeadBytesLength) {
+                        const headLength = message.ProtocolHeadBytesLength;
+                        if (headLength > 0 && receiveBuffer.length >= headLength) {
+                            message.HeadBytes = receiveBuffer.subarray(0, headLength);
+                            receiveBuffer = receiveBuffer.subarray(headLength);
+                            // 检查头部合法性
+                            if (!message.CheckHeadBytesLegal()) {
+                                finish(new Core_1.OperateResult('Invalid message head', -3));
+                                return;
+                            }
+                        }
+                        else {
+                            return; // 继续等待
+                        }
+                    }
+                    // 第二步：获取内容长度
+                    const contentLength = message.GetContentLengthByHeadBytes();
+                    if (contentLength < 0) {
+                        // 需要更多数据来确定长度
+                        return;
+                    }
+                    // 第三步：接收内容
+                    if (receiveBuffer.length >= contentLength) {
+                        message.ContentBytes = receiveBuffer.subarray(0, contentLength);
+                        // 检查消息匹配
+                        const matchResult = message.CheckMessageMatch(frame, Buffer.concat([message.HeadBytes, message.ContentBytes]));
+                        if (matchResult === 0) {
+                            finish(new Core_1.OperateResult('Message match failed', -4));
+                        }
+                        else if (matchResult === 1) {
+                            finish(Core_1.OperateResult.CreateSuccessResult(message.ContentBytes));
+                        }
+                        // matchResult === -1 继续等待
+                    }
+                }
+                catch (e) {
+                    finish(new Core_1.OperateResult(`Parse error: ${e.message}`, -5));
+                }
+            };
+            const timer = setTimeout(() => {
+                finish(new Core_1.OperateResult('Receive timeout', -2));
+            }, this.ReceiveTimeOut);
+            socket.on('message', onMessage);
+            // 发送数据
+            socket.send(frame, this.Port, this.IpAddress, (err) => {
+                if (err) {
+                    finish(new Core_1.OperateResult(`UDP send error: ${err.message}`, -1));
+                }
+            });
+        });
+    }
+    /**
+     * 简单的请求响应（不使用 INetMessage）
+     */
+    async requestSimple(frame, parser) {
+        return new Promise((resolve) => {
+            const socket = this.socket;
+            let chunks = [];
+            let done = false;
+            const finish = (result) => {
+                if (done)
+                    return;
+                done = true;
+                clearTimeout(timer);
+                socket.removeListener('message', onMessage);
+                resolve(result);
+            };
+            const onMessage = (msg, rinfo) => {
+                // 验证响应来自目标服务器
+                if (rinfo.address !== this.IpAddress || rinfo.port !== this.Port) {
+                    return;
+                }
+                chunks.push(msg);
+                try {
+                    const body = parser(Buffer.concat(chunks));
+                    if (body)
+                        finish(Core_1.OperateResult.CreateSuccessResult(body));
+                }
+                catch {
+                    // 继续等待
+                }
+            };
+            const timer = setTimeout(() => {
+                finish(new Core_1.OperateResult('Receive timeout', -2));
+            }, this.ReceiveTimeOut);
+            socket.on('message', onMessage);
+            socket.send(frame, this.Port, this.IpAddress, (err) => {
+                if (err) {
+                    finish(new Core_1.OperateResult(`UDP send error: ${err.message}`, -1));
+                }
+            });
+        });
+    }
+    /**
+     * 批量发送请求（自动合并结果）
+     */
+    async ReadFromCoreServer(commands) {
+        if (commands.length === 0) {
+            return Core_1.OperateResult.CreateSuccessResult(Buffer.alloc(0));
+        }
+        if (commands.length === 1) {
+            return this.request(commands[0]);
+        }
+        // 批量发送
+        const results = [];
+        for (const cmd of commands) {
+            const result = await this.request(cmd);
+            if (!result.IsSuccess) {
+                return result;
+            }
+            results.push(result.Content);
+        }
+        return Core_1.OperateResult.CreateSuccessResult(Buffer.concat(results));
+    }
+    fromResult(result, fn) {
+        return result.IsSuccess ? Core_1.OperateResult.CreateSuccessResult(fn(result.Content)) : Core_1.OperateResult.CreateFailedResult(result);
+    }
+    /**
+     * 释放资源
+     */
+    async Dispose() {
+        await this.ConnectClose();
+        this.communicationLock.dispose();
+        this.requestQueue.clear();
+    }
+}
+exports.DeviceUdpNet = DeviceUdpNet;