@iot9x.com/ipc-utils
Version:
九星云、九星小程序、九星配置工具所共用的库方法
575 lines (574 loc) • 31.4 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ModbusPDU = void 0;
const constant_1 = require("./constant");
const util_1 = require("./util");
const validator_1 = require("./validator");
class ModbusPDU {
/**
* 实例化ModbusRTU类
* @param params 初始化参数
*/
constructor(params) {
/** 16位整型编码（有符号+无符号） */
this.i16Encode = constant_1.I16Encode.AB;
/** 32位整型编码（有符号+无符号） */
this.i32Encode = constant_1.I32Encode.ABCD;
/** 32位浮点型编码（FLOAT） */
this.f32Encode = constant_1.F32Encode.ABCD;
/** 64位整型编码（有符号+无符号） */
this.i64Encode = constant_1.I64Encode.ABCDEFGH;
/** 64位浮点型编码（Double） */
this.f64Encode = constant_1.F64Encode.ABCDEFGH;
if (params === null || params === void 0 ? void 0 : params.i16)
this.i16Encode = params.i16;
if (params === null || params === void 0 ? void 0 : params.i32)
this.i32Encode = params.i32;
if (params === null || params === void 0 ? void 0 : params.f32)
this.f32Encode = params.f32;
if (params === null || params === void 0 ? void 0 : params.i64)
this.i64Encode = params.i64;
if (params === null || params === void 0 ? void 0 : params.f64)
this.f64Encode = params.f64;
}
//#region 读取指令生成
/**
* 读线圈寄存器——01功能码
* @param startAddress 起始地址
* @param count 线圈数量
* @param options 生成指令额外参数
* @returns 读取命令——十六进制字符串
*/
static readCoilCMD(startAddress, count, options) {
return new ModbusPDU().getReadCMD('01', startAddress, Math.ceil(count / 8), options);
}
/**
* 读离散输入寄存器——02功能码
* @param startAddress 起始地址
* @param count 离散输入寄存器数量
* @param options 生成指令额外参数
* @returns 读取命令——十六进制字符串
*/
static readDiscreteInputCMD(startAddress, count, options) {
return new ModbusPDU().getReadCMD('02', startAddress, Math.ceil(count / 8), options);
}
/**
* 读保持寄存器——03功能码
* @param startAddress 起始地址
* @param count 保持寄存器数量
* @param options 生成指令额外参数
* @returns 读取命令——十六进制字符串
*/
static readHoldCMD(startAddress, count, options) {
return new ModbusPDU().getReadCMD('03', startAddress, count, options);
}
/**
* 根据数据类型读保持寄存器——03功能码
* @param startAddress 起始地址
* @param dataType 想要读取的数据类型
* @param options 生成指令额外参数
* @returns 读取命令——十六进制字符串
*/
static readHoldCMDByDataType(startAddress, dataType, options) {
const count = util_1.Util.getRegisterCountByDataType(dataType);
if (!count || count === 0)
throw new Error('数据类型格式不正确');
return new ModbusPDU().getReadCMD('03', startAddress, count, options);
}
/**
* 根据数据类型列表读保持寄存器——03功能码
* @param startAddress 起始地址
* @param dataTypeList 想要读取的数据类型列表（按顺序排列哦）
* @param options 生成指令额外参数
* @returns 读取命令——十六进制字符串
*/
static readHoldCMDByDataTypeList(startAddress, dataTypeList, options) {
let sumCount = 0;
for (const dataType of dataTypeList) {
const count = util_1.Util.getRegisterCountByDataType(dataType);
if (!count || count === 0)
throw new Error('数据类型列表中有格式不正确的数据类型');
sumCount += count;
}
return new ModbusPDU().getReadCMD('03', startAddress, sumCount, options);
}
/**
* 读输入寄存器——04功能码
* @param startAddress 起始地址
* @param count 输入寄存器数量
* @param options 生成指令额外参数
* @returns 读取命令——十六进制字符串
*/
static readInputCMD(startAddress, count, options) {
return new ModbusPDU().getReadCMD('04', startAddress, count, options);
}
/**
* 根据数据类型读输入寄存器——04功能码
* @param startAddress 起始地址
* @param dataType 想要读取的数据类型
* @param options 生成指令额外参数
* @returns 读取命令——十六进制字符串
*/
static readInputCMDByDataType(startAddress, dataType, options) {
const count = util_1.Util.getRegisterCountByDataType(dataType);
if (!count || count === 0)
throw new Error('数据类型格式不正确');
return new ModbusPDU().getReadCMD('04', startAddress, count, options);
}
/**
* 根据数据类型列表读输入寄存器——04功能码
* @param startAddress 起始地址
* @param dataTypeList 想要读取的数据类型列表（按顺序排列哦）
* @param options 生成指令额外参数
* @returns 读取命令——十六进制字符串
*/
static readInputCMDByDataTypeList(startAddress, dataTypeList, options) {
let sumCount = 0;
for (const dataType of dataTypeList) {
const count = util_1.Util.getRegisterCountByDataType(dataType);
if (!count || count === 0)
throw new Error('数据类型列表中有格式不正确的数据类型');
sumCount += count;
}
return new ModbusPDU().getReadCMD('04', startAddress, sumCount, options);
}
/**
* 读取指令统一实现
* @param codeHex 功能码
* @param startAddress 起始地址
* @param count 寄存器数量
* @param options 生成指令额外参数
* @returns 读取命令——十六进制字符串
*/
getReadCMD(codeHex, startAddress, count, options) {
const startAddressValidateError = validator_1.Validator.startAddress(startAddress);
if (startAddressValidateError)
throw new Error(startAddressValidateError);
const countValidateError = validator_1.Validator.registerCount(count);
if (countValidateError)
throw new Error(countValidateError);
const startAddressHex = startAddress.toString(16).padStart(4, '0');
const lengthHex = count.toString(16).padStart(4, '0');
const cmdHex = codeHex + startAddressHex + lengthHex;
let result = (options === null || options === void 0 ? void 0 : options.lowerCase) ? cmdHex.toLowerCase() : cmdHex.toUpperCase();
if (options === null || options === void 0 ? void 0 : options.separator)
result = util_1.Util.hexSeparator(result, options.separator);
return result;
}
//#endregion
//#region 读取返回解析
/**
* 解析01功能码返回内容
* @param resHex 发送读取线圈指令（01功能码）后modbus从机返回内容，十六进制字符串
* @returns 解析结果
*/
static resolveCoilRes(resHex) {
new ModbusPDU().resCheck('01', resHex);
resHex = resHex.match(/\w/g).join(''); // 去除可能有的分隔符。
const result = [];
// * 读取payload并解析
const payload = resHex.slice(4);
for (const byte of payload.match(/\w{2}/g)) {
for (const coilValue of parseInt(byte, 16).toString(2).padStart(8, '0').split('').reverse()) {
result.push(parseInt(coilValue));
}
}
return result;
}
/**
* 解析02功能码返回内容
* @param resHex 发送读取输入寄存器指令（02功能码）后modbus从机返回内容，十六进制字符串
* @returns 解析结果
*/
static resolveDiscreteInputRes(resHex) {
new ModbusPDU().resCheck('02', resHex);
resHex = resHex.match(/\w/g).join(''); // 去除可能有的分隔符。
const result = [];
// * 读取payload并解析
const payload = resHex.slice(4);
for (const byte of payload.match(/\w{2}/g)) {
for (const coilValue of parseInt(byte, 16).toString(2).padStart(8, '0').split('').reverse()) {
result.push(parseInt(coilValue));
}
}
return result;
}
/**
* 解析03功能码返回内容
* @param resHex 发送读取保持寄存器指令（03功能码）后modbus从机返回内容，十六进制字符串
* @returns 寄存器原始值，十六进制字符串
*/
static resolveHoldResRaw(resHex) {
new ModbusPDU().resCheck('03', resHex);
resHex = resHex.match(/\w/g).join(''); // 去除可能有的分隔符。
return resHex.slice(4);
}
/**
* 按照数据类型解析03功能码返回内容
* @param resHex 发送读取保持寄存器指令（03功能码）后modbus从机返回内容，十六进制字符串
* @param dataType 数据类型
* @param options 附加参数
* @returns 寄存器值
*/
resolveHoldResByDataType(resHex, dataType, options) {
this.resCheck('03', resHex);
resHex = resHex.match(/\w/g).join(''); // 去除可能有的分隔符。
const payload = resHex.slice(4);
return util_1.Util.getValueByDataType(payload, dataType, (options === null || options === void 0 ? void 0 : options.i16) || this.i16Encode, (options === null || options === void 0 ? void 0 : options.i32) || this.i32Encode, (options === null || options === void 0 ? void 0 : options.f32) || this.f32Encode, (options === null || options === void 0 ? void 0 : options.i64) || this.i64Encode, (options === null || options === void 0 ? void 0 : options.f64) || this.f64Encode);
}
/**
* 按照数据类型列表解析03功能码返回内容
* @param resHex 送读取保持寄存器指令（03功能码）后modbus从机返回内容，十六进制字符串
* @param dataTypeList 数据类型列表
* @param options 附加参数
* @returns 寄存器值列表
*/
resolveHoldResByDataTypeList(resHex, dataTypeList, options) {
this.resCheck('03', resHex);
resHex = resHex.match(/\w/g).join(''); // 去除可能有的分隔符。
const payload = resHex.slice(4);
const result = [];
let startIndex = 0;
for (const dataType of dataTypeList) {
const dataLength = util_1.Util.getRegisterCountByDataType(dataType) * 4;
const value = util_1.Util.getValueByDataType(payload.slice(startIndex, startIndex + dataLength), dataType, (options === null || options === void 0 ? void 0 : options.i16) || this.i16Encode, (options === null || options === void 0 ? void 0 : options.i32) || this.i32Encode, (options === null || options === void 0 ? void 0 : options.f32) || this.f32Encode, (options === null || options === void 0 ? void 0 : options.i64) || this.i64Encode, (options === null || options === void 0 ? void 0 : options.f64) || this.f64Encode);
result.push(value);
startIndex += dataLength;
}
return result;
}
/**
* 按照数据类型解析03功能码返回内容
* @param resHex 发送读取保持寄存器指令（03功能码）后modbus从机返回内容，十六进制字符串
* @param dataType 数据类型
* @param options 附加参数
* @returns 寄存器值
*/
static resolveHoldResByDataType(resHex, dataType, options) {
const pdu = new ModbusPDU(options);
return pdu.resolveHoldResByDataType(resHex, dataType, options);
}
/**
* 按照数据类型列表解析03功能码返回内容
* @param resHex 送读取保持寄存器指令（03功能码）后modbus从机返回内容，十六进制字符串
* @param dataTypeList 数据类型列表
* @param options 附加参数
* @returns 寄存器值列表
*/
static resolveHoldResByDataTypeList(resHex, dataTypeList, options) {
const pdu = new ModbusPDU(options);
return pdu.resolveHoldResByDataTypeList(resHex, dataTypeList, options);
}
/**
* Modbus读取返回内容合法性校验
* @param codeHex 功能码十六进制字符串
* @param resHex 读取返回内容
*/
resCheck(codeHex, resHex) {
if (!resHex || !resHex.length)
throw new Error('要解析的内容不可为空');
resHex = resHex.match(/\w/g).join(''); // 去除可能有的分隔符。
if (resHex.length < 4)
throw new Error('返回内容长度不足'); // 十六进制的返回值最少也要4个字符，小于4个字符肯定不合理
// * 错误码校验
const resError = util_1.Util.checkResCode(codeHex, resHex.slice(0, 2), resHex.slice(2, 4));
if (resError)
throw new Error(resError);
}
//#endregion
//#region 写入（控制）相关指令生成
/**
* 写单个线圈——05功能码
* @param startAddress 线圈寄存器地址
* @param value 线圈值
* @param options 生成指令额外参数
* @returns 写入命令——十六进制字符串
*/
static writeCoilCMD(startAddress, value, options) {
const startAddressValidateError = validator_1.Validator.startAddress(startAddress);
if (startAddressValidateError)
throw new Error(startAddressValidateError);
const valueHex = value ? 'FF00' : '0000';
const startAddressHex = startAddress.toString(16).padStart(4, '0');
const cmdHex = '05' + startAddressHex + valueHex;
let result = (options === null || options === void 0 ? void 0 : options.lowerCase) ? cmdHex.toLowerCase() : cmdHex.toUpperCase();
if (options === null || options === void 0 ? void 0 : options.separator)
result = util_1.Util.hexSeparator(result, options.separator);
return result;
}
/**
* 写多个线圈——0F功能码
* @param startAddress 线圈寄存器起始地址
* @param valueList 线圈值列表（按顺序哦）
* @param options 生成指令额外参数
* @returns 写入命令——十六进制字符串
*/
static writeMultiCoilCMD(startAddress, valueList, options) {
const startAddressValidateError = validator_1.Validator.startAddress(startAddress);
if (startAddressValidateError)
throw new Error(startAddressValidateError);
const coilCountHex = valueList.length.toString(16).toUpperCase().padStart(4, '0');
const byteCountHex = Math.ceil(valueList.length / 8)
.toString(16)
.toUpperCase()
.padStart(2, '0');
const valueHexList = [];
for (let i = 0; i < valueList.length; i += 8) {
const valueHex = parseInt(valueList
.slice(i, i + 8)
.reverse()
.join(''), 2)
.toString(16)
.toUpperCase()
.padStart(2, '0');
valueHexList.push(valueHex);
}
const valueHex = valueHexList.join('');
const startAddressHex = startAddress.toString(16).padStart(4, '0');
const cmdHex = '0F' + startAddressHex + coilCountHex + byteCountHex + valueHex;
let result = (options === null || options === void 0 ? void 0 : options.lowerCase) ? cmdHex.toLowerCase() : cmdHex.toUpperCase();
if (options === null || options === void 0 ? void 0 : options.separator)
result = util_1.Util.hexSeparator(result, options.separator);
return result;
}
/**
* 写单个保持寄存器——06功能码
* @param startAddress 保持寄存器的地址
* @param valueHex 保持寄存器的值，十六进制字符串格式
* @param options 生成指令额外参数
* @returns 写入命令——十六进制字符串
*/
static writeHoldCMD(startAddress, valueHex, options) {
const startAddressValidateError = validator_1.Validator.startAddress(startAddress);
if (startAddressValidateError)
throw new Error(startAddressValidateError);
valueHex = valueHex.match(/\w/g).join(''); // * 去除十六进制字符串中可能有的分隔符
if (valueHex.length !== 4)
throw new Error('寄存器内容长度必须为4个字符');
const startAddressHex = startAddress.toString(16).padStart(4, '0');
const cmdHex = '06' + startAddressHex + valueHex;
let result = (options === null || options === void 0 ? void 0 : options.lowerCase) ? cmdHex.toLowerCase() : cmdHex.toUpperCase();
if (options === null || options === void 0 ? void 0 : options.separator)
result = util_1.Util.hexSeparator(result, options.separator);
return result;
}
/**
* 根据数据类型写单个保持寄存器——06功能码
* @param startAddress 保持寄存器的地址
* @param data 数据值
* @param dataType 数据类型
* @param options 生成指令额外参数
* @returns 写入命令——十六进制字符串
*/
writeHoldByDataTypeCMD(startAddress, data, dataType, options) {
const startAddressValidateError = validator_1.Validator.startAddress(startAddress);
if (startAddressValidateError)
throw new Error(startAddressValidateError);
if (dataType !== constant_1.ModbusDataType.I16 && dataType !== constant_1.ModbusDataType.U16 && dataType !== constant_1.ModbusDataType.S2)
throw new Error('数据类型仅支持Int16、UInt16和两字节字符串');
const valueHex = util_1.Util.dataEncode(data, dataType, (options === null || options === void 0 ? void 0 : options.i16) || this.i16Encode, (options === null || options === void 0 ? void 0 : options.i32) || this.i32Encode, (options === null || options === void 0 ? void 0 : options.f32) || this.f32Encode, (options === null || options === void 0 ? void 0 : options.i64) || this.i64Encode, (options === null || options === void 0 ? void 0 : options.f64) || this.f64Encode);
const startAddressHex = startAddress.toString(16).padStart(4, '0');
const cmdHex = '06' + startAddressHex + valueHex;
let result = (options === null || options === void 0 ? void 0 : options.lowerCase) ? cmdHex.toLowerCase() : cmdHex.toUpperCase();
if (options === null || options === void 0 ? void 0 : options.separator)
result = util_1.Util.hexSeparator(result, options.separator);
return result;
}
/**
* 根据数据类型写单个保持寄存器——06功能码
* @param startAddress 保持寄存器的地址
* @param data 数据值
* @param dataType 数据类型
* @param options 生成指令额外参数
* @returns 写入命令——十六进制字符串
*/
static writeHoldByDataTypeCMD(startAddress, data, dataType, options) {
const pdu = new ModbusPDU(options);
return pdu.writeHoldByDataTypeCMD(startAddress, data, dataType, options);
}
/**
* 写多个保持寄存器——10功能码
* @param startAddress 保持寄存器起始地址
* @param valueHex 保持寄存器的值，十六进制字符串格式
* @param options 生成指令额外参数
* @returns 写入命令——十六进制字符串
*/
static writeMultiHoldCMD(startAddress, valueHex, options) {
const startAddressValidateError = validator_1.Validator.startAddress(startAddress);
if (startAddressValidateError)
throw new Error(startAddressValidateError);
valueHex = valueHex.match(/\w/g).join(''); // * 去除十六进制字符串中可能有的分隔符
if (valueHex.length % 4)
throw new Error('寄存器内容长度不合法');
const startAddressHex = startAddress.toString(16).padStart(4, '0');
const registerCountHex = (valueHex.length / 4).toString(16).padStart(4, '0');
const byteCountHex = (valueHex.length / 2).toString(16).padStart(2, '0');
const cmdHex = '10' + startAddressHex + registerCountHex + byteCountHex + valueHex;
let result = (options === null || options === void 0 ? void 0 : options.lowerCase) ? cmdHex.toLowerCase() : cmdHex.toUpperCase();
if (options === null || options === void 0 ? void 0 : options.separator)
result = util_1.Util.hexSeparator(result, options.separator);
return result;
}
/**
* 根据数据类型写多个保持寄存器——10功能码
* @param startAddress 保持寄存器起始地址
* @param data 数据值
* @param dataType 数据类型
* @param options 生成指令额外参数
* @returns 写入命令——十六进制字符串
*/
writeMultiHoldByDataTypeCMD(startAddress, data, dataType, options) {
const startAddressValidateError = validator_1.Validator.startAddress(startAddress);
if (startAddressValidateError)
throw new Error(startAddressValidateError);
if (dataType === constant_1.ModbusDataType.Coil)
throw new Error('不支持写入线圈类型数据');
const registerCount = util_1.Util.getRegisterCountByDataType(dataType);
const valueHex = util_1.Util.dataEncode(data, dataType, (options === null || options === void 0 ? void 0 : options.i16) || this.i16Encode, (options === null || options === void 0 ? void 0 : options.i32) || this.i32Encode, (options === null || options === void 0 ? void 0 : options.f32) || this.f32Encode, (options === null || options === void 0 ? void 0 : options.i64) || this.i64Encode, (options === null || options === void 0 ? void 0 : options.f64) || this.f64Encode);
const startAddressHex = startAddress.toString(16).padStart(4, '0');
const registerCountHex = registerCount.toString(16).padStart(4, '0');
const byteCountHex = (registerCount * 2).toString(16).padStart(2, '0');
const cmdHex = '10' + startAddressHex + registerCountHex + byteCountHex + valueHex;
let result = (options === null || options === void 0 ? void 0 : options.lowerCase) ? cmdHex.toLowerCase() : cmdHex.toUpperCase();
if (options === null || options === void 0 ? void 0 : options.separator)
result = util_1.Util.hexSeparator(result, options.separator);
return result;
}
/**
* 根据数据类型写多个保持寄存器——10功能码
* @param startAddress 保持寄存器起始地址
* @param data 数据值
* @param dataType 数据类型
* @param options 生成指令额外参数
* @returns 写入命令——十六进制字符串
*/
static writeMultiHoldByDataTypeCMD(startAddress, data, dataType, options) {
const pdu = new ModbusPDU(options);
return pdu.writeMultiHoldByDataTypeCMD(startAddress, data, dataType, options);
}
/**
* 根据数据列表写多个保持寄存器——10功能码
* @param startAddress 保持寄存器起始地址
* @param dataList 要写入的数据和类型元组的列表
* @param options 生成指令额外参数
* @returns 写入命令——十六进制字符串
*/
writeMultiHoldByDataTypeListCMD(startAddress, dataList, options) {
const startAddressValidateError = validator_1.Validator.startAddress(startAddress);
if (startAddressValidateError)
throw new Error(startAddressValidateError);
let registerCount = 0;
let valueHex = '';
for (const [data, dataType] of dataList) {
if (dataType === constant_1.ModbusDataType.Coil)
throw new Error('不支持写入线圈类型数据');
registerCount += util_1.Util.getRegisterCountByDataType(dataType);
valueHex += util_1.Util.dataEncode(data, dataType, (options === null || options === void 0 ? void 0 : options.i16) || this.i16Encode, (options === null || options === void 0 ? void 0 : options.i32) || this.i32Encode, (options === null || options === void 0 ? void 0 : options.f32) || this.f32Encode, (options === null || options === void 0 ? void 0 : options.i64) || this.i64Encode, (options === null || options === void 0 ? void 0 : options.f64) || this.f64Encode);
}
const startAddressHex = startAddress.toString(16).padStart(4, '0');
const registerCountHex = registerCount.toString(16).padStart(4, '0');
const byteCountHex = (registerCount * 2).toString(16).padStart(2, '0');
const cmdHex = '10' + startAddressHex + registerCountHex + byteCountHex + valueHex;
let result = (options === null || options === void 0 ? void 0 : options.lowerCase) ? cmdHex.toLowerCase() : cmdHex.toUpperCase();
if (options === null || options === void 0 ? void 0 : options.separator)
result = util_1.Util.hexSeparator(result, options.separator);
return result;
}
/**
* 根据数据列表写多个保持寄存器——10功能码
* @param startAddress 保持寄存器起始地址
* @param dataList 要写入的数据和类型元组的列表
* @param options 生成指令额外参数
* @returns 写入命令——十六进制字符串
*/
static writeMultiHoldByDataTypeListCMD(startAddress, dataList, options) {
const pdu = new ModbusPDU(options);
return pdu.writeMultiHoldByDataTypeListCMD(startAddress, dataList, options);
}
//#endregion
//#region 写入（控制）返回解析
/**
* 解析06功能码返回内容
* @param resHex 发送写入单个寄存器（06功能码）指令后modbus从机返回内容，十六进制字符串
* @param startAddress 保持寄存器的地址
* @param valueHex 保持寄存器的值，十六进制字符串格式
* @returns 写入结果
*/
resolveWriteHoldRes(resHex, startAddress, valueHex) {
const startAddressValidateError = validator_1.Validator.startAddress(startAddress);
if (startAddressValidateError)
throw new Error(startAddressValidateError);
this.resCheck('06', resHex);
resHex = resHex.match(/\w/g).join(''); // 去除可能有的分隔符。
const startAddressHex = startAddress.toString(16).padStart(4, '0');
const cmdHex = '06' + startAddressHex + valueHex.match(/\w/g).join('');
return cmdHex.toLowerCase() === resHex.toLowerCase();
}
/**
* 解析06功能码返回内容
* @param resHex 发送写入单个寄存器（06功能码）指令后modbus从机返回内容，十六进制字符串
* @param startAddress 保持寄存器的地址
* @param valueHex 保持寄存器的值，十六进制字符串格式
* @returns 写入结果
*/
static resolveWriteHoldRes(resHex, startAddress, valueHex) {
return new ModbusPDU().resolveWriteHoldRes(resHex, startAddress, valueHex);
}
/**
* 解析06功能码返回内容
* @param resHex 发送写入单个寄存器（06功能码）指令后modbus从机返回内容，十六进制字符串
* @param startAddress 保持寄存器的地址
* @param data 数据值
* @param dataType 数据类型
* @param options 附加参数
* @returns 写入结果
*/
resolveWriteHoldByDataTypeRes(resHex, startAddress, data, dataType, options) {
if (dataType !== constant_1.ModbusDataType.I16 && dataType !== constant_1.ModbusDataType.U16 && dataType !== constant_1.ModbusDataType.S2)
throw new Error('数据类型仅支持Int16、UInt16和两字节字符串');
const startAddressValidateError = validator_1.Validator.startAddress(startAddress);
if (startAddressValidateError)
throw new Error(startAddressValidateError);
this.resCheck('06', resHex);
resHex = resHex.match(/\w/g).join(''); // 去除可能有的分隔符。
const valueHex = util_1.Util.dataEncode(data, dataType, (options === null || options === void 0 ? void 0 : options.i16) || this.i16Encode, (options === null || options === void 0 ? void 0 : options.i32) || this.i32Encode, (options === null || options === void 0 ? void 0 : options.f32) || this.f32Encode, (options === null || options === void 0 ? void 0 : options.i64) || this.i64Encode, (options === null || options === void 0 ? void 0 : options.f64) || this.f64Encode);
const startAddressHex = startAddress.toString(16).padStart(4, '0');
const cmdHex = '06' + startAddressHex + valueHex;
return cmdHex.toLowerCase() === resHex.toLowerCase();
}
/**
* 解析06功能码返回内容
* @param resHex 发送写入单个寄存器（06功能码）指令后modbus从机返回内容，十六进制字符串
* @param startAddress 保持寄存器的地址
* @param data 数据值
* @param dataType 数据类型
* @param options 附加参数
* @returns 写入结果
*/
static resolveWriteHoldByDataTypeRes(resHex, startAddress, data, dataType, options) {
return new ModbusPDU(options).resolveWriteHoldByDataTypeRes(resHex, startAddress, data, dataType, options);
}
/**
* 解析10功能码返回内容
* @param resHex 发送写入多个寄存器（10功能码）指令后modbus从机返回内容，十六进制字符串
* @param options 附加参数
* @returns 元组类型，第一个元素为写入寄存器的地址，第二个元素为写入寄存器的数量
*/
resolveWriteMultiHoldRes(resHex, options) {
this.resCheck('10', resHex);
resHex = resHex.match(/\w/g).join(''); // 去除可能有的分隔符。
const address = util_1.Util.getValueByDataType(resHex.slice(2, 6), constant_1.ModbusDataType.U16, (options === null || options === void 0 ? void 0 : options.i16) || this.i16Encode, (options === null || options === void 0 ? void 0 : options.i32) || this.i32Encode, (options === null || options === void 0 ? void 0 : options.f32) || this.f32Encode, (options === null || options === void 0 ? void 0 : options.i64) || this.i64Encode, (options === null || options === void 0 ? void 0 : options.f64) || this.f64Encode);
const count = util_1.Util.getValueByDataType(resHex.slice(6), constant_1.ModbusDataType.U16, (options === null || options === void 0 ? void 0 : options.i16) || this.i16Encode, (options === null || options === void 0 ? void 0 : options.i32) || this.i32Encode, (options === null || options === void 0 ? void 0 : options.f32) || this.f32Encode, (options === null || options === void 0 ? void 0 : options.i64) || this.i64Encode, (options === null || options === void 0 ? void 0 : options.f64) || this.f64Encode);
return [address, count];
}
/**
* 解析10功能码返回内容
* @param resHex 发送写入多个寄存器（10功能码）指令后modbus从机返回内容，十六进制字符串
* @param options 附加参数
* @returns 元组类型，第一个元素为写入寄存器的地址，第二个元素为写入寄存器的数量
*/
static resolveWriteMultiHoldRes(resHex, options) {
return new ModbusPDU(options).resolveWriteMultiHoldRes(resHex, options);
}
}
exports.ModbusPDU = ModbusPDU;