ts-communication 1.0.0 → 1.1.0

package/dist/modbus/ModbusAsciiOverTcp.d.ts

@@ -1,4 +1,22 @@
-import { ModbusRtuOverTcp } from './ModbusRtuOverTcp';
-/** Modbus ASCII frame carried over TCP. */
-export declare class ModbusAsciiOverTcp extends ModbusRtuOverTcp {
+import { DeviceClient, DataFormat } from '../core/Core';
+import { OperateResult } from '../core/Core';
+import { INetMessage } from '../core/INetMessage';
+/**
+ * Modbus ASCII over TCP 客户端
+ * TCP 传输 ASCII 帧
+ */
+export declare class ModbusAsciiOverTcp extends DeviceClient {
+    Station: number;
+    AddressStartWithZero: boolean;
+    BroadcastStation: number;
+    get DataFormat(): DataFormat;
+    set DataFormat(value: DataFormat);
+    constructor(ipAddress?: string, port?: number, station?: number);
+    protected GetNewNetMessage(): INetMessage;
+    private packCommand;
+    private unpackResponse;
+    protected sendRequest(command: Buffer): Promise<OperateResult<Buffer>>;
+    Read(address: string, length: number): Promise<OperateResult<Buffer>>;
+    ReadInt16(address: string, length?: number): Promise<OperateResult<number | number[]>>;
+    ReadFloat(address: string, length?: number): Promise<OperateResult<number | number[]>>;
 }

package/dist/modbus/ModbusAsciiOverTcp.js

@@ -1,8 +1,72 @@
 "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 {
+const Core_1 = require("../core/Core");
+const Core_2 = require("../core/Core");
+const INetMessage_1 = require("../core/INetMessage");
+const ModbusAscii_1 = require("./ModbusAscii");
+/**
+ * Modbus ASCII over TCP 客户端
+ * TCP 传输 ASCII 帧
+ */
+class ModbusAsciiOverTcp extends Core_1.DeviceClient {
+    Station = 1;
+    AddressStartWithZero = true;
+    BroadcastStation = -1;
+    get DataFormat() {
+        return this.ByteTransform.DataFormat;
+    }
+    set DataFormat(value) {
+        this.ByteTransform.DataFormat = value;
+    }
+    constructor(ipAddress, port = 502, station = 1) {
+        super(ipAddress, port);
+        this.Station = station;
+        this.ByteTransform.DataFormat = Core_1.DataFormat.CDAB;
+    }
+    GetNewNetMessage() {
+        return new INetMessage_1.ModbusAsciiMessage();
+    }
+    packCommand(command) {
+        const core = Buffer.concat([Buffer.from([this.Station]), command]);
+        const lrc = ModbusAscii_1.ModbusAscii.calculateLrc(core);
+        const hex = Buffer.concat([core, Buffer.from([lrc])]).toString('hex').toUpperCase();
+        return Buffer.from(':' + hex + '\r\n', 'ascii');
+    }
+    unpackResponse(send, response) {
+        return ModbusAscii_1.ModbusAscii.ExtraAsciiResponseContent(send, response, this.BroadcastStation);
+    }
+    async sendRequest(command) {
+        const packed = this.packCommand(command);
+        const result = await this.request(packed);
+        if (!result.IsSuccess)
+            return result;
+        return this.unpackResponse(packed, result.Content);
+    }
+    async Read(address, length) {
+        const cmd = Buffer.alloc(5);
+        cmd[0] = 3;
+        cmd.writeUInt16BE(parseInt(address), 1);
+        cmd.writeUInt16BE(length, 3);
+        return this.sendRequest(cmd);
+    }
+    async ReadInt16(address, length = 1) {
+        const result = await this.Read(address, length);
+        if (!result.IsSuccess)
+            return Core_2.OperateResult.CreateFailedResult(result);
+        const values = [];
+        for (let i = 0; i < length; i++)
+            values.push(this.ByteTransform.TransInt16(result.Content, i * 2));
+        return Core_2.OperateResult.CreateSuccessResult(length === 1 ? values[0] : values);
+    }
+    async ReadFloat(address, length = 1) {
+        const result = await this.Read(address, length * 2);
+        if (!result.IsSuccess)
+            return Core_2.OperateResult.CreateFailedResult(result);
+        const values = [];
+        for (let i = 0; i < length; i++)
+            values.push(this.ByteTransform.TransSingle(result.Content, i * 4));
+        return Core_2.OperateResult.CreateSuccessResult(length === 1 ? values[0] : values);
+    }
 }
 exports.ModbusAsciiOverTcp = ModbusAsciiOverTcp;

package/dist/modbus/ModbusRtu.d.ts

@@ -1,15 +1,103 @@
-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;
+import { DeviceSerialPort } from '../core/DeviceSerialPort';
+import { OperateResult, DataFormat } from '../core/Core';
+import { INetMessage } from '../core/INetMessage';
+/**
+ * Modbus RTU 串口客户端
+ * Modbus-Rtu serial client with CRC16 check
+ */
+export declare class ModbusRtu extends DeviceSerialPort {
+    Station: number;
+    AddressStartWithZero: boolean;
+    get IsStringReverse(): boolean;
+    set IsStringReverse(value: boolean);
+    StationCheckMatch: boolean;
+    Crc16CheckEnable: boolean;
+    BroadcastStation: number;
+    WordReadBatchLength: number;
+    DisableFunctionCode06: boolean;
+    EnableWriteMaskCode: boolean;
+    get DataFormat(): DataFormat;
+    set DataFormat(value: DataFormat);
     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>>;
+    protected GetNewNetMessage(): INetMessage;
+    /**
+     * 打包命令：添加站号和 CRC16 校验
+     */
+    protected PackCommandWithHeader(command: Buffer): Buffer;
+    /**
+     * 解包响应：验证 CRC16 和站号
+     */
+    protected UnpackResponseContent(send: Buffer, response: Buffer): OperateResult<Buffer>;
+    /**
+     * CRC16 校验（多项式 0xA001）
+     */
+    static crc16(data: Buffer): Buffer;
+    /**
+     * 验证 CRC16
+     */
+    static checkCrc16(data: Buffer): boolean;
+    /**
+     * 提取 RTU 响应内容
+     */
+    static ExtraRtuResponseContent(send: Buffer, response: Buffer, crcCheck?: boolean, broadcastStation?: number): OperateResult<Buffer>;
+    /**
+     * 提取实际数据
+     */
+    static ExtractActualData(core: Buffer): OperateResult<Buffer>;
+    /**
+     * 获取 Modbus 异常描述
+     */
+    static GetModbusExceptionDescription(code: number): string;
+    /**
+     * 地址解析
+     */
+    private addr;
+    /**
+     * 构建读取命令
+     */
+    private buildReadCommand;
+    /**
+     * 读取字节数据
+     */
+    Read(address: string, length: number): Promise<OperateResult<Buffer>>;
+    /**
+     * 读取线圈
+     */
+    ReadCoil(address: string, length?: number): Promise<OperateResult<boolean | boolean[]>>;
+    /**
+     * 读取离散输入
+     */
+    ReadDiscrete(address: string, length?: number): Promise<OperateResult<boolean | boolean[]>>;
+    /**
+     * 写入单个线圈
+     */
+    WriteCoil(address: string, value: boolean): Promise<OperateResult<void>>;
+    /**
+     * 写入多个线圈
+     */
+    WriteCoils(address: string, values: boolean[]): Promise<OperateResult<void>>;
+    /**
+     * 写入单个寄存器
+     */
+    WriteRegister(address: string, value: number): Promise<OperateResult<void>>;
+    /**
+     * 写入多个寄存器
+     */
+    WriteRegisters(address: string, values: 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[]>>;
 }

package/dist/modbus/ModbusRtu.js

@@ -1,27 +1,361 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ModbusRtu = void 0;
-const ModbusTcpNet_1 = require("./ModbusTcpNet");
+const DeviceSerialPort_1 = require("../core/DeviceSerialPort");
 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(); }
+const INetMessage_1 = require("../core/INetMessage");
+const ModbusTcpNet_1 = require("./ModbusTcpNet");
+/**
+ * Modbus RTU 串口客户端
+ * Modbus-Rtu serial client with CRC16 check
+ */
+class ModbusRtu extends DeviceSerialPort_1.DeviceSerialPort {
+    Station = 1;
+    AddressStartWithZero = true;
+    get IsStringReverse() {
+        return this.ByteTransform.IsStringReverseByteWord;
+    }
+    set IsStringReverse(value) {
+        this.ByteTransform.IsStringReverseByteWord = value;
+    }
+    StationCheckMatch = true;
+    Crc16CheckEnable = true;
+    BroadcastStation = -1;
+    WordReadBatchLength = 120;
+    DisableFunctionCode06 = false;
+    EnableWriteMaskCode = true;
+    get DataFormat() {
+        return this.ByteTransform.DataFormat;
+    }
+    set DataFormat(value) {
+        this.ByteTransform.DataFormat = value;
+    }
+    constructor(station = 1) {
+        super();
+        this.Station = station;
+        this.ByteTransform.DataFormat = Core_1.DataFormat.CDAB;
+        this.ReceiveEmptyDataCount = 8; // RTU 帧间隔检测
+    }
+    GetNewNetMessage() {
+        return new INetMessage_1.ModbusRtuMessage(this.StationCheckMatch);
+    }
+    /**
+     * 打包命令：添加站号和 CRC16 校验
+     */
+    PackCommandWithHeader(command) {
+        const frame = Buffer.concat([Buffer.from([this.Station]), command]);
+        const crc = ModbusRtu.crc16(frame);
+        return Buffer.concat([frame, crc]);
+    }
+    /**
+     * 解包响应：验证 CRC16 和站号
+     */
+    UnpackResponseContent(send, response) {
+        return ModbusRtu.ExtraRtuResponseContent(send, response, this.Crc16CheckEnable, this.BroadcastStation);
+    }
+    /**
+     * CRC16 校验（多项式 0xA001）
+     */
+    static crc16(data) {
+        let crc = 0xFFFF;
+        for (const byte of data) {
+            crc ^= byte;
+            for (let i = 0; i < 8; i++) {
+                if (crc & 1) {
+                    crc = (crc >>> 1) ^ 0xA001;
+                }
+                else {
+                    crc = crc >>> 1;
+                }
+            }
+        }
+        return Buffer.from([crc & 0xFF, (crc >>> 8) & 0xFF]);
+    }
+    /**
+     * 验证 CRC16
+     */
+    static checkCrc16(data) {
+        if (data.length < 2)
+            return false;
+        const received = data.subarray(0, data.length - 2);
+        const crcReceived = data.subarray(data.length - 2);
+        const crcCalculated = ModbusRtu.crc16(received);
+        return crcReceived[0] === crcCalculated[0] && crcReceived[1] === crcCalculated[1];
+    }
+    /**
+     * 提取 RTU 响应内容
+     */
+    static ExtraRtuResponseContent(send, response, crcCheck = true, broadcastStation = -1) {
+        // 广播站不需要响应
+        if (broadcastStation >= 0 && send[0] === broadcastStation) {
+            return Core_1.OperateResult.CreateSuccessResult(Buffer.alloc(0));
+        }
+        if (response.length < 5) {
+            return new Core_1.OperateResult(`Receive data length too short: ${response.length}`, -1);
+        }
+        let frame = response;
+        // CRC 校验
+        if (crcCheck && !ModbusRtu.checkCrc16(frame)) {
+            // 尝试去掉第一个字节后再验证（可能有干扰）
+            if (frame.length > 1) {
+                frame = frame.subarray(1);
+                if (!ModbusRtu.checkCrc16(frame)) {
+                    return new Core_1.OperateResult(`Modbus CRC check failed: ${response.toString('hex')}`, -2);
+                }
+            }
+            else {
+                return new Core_1.OperateResult(`Modbus CRC check failed: ${response.toString('hex')}`, -2);
+            }
+        }
+        // 去除 CRC
+        const dataWithoutCrc = frame.subarray(0, frame.length - 2);
+        // 检查站号
+        if (send[0] !== dataWithoutCrc[0]) {
+            return new Core_1.OperateResult(`Station not match, request: ${send[0]}, response: ${dataWithoutCrc[0]}`, -3);
+        }
+        // 检查功能码
+        const sendFunctionCode = send[1];
+        const receiveFunctionCode = dataWithoutCrc[1];
+        // 异常响应
+        if (receiveFunctionCode === (sendFunctionCode | 0x80)) {
+            const exceptionCode = dataWithoutCrc[2];
+            return new Core_1.OperateResult(ModbusRtu.GetModbusExceptionDescription(exceptionCode), exceptionCode);
+        }
+        // 功能码不匹配
+        if (sendFunctionCode !== receiveFunctionCode) {
+            return new Core_1.OperateResult(`Function code not match: ${sendFunctionCode} != ${receiveFunctionCode}`, -4);
+        }
+        // 提取数据部分
+        return ModbusRtu.ExtractActualData(dataWithoutCrc);
+    }
+    /**
+     * 提取实际数据
+     */
+    static ExtractActualData(core) {
+        const functionCode = core[1];
+        // 读取响应：01/02/03/04
+        if (functionCode === 0x01 || functionCode === 0x02 || functionCode === 0x03 || functionCode === 0x04 || functionCode === 0x17) {
+            const length = core[2];
+            return Core_1.OperateResult.CreateSuccessResult(core.subarray(3, 3 + length));
+        }
+        // 写入响应：05/06/0F/10/16
+        if (functionCode === 0x05 || functionCode === 0x06 || functionCode === 0x0F || functionCode === 0x10 || functionCode === 0x16) {
+            return Core_1.OperateResult.CreateSuccessResult(core.subarray(2));
+        }
+        return Core_1.OperateResult.CreateSuccessResult(core.subarray(2));
+    }
+    /**
+     * 获取 Modbus 异常描述
+     */
+    static GetModbusExceptionDescription(code) {
+        const descriptions = {
+            0x01: 'Illegal Function',
+            0x02: 'Illegal Data Address',
+            0x03: 'Illegal Data Value',
+            0x04: 'Slave Device Failure',
+            0x05: 'Acknowledge',
+            0x06: 'Slave Device Busy',
+            0x08: 'Memory Parity Error',
+            0x0A: 'Gateway Path Unavailable',
+            0x0B: 'Gateway Target Device Failed to Respond'
+        };
+        return descriptions[code] || `Unknown Exception: 0x${code.toString(16).toUpperCase()}`;
+    }
+    /**
+     * 地址解析
+     */
+    addr(input, code) {
+        const p = (0, ModbusTcpNet_1.parseModbusAddress)(input, this.Station, code);
+        if (p.IsSuccess && !this.AddressStartWithZero) {
+            p.Content.address--;
+        }
+        return p;
+    }
+    /**
+     * 构建读取命令
+     */
+    buildReadCommand(address, length, functionCode) {
+        const a = this.addr(address, functionCode);
+        if (!a.IsSuccess)
+            return Core_1.OperateResult.CreateFailedResult(a);
+        const cmd = Buffer.alloc(5);
+        cmd[0] = a.Content.code;
+        cmd.writeUInt16BE(a.Content.address, 1);
+        cmd.writeUInt16BE(length, 3);
+        return Core_1.OperateResult.CreateSuccessResult(cmd);
+    }
+    /**
+     * 读取字节数据
+     */
+    async Read(address, length) {
+        const cmdResult = this.buildReadCommand(address, length, 3);
+        if (!cmdResult.IsSuccess)
+            return cmdResult;
+        return this.ReadFromCoreServer(cmdResult.Content);
+    }
+    /**
+     * 读取线圈
+     */
+    async ReadCoil(address, length = 1) {
+        const cmdResult = this.buildReadCommand(address, length, 1);
+        if (!cmdResult.IsSuccess)
+            return Core_1.OperateResult.CreateFailedResult(cmdResult);
+        const result = await this.ReadFromCoreServer(cmdResult.Content);
+        if (!result.IsSuccess)
+            return Core_1.OperateResult.CreateFailedResult(result);
+        const bools = [];
+        for (let i = 0; i < length; i++) {
+            const byteIndex = Math.floor(i / 8);
+            const bitIndex = i % 8;
+            bools.push((result.Content[byteIndex] & (1 << bitIndex)) !== 0);
+        }
+        return Core_1.OperateResult.CreateSuccessResult(length === 1 ? bools[0] : bools);
+    }
+    /**
+     * 读取离散输入
+     */
+    async ReadDiscrete(address, length = 1) {
+        const cmdResult = this.buildReadCommand(address, length, 2);
+        if (!cmdResult.IsSuccess)
+            return Core_1.OperateResult.CreateFailedResult(cmdResult);
+        const result = await this.ReadFromCoreServer(cmdResult.Content);
+        if (!result.IsSuccess)
+            return Core_1.OperateResult.CreateFailedResult(result);
+        const bools = [];
+        for (let i = 0; i < length; i++) {
+            const byteIndex = Math.floor(i / 8);
+            const bitIndex = i % 8;
+            bools.push((result.Content[byteIndex] & (1 << bitIndex)) !== 0);
+        }
+        return Core_1.OperateResult.CreateSuccessResult(length === 1 ? bools[0] : bools);
+    }
+    /**
+     * 写入单个线圈
+     */
+    async WriteCoil(address, value) {
+        const a = this.addr(address, 5);
+        if (!a.IsSuccess)
+            return Core_1.OperateResult.CreateFailedResult(a);
+        const cmd = Buffer.alloc(5);
+        cmd[0] = 5;
+        cmd.writeUInt16BE(a.Content.address, 1);
+        cmd.writeUInt16BE(value ? 0xFF00 : 0x0000, 3);
+        const result = await this.ReadFromCoreServer(cmd);
+        return result.IsSuccess ? Core_1.OperateResult.CreateSuccessResult() : Core_1.OperateResult.CreateFailedResult(result);
+    }
+    /**
+     * 写入多个线圈
+     */
+    async WriteCoils(address, values) {
+        const a = this.addr(address, 15);
+        if (!a.IsSuccess)
+            return Core_1.OperateResult.CreateFailedResult(a);
+        const byteCount = Math.ceil(values.length / 8);
+        const data = Buffer.alloc(byteCount);
+        for (let i = 0; i < values.length; i++) {
+            if (values[i]) {
+                const byteIndex = Math.floor(i / 8);
+                const bitIndex = i % 8;
+                data[byteIndex] |= (1 << bitIndex);
+            }
+        }
+        const cmd = Buffer.alloc(6 + byteCount);
+        cmd[0] = 15;
+        cmd.writeUInt16BE(a.Content.address, 1);
+        cmd.writeUInt16BE(values.length, 3);
+        cmd[5] = byteCount;
+        data.copy(cmd, 6);
+        const result = await this.ReadFromCoreServer(cmd);
+        return result.IsSuccess ? Core_1.OperateResult.CreateSuccessResult() : Core_1.OperateResult.CreateFailedResult(result);
+    }
+    /**
+     * 写入单个寄存器
+     */
+    async WriteRegister(address, value) {
+        if (this.DisableFunctionCode06) {
+            return this.WriteRegisters(address, [value]);
+        }
+        const a = this.addr(address, 6);
+        if (!a.IsSuccess)
+            return Core_1.OperateResult.CreateFailedResult(a);
+        const cmd = Buffer.alloc(5);
+        cmd[0] = 6;
+        cmd.writeUInt16BE(a.Content.address, 1);
+        cmd.writeUInt16BE(value & 0xFFFF, 3);
+        const result = await this.ReadFromCoreServer(cmd);
+        return result.IsSuccess ? Core_1.OperateResult.CreateSuccessResult() : Core_1.OperateResult.CreateFailedResult(result);
+    }
+    /**
+     * 写入多个寄存器
+     */
+    async WriteRegisters(address, values) {
+        const a = this.addr(address, 16);
+        if (!a.IsSuccess)
+            return Core_1.OperateResult.CreateFailedResult(a);
+        const data = Buffer.alloc(values.length * 2);
+        for (let i = 0; i < values.length; i++) {
+            data.writeUInt16BE(values[i] & 0xFFFF, i * 2);
+        }
+        const cmd = Buffer.alloc(6 + data.length);
+        cmd[0] = 16;
+        cmd.writeUInt16BE(a.Content.address, 1);
+        cmd.writeUInt16BE(values.length, 3);
+        cmd[5] = data.length;
+        data.copy(cmd, 6);
+        const result = await this.ReadFromCoreServer(cmd);
+        return result.IsSuccess ? Core_1.OperateResult.CreateSuccessResult() : Core_1.OperateResult.CreateFailedResult(result);
+    }
+    /**
+     * 读取 Int16
+     */
+    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);
+    }
+    /**
+     * 读取 UInt16
+     */
+    async ReadUInt16(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.TransUInt16(result.Content, i * 2));
+        }
+        return Core_1.OperateResult.CreateSuccessResult(length === 1 ? values[0] : values);
+    }
+    /**
+     * 读取 Int32
+     */
+    async ReadInt32(address, length = 1) {
+        const result = await this.Read(address, length * 2);
+        if (!result.IsSuccess)
+            return Core_1.OperateResult.CreateFailedResult(result);
+        const values = [];
+        for (let i = 0; i < length; i++) {
+            values.push(this.ByteTransform.TransInt32(result.Content, i * 4));
+        }
+        return Core_1.OperateResult.CreateSuccessResult(length === 1 ? values[0] : values);
+    }
+    /**
+     * 读取 Float
+     */
+    async ReadFloat(address, length = 1) {
+        const result = await this.Read(address, length * 2);
+        if (!result.IsSuccess)
+            return Core_1.OperateResult.CreateFailedResult(result);
+        const values = [];
+        for (let i = 0; i < length; i++) {
+            values.push(this.ByteTransform.TransSingle(result.Content, i * 4));
+        }
+        return Core_1.OperateResult.CreateSuccessResult(length === 1 ? values[0] : values);
+    }
 }
 exports.ModbusRtu = ModbusRtu;

package/dist/modbus/ModbusRtuOverTcp.d.ts

@@ -1,4 +1,24 @@
-import { ModbusTcpNet } from './ModbusTcpNet';
-/** Modbus RTU frame carried over TCP. */
-export declare class ModbusRtuOverTcp extends ModbusTcpNet {
+import { DeviceClient, DataFormat } from '../core/Core';
+import { OperateResult } from '../core/Core';
+import { INetMessage } from '../core/INetMessage';
+/**
+ * Modbus RTU over TCP 客户端
+ * TCP 传输 RTU 帧（无 MBAP 头）
+ */
+export declare class ModbusRtuOverTcp extends DeviceClient {
+    Station: number;
+    AddressStartWithZero: boolean;
+    StationCheckMatch: boolean;
+    Crc16CheckEnable: boolean;
+    BroadcastStation: number;
+    get DataFormat(): DataFormat;
+    set DataFormat(value: DataFormat);
+    constructor(ipAddress?: string, port?: number, station?: number);
+    protected GetNewNetMessage(): INetMessage;
+    private packCommand;
+    private unpackResponse;
+    protected sendRequest(command: Buffer): Promise<OperateResult<Buffer>>;
+    Read(address: string, length: number): Promise<OperateResult<Buffer>>;
+    ReadInt16(address: string, length?: number): Promise<OperateResult<number | number[]>>;
+    ReadFloat(address: string, length?: number): Promise<OperateResult<number | number[]>>;
 }