ts-communication 1.0.0

package/dist/inovance/InovanceTcpNet.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InovanceSerialOverTcp = exports.InovanceSerial = exports.InovanceTcpNet = exports.InovanceSeries = void 0;
+exports.parseInovanceAddress = parseInovanceAddress;
+const ModbusTcpNet_1 = require("../modbus/ModbusTcpNet");
+const Core_1 = require("../core/Core");
+var InovanceSeries;
+(function (InovanceSeries) {
+    InovanceSeries["AM"] = "AM";
+    InovanceSeries["H3U"] = "H3U";
+    InovanceSeries["H5U"] = "H5U";
+    InovanceSeries["Easy"] = "Easy";
+    InovanceSeries["EVO"] = "EVO";
+})(InovanceSeries || (exports.InovanceSeries = InovanceSeries = {}));
+function parseInovanceAddress(series, address, modbusCode) {
+    try {
+        let station = '';
+        const sm = address.match(/^s=(\d+);(.*)$/i);
+        if (sm) {
+            station = `s=${sm[1]};`;
+            address = sm[2];
+        }
+        const upper = address.toUpperCase();
+        const bit = (text) => text.includes('.') ? `${parseInt(text.split('.')[0], 10) * 8 + parseInt(text.split('.')[1], 10)}` : text;
+        const isBitCode = modbusCode === 1 || modbusCode === 5 || modbusCode === 15;
+        if (series === InovanceSeries.AM || series === InovanceSeries.EVO) {
+            if (/^(QX|Q)/i.test(address))
+                return Core_1.OperateResult.CreateSuccessResult(station + bit(address.replace(/^QX?/i, '')));
+            if (/^(IX|I)/i.test(address))
+                return Core_1.OperateResult.CreateSuccessResult(station + 'x=2;' + bit(address.replace(/^IX?/i, '')));
+            if (/^MW/i.test(address))
+                return Core_1.OperateResult.CreateSuccessResult(station + address.slice(2));
+            if (/^MD/i.test(address)) {
+                const suffix = address.slice(2);
+                if (isBitCode && suffix.includes('.'))
+                    return Core_1.OperateResult.CreateSuccessResult(station + `${Number(suffix.split('.')[0]) * 2}.${Number(suffix.split('.')[1])}`);
+                return Core_1.OperateResult.CreateSuccessResult(station + String(Number(suffix) * 2));
+            }
+            if (/^MB/i.test(address)) {
+                const n = Number(address.slice(2));
+                if (!Number.isInteger(n) || n % 2 !== 0)
+                    return new Core_1.OperateResult(`Address[${address}] must use an even byte offset`);
+                return Core_1.OperateResult.CreateSuccessResult(station + String(n / 2));
+            }
+            if (/^MX/i.test(address)) {
+                const suffix = address.slice(2).split('.');
+                const n = Number(suffix[0]);
+                if (isBitCode)
+                    return Core_1.OperateResult.CreateSuccessResult(station + `${Math.floor(n / 2)}.${(n % 2) * 8 + Number(suffix[1] ?? 0)}`);
+                return Core_1.OperateResult.CreateSuccessResult(station + String(Math.floor(n / 2)));
+            }
+            if (/^M/i.test(address))
+                return Core_1.OperateResult.CreateSuccessResult(station + address.slice(1));
+            if (isBitCode && /^SMX?/i.test(address))
+                return Core_1.OperateResult.CreateSuccessResult(station + `x=${modbusCode + 48};` + bit(address.replace(/^SMX?/i, '')));
+            if (!isBitCode && /^SDW?/i.test(address))
+                return Core_1.OperateResult.CreateSuccessResult(station + `x=${modbusCode + 48};` + address.replace(/^SDW?/i, ''));
+        }
+        if (series === InovanceSeries.H3U) {
+            const map = { X: 63488, Y: 64512, SM: 9216, S: 57344, T: 61440, C: 62464, D: 0, SD: 9216, R: 12288 };
+            const m = upper.match(/^(SM|SD|[A-Z]+)(.+)$/);
+            if (m && map[m[1]] !== undefined)
+                return Core_1.OperateResult.CreateSuccessResult(station + String(map[m[1]] + (m[1] === 'X' || m[1] === 'Y' ? parseInt(m[2], 8) : parseInt(m[2], 10))));
+        }
+        if (series === InovanceSeries.H5U || series === InovanceSeries.Easy) {
+            const map = { M: 0, B: 12288, S: 57344, X: 63488, Y: 64512, D: 0, R: 12288 };
+            const m = upper.match(/^([A-Z]+)(.+)$/);
+            if (m && map[m[1]] !== undefined)
+                return Core_1.OperateResult.CreateSuccessResult(station + String(map[m[1]] + parseInt(m[2], 10)));
+        }
+        throw new Error(`Unsupported Inovance address: ${address}`);
+    }
+    catch (e) {
+        return new Core_1.OperateResult(e.message);
+    }
+}
+class InovanceTcpNet extends ModbusTcpNet_1.ModbusTcpNet {
+    Series = InovanceSeries.AM;
+    constructor(ipAddress, port = 502, station = 1) { super(ipAddress, port, station); }
+    TranslateToModbusAddress(address, modbusCode) { return parseInovanceAddress(this.Series, address, modbusCode); }
+    // Address translation changes only the wire address; data API remains Modbus-compatible.
+    async Read(address, length) { const a = this.TranslateToModbusAddress(address, 3); return a.IsSuccess ? super.Read(a.Content, length) : Core_1.OperateResult.CreateFailedResult(a); }
+    async ReadBool(address, length) { const a = this.TranslateToModbusAddress(address, 1); return a.IsSuccess ? super.ReadBool(a.Content, length) : Core_1.OperateResult.CreateFailedResult(a); }
+    async Write(address, value) { const code = typeof value === 'boolean' || (Array.isArray(value) && typeof value[0] === 'boolean') ? 1 : 16; const a = this.TranslateToModbusAddress(address, code); return a.IsSuccess ? super.Write(a.Content, value) : Core_1.OperateResult.CreateFailedResult(a); }
+    async ReadByte(address) { const n = Number(address.replace(/^MB?/i, '')); const r = await this.Read(`MW${Math.floor(n / 2)}`, 1); return r.IsSuccess ? Core_1.OperateResult.CreateSuccessResult(n % 2 === 0 ? r.Content[1] : r.Content[0]) : Core_1.OperateResult.CreateFailedResult(r); }
+}
+exports.InovanceTcpNet = InovanceTcpNet;
+class InovanceSerial extends InovanceTcpNet {
+}
+exports.InovanceSerial = InovanceSerial;
+class InovanceSerialOverTcp extends InovanceTcpNet {
+}
+exports.InovanceSerialOverTcp = InovanceSerialOverTcp;

package/dist/melsec/MelsecMcNet.d.ts

@@ -0,0 +1,55 @@
+import { DataFormat, DeviceClient, OperateResult } from '../core/Core';
+export interface McAddressData {
+    AddressStart: number;
+    Length: number;
+    DataCode: number;
+    DataType: number;
+    FromBase: number;
+}
+export declare function parseMelsecAddress(input: string, length: number, isBit?: boolean): OperateResult<McAddressData>;
+export declare class MelsecMcNet extends DeviceClient {
+    NetworkNumber: number;
+    PLCNumber: number;
+    NetworkStationNumber: number;
+    TargetIOStation: number;
+    EnableWriteBitToWordRegister: boolean;
+    DataFormat: DataFormat;
+    constructor(ipAddress?: string, port?: number);
+    protected pack(core: Buffer): Buffer<ArrayBuffer>;
+    private transact;
+    Read(address: string, length: number): Promise<OperateResult<Buffer>>;
+    ReadBool(address: string, length?: number): Promise<OperateResult<boolean | boolean[]>>;
+    private typedRead;
+    ReadInt16(a: string, l?: number): Promise<OperateResult<any>>;
+    ReadUInt16(a: string, l?: number): Promise<OperateResult<any>>;
+    ReadInt32(a: string, l?: number): Promise<OperateResult<any>>;
+    ReadUInt32(a: string, l?: number): Promise<OperateResult<any>>;
+    ReadFloat(a: string, l?: number): Promise<OperateResult<any>>;
+    ReadDouble(a: string, l?: number): Promise<OperateResult<any>>;
+    ReadInt64(a: string, l?: number): Promise<OperateResult<any>>;
+    ReadUInt64(a: string, l?: number): Promise<OperateResult<any>>;
+    ReadString(address: string, length: number, encoding?: BufferEncoding): Promise<OperateResult<string>>;
+    Write(address: string, value: number | boolean | string | Buffer | number[] | boolean[]): Promise<OperateResult<any>>;
+    WriteByte(a: string, v: number): Promise<OperateResult<any>>;
+    WriteInt16(a: string, v: number): Promise<OperateResult<any>>;
+    WriteUInt16(a: string, v: number): Promise<OperateResult<any>>;
+    WriteInt32(a: string, v: number): Promise<OperateResult<any>>;
+    WriteUInt32(a: string, v: number): Promise<OperateResult<any>>;
+    WriteFloat(a: string, v: number): Promise<OperateResult<any>>;
+    WriteDouble(a: string, v: number): Promise<OperateResult<any>>;
+    WriteInt64(a: string, v: bigint | number): Promise<OperateResult<any>>;
+    WriteUInt64(a: string, v: bigint | number): Promise<OperateResult<any>>;
+    ReadRandom(address: string[], length?: number[]): Promise<OperateResult<Buffer>>;
+    ReadRandomInt16(address: string[]): Promise<OperateResult<number[]>>;
+    ReadRandomUInt16(address: string[]): Promise<OperateResult<number[]>>;
+    ConnectServerAsync(): Promise<OperateResult<any>>;
+    ConnectCloseAsync(): Promise<OperateResult<any>>;
+    RemoteRun(): Promise<OperateResult<string>>;
+    RemoteStop(): Promise<OperateResult<string>>;
+}
+export declare class MelsecMcAsciiNet extends MelsecMcNet {
+}
+export declare class MelsecMcUdp extends MelsecMcNet {
+}
+export declare class MelsecMcAsciiUdp extends MelsecMcNet {
+}

package/dist/melsec/MelsecMcNet.js

@@ -0,0 +1,271 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MelsecMcAsciiUdp = exports.MelsecMcUdp = exports.MelsecMcAsciiNet = exports.MelsecMcNet = void 0;
+exports.parseMelsecAddress = parseMelsecAddress;
+const Core_1 = require("../core/Core");
+const MC = {
+    M: [0x90, 1, 10],
+    X: [0x9c, 1, 16],
+    Y: [0x9d, 1, 16],
+    SM: [0x91, 1, 10],
+    S: [0x98, 1, 10],
+    L: [0x92, 1, 10],
+    F: [0x93, 1, 10],
+    V: [0x94, 1, 10],
+    B: [0xa0, 1, 16],
+    SB: [0xa1, 1, 16],
+    DX: [0xa2, 1, 16],
+    DY: [0xa3, 1, 16],
+    D: [0xa8, 0, 10],
+    SD: [0xa9, 0, 10],
+    W: [0xb4, 0, 16],
+    SW: [0xb5, 0, 16],
+    R: [0xaf, 0, 10],
+    Z: [0xcc, 0, 10],
+    ZR: [0xb0, 0, 10],
+    TN: [0xc2, 0, 10],
+    TS: [0xc1, 1, 10],
+    TC: [0xc0, 1, 10],
+    SS: [0xc7, 1, 10],
+    SC: [0xc6, 1, 10],
+    SN: [0xc8, 0, 10],
+    CN: [0xc5, 0, 10],
+    CS: [0xc4, 1, 10],
+    CC: [0xc3, 1, 10]
+};
+function parseMelsecAddress(input, length, isBit = false) {
+    try {
+        const m = input.match(/^([A-Za-z]+)([0-9A-Fa-f]+)$/);
+        if (!m)
+            throw new Error(`Invalid Mitsubishi address: ${input}`);
+        const key = m[1].toUpperCase();
+        const type = MC[key];
+        if (!type)
+            throw new Error(`Unsupported Mitsubishi address: ${input}`);
+        const value = parseInt(m[2], type[2]);
+        return Core_1.OperateResult.CreateSuccessResult({
+            AddressStart: value,
+            Length: length,
+            DataCode: type[0],
+            DataType: type[1],
+            FromBase: type[2]
+        });
+    }
+    catch (e) {
+        return new Core_1.OperateResult(e.message);
+    }
+}
+class MelsecMcNet extends Core_1.DeviceClient {
+    NetworkNumber = 0;
+    PLCNumber = 0xff;
+    NetworkStationNumber = 0;
+    TargetIOStation = 1023;
+    EnableWriteBitToWordRegister = true;
+    DataFormat = Core_1.DataFormat.DCBA;
+    constructor(ipAddress, port = 6000) {
+        super(ipAddress, ipAddress === undefined ? undefined : port);
+        this.Port = ipAddress === undefined ? 5000 : port;
+        this.ByteTransform = new Core_1.ByteTransform(this.DataFormat);
+    }
+    pack(core) {
+        const h = Buffer.alloc(11 + core.length);
+        h[0] = 0x50;
+        h[1] = 0;
+        h[2] = this.NetworkNumber;
+        h[3] = this.PLCNumber;
+        h.writeUInt16LE(this.TargetIOStation, 4);
+        h[6] = this.NetworkStationNumber;
+        h.writeUInt16LE(core.length + 2, 7);
+        h.writeUInt16LE(10, 9);
+        core.copy(h, 11);
+        return h;
+    }
+    async transact(core) {
+        const frame = this.pack(core);
+        const r = await this.request(frame, data => {
+            if (data.length < 11)
+                throw new Error('incomplete Mitsubishi response');
+            const n = data.readUInt16LE(7);
+            if (data.length < 9 + n)
+                throw new Error('incomplete Mitsubishi response');
+            return data.subarray(0, 9 + n);
+        });
+        if (!r.IsSuccess)
+            return r;
+        const body = r.Content;
+        const status = body.readUInt16LE(9);
+        if (status !== 0)
+            return new Core_1.OperateResult(`Mitsubishi error 0x${status.toString(16)}`, status);
+        return Core_1.OperateResult.CreateSuccessResult(body.subarray(11));
+    }
+    async Read(address, length) {
+        const a = parseMelsecAddress(address, length, false);
+        if (!a.IsSuccess)
+            return Core_1.OperateResult.CreateFailedResult(a);
+        const d = a.Content;
+        const core = Buffer.alloc(10);
+        core[0] = 1;
+        core[1] = 4;
+        core[2] = 0;
+        core.writeUIntLE(d.AddressStart, 4, 3);
+        core[7] = d.DataCode;
+        core.writeUInt16LE(length, 8);
+        return this.transact(core);
+    }
+    async ReadBool(address, length) {
+        const a = parseMelsecAddress(address, length ?? 1, true);
+        if (!a.IsSuccess)
+            return Core_1.OperateResult.CreateFailedResult(a);
+        const d = a.Content;
+        const core = Buffer.alloc(10);
+        core[0] = 1;
+        core[1] = 4;
+        core[2] = 1;
+        core.writeUIntLE(d.AddressStart, 4, 3);
+        core[7] = d.DataCode;
+        core.writeUInt16LE(length ?? 1, 8);
+        const r = await this.transact(core);
+        if (!r.IsSuccess)
+            return Core_1.OperateResult.CreateFailedResult(r);
+        const values = [];
+        for (let i = 0; i < (length ?? 1); i++)
+            values.push(r.Content[i] !== 0);
+        return Core_1.OperateResult.CreateSuccessResult(length === undefined ? values[0] : values);
+    }
+    async typedRead(address, length, width, fn) {
+        const r = await this.Read(address, length * width / 2);
+        if (!r.IsSuccess)
+            return Core_1.OperateResult.CreateFailedResult(r);
+        const values = Array.from({ length }, (_, i) => fn(r.Content, i * width));
+        return Core_1.OperateResult.CreateSuccessResult(length === 1 ? values[0] : values);
+    }
+    async ReadInt16(a, l) {
+        return this.typedRead(a, l ?? 1, 2, (b, o) => this.ByteTransform.TransInt16(b, o));
+    }
+    async ReadUInt16(a, l) {
+        return this.typedRead(a, l ?? 1, 2, (b, o) => this.ByteTransform.TransUInt16(b, o));
+    }
+    async ReadInt32(a, l) {
+        return this.typedRead(a, l ?? 1, 4, (b, o) => this.ByteTransform.TransInt32(b, o));
+    }
+    async ReadUInt32(a, l) {
+        return this.typedRead(a, l ?? 1, 4, (b, o) => this.ByteTransform.TransUInt32(b, o));
+    }
+    async ReadFloat(a, l) {
+        return this.typedRead(a, l ?? 1, 4, (b, o) => this.ByteTransform.TransSingle(b, o));
+    }
+    async ReadDouble(a, l) {
+        return this.typedRead(a, l ?? 1, 8, (b, o) => this.ByteTransform.TransDouble(b, o));
+    }
+    async ReadInt64(a, l) {
+        return this.typedRead(a, l ?? 1, 8, (b, o) => this.ByteTransform.TransInt64(b, o));
+    }
+    async ReadUInt64(a, l) {
+        return this.typedRead(a, l ?? 1, 8, (b, o) => this.ByteTransform.TransUInt64(b, o));
+    }
+    async ReadString(address, length, encoding = 'utf8') {
+        const r = await this.Read(address, length);
+        return r.IsSuccess ? Core_1.OperateResult.CreateSuccessResult(this.ByteTransform.TransString(r.Content, encoding)) : Core_1.OperateResult.CreateFailedResult(r);
+    }
+    async Write(address, value) {
+        const isBit = typeof value === 'boolean' || (Array.isArray(value) && typeof value[0] === 'boolean');
+        const a = parseMelsecAddress(address, Array.isArray(value) ? value.length : 1, isBit);
+        if (!a.IsSuccess)
+            return a;
+        const d = a.Content;
+        let data;
+        if (typeof value === 'boolean')
+            data = Buffer.from([value ? 1 : 0]);
+        else if (typeof value === 'string')
+            data = Buffer.from(value);
+        else if (Buffer.isBuffer(value))
+            data = value;
+        else if (Array.isArray(value) && typeof value[0] === 'boolean')
+            data = Buffer.from(value.map(v => v ? 1 : 0));
+        else
+            data = this.ByteTransform.TransByte(value, 2);
+        const core = Buffer.alloc(10 + data.length);
+        core[0] = 1;
+        core[1] = 0x14;
+        core[2] = isBit ? 1 : 0;
+        core.writeUIntLE(d.AddressStart, 4, 3);
+        core[7] = d.DataCode;
+        core.writeUInt16LE(isBit ? data.length : data.length / 2, 8);
+        data.copy(core, 10);
+        const r = await this.transact(core);
+        return r.IsSuccess ? Core_1.OperateResult.CreateSuccessResult() : r;
+    }
+    WriteByte(a, v) {
+        return this.Write(a, this.ByteTransform.TransByte(new Core_1.Byte(v)));
+    }
+    WriteInt16(a, v) {
+        return this.Write(a, this.ByteTransform.TransByte(new Core_1.Int16(v)));
+    }
+    WriteUInt16(a, v) {
+        return this.Write(a, this.ByteTransform.TransByte(new Core_1.UInt16(v)));
+    }
+    WriteInt32(a, v) {
+        return this.Write(a, this.ByteTransform.TransByte(new Core_1.Int32(v)));
+    }
+    WriteUInt32(a, v) {
+        return this.Write(a, this.ByteTransform.TransByte(new Core_1.UInt32(v)));
+    }
+    WriteFloat(a, v) {
+        return this.Write(a, this.ByteTransform.TransByte(new Core_1.Float(v)));
+    }
+    WriteDouble(a, v) {
+        return this.Write(a, this.ByteTransform.TransByte(new Core_1.Double(v)));
+    }
+    WriteInt64(a, v) {
+        return this.Write(a, this.ByteTransform.TransByte(new Core_1.Int64(v)));
+    }
+    WriteUInt64(a, v) {
+        return this.Write(a, this.ByteTransform.TransByte(new Core_1.UInt64(v)));
+    }
+    async ReadRandom(address, length) {
+        const ds = address.map((x, i) => parseMelsecAddress(x, length?.[i] ?? 1, false));
+        const bad = ds.find(x => !x.IsSuccess);
+        if (bad)
+            return Core_1.OperateResult.CreateFailedResult(bad);
+        const list = ds.map(x => x.Content);
+        const core = Buffer.alloc(6 + list.length * 4);
+        core[0] = 3;
+        core[1] = 4;
+        core[4] = list.length;
+        list.forEach((d, i) => {
+            core.writeUIntLE(d.AddressStart, 6 + i * 4, 3);
+            core[9 + i * 4] = d.DataCode;
+        });
+        return this.transact(core);
+    }
+    async ReadRandomInt16(address) {
+        const r = await this.ReadRandom(address);
+        return r.IsSuccess ? Core_1.OperateResult.CreateSuccessResult(Array.from({ length: address.length }, (_, i) => this.ByteTransform.TransInt16(r.Content, i * 2))) : Core_1.OperateResult.CreateFailedResult(r);
+    }
+    async ReadRandomUInt16(address) {
+        const r = await this.ReadRandom(address);
+        return r.IsSuccess ? Core_1.OperateResult.CreateSuccessResult(Array.from({ length: address.length }, (_, i) => this.ByteTransform.TransUInt16(r.Content, i * 2))) : Core_1.OperateResult.CreateFailedResult(r);
+    }
+    async ConnectServerAsync() {
+        return this.ConnectServer();
+    }
+    async ConnectCloseAsync() {
+        return this.ConnectClose();
+    }
+    async RemoteRun() {
+        return new Core_1.OperateResult('RemoteRun is not implemented for this transport');
+    }
+    async RemoteStop() {
+        return new Core_1.OperateResult('RemoteStop is not implemented for this transport');
+    }
+}
+exports.MelsecMcNet = MelsecMcNet;
+class MelsecMcAsciiNet extends MelsecMcNet {
+}
+exports.MelsecMcAsciiNet = MelsecMcAsciiNet;
+class MelsecMcUdp extends MelsecMcNet {
+}
+exports.MelsecMcUdp = MelsecMcUdp;
+class MelsecMcAsciiUdp extends MelsecMcNet {
+}
+exports.MelsecMcAsciiUdp = MelsecMcAsciiUdp;

package/dist/modbus/ModbusAscii.d.ts

@@ -0,0 +1,4 @@
+import { ModbusRtu } from './ModbusRtu';
+/** Modbus ASCII serial client. */
+export declare class ModbusAscii extends ModbusRtu {
+}

package/dist/modbus/ModbusAscii.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModbusAscii = void 0;
+const ModbusRtu_1 = require("./ModbusRtu");
+/** Modbus ASCII serial client. */
+class ModbusAscii extends ModbusRtu_1.ModbusRtu {
+}
+exports.ModbusAscii = ModbusAscii;

package/dist/modbus/ModbusAsciiOverTcp.d.ts

@@ -0,0 +1,4 @@
+import { ModbusRtuOverTcp } from './ModbusRtuOverTcp';
+/** Modbus ASCII frame carried over TCP. */
+export declare class ModbusAsciiOverTcp extends ModbusRtuOverTcp {
+}

package/dist/modbus/ModbusAsciiOverTcp.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModbusAsciiOverTcp = void 0;
+const ModbusRtuOverTcp_1 = require("./ModbusRtuOverTcp");
+/** Modbus ASCII frame carried over TCP. */
+class ModbusAsciiOverTcp extends ModbusRtuOverTcp_1.ModbusRtuOverTcp {
+}
+exports.ModbusAsciiOverTcp = ModbusAsciiOverTcp;

package/dist/modbus/ModbusRtu.d.ts

@@ -0,0 +1,15 @@
+import { ModbusTcpNet } from './ModbusTcpNet';
+import { OperateResult } from '../core/Core';
+/** Modbus RTU serial client. */
+export declare class ModbusRtu extends ModbusTcpNet {
+    PortName: string;
+    BaudRate: number;
+    DataBits: number;
+    StopBits: number | string;
+    Parity: number | string;
+    private serial;
+    constructor(station?: number);
+    SerialPortInni(portName: string, baudRate?: number, dataBits?: number, stopBits?: number | string, parity?: number | string): this;
+    Open(): Promise<OperateResult<any>>;
+    Close(): Promise<OperateResult<void>>;
+}

package/dist/modbus/ModbusRtu.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModbusRtu = void 0;
+const ModbusTcpNet_1 = require("./ModbusTcpNet");
+const Core_1 = require("../core/Core");
+/** Modbus RTU serial client. */
+class ModbusRtu extends ModbusTcpNet_1.ModbusTcpNet {
+    PortName = '';
+    BaudRate = 9600;
+    DataBits = 8;
+    StopBits = 1;
+    Parity = 'none';
+    serial;
+    constructor(station = 1) { super(); this.Station = station; }
+    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; return this; }
+    async Open() { try {
+        const mod = await import('serialport');
+        this.serial = new mod.SerialPort({ path: this.PortName, baudRate: this.BaudRate, dataBits: this.DataBits, stopBits: Number(this.StopBits), parity: String(this.Parity) });
+        return Core_1.OperateResult.CreateSuccessResult();
+    }
+    catch (e) {
+        return new Core_1.OperateResult(`Unable to open serial port: ${e.message}`);
+    } }
+    async Close() { if (this.serial)
+        await new Promise(r => this.serial.close(() => r())); this.serial = undefined; return Core_1.OperateResult.CreateSuccessResult(); }
+}
+exports.ModbusRtu = ModbusRtu;

package/dist/modbus/ModbusRtuOverTcp.d.ts

@@ -0,0 +1,4 @@
+import { ModbusTcpNet } from './ModbusTcpNet';
+/** Modbus RTU frame carried over TCP. */
+export declare class ModbusRtuOverTcp extends ModbusTcpNet {
+}

package/dist/modbus/ModbusRtuOverTcp.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModbusRtuOverTcp = void 0;
+const ModbusTcpNet_1 = require("./ModbusTcpNet");
+/** Modbus RTU frame carried over TCP. */
+class ModbusRtuOverTcp extends ModbusTcpNet_1.ModbusTcpNet {
+}
+exports.ModbusRtuOverTcp = ModbusRtuOverTcp;

package/dist/modbus/ModbusTcpNet.d.ts

@@ -0,0 +1,55 @@
+import { DataFormat, DeviceClient, OperateResult } from '../core/Core';
+export interface ModbusAddress {
+    station: number;
+    code: number;
+    address: number;
+    bit?: number;
+    writeCode?: number;
+    format?: DataFormat;
+}
+export declare function parseModbusAddress(input: string, defaultStation?: number, defaultCode?: number): OperateResult<ModbusAddress>;
+export declare class ModbusTcpNet extends DeviceClient {
+    Station: number;
+    AddressStartWithZero: boolean;
+    IsStringReverse: boolean;
+    StationCheckMatch: boolean;
+    BroadcastStation: number;
+    WordReadBatchLength: number;
+    DisableFunctionCode06: boolean;
+    EnableWriteMaskCode: boolean;
+    DataFormat: DataFormat;
+    MessageId: number;
+    constructor(ipAddress?: string, port?: number, station?: number);
+    private nextId;
+    private frame;
+    private transact;
+    private addr;
+    Read(address: string, length: number): Promise<OperateResult<Buffer>>;
+    ReadBool(address: string, length?: number): Promise<OperateResult<boolean | boolean[]>>;
+    ReadCoil(address: string, length?: number): Promise<OperateResult<boolean | boolean[]>>;
+    ReadDiscrete(address: string, length?: number): Promise<OperateResult<boolean | boolean[]>>;
+    private readTyped;
+    ReadInt16(address: string, length?: number): Promise<OperateResult<any>>;
+    ReadUInt16(address: string, length?: number): Promise<OperateResult<any>>;
+    ReadInt32(address: string, length?: number): Promise<OperateResult<any>>;
+    ReadUInt32(address: string, length?: number): Promise<OperateResult<any>>;
+    ReadFloat(address: string, length?: number): Promise<OperateResult<any>>;
+    ReadDouble(address: string, length?: number): Promise<OperateResult<any>>;
+    ReadInt64(address: string, length?: number): Promise<OperateResult<any>>;
+    ReadUInt64(address: string, length?: number): Promise<OperateResult<any>>;
+    ReadByte(address: string): Promise<OperateResult<number>>;
+    ReadString(address: string, length: number, encoding?: BufferEncoding): Promise<OperateResult<string>>;
+    Write(address: string, value: number | boolean | string | Buffer | number[] | boolean[]): Promise<OperateResult<any>>;
+    WriteMask(address: string, andMask: number, orMask: number): Promise<OperateResult<any>>;
+    WriteByte(a: string, v: number): Promise<OperateResult<any>>;
+    WriteInt16(a: string, v: number): Promise<OperateResult<any>>;
+    WriteUInt16(a: string, v: number): Promise<OperateResult<any>>;
+    WriteInt32(a: string, v: number): Promise<OperateResult<any>>;
+    WriteUInt32(a: string, v: number): Promise<OperateResult<any>>;
+    WriteFloat(a: string, v: number): Promise<OperateResult<any>>;
+    WriteDouble(a: string, v: number): Promise<OperateResult<any>>;
+    WriteInt64(a: string, v: bigint | number): Promise<OperateResult<any>>;
+    WriteUInt64(a: string, v: bigint | number): Promise<OperateResult<any>>;
+    ConnectServerAsync(): Promise<OperateResult<any>>;
+    ConnectCloseAsync(): Promise<OperateResult<any>>;
+}