ts-communication 1.0.0

package/dist/modbus/ModbusTcpNet.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModbusTcpNet = void 0;
+exports.parseModbusAddress = parseModbusAddress;
+const Core_1 = require("../core/Core");
+function parseModbusAddress(input, defaultStation = 1, defaultCode = 3) {
+    try {
+        let text = input.trim(), station = defaultStation, code = defaultCode, writeCode, format;
+        for (;;) {
+            const m = text.match(/^([^;=]+)=([^;]+);(.*)$/);
+            if (!m)
+                break;
+            const key = m[1].toLowerCase(), value = m[2];
+            text = m[3];
+            if (key === 's')
+                station = Number(value);
+            else if (key === 'x')
+                code = Number(value);
+            else if (key === 'w')
+                writeCode = Number(value);
+            else if (key === 'format')
+                format = value.toUpperCase();
+        }
+        const [addrText, bitText] = text.split('.');
+        const address = Number(addrText);
+        if (!Number.isInteger(address) || address < 0)
+            throw new Error(`Invalid address: ${input}`);
+        const bit = bitText === undefined ? undefined : Number(bitText);
+        if (bit !== undefined && (bit < 0 || bit > 15))
+            throw new Error(`Invalid bit address: ${input}`);
+        if (![1, 2, 3, 4, 5, 6, 15, 16, 22].includes(code))
+            throw new Error(`Unsupported Modbus function code: ${code}`);
+        return Core_1.OperateResult.CreateSuccessResult({ station, code, address, bit, writeCode, format });
+    }
+    catch (e) {
+        return new Core_1.OperateResult(e.message);
+    }
+}
+function crc16(data) { let crc = 0xffff; for (const b of data) {
+    crc ^= b;
+    for (let i = 0; i < 8; i++)
+        crc = (crc & 1) ? (crc >>> 1) ^ 0xa001 : crc >>> 1;
+} return Buffer.from([crc & 0xff, crc >>> 8]); }
+class ModbusTcpNet extends Core_1.DeviceClient {
+    Station = 1;
+    AddressStartWithZero = true;
+    IsStringReverse = false;
+    StationCheckMatch = true;
+    BroadcastStation = -1;
+    WordReadBatchLength = 120;
+    DisableFunctionCode06 = false;
+    EnableWriteMaskCode = true;
+    DataFormat = Core_1.DataFormat.CDAB;
+    MessageId = 0;
+    constructor(ipAddress, port = 502, station = 1) { super(ipAddress, ipAddress === undefined ? undefined : port); this.Port = ipAddress === undefined ? 5000 : port; this.Station = station; this.ByteTransform = new Core_1.ByteTransform(this.DataFormat); }
+    nextId() { const id = this.MessageId; this.MessageId = (this.MessageId + 1) & 0xffff; return id; }
+    frame(pdu, station) { const id = this.nextId(); const out = Buffer.alloc(7 + pdu.length); out.writeUInt16BE(id, 0); out.writeUInt16BE(0, 2); out.writeUInt16BE(pdu.length + 1, 4); out[6] = station; pdu.copy(out, 7); return out; }
+    async transact(pdu, station) {
+        const id = this.MessageId;
+        const result = await this.request(this.frame(pdu, station), data => {
+            if (data.length < 7)
+                throw new Error('incomplete Modbus TCP response');
+            const len = data.readUInt16BE(4);
+            if (data.length < 6 + len)
+                throw new Error('incomplete Modbus TCP response');
+            if (data.readUInt16BE(0) !== id)
+                throw new Error('Modbus transaction id mismatch');
+            return data.subarray(6, 6 + len);
+        });
+        if (!result.IsSuccess)
+            return result;
+        const body = result.Content;
+        if (body.length < 2)
+            return new Core_1.OperateResult('Invalid Modbus response');
+        if ((body[1] & 0x80) !== 0)
+            return new Core_1.OperateResult(`Modbus exception ${body[2]}`, body[2]);
+        return Core_1.OperateResult.CreateSuccessResult(body);
+    }
+    addr(input, code) { const p = parseModbusAddress(input, this.Station, code); if (p.IsSuccess && !this.AddressStartWithZero)
+        p.Content.address--; return p; }
+    async Read(address, length) {
+        const a = this.addr(address, 3);
+        if (!a.IsSuccess)
+            return Core_1.OperateResult.CreateFailedResult(a);
+        const p = a.Content;
+        const fn = p.code === 1 || p.code === 2 || p.code === 4 ? p.code : 3;
+        const req = Buffer.alloc(5);
+        req[0] = fn;
+        req.writeUInt16BE(p.address, 1);
+        req.writeUInt16BE(length, 3);
+        const result = await this.transact(req, p.station);
+        if (!result.IsSuccess)
+            return result;
+        const body = result.Content;
+        if (body.length < 3 || body[1] !== fn)
+            return new Core_1.OperateResult('Invalid Modbus read response');
+        const byteCount = body[2];
+        if (body.length < 3 + byteCount)
+            return new Core_1.OperateResult('Invalid Modbus read response');
+        return Core_1.OperateResult.CreateSuccessResult(body.subarray(3, 3 + byteCount));
+    }
+    async ReadBool(address, length) {
+        const p = this.addr(address, 1);
+        if (!p.IsSuccess)
+            return Core_1.OperateResult.CreateFailedResult(p);
+        const a = p.Content;
+        const count = length ?? 1;
+        const req = Buffer.alloc(5);
+        req[0] = a.code;
+        req.writeUInt16BE(a.address, 1);
+        req.writeUInt16BE(count, 3);
+        const r = await this.transact(req, a.station);
+        if (!r.IsSuccess)
+            return Core_1.OperateResult.CreateFailedResult(r);
+        const out = [];
+        for (let i = 0; i < count; i++)
+            out.push((r.Content[3 + (i >> 3)] & (1 << (i & 7))) !== 0);
+        return Core_1.OperateResult.CreateSuccessResult(length === undefined ? out[0] : out);
+    }
+    async ReadCoil(address, length) { return this.ReadBool(address, length); }
+    async ReadDiscrete(address, length) { const p = this.addr(address, 2); if (!p.IsSuccess)
+        return Core_1.OperateResult.CreateFailedResult(p); return this.ReadBool(address.replace(/^((?:s=\d+;)?)/, '$1x=2;'), length); }
+    async readTyped(address, length, width, fn) { const r = await this.Read(address, (0, Core_1.wordsFor)('x', length) * width / 2); if (!r.IsSuccess)
+        return Core_1.OperateResult.CreateFailedResult(r); const transform = this.ByteTransform; const values = Array.from({ length }, (_, i) => fn(r.Content, i * width)); return Core_1.OperateResult.CreateSuccessResult(length === 1 ? values[0] : values); }
+    async ReadInt16(address, length) { return this.readTyped(address, length ?? 1, 2, (b, o) => this.ByteTransform.TransInt16(b, o)); }
+    async ReadUInt16(address, length) { return this.readTyped(address, length ?? 1, 2, (b, o) => this.ByteTransform.TransUInt16(b, o)); }
+    async ReadInt32(address, length) { return this.readTyped(address, length ?? 1, 4, (b, o) => this.ByteTransform.TransInt32(b, o)); }
+    async ReadUInt32(address, length) { return this.readTyped(address, length ?? 1, 4, (b, o) => this.ByteTransform.TransUInt32(b, o)); }
+    async ReadFloat(address, length) { return this.readTyped(address, length ?? 1, 4, (b, o) => this.ByteTransform.TransSingle(b, o)); }
+    async ReadDouble(address, length) { return this.readTyped(address, length ?? 1, 8, (b, o) => this.ByteTransform.TransDouble(b, o)); }
+    async ReadInt64(address, length) { return this.readTyped(address, length ?? 1, 8, (b, o) => this.ByteTransform.TransInt64(b, o)); }
+    async ReadUInt64(address, length) { return this.readTyped(address, length ?? 1, 8, (b, o) => this.ByteTransform.TransUInt64(b, o)); }
+    async ReadByte(address) { const r = await this.Read(address, 1); return r.IsSuccess ? Core_1.OperateResult.CreateSuccessResult(r.Content[0]) : Core_1.OperateResult.CreateFailedResult(r); }
+    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 p = this.addr(address, Array.isArray(value) && typeof value[0] === 'boolean' ? 15 : typeof value === 'boolean' ? 5 : 16);
+        if (!p.IsSuccess)
+            return p;
+        const a = p.Content;
+        let fn = p.Content.writeCode ?? p.Content.code;
+        let data;
+        if (typeof value === 'boolean') {
+            const req = Buffer.alloc(5);
+            req[0] = fn || 5;
+            req.writeUInt16BE(a.address, 1);
+            req.writeUInt16BE(value ? 0xff00 : 0, 3);
+            const r = await this.transact(req, a.station);
+            return r.IsSuccess ? Core_1.OperateResult.CreateSuccessResult() : r;
+        }
+        if (typeof value === 'string')
+            data = Buffer.from(value, 'utf8');
+        else if (Buffer.isBuffer(value))
+            data = value;
+        else if (Array.isArray(value) && typeof value[0] === 'boolean') {
+            data = Buffer.alloc(Math.ceil(value.length / 8));
+            value.forEach((v, i) => { if (v)
+                data[i >> 3] |= 1 << (i & 7); });
+        }
+        else if (Array.isArray(value))
+            data = this.ByteTransform.TransByte(value, 2);
+        else
+            data = this.ByteTransform.TransByte(value, 2);
+        const words = Math.ceil(data.length / 2);
+        const useSingle = words === 1 && !this.DisableFunctionCode06 && (fn === 6 || fn === 16);
+        const req = useSingle ? Buffer.alloc(5) : Buffer.alloc(6 + data.length);
+        req[0] = useSingle ? 6 : (fn || 16);
+        req.writeUInt16BE(a.address, 1);
+        if (useSingle)
+            data.copy(req, 3);
+        else {
+            req.writeUInt16BE(words, 3);
+            req[5] = data.length;
+            data.copy(req, 6);
+        }
+        const r = await this.transact(req, a.station);
+        return r.IsSuccess ? Core_1.OperateResult.CreateSuccessResult() : r;
+    }
+    async WriteMask(address, andMask, orMask) { const p = this.addr(address, 22); if (!p.IsSuccess)
+        return p; const req = Buffer.alloc(7); req[0] = 22; req.writeUInt16BE(p.Content.address, 1); req.writeUInt16BE(andMask, 3); req.writeUInt16BE(orMask, 5); const r = await this.transact(req, p.Content.station); 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 ConnectServerAsync() { return this.ConnectServer(); }
+    async ConnectCloseAsync() { return this.ConnectClose(); }
+}
+exports.ModbusTcpNet = ModbusTcpNet;

package/dist/modbus/ModbusUdpNet.d.ts

@@ -0,0 +1,4 @@
+import { ModbusTcpNet } from './ModbusTcpNet';
+/** Modbus UDP client. */
+export declare class ModbusUdpNet extends ModbusTcpNet {
+}

package/dist/modbus/ModbusUdpNet.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModbusUdpNet = void 0;
+const ModbusTcpNet_1 = require("./ModbusTcpNet");
+/** Modbus UDP client. */
+class ModbusUdpNet extends ModbusTcpNet_1.ModbusTcpNet {
+}
+exports.ModbusUdpNet = ModbusUdpNet;

package/dist/omron/OmronFinsNet.d.ts

@@ -0,0 +1,57 @@
+import { DeviceClient, OperateResult } from '../core/Core';
+export declare enum OmronPlcType {
+    CSCJ = 1,
+    CV = 2
+}
+export interface OmronAddress {
+    BitCode: number;
+    WordCode: number;
+    AddressStart: number;
+}
+export declare function parseOmronAddress(input: string): OperateResult<OmronAddress>;
+export declare class OmronFinsNet extends DeviceClient {
+    ICF: number;
+    RSV: number;
+    GCT: number;
+    DNA: number;
+    DA1: number;
+    DA2: number;
+    SNA: number;
+    SA1: number;
+    SA2: number;
+    SID: number;
+    ReadSplits: number;
+    PlcType: OmronPlcType;
+    ReceiveUntilEmpty: boolean;
+    constructor(ipAddress?: string, port?: number);
+    private pack;
+    private transact;
+    private command;
+    Read(address: string, length: number): Promise<OperateResult<Buffer<ArrayBufferLike>>>;
+    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>>;
+    Write(address: string, value: Buffer | number | boolean | string | 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>>;
+    Run(): Promise<OperateResult<void> | OperateResult<Buffer<ArrayBufferLike>>>;
+    Stop(): Promise<OperateResult<void> | OperateResult<Buffer<ArrayBufferLike>>>;
+    ConnectServerAsync(): Promise<OperateResult<any>>;
+    ConnectCloseAsync(): Promise<OperateResult<any>>;
+}
+export declare class OmronFinsUdp extends OmronFinsNet {
+}

package/dist/omron/OmronFinsNet.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OmronFinsUdp = exports.OmronFinsNet = exports.OmronPlcType = void 0;
+exports.parseOmronAddress = parseOmronAddress;
+const Core_1 = require("../core/Core");
+var OmronPlcType;
+(function (OmronPlcType) {
+    OmronPlcType[OmronPlcType["CSCJ"] = 1] = "CSCJ";
+    OmronPlcType[OmronPlcType["CV"] = 2] = "CV";
+})(OmronPlcType || (exports.OmronPlcType = OmronPlcType = {}));
+const area = { D: [0x02, 0x82], DM: [0x02, 0x82], C: [0x30, 0xB0], CIO: [0x30, 0xB0], W: [0x31, 0xB1], WR: [0x31, 0xB1], H: [0x32, 0xB2], HR: [0x32, 0xB2], A: [0x33, 0xB3], AR: [0x33, 0xB3], E: [0x20, 0xA0], EM: [0x20, 0xA0], TIM: [0x09, 0x89], CNT: [0x09, 0x89] };
+function parseOmronAddress(input) { try {
+    const m = input.trim().match(/^([A-Za-z]+)([0-9A-Fa-f]+)(?:\.([0-9]+))?$/);
+    if (!m)
+        throw new Error(`Invalid Omron address: ${input}`);
+    const key = m[1].toUpperCase(), a = area[key];
+    if (!a)
+        throw new Error(`Unsupported Omron address: ${input}`);
+    const word = Number.parseInt(m[2], key === 'E' || key === 'EM' ? 16 : 10);
+    const bit = Number(m[3] ?? 0);
+    if (bit < 0 || bit > 15)
+        throw new Error('Invalid bit index');
+    return Core_1.OperateResult.CreateSuccessResult({ BitCode: a[0], WordCode: a[1], AddressStart: word * 16 + bit });
+}
+catch (e) {
+    return new Core_1.OperateResult(e.message);
+} }
+class OmronFinsNet extends Core_1.DeviceClient {
+    ICF = 0x80;
+    RSV = 0;
+    GCT = 2;
+    DNA = 0;
+    DA1 = 0;
+    DA2 = 0;
+    SNA = 0;
+    SA1 = 1;
+    SA2 = 0;
+    SID = 0;
+    ReadSplits = 500;
+    PlcType = OmronPlcType.CSCJ;
+    ReceiveUntilEmpty = false;
+    constructor(ipAddress, port = 9600) { super(ipAddress, ipAddress === undefined ? undefined : port); this.Port = ipAddress === undefined ? 5000 : port; this.ByteTransform = new Core_1.ByteTransform(Core_1.DataFormat.CDAB); this.ByteTransform.IsStringReverseByteWord = true; }
+    pack(core) { const h = Buffer.alloc(26 + core.length); Buffer.from('FINS').copy(h); h.writeUInt32BE(18 + core.length, 4); h[11] = 2; h[16] = this.ICF; h[17] = this.RSV; h[18] = this.GCT; h[19] = this.DNA; h[20] = this.DA1; h[21] = this.DA2; h[22] = this.SNA; h[23] = this.SA1; h[24] = this.SA2; this.SID = (this.SID + 1) & 255; h[25] = this.SID; core.copy(h, 26); return h; }
+    async transact(core) { const frame = this.pack(core); const r = await this.request(frame, data => { if (data.length < 30)
+        throw new Error('incomplete FINS response'); const n = data.readUInt32BE(4); if (data.length < 8 + n)
+        throw new Error('incomplete FINS response'); return data.subarray(0, 8 + n); }); if (!r.IsSuccess)
+        return r; const b = r.Content; const status = b.readUInt32BE(12); if (status !== 0)
+        return new Core_1.OperateResult(`FINS TCP error ${status}`, status); const end = b.length; return Core_1.OperateResult.CreateSuccessResult(b.subarray(30, end)); }
+    command(address, length, isBit = false, write) { const a = parseOmronAddress(address); if (!a.IsSuccess)
+        return Core_1.OperateResult.CreateFailedResult(a); const d = a.Content; const c = Buffer.alloc(8 + (write?.length ?? 0)); c[0] = 1; c[1] = write ? 2 : 1; c[2] = isBit ? d.BitCode : d.WordCode; c[3] = (d.AddressStart >> 16) & 255; c[4] = (d.AddressStart >> 8) & 255; c[5] = d.AddressStart & 255; c[6] = (length >> 8) & 255; c[7] = length & 255; if (write)
+        write.copy(c, 8); return Core_1.OperateResult.CreateSuccessResult(c); }
+    async Read(address, length) { const c = this.command(address, length, false); if (!c.IsSuccess)
+        return c; return this.transact(c.Content); }
+    async ReadBool(address, length) { const n = length ?? 1, c = this.command(address, n, true); if (!c.IsSuccess)
+        return Core_1.OperateResult.CreateFailedResult(c); const r = await this.transact(c.Content); if (!r.IsSuccess)
+        return Core_1.OperateResult.CreateFailedResult(r); const vals = Array.from(r.Content, x => x !== 0).slice(0, n); return Core_1.OperateResult.CreateSuccessResult(length === undefined ? vals[0] : vals); }
+    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 vals = Array.from({ length }, (_, i) => fn(r.Content, i * width)); return Core_1.OperateResult.CreateSuccessResult(length === 1 ? vals[0] : vals); }
+    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 Write(address, value) { const isBit = typeof value === 'boolean' || (Array.isArray(value) && typeof value[0] === 'boolean'); 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(x => x ? 1 : 0));
+    else
+        data = this.ByteTransform.TransByte(value, 2); const c = this.command(address, isBit ? data.length : data.length / 2, isBit, data); if (!c.IsSuccess)
+        return c; const r = await this.transact(c.Content); 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 Run() { const r = await this.transact(Buffer.from([4, 1, 255, 255, 4])); return r.IsSuccess ? Core_1.OperateResult.CreateSuccessResult() : r; }
+    async Stop() { const r = await this.transact(Buffer.from([4, 2, 255, 255])); return r.IsSuccess ? Core_1.OperateResult.CreateSuccessResult() : r; }
+    async ConnectServerAsync() { return this.ConnectServer(); }
+    async ConnectCloseAsync() { return this.ConnectClose(); }
+}
+exports.OmronFinsNet = OmronFinsNet;
+class OmronFinsUdp extends OmronFinsNet {
+}
+exports.OmronFinsUdp = OmronFinsUdp;

package/dist/siemens/SiemensS7Net.d.ts

@@ -0,0 +1,69 @@
+import { DeviceClient, OperateResult } from '../core/Core';
+export declare enum SiemensPLCS {
+    S1200 = 0,
+    S300 = 1,
+    S400 = 2,
+    S1500 = 3,
+    S200Smart = 4,
+    S200 = 5
+}
+export interface S7Address {
+    area: number;
+    db: number;
+    byteAddress: number;
+    bit: number;
+}
+export declare function parseS7Address(input: string): OperateResult<S7Address>;
+export declare class SiemensS7Net extends DeviceClient {
+    Port: number;
+    Rack: number;
+    Slot: number;
+    ConnectionType: number;
+    LocalTSAP: number;
+    DestTSAP: number;
+    PDULength: number;
+    PlcType: SiemensPLCS;
+    private initialized;
+    private initializing?;
+    constructor(siemens?: SiemensPLCS, ipAddress?: string, port?: number);
+    private static parseTpkt;
+    private item;
+    private packet;
+    private messageId;
+    private nextMessageId;
+    ConnectServer(): Promise<OperateResult<any>>;
+    ConnectClose(): Promise<OperateResult<any>>;
+    private connectionSetupPacket;
+    private setupCommunicationPacket;
+    private transact;
+    Read(address: string, length: number): Promise<OperateResult<Buffer<ArrayBufferLike>>>;
+    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: Buffer | number | boolean | string | 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>>;
+    ReadOrderNumber(): Promise<OperateResult<string>>;
+    HotStart(): Promise<OperateResult<string>>;
+    ColdStart(): Promise<OperateResult<string>>;
+    Stop(): Promise<OperateResult<string>>;
+    ForceBool(): Promise<OperateResult<string>>;
+    CancelAllForce(): Promise<OperateResult<string>>;
+    ConnectServerAsync(): Promise<OperateResult<any>>;
+    ConnectCloseAsync(): Promise<OperateResult<any>>;
+}