ts-communication 1.0.0 → 1.1.0

package/dist/ge/GeSRTPNet.js

@@ -0,0 +1,337 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeSRTPNet = void 0;
+exports.parseGeSRTPAddress = parseGeSRTPAddress;
+const Core_1 = require("../core/Core");
+const INetMessage_1 = require("../core/INetMessage");
+const BIT_CODES = { I: 70, Q: 72, M: 76, T: 74, S: 84, G: 86 };
+const BYTE_CODES = { I: 16, Q: 18, M: 22, T: 20, S: 30, G: 56 };
+const SPECIAL_CODES = { SA: [78, 24], SB: [80, 26], SC: [82, 28] };
+/** 解析 GE 地址。PLC 地址从 1 开始，报文内部从 0 开始。 */
+function parseGeSRTPAddress(input, length, isBit) {
+    try {
+        const text = input.trim();
+        const match = text.match(/^([A-Za-z]+)(\d+)$/);
+        if (!match)
+            throw new Error(`地址格式错误: ${input}`);
+        const prefix = match[1].toUpperCase();
+        const number = Number(match[2]);
+        if (!Number.isSafeInteger(number) || number < 1 || number > 65536)
+            throw new Error(`地址超出范围: ${input}`);
+        let code;
+        if (prefix === 'AI' || prefix === 'AQ' || prefix === 'R') {
+            if (isBit)
+                throw new Error('AI、AQ、R 不支持位读写');
+            code = prefix === 'AI' ? 10 : prefix === 'AQ' ? 12 : 8;
+        }
+        else if (SPECIAL_CODES[prefix]) {
+            code = SPECIAL_CODES[prefix][isBit ? 0 : 1];
+        }
+        else {
+            code = (isBit ? BIT_CODES : BYTE_CODES)[prefix];
+        }
+        if (code === undefined)
+            throw new Error(`不支持的 GE 地址类型: ${input}`);
+        if (!Number.isInteger(length) || length < 0 || length > 65535)
+            throw new Error(`长度无效: ${length}`);
+        return Core_1.OperateResult.CreateSuccessResult({
+            DataCode: code,
+            AddressStart: number - 1,
+            Length: length,
+            IsBit: isBit
+        });
+    }
+    catch (e) {
+        return new Core_1.OperateResult(e.message);
+    }
+}
+function readCore(id, code, address, length) {
+    const frame = Buffer.alloc(56);
+    frame[0] = 2;
+    frame.writeUInt16LE(id & 0xffff, 2);
+    frame[9] = 1;
+    frame[17] = 1;
+    frame[30] = 6;
+    frame[31] = 0xc0;
+    frame[36] = 16;
+    frame[37] = 14;
+    frame[40] = 1;
+    frame[41] = 1;
+    frame[42] = 4;
+    frame[43] = code;
+    frame.writeUInt16LE(address & 0xffff, 44);
+    frame.writeUInt16LE(length & 0xffff, 46);
+    return frame;
+}
+function writeCore(id, code, address, length, value) {
+    const frame = Buffer.alloc(56 + value.length);
+    frame[0] = 2;
+    frame.writeUInt16LE(id & 0xffff, 2);
+    frame.writeUInt16LE(value.length, 4);
+    frame[9] = 2;
+    frame[17] = 2;
+    frame[30] = 9;
+    frame[31] = 0x80;
+    frame[36] = 16;
+    frame[37] = 14;
+    frame[40] = 1;
+    frame[41] = 1;
+    frame[42] = 2;
+    frame[48] = 1;
+    frame[49] = 1;
+    frame[50] = 7;
+    frame[51] = code;
+    frame.writeUInt16LE(address & 0xffff, 52);
+    frame.writeUInt16LE(length & 0xffff, 54);
+    value.copy(frame, 56);
+    return frame;
+}
+function responseFrame(data) {
+    if (data.length < 56)
+        throw new Error('GE 响应头不完整');
+    const size = data[4] | (data[5] << 8);
+    const total = 56 + size;
+    if (data.length < total)
+        throw new Error('GE 响应数据不完整');
+    return data.subarray(0, total);
+}
+function responseContent(frame) {
+    try {
+        if (frame.length < 56 || frame[0] !== 3)
+            return new Core_1.OperateResult('GE 响应格式错误');
+        const status = frame[42] | (frame[43] << 8);
+        if (frame[31] === 0xd4) {
+            if (status !== 0)
+                return new Core_1.OperateResult(`GE 操作失败: ${status}`, status);
+            return Core_1.OperateResult.CreateSuccessResult(frame.subarray(44, 50));
+        }
+        if (frame[31] === 0x94) {
+            return Core_1.OperateResult.CreateSuccessResult(frame.subarray(56));
+        }
+        return new Core_1.OperateResult('GE 响应类型错误');
+    }
+    catch (e) {
+        return new Core_1.OperateResult(e.message);
+    }
+}
+class GeSRTPNet extends Core_1.DeviceClient {
+    ByteTransform = new Core_1.ByteTransform(Core_1.DataFormat.DCBA);
+    messageId = 0;
+    initializedSocket;
+    constructor(ipAddress, port = 18245) {
+        super(ipAddress, ipAddress === undefined ? undefined : port);
+        this.Port = ipAddress === undefined ? 5000 : port;
+        this.ByteTransform = new Core_1.ByteTransform(Core_1.DataFormat.DCBA);
+    }
+    get DataFormat() {
+        return this.ByteTransform.DataFormat;
+    }
+    set DataFormat(value) {
+        this.ByteTransform.DataFormat = value;
+    }
+    GetNewNetMessage() {
+        return new INetMessage_1.GeSRTPMessage();
+    }
+    async ConnectServer() {
+        const result = await super.ConnectServer();
+        if (!result.IsSuccess || !this.socket)
+            return result;
+        if (this.initializedSocket === this.socket)
+            return result;
+        const handshake = await this.requestConnected(Buffer.alloc(56), data => data.length >= 56 ? data.subarray(0, 56) : (() => {
+            throw new Error('等待 GE 握手响应');
+        })());
+        if (!handshake.IsSuccess) {
+            await super.ConnectClose();
+            return handshake;
+        }
+        this.initializedSocket = this.socket;
+        return result;
+    }
+    async ConnectClose() {
+        this.initializedSocket = undefined;
+        return super.ConnectClose();
+    }
+    nextId() {
+        const id = this.messageId;
+        this.messageId = (this.messageId + 1) & 0xffff;
+        return id;
+    }
+    async transact(frame) {
+        const id = frame.readUInt16LE(2);
+        const result = await this.request(frame, data => {
+            const response = responseFrame(data);
+            if (response[2] !== (id & 0xff) || response[3] !== ((id >>> 8) & 0xff))
+                throw new Error('GE 响应消息号不匹配');
+            return response;
+        });
+        if (!result.IsSuccess)
+            return Core_1.OperateResult.CreateFailedResult(result);
+        return responseContent(result.Content);
+    }
+    async Read(address, length) {
+        const parsed = parseGeSRTPAddress(address, length, false);
+        if (!parsed.IsSuccess)
+            return Core_1.OperateResult.CreateFailedResult(parsed);
+        const p = parsed.Content;
+        // 对于R、AI、AQ寄存器，长度以字（word，2字节）为单位
+        // length是字节数，需要转换为字数发送给PLC
+        const units = p.DataCode === 8 || p.DataCode === 10 || p.DataCode === 12 ? Math.floor(length / 2) : length;
+        const result = await this.transact(readCore(this.nextId(), p.DataCode, p.AddressStart, units));
+        // 确保返回的数据长度正确（PLC返回的是实际请求的字节数）
+        if (result.IsSuccess && result.Content.length < length) {
+            // 如果返回的数据不足，用0填充（这不应该发生，但作为保护）
+            const padded = Buffer.alloc(length);
+            result.Content.copy(padded);
+            return Core_1.OperateResult.CreateSuccessResult(padded);
+        }
+        return result;
+    }
+    async ReadBool(address, length) {
+        const count = length ?? 1;
+        const parsed = parseGeSRTPAddress(address, count, true);
+        if (!parsed.IsSuccess)
+            return Core_1.OperateResult.CreateFailedResult(parsed);
+        const p = parsed.Content;
+        const result = await this.transact(readCore(this.nextId(), p.DataCode, p.AddressStart, count));
+        if (!result.IsSuccess)
+            return Core_1.OperateResult.CreateFailedResult(result);
+        // Convert bytes to bool array and extract from bit offset
+        const boolArray = [];
+        for (let i = 0; i < result.Content.length * 8; i++) {
+            boolArray.push((result.Content[i >> 3] & (1 << (i & 7))) !== 0);
+        }
+        const bitOffset = p.AddressStart % 8;
+        const values = boolArray.slice(bitOffset, bitOffset + count);
+        return Core_1.OperateResult.CreateSuccessResult(length === undefined ? values[0] : values);
+    }
+    async ReadByte(address) {
+        const p = parseGeSRTPAddress(address, 1, true);
+        if (!p.IsSuccess)
+            return Core_1.OperateResult.CreateFailedResult(p);
+        if (p.Content.DataCode === 8 || p.Content.DataCode === 10 || p.Content.DataCode === 12)
+            return new Core_1.OperateResult('AI、AQ、R 不支持字节读写');
+        const r = await this.Read(address, 1);
+        return r.IsSuccess ? Core_1.OperateResult.CreateSuccessResult(r.Content[0]) : Core_1.OperateResult.CreateFailedResult(r);
+    }
+    async typedRead(address, count, width, fn) {
+        const r = await this.Read(address, count * width);
+        if (!r.IsSuccess)
+            return Core_1.OperateResult.CreateFailedResult(r);
+        const values = Array.from({ length: count }, (_, i) => fn(r.Content, i * width));
+        return Core_1.OperateResult.CreateSuccessResult(count === 1 ? values[0] : values);
+    }
+    ReadInt16(a, l) {
+        return this.typedRead(a, l ?? 1, 2, (b, o) => this.ByteTransform.TransInt16(b, o));
+    }
+    ReadUInt16(a, l) {
+        return this.typedRead(a, l ?? 1, 2, (b, o) => this.ByteTransform.TransUInt16(b, o));
+    }
+    ReadInt32(a, l) {
+        return this.typedRead(a, l ?? 1, 4, (b, o) => this.ByteTransform.TransInt32(b, o));
+    }
+    ReadUInt32(a, l) {
+        return this.typedRead(a, l ?? 1, 4, (b, o) => this.ByteTransform.TransUInt32(b, o));
+    }
+    ReadFloat(a, l) {
+        return this.typedRead(a, l ?? 1, 4, (b, o) => this.ByteTransform.TransSingle(b, o));
+    }
+    ReadDouble(a, l) {
+        return this.typedRead(a, l ?? 1, 8, (b, o) => this.ByteTransform.TransDouble(b, o));
+    }
+    ReadInt64(a, l) {
+        return this.typedRead(a, l ?? 1, 8, (b, o) => this.ByteTransform.TransInt64(b, o));
+    }
+    ReadUInt64(a, l) {
+        return this.typedRead(a, l ?? 1, 8, (b, o) => this.ByteTransform.TransUInt64(b, o));
+    }
+    async ReadString(address, length, encoding = 'ascii') {
+        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) && (value.length === 0 || typeof value[0] === 'boolean'));
+        const length = isBit ? (Array.isArray(value) ? value.length : 1) : Buffer.isBuffer(value) ? value.length : typeof value === 'string' ? Buffer.byteLength(value, 'ascii') : Array.isArray(value) ? value.length * 2 : 2;
+        const parsed = parseGeSRTPAddress(address, length, isBit);
+        if (!parsed.IsSuccess)
+            return parsed;
+        const p = parsed.Content;
+        let data;
+        if (typeof value === 'boolean') {
+            // For single boolean, create array with proper bit offset alignment
+            const bitOffset = p.AddressStart % 8;
+            const boolArray = new Array(bitOffset + 1).fill(false);
+            boolArray[bitOffset] = value;
+            data = Buffer.alloc(Math.ceil(boolArray.length / 8));
+            boolArray.forEach((v, i) => {
+                if (v)
+                    data[i >> 3] |= 1 << (i & 7);
+            });
+        }
+        else if (typeof value === 'string')
+            data = Buffer.from(value, 'ascii');
+        else if (Buffer.isBuffer(value))
+            data = value;
+        else if (Array.isArray(value) && (value.length === 0 || typeof value[0] === 'boolean')) {
+            // For boolean array, align with bit offset
+            const bitOffset = p.AddressStart % 8;
+            const boolArray = new Array(bitOffset + value.length).fill(false);
+            value.forEach((v, i) => {
+                boolArray[bitOffset + i] = v;
+            });
+            data = Buffer.alloc(Math.ceil(boolArray.length / 8));
+            boolArray.forEach((v, i) => {
+                if (v)
+                    data[i >> 3] |= 1 << (i & 7);
+            });
+        }
+        else
+            data = this.ByteTransform.TransByte(value, 2);
+        if (!isBit && (p.DataCode === 8 || p.DataCode === 10 || p.DataCode === 12) && data.length % 2 !== 0)
+            return new Core_1.OperateResult('AI、AQ、R 写入长度必须为偶数');
+        const units = p.DataCode === 8 || p.DataCode === 10 || p.DataCode === 12 ? Math.floor(data.length / 2) : isBit ? p.Length : data.length;
+        return this.transact(writeCore(this.nextId(), p.DataCode, p.AddressStart, units, data));
+    }
+    WriteByte(a, v) {
+        const p = parseGeSRTPAddress(a, 1, true);
+        if (!p.IsSuccess)
+            return Core_1.OperateResult.CreateFailedResult(p);
+        if (p.Content.DataCode === 8 || p.Content.DataCode === 10 || p.Content.DataCode === 12)
+            return new Core_1.OperateResult('AI、AQ、R 不支持字节读写');
+        return this.Write(a, this.ByteTransform.TransByte(new Core_1.Byte(v), 1));
+    }
+    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();
+    }
+    toString() {
+        return `GeSRTPNet[${this.IpAddress}:${this.Port}]`;
+    }
+}
+exports.GeSRTPNet = GeSRTPNet;

package/dist/inovance/InovanceEasyNet.d.ts

@@ -0,0 +1,8 @@
+import { DeviceClient, OperateResult } from '../core/Core';
+export declare class InovanceEasyNet extends DeviceClient {
+    constructor(ipAddress?: string, port?: number);
+    private AnalysisAddressBytes;
+    private BuildReadCommand;
+    Read(address: string, length: number): Promise<OperateResult<Buffer>>;
+    ReadInt16(address: string, length?: number): Promise<OperateResult<number | number[]>>;
+}

package/dist/inovance/InovanceEasyNet.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InovanceEasyNet = void 0;
+const Core_1 = require("../core/Core");
+class InovanceEasyNet extends Core_1.DeviceClient {
+    constructor(ipAddress, port = 8000) {
+        super(ipAddress, port);
+        this.ByteTransform.DataFormat = Core_1.DataFormat.CDAB;
+    }
+    AnalysisAddressBytes(address) {
+        try {
+            const upper = address.toUpperCase();
+            const result = Buffer.alloc(4);
+            if (upper.startsWith('SM')) {
+                result[0] = 0x01;
+                result.writeUInt16LE(parseInt(upper.substring(2)), 1);
+                return Core_1.OperateResult.CreateSuccessResult(result);
+            }
+            if (upper.startsWith('S')) {
+                result[0] = 0x02;
+                result.writeUInt16LE(parseInt(upper.substring(1)), 1);
+                return Core_1.OperateResult.CreateSuccessResult(result);
+            }
+            if (upper.startsWith('X')) {
+                result[0] = 0x03;
+                result.writeUInt16LE(parseInt(upper.substring(1)), 1);
+                return Core_1.OperateResult.CreateSuccessResult(result);
+            }
+            if (upper.startsWith('Y')) {
+                result[0] = 0x04;
+                result.writeUInt16LE(parseInt(upper.substring(1)), 1);
+                return Core_1.OperateResult.CreateSuccessResult(result);
+            }
+            if (upper.startsWith('M')) {
+                result[0] = 0x05;
+                result.writeUInt16LE(parseInt(upper.substring(1)), 1);
+                return Core_1.OperateResult.CreateSuccessResult(result);
+            }
+            if (upper.startsWith('D')) {
+                result[0] = 0x06;
+                result.writeUInt16LE(parseInt(upper.substring(1)), 1);
+                return Core_1.OperateResult.CreateSuccessResult(result);
+            }
+            return new Core_1.OperateResult('Unsupported address: ' + address, -1);
+        }
+        catch (e) {
+            return new Core_1.OperateResult('Address parse error', -1);
+        }
+    }
+    BuildReadCommand(address, length) {
+        const addressBytes = this.AnalysisAddressBytes(address);
+        if (!addressBytes.IsSuccess)
+            return Core_1.OperateResult.CreateFailedResult(addressBytes);
+        const cmd = Buffer.alloc(21);
+        cmd[0] = 0x4B;
+        cmd[1] = 0x4D;
+        cmd[2] = 0x01;
+        cmd[3] = 0x00;
+        cmd[4] = 0x00;
+        cmd[5] = 0x00;
+        cmd[6] = 0x00;
+        cmd[7] = 0x01;
+        cmd[8] = 0x00;
+        cmd[9] = 0x0C;
+        cmd[10] = 0x00;
+        cmd[11] = 0x01;
+        cmd[12] = 0x01;
+        cmd[13] = 0x01;
+        addressBytes.Content.copy(cmd, 14);
+        cmd.writeUInt16LE(length * 16, 18);
+        cmd.writeUInt16LE(length * 16, 20);
+        return Core_1.OperateResult.CreateSuccessResult([cmd]);
+    }
+    async Read(address, length) {
+        const cmdResult = this.BuildReadCommand(address, length);
+        if (!cmdResult.IsSuccess)
+            return Core_1.OperateResult.CreateFailedResult(cmdResult);
+        const result = await this.request(cmdResult.Content[0], (data) => {
+            if (data.length < 11)
+                throw new Error('incomplete');
+            const dataLength = data.readUInt16LE(9);
+            if (data.length < 11 + dataLength)
+                throw new Error('incomplete');
+            return data.subarray(0, 11 + dataLength);
+        });
+        if (!result.IsSuccess)
+            return result;
+        const errorCode = result.Content.readUInt16LE(5);
+        if (errorCode !== 0)
+            return new Core_1.OperateResult('Inovance Easy error: ' + errorCode, errorCode);
+        return Core_1.OperateResult.CreateSuccessResult(result.Content.subarray(11));
+    }
+    async ReadInt16(address, length = 1) {
+        const result = await this.Read(address, length);
+        if (!result.IsSuccess)
+            return Core_1.OperateResult.CreateFailedResult(result);
+        const values = [];
+        for (let i = 0; i < length; i++)
+            values.push(this.ByteTransform.TransInt16(result.Content, i * 2));
+        return Core_1.OperateResult.CreateSuccessResult(length === 1 ? values[0] : values);
+    }
+}
+exports.InovanceEasyNet = InovanceEasyNet;

package/dist/inovance/InovanceSerial.d.ts

@@ -0,0 +1,55 @@
+import { ModbusRtu } from '../modbus/ModbusRtu';
+import { OperateResult } from '../core/Core';
+import { InovanceSeries } from './InovanceTcpNet';
+/**
+ * 汇川 PLC 串口通信客户端（基于 Modbus RTU）
+ * Inovance PLC serial communication client (based on Modbus RTU)
+ */
+export declare class InovanceSerial extends ModbusRtu {
+    Series: InovanceSeries;
+    constructor(station?: number);
+    /**
+     * 地址转换：将汇川地址转换为 Modbus 地址
+     */
+    TranslateToModbusAddress(address: string, modbusCode: number): OperateResult<string>;
+    /**
+     * 读取数据
+     */
+    Read(address: string, length: number): Promise<OperateResult<Buffer>>;
+    /**
+     * 读取布尔值
+     */
+    ReadBool(address: string, length?: number): Promise<OperateResult<boolean | boolean[]>>;
+    /**
+     * 写入数据
+     */
+    Write(address: string, value: Buffer | boolean | boolean[] | number | number[]): Promise<OperateResult<void>>;
+    /**
+     * 读取 Int16
+     */
+    ReadInt16(address: string, length?: number): Promise<OperateResult<number | number[]>>;
+    /**
+     * 读取 UInt16
+     */
+    ReadUInt16(address: string, length?: number): Promise<OperateResult<number | number[]>>;
+    /**
+     * 读取 Int32
+     */
+    ReadInt32(address: string, length?: number): Promise<OperateResult<number | number[]>>;
+    /**
+     * 读取 Float
+     */
+    ReadFloat(address: string, length?: number): Promise<OperateResult<number | number[]>>;
+    /**
+     * 读取字节（MB 地址）
+     */
+    ReadByte(address: string): Promise<OperateResult<number>>;
+    /**
+     * 写入 Int16
+     */
+    WriteInt16(address: string, value: number): Promise<OperateResult<void>>;
+    /**
+     * 写入 Float
+     */
+    WriteFloat(address: string, value: number): Promise<OperateResult<void>>;
+}

package/dist/inovance/InovanceSerial.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InovanceSerial = void 0;
+const ModbusRtu_1 = require("../modbus/ModbusRtu");
+const Core_1 = require("../core/Core");
+const InovanceTcpNet_1 = require("./InovanceTcpNet");
+/**
+ * 汇川 PLC 串口通信客户端（基于 Modbus RTU）
+ * Inovance PLC serial communication client (based on Modbus RTU)
+ */
+class InovanceSerial extends ModbusRtu_1.ModbusRtu {
+    Series = InovanceTcpNet_1.InovanceSeries.AM;
+    constructor(station = 1) {
+        super(station);
+    }
+    /**
+     * 地址转换：将汇川地址转换为 Modbus 地址
+     */
+    TranslateToModbusAddress(address, modbusCode) {
+        return (0, InovanceTcpNet_1.parseInovanceAddress)(this.Series, address, modbusCode);
+    }
+    /**
+     * 读取数据
+     */
+    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 = 1) {
+        const a = this.TranslateToModbusAddress(address, 1);
+        return a.IsSuccess ? super.ReadCoil(a.Content, length) : Core_1.OperateResult.CreateFailedResult(a);
+    }
+    /**
+     * 写入数据
+     */
+    async Write(address, value) {
+        // 判断是位写入还是字写入
+        const isBitWrite = typeof value === 'boolean' || (Array.isArray(value) && typeof value[0] === 'boolean');
+        const code = isBitWrite ? 5 : 6;
+        const a = this.TranslateToModbusAddress(address, code);
+        if (!a.IsSuccess)
+            return Core_1.OperateResult.CreateFailedResult(a);
+        // 布尔值写入
+        if (typeof value === 'boolean') {
+            return super.WriteCoil(a.Content, value);
+        }
+        // 布尔数组写入
+        if (Array.isArray(value) && typeof value[0] === 'boolean') {
+            return super.WriteCoils(a.Content, value);
+        }
+        // Buffer 写入
+        if (Buffer.isBuffer(value)) {
+            const length = Math.ceil(value.length / 2);
+            const a16 = this.TranslateToModbusAddress(address, 16);
+            if (!a16.IsSuccess)
+                return Core_1.OperateResult.CreateFailedResult(a16);
+            if (length === 1) {
+                return super.WriteRegister(a16.Content, value.readUInt16BE(0));
+            }
+            else {
+                const values = [];
+                for (let i = 0; i < length; i++) {
+                    values.push(value.readUInt16BE(i * 2));
+                }
+                return super.WriteRegisters(a16.Content, values);
+            }
+        }
+        // 数字写入
+        if (typeof value === 'number') {
+            return super.WriteRegister(a.Content, value);
+        }
+        // 数字数组写入
+        if (Array.isArray(value) && typeof value[0] === 'number') {
+            return super.WriteRegisters(a.Content, value);
+        }
+        return new Core_1.OperateResult('Unsupported value type', -1);
+    }
+    /**
+     * 读取 Int16
+     */
+    async ReadInt16(address, length = 1) {
+        const a = this.TranslateToModbusAddress(address, 3);
+        return a.IsSuccess ? super.ReadInt16(a.Content, length) : Core_1.OperateResult.CreateFailedResult(a);
+    }
+    /**
+     * 读取 UInt16
+     */
+    async ReadUInt16(address, length = 1) {
+        const a = this.TranslateToModbusAddress(address, 3);
+        return a.IsSuccess ? super.ReadUInt16(a.Content, length) : Core_1.OperateResult.CreateFailedResult(a);
+    }
+    /**
+     * 读取 Int32
+     */
+    async ReadInt32(address, length = 1) {
+        const a = this.TranslateToModbusAddress(address, 3);
+        return a.IsSuccess ? super.ReadInt32(a.Content, length) : Core_1.OperateResult.CreateFailedResult(a);
+    }
+    /**
+     * 读取 Float
+     */
+    async ReadFloat(address, length = 1) {
+        const a = this.TranslateToModbusAddress(address, 3);
+        return a.IsSuccess ? super.ReadFloat(a.Content, length) : Core_1.OperateResult.CreateFailedResult(a);
+    }
+    /**
+     * 读取字节（MB 地址）
+     */
+    async ReadByte(address) {
+        const n = Number(address.replace(/^MB?/i, ''));
+        const r = await this.Read(`MW${Math.floor(n / 2)}`, 1);
+        if (!r.IsSuccess)
+            return Core_1.OperateResult.CreateFailedResult(r);
+        // 偶数字节在高位，奇数字节在低位
+        return Core_1.OperateResult.CreateSuccessResult(n % 2 === 0 ? r.Content[1] : r.Content[0]);
+    }
+    /**
+     * 写入 Int16
+     */
+    async WriteInt16(address, value) {
+        const a = this.TranslateToModbusAddress(address, 6);
+        if (!a.IsSuccess)
+            return Core_1.OperateResult.CreateFailedResult(a);
+        const buffer = Buffer.alloc(2);
+        this.ByteTransform.TransByte(value);
+        buffer.writeInt16BE(value, 0);
+        return super.WriteRegister(a.Content, buffer.readUInt16BE(0));
+    }
+    /**
+     * 写入 Float
+     */
+    async WriteFloat(address, value) {
+        const a = this.TranslateToModbusAddress(address, 16);
+        if (!a.IsSuccess)
+            return Core_1.OperateResult.CreateFailedResult(a);
+        const buffer = Buffer.alloc(4);
+        buffer.writeFloatBE(value, 0);
+        const values = [buffer.readUInt16BE(0), buffer.readUInt16BE(2)];
+        return super.WriteRegisters(a.Content, values);
+    }
+}
+exports.InovanceSerial = InovanceSerial;

package/dist/inovance/InovanceSerialOverTcp.d.ts

@@ -0,0 +1,39 @@
+import { ModbusRtuOverTcp } from '../modbus/ModbusRtuOverTcp';
+import { OperateResult } from '../core/Core';
+import { InovanceSeries } from './InovanceTcpNet';
+/**
+ * 汇川 PLC 串口协议 over TCP 客户端（基于 Modbus RTU over TCP）
+ * Inovance PLC serial protocol over TCP client (based on Modbus RTU over TCP)
+ */
+export declare class InovanceSerialOverTcp extends ModbusRtuOverTcp {
+    Series: InovanceSeries;
+    constructor(ipAddress?: string, port?: number, station?: number);
+    /**
+     * 地址转换：将汇川地址转换为 Modbus 地址
+     */
+    TranslateToModbusAddress(address: string, modbusCode: number): OperateResult<string>;
+    /**
+     * 读取数据
+     */
+    Read(address: string, length: number): Promise<OperateResult<Buffer>>;
+    /**
+     * 读取布尔值
+     */
+    ReadBool(address: string, length?: number): Promise<OperateResult<boolean | boolean[]>>;
+    /**
+     * 写入数据
+     */
+    Write(address: string, value: Buffer | boolean | boolean[] | number | number[]): Promise<OperateResult<void>>;
+    /**
+     * 读取 Int16
+     */
+    ReadInt16(address: string, length?: number): Promise<OperateResult<number | number[]>>;
+    /**
+     * 读取 Float
+     */
+    ReadFloat(address: string, length?: number): Promise<OperateResult<number | number[]>>;
+    /**
+     * 读取字节（MB 地址）
+     */
+    ReadByte(address: string): Promise<OperateResult<number>>;
+}