ts-communication 1.0.0

package/dist/siemens/SiemensS7Net.js

@@ -0,0 +1,276 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SiemensS7Net = exports.SiemensPLCS = void 0;
+exports.parseS7Address = parseS7Address;
+const Core_1 = require("../core/Core");
+var SiemensPLCS;
+(function (SiemensPLCS) {
+    SiemensPLCS[SiemensPLCS["S1200"] = 0] = "S1200";
+    SiemensPLCS[SiemensPLCS["S300"] = 1] = "S300";
+    SiemensPLCS[SiemensPLCS["S400"] = 2] = "S400";
+    SiemensPLCS[SiemensPLCS["S1500"] = 3] = "S1500";
+    SiemensPLCS[SiemensPLCS["S200Smart"] = 4] = "S200Smart";
+    SiemensPLCS[SiemensPLCS["S200"] = 5] = "S200";
+})(SiemensPLCS || (exports.SiemensPLCS = SiemensPLCS = {}));
+function parseS7Address(input) {
+    try {
+        let s = input.trim().toUpperCase(), db = 0;
+        const dm = s.match(/^DB(\d+)\.(?:DB[BDW]?|)(\d+)(?:\.(\d+))?$/);
+        if (dm) {
+            db = Number(dm[1]);
+            return Core_1.OperateResult.CreateSuccessResult({
+                area: 0x84,
+                db,
+                byteAddress: Number(dm[2]),
+                bit: Number(dm[3] ?? 0)
+            });
+        }
+        const m = s.match(/^(PIW|PQW|SM|AI|AQ|I|Q|M|V|P|T|C)(\d+)(?:\.(\d+))?$/);
+        if (!m)
+            throw new Error(`Invalid Siemens address: ${input}`);
+        const area = {
+            I: 0x81,
+            Q: 0x82,
+            M: 0x83,
+            V: 0x84,
+            SM: 0x05,
+            P: 0x80, PIW: 0x80, PQW: 0x80, AI: 0x06, AQ: 0x07,
+            T: 0x1f,
+            C: 0x1e
+        };
+        return Core_1.OperateResult.CreateSuccessResult({
+            area: area[m[1]],
+            db: 0,
+            byteAddress: Number(m[2]),
+            bit: Number(m[3] ?? 0)
+        });
+    }
+    catch (e) {
+        return new Core_1.OperateResult(e.message);
+    }
+}
+class SiemensS7Net extends Core_1.DeviceClient {
+    Port = 102;
+    Rack = 0;
+    Slot = 0;
+    ConnectionType = 2;
+    LocalTSAP = 0x0100;
+    DestTSAP = 0x0102;
+    PDULength = 480;
+    PlcType;
+    initialized = false;
+    initializing;
+    constructor(siemens = SiemensPLCS.S1200, ipAddress, port) {
+        super(ipAddress, ipAddress === undefined ? undefined : 102);
+        this.Port = port ?? 102;
+        this.PlcType = siemens;
+        // S7 values are transmitted most-significant byte first.
+        this.ByteTransform = new Core_1.ByteTransform(Core_1.DataFormat.ABCD);
+    }
+    static parseTpkt(data) {
+        if (data.length < 4 || data[0] !== 3)
+            throw new Error('invalid Siemens TPKT response');
+        const length = data.readUInt16BE(2);
+        if (length < 4 || data.length < length)
+            throw new Error('incomplete Siemens TPKT response');
+        return data.subarray(4, length);
+    }
+    item(area, length, transportSize = 2) {
+        const item = Buffer.alloc(12);
+        item[0] = 0x12;
+        item[1] = 0x0a;
+        item[2] = 0x10;
+        item[3] = transportSize;
+        item.writeUInt16BE(length, 4);
+        item.writeUInt16BE(area.db, 6);
+        item[8] = area.area;
+        const address = area.byteAddress * 8 + area.bit;
+        item[9] = (address >>> 16) & 0xff;
+        item[10] = (address >>> 8) & 0xff;
+        item[11] = address & 0xff;
+        return item;
+    }
+    packet(area, length, write) {
+        const isWrite = write !== undefined;
+        const parameter = this.item(area, isWrite ? write.length : length, isWrite ? 2 : 2);
+        const data = isWrite ? Buffer.concat([Buffer.from([0, 4, (write.length * 8) >>> 8, (write.length * 8) & 0xff]), write, write.length % 2 ? Buffer.from([0]) : Buffer.alloc(0)]) : Buffer.alloc(0);
+        const s7 = Buffer.alloc(12 + parameter.length + data.length);
+        s7[0] = 0x32;
+        s7[1] = 1;
+        s7[2] = 0;
+        s7[3] = 0;
+        s7.writeUInt16BE(this.nextMessageId(), 4);
+        s7.writeUInt16BE(parameter.length, 6);
+        s7.writeUInt16BE(data.length, 8);
+        s7[10] = isWrite ? 5 : 4;
+        s7[11] = 1;
+        parameter.copy(s7, 12);
+        data.copy(s7, 12 + parameter.length);
+        const tpkt = Buffer.concat([Buffer.from([3, 0, 0, 0, 2, 0xf0, 0x80]), s7]);
+        tpkt.writeUInt16BE(tpkt.length, 2);
+        return tpkt;
+    }
+    messageId = 1;
+    nextMessageId() { const id = this.messageId; this.messageId = (this.messageId + 1) & 0xffff; return id; }
+    async ConnectServer() {
+        const connected = await super.ConnectServer();
+        if (!connected.IsSuccess || this.initialized)
+            return connected;
+        if (this.initializing)
+            return this.initializing;
+        this.initializing = (async () => {
+            const first = await this.requestConnected(this.connectionSetupPacket(), SiemensS7Net.parseTpkt);
+            if (!first.IsSuccess)
+                return first;
+            const second = await this.requestConnected(this.setupCommunicationPacket(), SiemensS7Net.parseTpkt);
+            if (!second.IsSuccess)
+                return second;
+            this.initialized = true;
+            return Core_1.OperateResult.CreateSuccessResult();
+        })().finally(() => { this.initializing = undefined; });
+        return this.initializing;
+    }
+    async ConnectClose() { this.initialized = false; this.initializing = undefined; return super.ConnectClose(); }
+    connectionSetupPacket() {
+        const packet = Buffer.from([3, 0, 0, 22, 0x11, 0xe0, 0, 0, 0, 1, 0, 0xc0, 1, 10, 0xc1, 2, 1, 2, 0xc2, 2, 1, 0]);
+        packet[20] = this.ConnectionType;
+        packet[21] = this.Rack * 32 + this.Slot;
+        return packet;
+    }
+    setupCommunicationPacket() {
+        const packet = Buffer.from([3, 0, 0, 25, 2, 0xf0, 0x80, 0x32, 1, 0, 0, 4, 0, 0, 8, 0, 0, 0xf0, 0, 0, 1, 0, 1, 1, 0xe0]);
+        return packet;
+    }
+    async transact(item) {
+        const r = await this.request(item, data => {
+            return SiemensS7Net.parseTpkt(data);
+        });
+        if (!r.IsSuccess)
+            return r;
+        const b = r.Content;
+        const marker = b.indexOf(0xff);
+        if (marker >= 0 && marker + 4 < b.length) {
+            const n = b.readUInt16BE(marker + 2);
+            return Core_1.OperateResult.CreateSuccessResult(b.subarray(marker + 4, marker + 4 + Math.ceil(n / 8)));
+        }
+        return Core_1.OperateResult.CreateSuccessResult(b);
+    }
+    async Read(address, length) {
+        const a = parseS7Address(address);
+        if (!a.IsSuccess)
+            return Core_1.OperateResult.CreateFailedResult(a);
+        return this.transact(this.packet(a.Content, length));
+    }
+    async ReadBool(address, length) {
+        const n = length ?? 1, r = await this.Read(address, Math.ceil(n / 8));
+        if (!r.IsSuccess)
+            return Core_1.OperateResult.CreateFailedResult(r);
+        const vals = Array.from({ length: n }, (_, i) => (r.Content[Math.floor(i / 8)] & (1 << (i % 8))) !== 0);
+        return Core_1.OperateResult.CreateSuccessResult(length === undefined ? vals[0] : vals);
+    }
+    async typedRead(address, length, width, fn) {
+        const r = await this.Read(address, length * width);
+        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 ReadString(address, length, encoding = 'utf8') {
+        const r = await this.Read(address, length ?? 254);
+        return r.IsSuccess ? Core_1.OperateResult.CreateSuccessResult(this.ByteTransform.TransString(r.Content, encoding)) : Core_1.OperateResult.CreateFailedResult(r);
+    }
+    async Write(address, value) {
+        const a = parseS7Address(address);
+        if (!a.IsSuccess)
+            return a;
+        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 r = await this.transact(this.packet(a.Content, data.length, data));
+        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 ReadOrderNumber() {
+        return new Core_1.OperateResult('ReadOrderNumber requires an active S7 connection and negotiated PDU');
+    }
+    async HotStart() {
+        return new Core_1.OperateResult('HotStart is not supported by this minimal S7 transport');
+    }
+    async ColdStart() {
+        return new Core_1.OperateResult('ColdStart is not supported by this minimal S7 transport');
+    }
+    async Stop() {
+        return new Core_1.OperateResult('Stop is not supported by this minimal S7 transport');
+    }
+    async ForceBool() {
+        return new Core_1.OperateResult('ForceBool is not supported by this minimal S7 transport');
+    }
+    async CancelAllForce() {
+        return new Core_1.OperateResult('CancelAllForce is not supported by this minimal S7 transport');
+    }
+    async ConnectServerAsync() {
+        return this.ConnectServer();
+    }
+    async ConnectCloseAsync() {
+        return this.ConnectClose();
+    }
+}
+exports.SiemensS7Net = SiemensS7Net;

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "ts-communication",
+  "version": "1.0.0",
+  "description": "工业 PLC 通讯库，支持 Siemens S7、Melsec MC、Omron FINS、Inovance 和 Modbus。",
+  "main": "dist/XCommunication.js",
+  "types": "dist/XCommunication.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "npm run build && node test/protocol.test.js"
+  },
+  "keywords": [
+    "plc",
+    "industrial-automation",
+    "siemens",
+    "s7",
+    "melsec",
+    "omron",
+    "fins",
+    "inovance",
+    "modbus",
+    "modbus-tcp",
+    "modbus-rtu",
+    "typescript",
+    "nodejs"
+  ],
+  "author": "X Communication",
+  "license": "ISC",
+  "engines": {
+    "node": ">=18"
+  },
+  "type": "commonjs",
+  "devDependencies": {
+    "@types/node": "^26.4.1",
+    "typescript": "^7.0.2"
+  }
+}