ts-communication 1.0.0 → 1.1.0

package/dist/core/INetMessage.d.ts

@@ -0,0 +1,145 @@
+/**
+ * 本系统的消息类，包含了各种解析规则，数据信息提取规则
+ * The message class of this system contains various parsing rules and data information extraction rules
+ */
+export interface INetMessage {
+    /**
+     * 消息头的指令长度，第一次接受数据的长度
+     * Instruction length of the message header, the length of the first received data
+     */
+    ProtocolHeadBytesLength: number;
+    /**
+     * 消息头字节
+     * Message header byte
+     */
+    HeadBytes: Buffer;
+    /**
+     * 消息内容字节
+     * Message content byte
+     */
+    ContentBytes: Buffer;
+    /**
+     * 发送的字节信息
+     * Byte information sent
+     */
+    SendBytes: Buffer;
+    /**
+     * 从当前的头子节文件中提取出接下来需要接收的数据长度
+     * Extract the length of the data to be received from the current header file
+     * @returns 返回接下来的数据内容长度，如果小于0表示头部未接收完整
+     */
+    GetContentLengthByHeadBytes(): number;
+    /**
+     * 在接收头报文的时候，返回前置无效的报文头字节长度，默认为0，不处理
+     * When receiving a header message, return the header byte length of the invalid header, the default is 0, and no processing is performed.
+     * @param headByte 接收到的头子节信息
+     * @returns 头子节中无效的字节长度信息
+     */
+    PependedUselesByteLength(headByte: Buffer): number;
+    /**
+     * 检查头子节的合法性
+     * Check the legitimacy of the head subsection
+     * @param token 特殊的令牌，有些特殊消息的验证
+     * @returns 是否合法
+     */
+    CheckHeadBytesLegal(token?: Buffer): boolean;
+    /**
+     * 获取头子节里的消息标识
+     * Get the message ID in the header subsection
+     * @returns 消息标识
+     */
+    GetHeadBytesIdentity(): number;
+    /**
+     * 检查发送的接收的报文是否是匹配的
+     * Check if the sent and received messages match
+     * @param send 当前发送的报文
+     * @param receive 当前接收的报文信息
+     * @returns 如果匹配返回 1，如果不匹配且直接返回错误返回 0，如果不匹配继续接收返回 -1
+     */
+    CheckMessageMatch(send: Buffer, receive: Buffer): number;
+}
+/**
+ * 消息基类
+ */
+export declare abstract class NetMessageBase implements INetMessage {
+    ProtocolHeadBytesLength: number;
+    HeadBytes: Buffer;
+    ContentBytes: Buffer;
+    SendBytes: Buffer;
+    abstract GetContentLengthByHeadBytes(): number;
+    PependedUselesByteLength(headByte: Buffer): number;
+    CheckHeadBytesLegal(token?: Buffer): boolean;
+    GetHeadBytesIdentity(): number;
+    CheckMessageMatch(send: Buffer, receive: Buffer): number;
+}
+/**
+ * Modbus TCP 消息
+ */
+export declare class ModbusTcpMessage extends NetMessageBase {
+    ProtocolHeadBytesLength: number;
+    private isCheckMessageId;
+    constructor(isCheckMessageId?: boolean);
+    GetContentLengthByHeadBytes(): number;
+    CheckHeadBytesLegal(token?: Buffer): boolean;
+    GetHeadBytesIdentity(): number;
+    CheckMessageMatch(send: Buffer, receive: Buffer): number;
+}
+/**
+ * Modbus RTU 消息
+ */
+export declare class ModbusRtuMessage extends NetMessageBase {
+    ProtocolHeadBytesLength: number;
+    private stationCheckMatch;
+    constructor(stationCheckMatch?: boolean);
+    GetContentLengthByHeadBytes(): number;
+    CheckHeadBytesLegal(token?: Buffer): boolean;
+    CheckMessageMatch(send: Buffer, receive: Buffer): number;
+}
+/**
+ * Modbus ASCII 消息
+ */
+export declare class ModbusAsciiMessage extends NetMessageBase {
+    ProtocolHeadBytesLength: number;
+    GetContentLengthByHeadBytes(): number;
+    CheckHeadBytesLegal(token?: Buffer): boolean;
+    PependedUselesByteLength(headByte: Buffer): number;
+}
+/**
+ * Siemens S7 消息
+ */
+export declare class S7Message extends NetMessageBase {
+    ProtocolHeadBytesLength: number;
+    GetContentLengthByHeadBytes(): number;
+    CheckHeadBytesLegal(token?: Buffer): boolean;
+}
+/**
+ * Omron FINS 消息
+ */
+export declare class FinsMessage extends NetMessageBase {
+    ProtocolHeadBytesLength: number;
+    GetContentLengthByHeadBytes(): number;
+    CheckHeadBytesLegal(token?: Buffer): boolean;
+}
+/**
+ * Omron FINS UDP 消息
+ */
+export declare class FinsUdpMessage extends NetMessageBase {
+    ProtocolHeadBytesLength: number;
+    GetContentLengthByHeadBytes(): number;
+    CheckHeadBytesLegal(token?: Buffer): boolean;
+}
+/**
+ * Melsec MC 消息
+ */
+export declare class MelsecMcMessage extends NetMessageBase {
+    ProtocolHeadBytesLength: number;
+    GetContentLengthByHeadBytes(): number;
+    CheckHeadBytesLegal(token?: Buffer): boolean;
+}
+/** 通用电气 SRTP 消息，头部固定为 56 字节，长度字段采用小端序。 */
+export declare class GeSRTPMessage extends NetMessageBase {
+    ProtocolHeadBytesLength: number;
+    GetContentLengthByHeadBytes(): number;
+    CheckHeadBytesLegal(): boolean;
+    CheckMessageMatch(send: Buffer, receive: Buffer): number;
+}

package/dist/core/INetMessage.js

@@ -0,0 +1,240 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeSRTPMessage = exports.MelsecMcMessage = exports.FinsUdpMessage = exports.FinsMessage = exports.S7Message = exports.ModbusAsciiMessage = exports.ModbusRtuMessage = exports.ModbusTcpMessage = exports.NetMessageBase = void 0;
+/**
+ * 消息基类
+ */
+class NetMessageBase {
+    ProtocolHeadBytesLength = 0;
+    HeadBytes = Buffer.alloc(0);
+    ContentBytes = Buffer.alloc(0);
+    SendBytes = Buffer.alloc(0);
+    PependedUselesByteLength(headByte) {
+        return 0;
+    }
+    CheckHeadBytesLegal(token) {
+        return true;
+    }
+    GetHeadBytesIdentity() {
+        return 0;
+    }
+    CheckMessageMatch(send, receive) {
+        return 1; // 默认匹配
+    }
+}
+exports.NetMessageBase = NetMessageBase;
+/**
+ * Modbus TCP 消息
+ */
+class ModbusTcpMessage extends NetMessageBase {
+    ProtocolHeadBytesLength = 6;
+    isCheckMessageId = true;
+    constructor(isCheckMessageId = true) {
+        super();
+        this.isCheckMessageId = isCheckMessageId;
+    }
+    GetContentLengthByHeadBytes() {
+        if (this.HeadBytes.length < 6)
+            return -1;
+        return this.HeadBytes.readUInt16BE(4) - 1;
+    }
+    CheckHeadBytesLegal(token) {
+        if (this.HeadBytes.length < 6)
+            return false;
+        // 检查协议标识符是否为 0
+        return this.HeadBytes.readUInt16BE(2) === 0;
+    }
+    GetHeadBytesIdentity() {
+        if (this.HeadBytes.length < 2)
+            return 0;
+        return this.HeadBytes.readUInt16BE(0);
+    }
+    CheckMessageMatch(send, receive) {
+        if (!this.isCheckMessageId)
+            return 1;
+        if (send.length < 2 || receive.length < 2)
+            return -1;
+        const sendId = send.readUInt16BE(0);
+        const receiveId = receive.readUInt16BE(0);
+        return sendId === receiveId ? 1 : -1;
+    }
+}
+exports.ModbusTcpMessage = ModbusTcpMessage;
+/**
+ * Modbus RTU 消息
+ */
+class ModbusRtuMessage extends NetMessageBase {
+    ProtocolHeadBytesLength = 3;
+    stationCheckMatch = true;
+    constructor(stationCheckMatch = true) {
+        super();
+        this.stationCheckMatch = stationCheckMatch;
+    }
+    GetContentLengthByHeadBytes() {
+        if (this.HeadBytes.length < 3)
+            return -1;
+        const functionCode = this.HeadBytes[1];
+        // 异常响应
+        if ((functionCode & 0x80) !== 0) {
+            return 3; // 站号 + 功能码 + 异常码 + CRC(2)
+        }
+        // 根据功能码判断长度
+        if (functionCode === 0x01 || functionCode === 0x02 || functionCode === 0x03 || functionCode === 0x04) {
+            // 读取响应：站号 + 功能码 + 字节数 + 数据 + CRC
+            return this.HeadBytes[2] + 2; // 字节数 + CRC
+        }
+        else if (functionCode === 0x05 || functionCode === 0x06 || functionCode === 0x0F || functionCode === 0x10) {
+            // 写入响应：站号 + 功能码 + 地址(2) + 数量(2) + CRC(2)
+            return 5; // 4字节数据 + 2字节CRC
+        }
+        else if (functionCode === 0x16) {
+            // 掩码写寄存器
+            return 5;
+        }
+        else if (functionCode === 0x17) {
+            // 读写寄存器
+            return this.HeadBytes[2] + 2;
+        }
+        return -1;
+    }
+    CheckHeadBytesLegal(token) {
+        if (this.HeadBytes.length < 1)
+            return false;
+        // 站号应该在 0-247 之间
+        return this.HeadBytes[0] >= 0 && this.HeadBytes[0] <= 247;
+    }
+    CheckMessageMatch(send, receive) {
+        if (!this.stationCheckMatch)
+            return 1;
+        if (send.length < 1 || receive.length < 1)
+            return -1;
+        // 检查站号是否匹配
+        return send[0] === receive[0] ? 1 : 0;
+    }
+}
+exports.ModbusRtuMessage = ModbusRtuMessage;
+/**
+ * Modbus ASCII 消息
+ */
+class ModbusAsciiMessage extends NetMessageBase {
+    ProtocolHeadBytesLength = -1; // 动态长度，以 \r\n 结尾
+    GetContentLengthByHeadBytes() {
+        // ASCII 模式下，消息以 ':' 开头，'\r\n' 结尾
+        // 在接收完整消息前返回 -1
+        return -1;
+    }
+    CheckHeadBytesLegal(token) {
+        if (this.HeadBytes.length < 1)
+            return false;
+        // 必须以 ':' 开头
+        return this.HeadBytes[0] === 0x3A; // ':'
+    }
+    PependedUselesByteLength(headByte) {
+        // 跳过开头的无效字符，直到遇到 ':'
+        for (let i = 0; i < headByte.length; i++) {
+            if (headByte[i] === 0x3A)
+                return i; // ':'
+        }
+        return 0;
+    }
+}
+exports.ModbusAsciiMessage = ModbusAsciiMessage;
+/**
+ * Siemens S7 消息
+ */
+class S7Message extends NetMessageBase {
+    ProtocolHeadBytesLength = 4; // TPKT 头部
+    GetContentLengthByHeadBytes() {
+        if (this.HeadBytes.length < 4)
+            return -1;
+        // TPKT 格式：版本(1) + 保留(1) + 长度(2)
+        if (this.HeadBytes[0] !== 0x03)
+            return -1; // 版本必须是 3
+        const totalLength = this.HeadBytes.readUInt16BE(2);
+        return totalLength - 4; // 减去头部长度
+    }
+    CheckHeadBytesLegal(token) {
+        if (this.HeadBytes.length < 1)
+            return false;
+        // 检查 TPKT 版本号
+        return this.HeadBytes[0] === 0x03;
+    }
+}
+exports.S7Message = S7Message;
+/**
+ * Omron FINS 消息
+ */
+class FinsMessage extends NetMessageBase {
+    ProtocolHeadBytesLength = 8; // FINS/TCP 头部
+    GetContentLengthByHeadBytes() {
+        if (this.HeadBytes.length < 8)
+            return -1;
+        // FINS/TCP 格式：'FINS'(4) + 长度(4)
+        if (this.HeadBytes.toString('ascii', 0, 4) !== 'FINS')
+            return -1;
+        const length = this.HeadBytes.readUInt32BE(4);
+        return length - 8; // 减去头部长度
+    }
+    CheckHeadBytesLegal(token) {
+        if (this.HeadBytes.length < 4)
+            return false;
+        // 检查 FINS 标识
+        return this.HeadBytes.toString('ascii', 0, 4) === 'FINS';
+    }
+}
+exports.FinsMessage = FinsMessage;
+/**
+ * Omron FINS UDP 消息
+ */
+class FinsUdpMessage extends NetMessageBase {
+    ProtocolHeadBytesLength = 10; // FINS UDP 头部
+    GetContentLengthByHeadBytes() {
+        if (this.HeadBytes.length < 10)
+            return -1;
+        // UDP 模式下，剩余长度由数据包总长度决定
+        // 这里返回一个足够大的值，实际长度由 UDP 数据包决定
+        return 2000;
+    }
+    CheckHeadBytesLegal(token) {
+        return true; // UDP 模式下不检查头部
+    }
+}
+exports.FinsUdpMessage = FinsUdpMessage;
+/**
+ * Melsec MC 消息
+ */
+class MelsecMcMessage extends NetMessageBase {
+    ProtocolHeadBytesLength = 11; // MC 协议头部
+    GetContentLengthByHeadBytes() {
+        if (this.HeadBytes.length < 11)
+            return -1;
+        // MC 二进制格式：副头部(2) + 网络号(1) + PC号(1) + 目标模块I/O号(2) + 目标站号(1) + 请求数据长度(2) + 监视定时器(2)
+        const dataLength = this.HeadBytes.readUInt16LE(7);
+        return dataLength - 2; // 减去监视定时器长度
+    }
+    CheckHeadBytesLegal(token) {
+        if (this.HeadBytes.length < 2)
+            return false;
+        // 检查副头部（二进制：0x5000，ASCII：0x3530 0x3030）
+        return this.HeadBytes.readUInt16LE(0) === 0x5000 || this.HeadBytes.readUInt16BE(0) === 0x3530;
+    }
+}
+exports.MelsecMcMessage = MelsecMcMessage;
+/** 通用电气 SRTP 消息，头部固定为 56 字节，长度字段采用小端序。 */
+class GeSRTPMessage extends NetMessageBase {
+    ProtocolHeadBytesLength = 56;
+    GetContentLengthByHeadBytes() {
+        if (this.HeadBytes.length < 56)
+            return -1;
+        return this.HeadBytes[4] | (this.HeadBytes[5] << 8);
+    }
+    CheckHeadBytesLegal() {
+        return this.HeadBytes.length >= 2 && (this.HeadBytes[0] === 1 || this.HeadBytes[0] === 2 || this.HeadBytes[0] === 3);
+    }
+    CheckMessageMatch(send, receive) {
+        if (send.length < 4 || receive.length < 4)
+            return -1;
+        return send[2] === receive[2] && send[3] === receive[3] ? 1 : -1;
+    }
+}
+exports.GeSRTPMessage = GeSRTPMessage;

package/dist/debug/PingTest.d.ts

@@ -0,0 +1,11 @@
+export interface PingResult {
+    success: boolean;
+    host: string;
+    time?: number;
+    message: string;
+}
+export declare class PingTest {
+    static ping(host: string, timeout?: number, count?: number): Promise<PingResult>;
+    private static parsePingOutput;
+    static isHostOnline(host: string, timeout?: number): Promise<boolean>;
+}

package/dist/debug/PingTest.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PingTest = void 0;
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const execAsync = (0, node_util_1.promisify)(node_child_process_1.exec);
+class PingTest {
+    static async ping(host, timeout = 5000, count = 4) {
+        try {
+            const isWindows = process.platform === 'win32';
+            let command;
+            if (isWindows) {
+                command = 'ping -n ' + count + ' -w ' + timeout + ' ' + host;
+            }
+            else {
+                const timeoutSec = Math.ceil(timeout / 1000);
+                command = 'ping -c ' + count + ' -W ' + timeoutSec + ' ' + host;
+            }
+            console.log('[PingTest] Executing: ' + command);
+            const { stdout, stderr } = await execAsync(command);
+            if (stderr) {
+                return { success: false, host, message: stderr };
+            }
+            return PingTest.parsePingOutput(stdout, host, isWindows);
+        }
+        catch (error) {
+            const err = error;
+            return { success: false, host, message: err.message };
+        }
+    }
+    static parsePingOutput(output, host, isWindows) {
+        const hasReply = output.includes('bytes from') || output.includes('来自');
+        if (!hasReply) {
+            return { success: false, host, message: 'Host unreachable or timeout' };
+        }
+        let avgTime;
+        if (isWindows) {
+            const match = output.match(/平均\s*=\s*(\d+)ms|Average\s*=\s*(\d+)ms/i);
+            if (match)
+                avgTime = parseInt(match[1] || match[2]);
+        }
+        else {
+            const match = output.match(/rtt\s+min\/avg\/max\/mdev\s+=\s+[\d.]+\/([\d.]+)\//);
+            if (match)
+                avgTime = parseFloat(match[1]);
+        }
+        return {
+            success: true,
+            host,
+            time: avgTime,
+            message: avgTime !== undefined ? 'Average: ' + avgTime + 'ms' : 'Success'
+        };
+    }
+    static async isHostOnline(host, timeout = 2000) {
+        const result = await PingTest.ping(host, timeout, 1);
+        return result.success;
+    }
+}
+exports.PingTest = PingTest;

package/dist/debug/tcpClient.d.ts

@@ -0,0 +1,11 @@
+export declare class TcpClient {
+    private socket?;
+    host: string;
+    port: number;
+    timeout: number;
+    constructor(host?: string, port?: number);
+    connect(): Promise<boolean>;
+    send(data: Buffer): Promise<boolean>;
+    sendAndReceive(data: Buffer, receiveTimeout?: number): Promise<Buffer | null>;
+    disconnect(): void;
+}

package/dist/debug/tcpClient.js

@@ -0,0 +1,116 @@
+"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.TcpClient = void 0;
+const net = __importStar(require("node:net"));
+class TcpClient {
+    socket;
+    host;
+    port;
+    timeout = 5000;
+    constructor(host = '127.0.0.1', port = 5000) {
+        this.host = host;
+        this.port = port;
+    }
+    async connect() {
+        return new Promise((resolve) => {
+            this.socket = new net.Socket();
+            const timer = setTimeout(() => {
+                this.socket?.destroy();
+                console.log('[TcpClient] Connection timeout');
+                resolve(false);
+            }, this.timeout);
+            this.socket.connect(this.port, this.host, () => {
+                clearTimeout(timer);
+                console.log('[TcpClient] Connected to ' + this.host + ':' + this.port);
+                resolve(true);
+            });
+            this.socket.on('error', (err) => {
+                clearTimeout(timer);
+                console.error('[TcpClient] Error:', err.message);
+                resolve(false);
+            });
+        });
+    }
+    async send(data) {
+        if (!this.socket || this.socket.destroyed) {
+            console.error('[TcpClient] Socket not connected');
+            return false;
+        }
+        return new Promise((resolve) => {
+            this.socket.write(data, (err) => {
+                if (err) {
+                    console.error('[TcpClient] Send error:', err.message);
+                    resolve(false);
+                }
+                else {
+                    console.log('[TcpClient] Sent ' + data.length + ' bytes:', data.toString('hex'));
+                    resolve(true);
+                }
+            });
+        });
+    }
+    async sendAndReceive(data, receiveTimeout = 5000) {
+        if (!this.socket || this.socket.destroyed)
+            return null;
+        return new Promise((resolve) => {
+            let received = Buffer.alloc(0);
+            let done = false;
+            const finish = (result) => {
+                if (done)
+                    return;
+                done = true;
+                clearTimeout(timer);
+                this.socket.removeListener('data', onData);
+                resolve(result);
+            };
+            const onData = (chunk) => {
+                received = Buffer.concat([received, chunk]);
+                console.log('[TcpClient] Received ' + chunk.length + ' bytes');
+            };
+            const timer = setTimeout(() => finish(received.length > 0 ? received : null), receiveTimeout);
+            this.socket.on('data', onData);
+            this.socket.write(data);
+        });
+    }
+    disconnect() {
+        if (this.socket) {
+            this.socket.destroy();
+            this.socket = undefined;
+            console.log('[TcpClient] Disconnected');
+        }
+    }
+}
+exports.TcpClient = TcpClient;

package/dist/debug/tcpServer.d.ts

@@ -0,0 +1,12 @@
+export declare class TcpServer {
+    private server?;
+    private clients;
+    port: number;
+    host: string;
+    constructor(port?: number, host?: string);
+    start(): Promise<boolean>;
+    private handleConnection;
+    broadcast(data: Buffer): void;
+    getClientCount(): number;
+    stop(): Promise<void>;
+}