ts-communication 1.0.0 → 1.1.0

package/dist/core/Core.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeviceClient = exports.ByteTransform = exports.OperateResult = exports.PlcString = exports.UInt64 = exports.Int64 = exports.Double = exports.Float = exports.UInt32 = exports.Int32 = exports.UInt16 = exports.Int16 = exports.Byte = exports.PlcValue = exports.DataFormat = void 0;
 exports.wordsFor = wordsFor;
 const net = __importStar(require("node:net"));
+const CommunicationLock_1 = require("./CommunicationLock");
 var DataFormat;
 (function (DataFormat) {
     DataFormat["ABCD"] = "ABCD";
@@ -55,54 +56,89 @@ class PlcValue {
         this.width = width;
         this.signed = signed;
     }
-    valueOf() { return this.value; }
+    valueOf() {
+        return this.value;
+    }
 }
 exports.PlcValue = PlcValue;
-function range(name, value, min, max) { if (!Number.isInteger(value) || value < min || value > max)
-    throw new RangeError(`${name} value out of range: ${value}`); }
+function range(name, value, min, max) {
+    if (!Number.isInteger(value) || value < min || value > max)
+        throw new RangeError(`${name} value out of range: ${value}`);
+}
 class Byte extends PlcValue {
-    constructor(value) { range('byte', value, 0, 255); super(value, 'byte', 1, false); }
+    constructor(value) {
+        range('byte', value, 0, 255);
+        super(value, 'byte', 1, false);
+    }
 }
 exports.Byte = Byte;
 class Int16 extends PlcValue {
-    constructor(value) { range('short', value, -32768, 32767); super(value, 'int16', 2, true); }
+    constructor(value) {
+        range('short', value, -32768, 32767);
+        super(value, 'int16', 2, true);
+    }
 }
 exports.Int16 = Int16;
 class UInt16 extends PlcValue {
-    constructor(value) { range('ushort', value, 0, 65535); super(value, 'uint16', 2, false); }
+    constructor(value) {
+        range('ushort', value, 0, 65535);
+        super(value, 'uint16', 2, false);
+    }
 }
 exports.UInt16 = UInt16;
 class Int32 extends PlcValue {
-    constructor(value) { range('int', value, -2147483648, 2147483647); super(value, 'int32', 4, true); }
+    constructor(value) {
+        range('int', value, -2147483648, 2147483647);
+        super(value, 'int32', 4, true);
+    }
 }
 exports.Int32 = Int32;
 class UInt32 extends PlcValue {
-    constructor(value) { range('uint', value, 0, 4294967295); super(value, 'uint32', 4, false); }
+    constructor(value) {
+        range('uint', value, 0, 4294967295);
+        super(value, 'uint32', 4, false);
+    }
 }
 exports.UInt32 = UInt32;
 class Float extends PlcValue {
-    constructor(value) { if (!Number.isFinite(value))
-        throw new RangeError(`float value is not finite: ${value}`); super(value, 'float', 4, true); }
+    constructor(value) {
+        if (!Number.isFinite(value))
+            throw new RangeError(`float value is not finite: ${value}`);
+        super(value, 'float', 4, true);
+    }
 }
 exports.Float = Float;
 class Double extends PlcValue {
-    constructor(value) { if (!Number.isFinite(value))
-        throw new RangeError(`double value is not finite: ${value}`); super(value, 'double', 8, true); }
+    constructor(value) {
+        if (!Number.isFinite(value))
+            throw new RangeError(`double value is not finite: ${value}`);
+        super(value, 'double', 8, true);
+    }
 }
 exports.Double = Double;
 class Int64 extends PlcValue {
-    constructor(value) { const n = BigInt(value); if (n < -9223372036854775808n || n > 9223372036854775807n)
-        throw new RangeError(`long value out of range: ${value}`); super(n, 'int64', 8, true); }
+    constructor(value) {
+        const n = BigInt(value);
+        if (n < -9223372036854775808n || n > 9223372036854775807n)
+            throw new RangeError(`long value out of range: ${value}`);
+        super(n, 'int64', 8, true);
+    }
 }
 exports.Int64 = Int64;
 class UInt64 extends PlcValue {
-    constructor(value) { const n = BigInt(value); if (n < 0n || n > 18446744073709551615n)
-        throw new RangeError(`ulong value out of range: ${value}`); super(n, 'uint64', 8, false); }
+    constructor(value) {
+        const n = BigInt(value);
+        if (n < 0n || n > 18446744073709551615n)
+            throw new RangeError(`ulong value out of range: ${value}`);
+        super(n, 'uint64', 8, false);
+    }
 }
 exports.UInt64 = UInt64;
 class PlcString extends String {
     kind = 'string';
-    constructor(value) { super(value); }
+    constructor(value) {
+        super(value);
+    }
 }
 exports.PlcString = PlcString;
 class OperateResult {
@@ -124,7 +160,9 @@ class OperateResult {
             this.ErrorCode = isSuccessOrErrorCode;
         }
     }
-    static CreateSuccessResult(content) { return new OperateResult(content, true, '', 0); }
+    static CreateSuccessResult(content) {
+        return new OperateResult(content, true, '', 0);
+    }
     static CreateFailedResult(resultOrMessage, errorCode = 10000) {
         return typeof resultOrMessage === 'string'
             ? new OperateResult(undefined, false, resultOrMessage, errorCode)
@@ -135,48 +173,146 @@ exports.OperateResult = OperateResult;
 class ByteTransform {
     IsStringReverseByteWord = false;
     DataFormat;
-    constructor(format = DataFormat.CDAB) { this.DataFormat = format; }
+    constructor(format = DataFormat.CDAB) {
+        this.DataFormat = format;
+    }
+    /**
+     * 按照 DataFormat 重新排序字节
+     * 完全匹配 C# RegularByteTransform 的 ByteTransDataFormat* 方法
+     * 转换后的字节将用小端序 DataView 读取
+     */
     order(bytes, width) {
-        if (width === 2)
-            return bytes;
         const out = new Uint8Array(bytes.length);
-        const map = {
-            [DataFormat.ABCD]: [0, 1, 2, 3], [DataFormat.BADC]: [1, 0, 3, 2],
-            [DataFormat.CDAB]: [2, 3, 0, 1], [DataFormat.DCBA]: [3, 2, 1, 0]
-        };
-        const m = map[this.DataFormat];
         for (let i = 0; i < bytes.length; i += width) {
             const chunk = bytes.subarray(i, i + width);
-            if (width === 4)
-                for (let j = 0; j < 4; j++)
-                    out[i + j] = chunk[m[j]] ?? 0;
+            if (width === 2) {
+                // 对应 C# ByteTransDataFormat2
+                switch (this.DataFormat) {
+                    case DataFormat.ABCD:
+                    case DataFormat.CDAB:
+                        out[i] = chunk[1];
+                        out[i + 1] = chunk[0];
+                        break;
+                    case DataFormat.BADC:
+                    case DataFormat.DCBA:
+                        out[i] = chunk[0];
+                        out[i + 1] = chunk[1];
+                        break;
+                }
+            }
+            else if (width === 4) {
+                // 对应 C# ByteTransDataFormat4
+                switch (this.DataFormat) {
+                    case DataFormat.ABCD:
+                        out[i] = chunk[3];
+                        out[i + 1] = chunk[2];
+                        out[i + 2] = chunk[1];
+                        out[i + 3] = chunk[0];
+                        break;
+                    case DataFormat.BADC:
+                        out[i] = chunk[2];
+                        out[i + 1] = chunk[3];
+                        out[i + 2] = chunk[0];
+                        out[i + 3] = chunk[1];
+                        break;
+                    case DataFormat.CDAB:
+                        out[i] = chunk[1];
+                        out[i + 1] = chunk[0];
+                        out[i + 2] = chunk[3];
+                        out[i + 3] = chunk[2];
+                        break;
+                    case DataFormat.DCBA:
+                        out[i] = chunk[0];
+                        out[i + 1] = chunk[1];
+                        out[i + 2] = chunk[2];
+                        out[i + 3] = chunk[3];
+                        break;
+                }
+            }
             else if (width === 8) {
-                const words = [chunk.subarray(0, 4), chunk.subarray(4, 8)];
-                const first = this.DataFormat === 'CDAB' || this.DataFormat === 'DCBA' ? words[1] : words[0];
-                const second = first === words[0] ? words[1] : words[0];
-                const a = this.order(first, 4), b = this.order(second, 4);
-                out.set(a, i);
-                out.set(b, i + 4);
+                // 对应 C# ByteTransDataFormat8
+                switch (this.DataFormat) {
+                    case DataFormat.ABCD:
+                        out[i] = chunk[7];
+                        out[i + 1] = chunk[6];
+                        out[i + 2] = chunk[5];
+                        out[i + 3] = chunk[4];
+                        out[i + 4] = chunk[3];
+                        out[i + 5] = chunk[2];
+                        out[i + 6] = chunk[1];
+                        out[i + 7] = chunk[0];
+                        break;
+                    case DataFormat.BADC:
+                        out[i] = chunk[6];
+                        out[i + 1] = chunk[7];
+                        out[i + 2] = chunk[4];
+                        out[i + 3] = chunk[5];
+                        out[i + 4] = chunk[2];
+                        out[i + 5] = chunk[3];
+                        out[i + 6] = chunk[0];
+                        out[i + 7] = chunk[1];
+                        break;
+                    case DataFormat.CDAB:
+                        out[i] = chunk[1];
+                        out[i + 1] = chunk[0];
+                        out[i + 2] = chunk[3];
+                        out[i + 3] = chunk[2];
+                        out[i + 4] = chunk[5];
+                        out[i + 5] = chunk[4];
+                        out[i + 6] = chunk[7];
+                        out[i + 7] = chunk[6];
+                        break;
+                    case DataFormat.DCBA:
+                        out[i] = chunk[0];
+                        out[i + 1] = chunk[1];
+                        out[i + 2] = chunk[2];
+                        out[i + 3] = chunk[3];
+                        out[i + 4] = chunk[4];
+                        out[i + 5] = chunk[5];
+                        out[i + 6] = chunk[6];
+                        out[i + 7] = chunk[7];
+                        break;
+                }
             }
-            else
+            else {
+                // 其他宽度，直接复制
                 out.set(chunk, i);
+            }
         }
         return out;
     }
-    view(data, offset, length) { return this.order(data.subarray(offset, offset + length), length); }
+    view(data, offset, length) {
+        return this.order(data.subarray(offset, offset + length), length);
+    }
     dataView(data, offset, length) {
         const view = this.view(data, offset, length);
         // Buffer.subarray shares an ArrayBuffer; preserve its byteOffset.
         return new DataView(view.buffer, view.byteOffset, view.byteLength);
     }
-    TransInt16(data, offset = 0) { return this.dataView(data, offset, 2).getInt16(0, false); }
-    TransUInt16(data, offset = 0) { return this.dataView(data, offset, 2).getUint16(0, false); }
-    TransInt32(data, offset = 0) { return this.dataView(data, offset, 4).getInt32(0, false); }
-    TransUInt32(data, offset = 0) { return this.dataView(data, offset, 4).getUint32(0, false); }
-    TransSingle(data, offset = 0) { return this.dataView(data, offset, 4).getFloat32(0, false); }
-    TransDouble(data, offset = 0) { return this.dataView(data, offset, 8).getFloat64(0, false); }
-    TransInt64(data, offset = 0) { return this.dataView(data, offset, 8).getBigInt64(0, false); }
-    TransUInt64(data, offset = 0) { return this.dataView(data, offset, 8).getBigUint64(0, false); }
+    TransInt16(data, offset = 0) {
+        return this.dataView(data, offset, 2).getInt16(0, true);
+    }
+    TransUInt16(data, offset = 0) {
+        return this.dataView(data, offset, 2).getUint16(0, true);
+    }
+    TransInt32(data, offset = 0) {
+        return this.dataView(data, offset, 4).getInt32(0, true);
+    }
+    TransUInt32(data, offset = 0) {
+        return this.dataView(data, offset, 4).getUint32(0, true);
+    }
+    TransSingle(data, offset = 0) {
+        return this.dataView(data, offset, 4).getFloat32(0, true);
+    }
+    TransDouble(data, offset = 0) {
+        return this.dataView(data, offset, 8).getFloat64(0, true);
+    }
+    TransInt64(data, offset = 0) {
+        return this.dataView(data, offset, 8).getBigInt64(0, true);
+    }
+    TransUInt64(data, offset = 0) {
+        return this.dataView(data, offset, 8).getBigUint64(0, true);
+    }
     TransByte(value, width) {
         const values = Array.isArray(value) ? value : [value];
         const first = values[0];
@@ -189,16 +325,16 @@ class ByteTransform {
             if (w === 1)
                 raw[0] = Number(scalar);
             else if (w === 2)
-                (v instanceof UInt16 ? view.setUint16 : view.setInt16).call(view, 0, Number(scalar), false);
+                (v instanceof UInt16 ? view.setUint16 : view.setInt16).call(view, 0, Number(scalar), true);
             else if (w === 4)
-                (v instanceof UInt32 ? view.setUint32 : v instanceof Float ? view.setFloat32 : view.setInt32).call(view, 0, Number(scalar), false);
+                (v instanceof UInt32 ? view.setUint32 : v instanceof Float ? view.setFloat32 : view.setInt32).call(view, 0, Number(scalar), true);
             else if (w === 8)
-                (v instanceof UInt64 ? view.setBigUint64 : view.setBigInt64).call(view, 0, BigInt(scalar), false);
+                (v instanceof UInt64 ? view.setBigUint64 : view.setBigInt64).call(view, 0, BigInt(scalar), true);
             out.set(this.order(raw, w), i * w);
         });
         return out;
     }
-    TransString(data, encoding = 'utf8') {
+    TransString(data, encoding = 'ascii') {
         let raw = Buffer.from(data);
         if (this.IsStringReverseByteWord)
             for (let i = 0; i + 1 < raw.length; i += 2)
@@ -217,9 +353,28 @@ class DeviceClient {
     ConnectionId = '';
     socket;
     connecting;
-    constructor(ipAddress, port) { if (ipAddress !== undefined)
-        this.IpAddress = ipAddress; if (port !== undefined)
-        this.Port = port; this.ConnectionId = `${this.IpAddress}:${this.Port}`; }
+    // 通信锁和请求队列
+    communicationLock;
+    requestQueue;
+    // 是否启用通信锁（默认启用）
+    EnableCommunicationLock = true;
+    constructor(ipAddress, port) {
+        if (ipAddress !== undefined)
+            this.IpAddress = ipAddress;
+        if (port !== undefined)
+            this.Port = port;
+        this.ConnectionId = `${this.IpAddress}:${this.Port}`;
+        // 初始化通信锁和队列
+        this.communicationLock = new CommunicationLock_1.CommunicationLockSimple();
+        this.requestQueue = new CommunicationLock_1.RequestQueue();
+    }
+    /**
+     * 获取当前协议的消息解析器
+     * 子类应该重写此方法以提供特定协议的消息解析器
+     */
+    GetNewNetMessage() {
+        return undefined;
+    }
     async ConnectServer() {
         if (this.socket && !this.socket.destroyed)
             return OperateResult.CreateSuccessResult();
@@ -227,18 +382,131 @@ class DeviceClient {
             return this.connecting;
         this.connecting = new Promise(resolve => {
             const socket = net.createConnection({ host: this.IpAddress, port: this.Port });
-            const timer = setTimeout(() => { socket.destroy(); resolve(new OperateResult('Connection timeout', -1)); }, this.ConnectTimeOut);
-            socket.once('connect', () => { clearTimeout(timer); this.socket = socket; resolve(OperateResult.CreateSuccessResult()); });
-            socket.once('error', e => { clearTimeout(timer); resolve(new OperateResult(e.message, -1)); });
-        }).finally(() => { this.connecting = undefined; });
+            const timer = setTimeout(() => {
+                socket.destroy();
+                resolve(new OperateResult('Connection timeout', -1));
+            }, this.ConnectTimeOut);
+            socket.once('connect', () => {
+                clearTimeout(timer);
+                this.socket = socket;
+                resolve(OperateResult.CreateSuccessResult());
+            });
+            socket.once('error', e => {
+                clearTimeout(timer);
+                resolve(new OperateResult(e.message, -1));
+            });
+        }).finally(() => {
+            this.connecting = undefined;
+        });
         return this.connecting;
     }
-    async ConnectClose() { this.socket?.destroy(); this.socket = undefined; return OperateResult.CreateSuccessResult(); }
+    async ConnectClose() {
+        this.socket?.destroy();
+        this.socket = undefined;
+        this.communicationLock.dispose();
+        return OperateResult.CreateSuccessResult();
+    }
+    /**
+     * 发送请求并接收响应（带通信锁和队列）
+     */
     async request(frame, parser) {
-        const connected = await this.ConnectServer();
-        if (!connected.IsSuccess)
-            return OperateResult.CreateFailedResult(connected);
-        return this.requestConnected(frame, parser);
+        // 加入请求队列
+        return this.requestQueue.enqueue(async () => {
+            // 进入通信锁
+            if (this.EnableCommunicationLock) {
+                const lockResult = await this.communicationLock.EnterLock(this.ConnectTimeOut);
+                if (!lockResult.IsSuccess) {
+                    return OperateResult.CreateFailedResult(lockResult);
+                }
+            }
+            try {
+                const connected = await this.ConnectServer();
+                if (!connected.IsSuccess) {
+                    return OperateResult.CreateFailedResult(connected);
+                }
+                // 如果有消息解析器，使用它
+                const message = this.GetNewNetMessage();
+                if (message && !parser) {
+                    return await this.requestWithMessage(frame, message);
+                }
+                // 否则使用传统的 parser 方式
+                return await this.requestConnected(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.off('data', onData);
+                socket.off('error', onError);
+                resolve(result);
+            };
+            const onError = (e) => finish(new OperateResult(e.message, -1));
+            const onData = (chunk) => {
+                receiveBuffer = Buffer.concat([receiveBuffer, chunk]);
+                try {
+                    // 第一步：接收头部
+                    if (message.HeadBytes.length < message.ProtocolHeadBytesLength) {
+                        const headLength = message.ProtocolHeadBytesLength;
+                        if (receiveBuffer.length >= headLength) {
+                            message.HeadBytes = receiveBuffer.subarray(0, headLength);
+                            receiveBuffer = receiveBuffer.subarray(headLength);
+                            // 检查头部合法性
+                            if (!message.CheckHeadBytesLegal()) {
+                                finish(new 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 OperateResult('Message match failed', -4));
+                        }
+                        else if (matchResult === 1) {
+                            finish(OperateResult.CreateSuccessResult(message.ContentBytes));
+                        }
+                        // matchResult === -1 继续等待
+                    }
+                }
+                catch (e) {
+                    finish(new OperateResult(`Parse error: ${e.message}`, -5));
+                }
+            };
+            const timer = setTimeout(() => finish(new OperateResult('Receive timeout', -2)), this.ReceiveTimeOut);
+            socket.on('data', onData);
+            socket.once('error', onError);
+            socket.write(frame);
+        });
     }
     /** Send one frame on an already connected socket (used by protocol handshakes). */
     async requestConnected(frame, parser) {
@@ -246,22 +514,58 @@ class DeviceClient {
             const socket = this.socket;
             let chunks = [];
             let done = false;
-            const finish = (result) => { if (done)
-                return; done = true; clearTimeout(timer); socket.off('data', onData); socket.off('error', onError); resolve(result); };
+            const finish = (result) => {
+                if (done)
+                    return;
+                done = true;
+                clearTimeout(timer);
+                socket.off('data', onData);
+                socket.off('error', onError);
+                resolve(result);
+            };
             const onError = (e) => finish(new OperateResult(e.message, -1));
-            const onData = (chunk) => { chunks.push(chunk); try {
-                const body = parser(Buffer.concat(chunks));
-                if (body)
-                    finish(OperateResult.CreateSuccessResult(body));
-            }
-            catch { /* wait for remaining frame */ } };
+            const onData = (chunk) => {
+                chunks.push(chunk);
+                try {
+                    const body = parser(Buffer.concat(chunks));
+                    if (body)
+                        finish(OperateResult.CreateSuccessResult(body));
+                }
+                catch { /* wait for remaining frame */
+                }
+            };
             const timer = setTimeout(() => finish(new OperateResult('Receive timeout', -2)), this.ReceiveTimeOut);
             socket.on('data', onData);
             socket.once('error', onError);
             socket.write(frame);
         });
     }
-    fromResult(result, fn) { return result.IsSuccess ? OperateResult.CreateSuccessResult(fn(result.Content)) : OperateResult.CreateFailedResult(result); }
+    /**
+     * 批量发送请求（自动合并结果）
+     */
+    async ReadFromCoreServer(commands) {
+        if (commands.length === 0) {
+            return 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 OperateResult.CreateSuccessResult(Buffer.concat(results));
+    }
+    fromResult(result, fn) {
+        return result.IsSuccess ? OperateResult.CreateSuccessResult(fn(result.Content)) : OperateResult.CreateFailedResult(result);
+    }
 }
 exports.DeviceClient = DeviceClient;
-function wordsFor(type, length) { return type === 'int32' || type === 'uint32' || type === 'float' ? length * 2 : type === 'int64' || type === 'uint64' || type === 'double' ? length * 4 : length; }
+function wordsFor(type, length) {
+    return type === 'int32' || type === 'uint32' || type === 'float' ? length * 2 : type === 'int64' || type === 'uint64' || type === 'double' ? length * 4 : length;
+}

package/dist/core/DeviceSerialPort.d.ts

@@ -0,0 +1,64 @@
+import { OperateResult, ByteTransform } from './Core';
+import { ICommunicationLock, RequestQueue } from './CommunicationLock';
+import { INetMessage } from './INetMessage';
+/**
+ * 串口设备基类
+ * Base class for serial port devices
+ */
+export declare abstract class DeviceSerialPort {
+    PortName: string;
+    BaudRate: number;
+    DataBits: 7 | 8;
+    StopBits: 1 | 2;
+    Parity: 'none' | 'even' | 'odd' | 'mark' | 'space';
+    ReceiveTimeOut: number;
+    ConnectTimeOut: number;
+    ByteTransform: ByteTransform;
+    ConnectionId: string;
+    protected communicationLock: ICommunicationLock;
+    protected requestQueue: RequestQueue;
+    EnableCommunicationLock: boolean;
+    private serial?;
+    private isOpen;
+    ReceiveEmptyDataCount: number;
+    constructor();
+    /**
+     * 获取当前协议的消息解析器
+     * 子类应该重写此方法以提供特定协议的消息解析器
+     */
+    protected abstract GetNewNetMessage(): INetMessage | undefined;
+    /**
+     * 打包命令（在发送前添加协议头、CRC等）
+     * 子类可以重写此方法
+     */
+    protected PackCommandWithHeader(command: Buffer): Buffer;
+    /**
+     * 解包响应（验证CRC、去除协议头等）
+     * 子类可以重写此方法
+     */
+    protected UnpackResponseContent(send: Buffer, response: Buffer): OperateResult<Buffer>;
+    /**
+     * 初始化串口配置
+     */
+    SerialPortInni(portName: string, baudRate?: number, dataBits?: 7 | 8, stopBits?: 1 | 2, parity?: 'none' | 'even' | 'odd' | 'mark' | 'space'): this;
+    /**
+     * 打开串口
+     */
+    Open(): Promise<OperateResult<void>>;
+    /**
+     * 关闭串口
+     */
+    Close(): Promise<OperateResult<void>>;
+    /**
+     * 发送请求并接收响应
+     */
+    protected ReadFromCoreServer(send: Buffer, hasResponseData?: boolean, usePackAndUnpack?: boolean): Promise<OperateResult<Buffer>>;
+    /**
+     * 使用 INetMessage 解析器读取数据
+     */
+    private readWithMessage;
+    /**
+     * 释放资源
+     */
+    Dispose(): Promise<void>;
+}