package cn.iocoder.yudao.module.iot.gateway.protocol.modbus.common.utils;
|
|
import cn.iocoder.yudao.module.iot.core.biz.dto.IotModbusPointRespDTO;
|
import cn.iocoder.yudao.module.iot.gateway.protocol.modbus.tcpclient.manager.IotModbusTcpClientConnectionManager;
|
import com.ghgande.j2mod.modbus.io.ModbusTCPTransaction;
|
import com.ghgande.j2mod.modbus.msg.*;
|
import com.ghgande.j2mod.modbus.procimg.InputRegister;
|
import com.ghgande.j2mod.modbus.procimg.Register;
|
import com.ghgande.j2mod.modbus.procimg.SimpleRegister;
|
import com.ghgande.j2mod.modbus.util.BitVector;
|
import io.vertx.core.Future;
|
import lombok.experimental.UtilityClass;
|
import lombok.extern.slf4j.Slf4j;
|
|
import static cn.iocoder.yudao.module.iot.gateway.protocol.modbus.common.utils.IotModbusCommonUtils.*;
|
|
/**
|
* IoT Modbus TCP 客户端工具类
|
* <p>
|
* 封装基于 j2mod 的 Modbus TCP 读写操作：
|
* 1. 根据功能码创建对应的 Modbus 读/写请求
|
* 2. 通过 {@link IotModbusTcpClientConnectionManager.ModbusConnection} 执行事务
|
* 3. 从响应中提取原始值
|
*
|
* @author 芋道源码
|
*/
|
@UtilityClass
|
@Slf4j
|
public class IotModbusTcpClientUtils {
|
|
/**
|
* 读取 Modbus 数据
|
*
|
* @param connection Modbus 连接
|
* @param slaveId 从站地址
|
* @param point 点位配置
|
* @return 原始值（int 数组）
|
*/
|
public static Future<int[]> read(IotModbusTcpClientConnectionManager.ModbusConnection connection,
|
Integer slaveId,
|
IotModbusPointRespDTO point) {
|
return read(connection, slaveId, point.getFunctionCode(),
|
point.getRegisterAddress(), point.getRegisterCount(), point.getIdentifier());
|
}
|
|
/**
|
* 读取 Modbus 数据
|
*
|
* @param connection Modbus 连接
|
* @param slaveId 从站地址
|
* @param functionCode 功能码
|
* @param registerAddress 寄存器起始地址
|
* @param registerCount 寄存器数量
|
* @return 原始值（int 数组）
|
*/
|
public static Future<int[]> read(IotModbusTcpClientConnectionManager.ModbusConnection connection,
|
Integer slaveId,
|
Integer functionCode,
|
Integer registerAddress,
|
Integer registerCount) {
|
return read(connection, slaveId, functionCode, registerAddress, registerCount, null);
|
}
|
|
private static Future<int[]> read(IotModbusTcpClientConnectionManager.ModbusConnection connection,
|
Integer slaveId,
|
Integer functionCode,
|
Integer registerAddress,
|
Integer registerCount,
|
String identifier) {
|
return connection.executeBlocking(tcpConnection -> {
|
try {
|
// 1. 创建请求
|
ModbusRequest request = createReadRequest(functionCode, registerAddress, registerCount);
|
request.setUnitID(slaveId);
|
|
// 2. 执行事务（请求）
|
ModbusTCPTransaction transaction = new ModbusTCPTransaction(tcpConnection);
|
transaction.setRequest(request);
|
transaction.execute();
|
|
// 3. 解析响应
|
ModbusResponse response = transaction.getResponse();
|
return extractValues(response, functionCode);
|
} catch (Exception e) {
|
throw new RuntimeException(String.format("Modbus 读取失败 [slaveId=%d, identifier=%s, functionCode=%d, address=%d, count=%d]",
|
slaveId, identifier, functionCode, registerAddress, registerCount), e);
|
}
|
});
|
}
|
|
/**
|
* 写入 Modbus 数据
|
*
|
* @param connection Modbus 连接
|
* @param slaveId 从站地址
|
* @param point 点位配置
|
* @param values 要写入的值
|
* @return 是否成功
|
*/
|
public static Future<Boolean> write(IotModbusTcpClientConnectionManager.ModbusConnection connection,
|
Integer slaveId,
|
IotModbusPointRespDTO point,
|
int[] values) {
|
return connection.executeBlocking(tcpConnection -> {
|
try {
|
// 1. 创建请求
|
ModbusRequest request = createWriteRequest(point.getFunctionCode(),
|
point.getRegisterAddress(), point.getRegisterCount(), values);
|
if (request == null) {
|
throw new RuntimeException("功能码 " + point.getFunctionCode() + " 不支持写操作");
|
}
|
request.setUnitID(slaveId);
|
|
// 2. 执行事务（请求）
|
ModbusTCPTransaction transaction = new ModbusTCPTransaction(tcpConnection);
|
transaction.setRequest(request);
|
transaction.execute();
|
return true;
|
} catch (Exception e) {
|
throw new RuntimeException(String.format("Modbus 写入失败 [slaveId=%d, identifier=%s, address=%d]",
|
slaveId, point.getIdentifier(), point.getRegisterAddress()), e);
|
}
|
});
|
}
|
|
/**
|
* 创建读取请求
|
*/
|
@SuppressWarnings("EnhancedSwitchMigration")
|
private static ModbusRequest createReadRequest(Integer functionCode, Integer address, Integer count) {
|
switch (functionCode) {
|
case FC_READ_COILS:
|
return new ReadCoilsRequest(address, count);
|
case FC_READ_DISCRETE_INPUTS:
|
return new ReadInputDiscretesRequest(address, count);
|
case FC_READ_HOLDING_REGISTERS:
|
return new ReadMultipleRegistersRequest(address, count);
|
case FC_READ_INPUT_REGISTERS:
|
return new ReadInputRegistersRequest(address, count);
|
default:
|
throw new IllegalArgumentException("不支持的功能码: " + functionCode);
|
}
|
}
|
|
/**
|
* 创建写入请求
|
*/
|
@SuppressWarnings("EnhancedSwitchMigration")
|
private static ModbusRequest createWriteRequest(Integer functionCode, Integer address, Integer count, int[] values) {
|
switch (functionCode) {
|
case FC_READ_COILS: // 写线圈（使用功能码 5 或 15）
|
if (count == 1) {
|
return new WriteCoilRequest(address, values[0] != 0);
|
} else {
|
BitVector bv = new BitVector(count);
|
for (int i = 0; i < Math.min(values.length, count); i++) {
|
bv.setBit(i, values[i] != 0);
|
}
|
return new WriteMultipleCoilsRequest(address, bv);
|
}
|
case FC_READ_HOLDING_REGISTERS: // 写保持寄存器（使用功能码 6 或 16）
|
if (count == 1) {
|
return new WriteSingleRegisterRequest(address, new SimpleRegister(values[0]));
|
} else {
|
Register[] registers = new SimpleRegister[count];
|
for (int i = 0; i < count; i++) {
|
registers[i] = new SimpleRegister(i < values.length ? values[i] : 0);
|
}
|
return new WriteMultipleRegistersRequest(address, registers);
|
}
|
case FC_READ_DISCRETE_INPUTS: // 只读
|
case FC_READ_INPUT_REGISTERS: // 只读
|
return null;
|
default:
|
throw new IllegalArgumentException("不支持的功能码: " + functionCode);
|
}
|
}
|
|
/**
|
* 从响应中提取值
|
*/
|
@SuppressWarnings("EnhancedSwitchMigration")
|
private static int[] extractValues(ModbusResponse response, Integer functionCode) {
|
switch (functionCode) {
|
case FC_READ_COILS:
|
ReadCoilsResponse coilsResponse = (ReadCoilsResponse) response;
|
int bitCount = coilsResponse.getBitCount();
|
int[] coilValues = new int[bitCount];
|
for (int i = 0; i < bitCount; i++) {
|
coilValues[i] = coilsResponse.getCoilStatus(i) ? 1 : 0;
|
}
|
return coilValues;
|
case FC_READ_DISCRETE_INPUTS:
|
ReadInputDiscretesResponse discretesResponse = (ReadInputDiscretesResponse) response;
|
int discreteCount = discretesResponse.getBitCount();
|
int[] discreteValues = new int[discreteCount];
|
for (int i = 0; i < discreteCount; i++) {
|
discreteValues[i] = discretesResponse.getDiscreteStatus(i) ? 1 : 0;
|
}
|
return discreteValues;
|
case FC_READ_HOLDING_REGISTERS:
|
ReadMultipleRegistersResponse holdingResponse = (ReadMultipleRegistersResponse) response;
|
InputRegister[] holdingRegisters = holdingResponse.getRegisters();
|
int[] holdingValues = new int[holdingRegisters.length];
|
for (int i = 0; i < holdingRegisters.length; i++) {
|
holdingValues[i] = holdingRegisters[i].getValue();
|
}
|
return holdingValues;
|
case FC_READ_INPUT_REGISTERS:
|
ReadInputRegistersResponse inputResponse = (ReadInputRegistersResponse) response;
|
InputRegister[] inputRegisters = inputResponse.getRegisters();
|
int[] inputValues = new int[inputRegisters.length];
|
for (int i = 0; i < inputRegisters.length; i++) {
|
inputValues[i] = inputRegisters[i].getValue();
|
}
|
return inputValues;
|
default:
|
throw new IllegalArgumentException("不支持的功能码: " + functionCode);
|
}
|
}
|
|
}
|
