ts-communication 1.0.0

package/README.md

@@ -0,0 +1,198 @@
+# ts-communication
+
+面向 Node.js 和 TypeScript 的工业 PLC 通讯库，提供统一的异步连接、读取、写入和在线监测 API。
+
+## 支持的设备与协议
+
+- Siemens S7：S7-200、S7-200 Smart、S7-300、S7-400、S7-1200、S7-1500
+- Melsec MC：MC 二进制 TCP/UDP 与 ASCII 兼容客户端
+- Omron FINS：FINS TCP/UDP 客户端
+- Inovance：AM、H3U、H5U、Easy、EVO 系列
+- Modbus：Modbus TCP、RTU、RTU over TCP、ASCII、UDP
+
+各协议客户端均按独立类提供，不需要在业务代码中处理底层报文。
+
+## 安装
+
+```bash
+npm install ts-communication
+```
+
+使用 Modbus RTU 或串口型客户端时，另外安装串口驱动：
+
+```bash
+npm install serialport
+```
+
+## 快速开始
+
+### Siemens S7
+
+```ts
+import { SiemensPLCS, SiemensS7Net } from 'ts-communication';
+
+const plc = new SiemensS7Net(SiemensPLCS.S1200, '192.168.1.10');
+const connected = await plc.ConnectServer();
+
+if (!connected.IsSuccess) {
+  throw new Error(connected.Message);
+}
+
+const temperature = await plc.ReadFloat('DB1.0');
+if (temperature.IsSuccess) {
+  console.log(temperature.Content);
+}
+
+const written = await plc.WriteFloat('DB1.0', 25.5);
+console.log(written.IsSuccess, written.Message);
+
+await plc.ConnectClose();
+```
+
+常用 Siemens 地址：`M100`、`M10.2`、`I0.0`、`Q0.0`、`DB1.0`、`DB1.DBD100`、`V100`。
+
+### Melsec MC
+
+```ts
+import { MelsecMcNet } from 'ts-communication';
+
+const plc = new MelsecMcNet('192.168.1.20', 6000);
+const connected = await plc.ConnectServer();
+if (!connected.IsSuccess) throw new Error(connected.Message);
+
+const result = await plc.ReadInt16('D100');
+if (result.IsSuccess) console.log(result.Content);
+
+await plc.WriteInt16('D100', 1234);
+await plc.ConnectClose();
+```
+
+### Omron FINS
+
+```ts
+import { OmronFinsNet } from 'ts-communication';
+
+const plc = new OmronFinsNet('192.168.1.30', 9600);
+const connected = await plc.ConnectServer();
+if (!connected.IsSuccess) throw new Error(connected.Message);
+
+const result = await plc.ReadUInt16('D100');
+if (result.IsSuccess) console.log(result.Content);
+
+await plc.ConnectClose();
+```
+
+### Inovance
+
+```ts
+import { InovanceSeries, InovanceTcpNet } from 'ts-communication';
+
+const plc = new InovanceTcpNet('192.168.1.40', 502, 1);
+plc.Series = InovanceSeries.AM;
+
+const connected = await plc.ConnectServer();
+if (!connected.IsSuccess) throw new Error(connected.Message);
+
+const result = await plc.ReadInt32('MD0');
+if (result.IsSuccess) console.log(result.Content);
+
+await plc.WriteInt32('MD0', 100);
+await plc.ConnectClose();
+```
+
+常用汇川地址：`M0`、`MX0.0`、`MW0`、`MD0`、`MB0`、`QX0.0`、`IX0.0`。地址格式会根据 `Series` 自动转换为对应的 Modbus 地址。
+
+### Modbus TCP
+
+```ts
+import { ModbusTcpNet } from 'ts-communication';
+
+const plc = new ModbusTcpNet('192.168.1.50', 502, 1);
+const connected = await plc.ConnectServer();
+if (!connected.IsSuccess) throw new Error(connected.Message);
+
+const value = await plc.ReadUInt16('100');
+if (value.IsSuccess) console.log(value.Content);
+
+await plc.WriteUInt16('100', 88);
+await plc.ConnectClose();
+```
+
+Modbus 地址支持站号和功能码前缀，例如：`s=2;100`、`x=4;100`、`format=ABCD;100`。
+
+## C# 数值类型
+
+JavaScript 的 `number` 不区分整数宽度。库提供与 PLC 常用类型对应的显式类型类，写入时可以保留 `byte`、`short`、`ushort`、`int`、`uint`、`float`、`double`、`long` 和 `ulong` 的范围与字节宽度。
+
+```ts
+import { Byte, Float, Int16, UInt16, Int64 } from 'ts-communication';
+
+const byteValue = new Byte(255);
+const shortValue = new Int16(-12);
+const unsignedValue = new UInt16(60000);
+const floatValue = new Float(12.5);
+const longValue = new Int64(9007199254740993n);
+```
+
+客户端也提供直接的强类型读写方法：
+
+```ts
+await plc.ReadInt16('D100');
+await plc.ReadUInt32('D102');
+await plc.ReadFloat('D104');
+await plc.ReadDouble('D106');
+await plc.ReadInt64('D110');
+await plc.WriteFloat('D104', 12.5);
+```
+
+当传入 `length` 时，读取方法返回数组；不传入时返回单个值。
+
+## 统一结果处理
+
+所有连接、读取和写入操作都返回 `OperateResult`。访问 `Content` 前应先检查 `IsSuccess`：
+
+```ts
+const result = await plc.ReadInt16('D100');
+if (result.IsSuccess) {
+  console.log(result.Content);
+} else {
+  console.error(result.Message);
+}
+```
+
+## 长任务与轮询
+
+库客户端可以在 Node.js Worker、Electron Worker 或其他后台线程中长期复用。建议保持一个客户端实例由一个工作线程独占，并在循环中复用连接：
+
+```ts
+while (running) {
+  const result = await plc.ReadInt16('D100');
+  if (result.IsSuccess) {
+    console.log(new Date().toISOString(), result.Content);
+  }
+  await new Promise(resolve => setTimeout(resolve, 1000));
+}
+```
+
+## 字节序
+
+客户端公开 `ByteTransform` 和 `DataFormat`，可根据 PLC 配置选择 `ABCD`、`BADC`、`CDAB` 或 `DCBA`。不同协议有各自的默认字节序，数值异常时应先确认 PLC 的字节排列方式。
+
+## TypeScript
+
+库内置 TypeScript 类型声明，可直接用于 TypeScript 项目：
+
+```ts
+import { SiemensS7Net } from 'ts-communication';
+```
+
+## 注意事项
+
+- 使用真实设备前，请确认 PLC IP、端口、站号、机架/槽号以及访问权限。
+- Siemens S7-1200/S7-1500 通常使用 TCP `102` 端口，并需要允许 PUT/GET 访问。
+- 串口协议需要操作系统具有对应串口权限，并正确配置波特率、数据位、停止位和校验位。
+- 所有示例都应检查 `IsSuccess` 后再读取 `Content`。
+
+## License
+
+ISC

package/dist/XCommunication.d.ts

@@ -0,0 +1,11 @@
+export * from './core/Core';
+export * from './modbus/ModbusTcpNet';
+export * from './modbus/ModbusRtu';
+export * from './modbus/ModbusRtuOverTcp';
+export * from './modbus/ModbusAscii';
+export * from './modbus/ModbusAsciiOverTcp';
+export * from './modbus/ModbusUdpNet';
+export * from './siemens/SiemensS7Net';
+export * from './melsec/MelsecMcNet';
+export * from './omron/OmronFinsNet';
+export * from './inovance/InovanceTcpNet';

package/dist/XCommunication.js

@@ -0,0 +1,27 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./core/Core"), exports);
+__exportStar(require("./modbus/ModbusTcpNet"), exports);
+__exportStar(require("./modbus/ModbusRtu"), exports);
+__exportStar(require("./modbus/ModbusRtuOverTcp"), exports);
+__exportStar(require("./modbus/ModbusAscii"), exports);
+__exportStar(require("./modbus/ModbusAsciiOverTcp"), exports);
+__exportStar(require("./modbus/ModbusUdpNet"), exports);
+__exportStar(require("./siemens/SiemensS7Net"), exports);
+__exportStar(require("./melsec/MelsecMcNet"), exports);
+__exportStar(require("./omron/OmronFinsNet"), exports);
+__exportStar(require("./inovance/InovanceTcpNet"), exports);

package/dist/core/Core.d.ts

@@ -0,0 +1,95 @@
+import * as net from 'node:net';
+export declare enum DataFormat {
+    ABCD = "ABCD",
+    BADC = "BADC",
+    CDAB = "CDAB",
+    DCBA = "DCBA"
+}
+/** Explicit PLC scalar types. JavaScript numbers do not carry the C# width/sign information. */
+export declare abstract class PlcValue<T extends number | bigint> {
+    readonly value: T;
+    readonly kind: string;
+    readonly width: number;
+    readonly signed: boolean;
+    protected constructor(value: T, kind: string, width: number, signed?: boolean);
+    valueOf(): any;
+}
+export declare class Byte extends PlcValue<number> {
+    constructor(value: number);
+}
+export declare class Int16 extends PlcValue<number> {
+    constructor(value: number);
+}
+export declare class UInt16 extends PlcValue<number> {
+    constructor(value: number);
+}
+export declare class Int32 extends PlcValue<number> {
+    constructor(value: number);
+}
+export declare class UInt32 extends PlcValue<number> {
+    constructor(value: number);
+}
+export declare class Float extends PlcValue<number> {
+    constructor(value: number);
+}
+export declare class Double extends PlcValue<number> {
+    constructor(value: number);
+}
+export declare class Int64 extends PlcValue<bigint> {
+    constructor(value: bigint | number);
+}
+export declare class UInt64 extends PlcValue<bigint> {
+    constructor(value: bigint | number);
+}
+export declare class PlcString extends String {
+    readonly kind = "string";
+    constructor(value: string);
+}
+export declare class OperateResult<T = void> {
+    readonly IsSuccess: boolean;
+    readonly Content: T;
+    readonly Message: string;
+    readonly ErrorCode: number;
+    constructor(content: T, isSuccess?: boolean, message?: string, errorCode?: number);
+    constructor(message: string, errorCode?: number);
+    static CreateSuccessResult<T>(content: T): OperateResult<T>;
+    static CreateSuccessResult(): OperateResult<void>;
+    static CreateFailedResult<T>(resultOrMessage: OperateResult<any> | string, errorCode?: number): OperateResult<T>;
+}
+export declare class ByteTransform {
+    IsStringReverseByteWord: boolean;
+    DataFormat: DataFormat;
+    constructor(format?: DataFormat);
+    private order;
+    private view;
+    private dataView;
+    TransInt16(data: Uint8Array, offset?: number): number;
+    TransUInt16(data: Uint8Array, offset?: number): number;
+    TransInt32(data: Uint8Array, offset?: number): number;
+    TransUInt32(data: Uint8Array, offset?: number): number;
+    TransSingle(data: Uint8Array, offset?: number): number;
+    TransDouble(data: Uint8Array, offset?: number): number;
+    TransInt64(data: Uint8Array, offset?: number): bigint;
+    TransUInt64(data: Uint8Array, offset?: number): bigint;
+    TransByte(value: number | bigint | PlcValue<any> | number[] | bigint[] | PlcValue<any>[], width?: number): Buffer;
+    TransString(data: Uint8Array, encoding?: BufferEncoding): string;
+}
+export declare abstract class DeviceClient {
+    IpAddress: string;
+    Port: number;
+    ConnectTimeOut: number;
+    ReceiveTimeOut: number;
+    AutoReConnect: boolean;
+    ByteTransform: ByteTransform;
+    ConnectionId: string;
+    protected socket?: net.Socket;
+    private connecting?;
+    constructor(ipAddress?: string, port?: number);
+    ConnectServer(): Promise<OperateResult<any>>;
+    ConnectClose(): Promise<OperateResult<any>>;
+    protected request(frame: Buffer, parser: (data: Buffer) => Buffer): Promise<OperateResult<Buffer>>;
+    /** Send one frame on an already connected socket (used by protocol handshakes). */
+    protected requestConnected(frame: Buffer, parser: (data: Buffer) => Buffer): Promise<OperateResult<Buffer>>;
+    protected fromResult<T>(result: OperateResult<Buffer>, fn: (data: Buffer) => T): OperateResult<T>;
+}
+export declare function wordsFor(type: string, length: number): number;

package/dist/core/Core.js

@@ -0,0 +1,267 @@
+"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.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"));
+var DataFormat;
+(function (DataFormat) {
+    DataFormat["ABCD"] = "ABCD";
+    DataFormat["BADC"] = "BADC";
+    DataFormat["CDAB"] = "CDAB";
+    DataFormat["DCBA"] = "DCBA";
+})(DataFormat || (exports.DataFormat = DataFormat = {}));
+/** Explicit PLC scalar types. JavaScript numbers do not carry the C# width/sign information. */
+class PlcValue {
+    value;
+    kind;
+    width;
+    signed;
+    constructor(value, kind, width, signed = true) {
+        this.value = value;
+        this.kind = kind;
+        this.width = width;
+        this.signed = signed;
+    }
+    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}`); }
+class Byte extends PlcValue {
+    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); }
+}
+exports.Int16 = Int16;
+class UInt16 extends PlcValue {
+    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); }
+}
+exports.Int32 = Int32;
+class UInt32 extends PlcValue {
+    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); }
+}
+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); }
+}
+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); }
+}
+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); }
+}
+exports.UInt64 = UInt64;
+class PlcString extends String {
+    kind = 'string';
+    constructor(value) { super(value); }
+}
+exports.PlcString = PlcString;
+class OperateResult {
+    IsSuccess;
+    Content;
+    Message;
+    ErrorCode;
+    constructor(contentOrMessage, isSuccessOrErrorCode = true, message = '', errorCode = 0) {
+        if (typeof isSuccessOrErrorCode === 'boolean') {
+            this.IsSuccess = isSuccessOrErrorCode;
+            this.Content = contentOrMessage;
+            this.Message = message;
+            this.ErrorCode = errorCode;
+        }
+        else {
+            this.IsSuccess = false;
+            this.Content = undefined;
+            this.Message = contentOrMessage;
+            this.ErrorCode = isSuccessOrErrorCode;
+        }
+    }
+    static CreateSuccessResult(content) { return new OperateResult(content, true, '', 0); }
+    static CreateFailedResult(resultOrMessage, errorCode = 10000) {
+        return typeof resultOrMessage === 'string'
+            ? new OperateResult(undefined, false, resultOrMessage, errorCode)
+            : new OperateResult(resultOrMessage.Message, resultOrMessage.ErrorCode);
+    }
+}
+exports.OperateResult = OperateResult;
+class ByteTransform {
+    IsStringReverseByteWord = false;
+    DataFormat;
+    constructor(format = DataFormat.CDAB) { this.DataFormat = format; }
+    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;
+            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);
+            }
+            else
+                out.set(chunk, i);
+        }
+        return out;
+    }
+    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); }
+    TransByte(value, width) {
+        const values = Array.isArray(value) ? value : [value];
+        const first = values[0];
+        const w = width ?? (first instanceof PlcValue ? first.width : typeof first === 'bigint' ? 8 : 2);
+        const out = Buffer.alloc(values.length * w);
+        values.forEach((v, i) => {
+            const scalar = v instanceof PlcValue ? v.value : v;
+            const raw = Buffer.alloc(w);
+            const view = new DataView(raw.buffer, raw.byteOffset, raw.byteLength);
+            if (w === 1)
+                raw[0] = Number(scalar);
+            else if (w === 2)
+                (v instanceof UInt16 ? view.setUint16 : view.setInt16).call(view, 0, Number(scalar), false);
+            else if (w === 4)
+                (v instanceof UInt32 ? view.setUint32 : v instanceof Float ? view.setFloat32 : view.setInt32).call(view, 0, Number(scalar), false);
+            else if (w === 8)
+                (v instanceof UInt64 ? view.setBigUint64 : view.setBigInt64).call(view, 0, BigInt(scalar), false);
+            out.set(this.order(raw, w), i * w);
+        });
+        return out;
+    }
+    TransString(data, encoding = 'utf8') {
+        let raw = Buffer.from(data);
+        if (this.IsStringReverseByteWord)
+            for (let i = 0; i + 1 < raw.length; i += 2)
+                [raw[i], raw[i + 1]] = [raw[i + 1], raw[i]];
+        return raw.toString(encoding).replace(/\0+$/, '');
+    }
+}
+exports.ByteTransform = ByteTransform;
+class DeviceClient {
+    IpAddress = '127.0.0.1';
+    Port = 5000;
+    ConnectTimeOut = 5000;
+    ReceiveTimeOut = 5000;
+    AutoReConnect = true;
+    ByteTransform = new ByteTransform();
+    ConnectionId = '';
+    socket;
+    connecting;
+    constructor(ipAddress, port) { if (ipAddress !== undefined)
+        this.IpAddress = ipAddress; if (port !== undefined)
+        this.Port = port; this.ConnectionId = `${this.IpAddress}:${this.Port}`; }
+    async ConnectServer() {
+        if (this.socket && !this.socket.destroyed)
+            return OperateResult.CreateSuccessResult();
+        if (this.connecting)
+            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; });
+        return this.connecting;
+    }
+    async ConnectClose() { this.socket?.destroy(); this.socket = undefined; return OperateResult.CreateSuccessResult(); }
+    async request(frame, parser) {
+        const connected = await this.ConnectServer();
+        if (!connected.IsSuccess)
+            return OperateResult.CreateFailedResult(connected);
+        return this.requestConnected(frame, parser);
+    }
+    /** Send one frame on an already connected socket (used by protocol handshakes). */
+    async requestConnected(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.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 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); }
+}
+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; }

package/dist/inovance/InovanceTcpNet.d.ts

@@ -0,0 +1,23 @@
+import { ModbusTcpNet } from '../modbus/ModbusTcpNet';
+import { OperateResult } from '../core/Core';
+export declare enum InovanceSeries {
+    AM = "AM",
+    H3U = "H3U",
+    H5U = "H5U",
+    Easy = "Easy",
+    EVO = "EVO"
+}
+export declare function parseInovanceAddress(series: InovanceSeries, address: string, modbusCode: number): OperateResult<string>;
+export declare class InovanceTcpNet extends ModbusTcpNet {
+    Series: InovanceSeries;
+    constructor(ipAddress?: string, port?: number, station?: number);
+    TranslateToModbusAddress(address: string, modbusCode: number): OperateResult<string>;
+    Read(address: string, length: number): Promise<any>;
+    ReadBool(address: string, length?: number): Promise<any>;
+    Write(address: string, value: any): Promise<any>;
+    ReadByte(address: string): Promise<OperateResult<any>>;
+}
+export declare class InovanceSerial extends InovanceTcpNet {
+}
+export declare class InovanceSerialOverTcp extends InovanceTcpNet {
+}