package cn.iocoder.yudao.module.iot.gateway.protocol.modbus.tcpserver;
|
|
import cn.hutool.core.util.HexUtil;
|
import cn.hutool.json.JSONObject;
|
import cn.hutool.json.JSONUtil;
|
import cn.iocoder.yudao.module.iot.core.biz.dto.IotDeviceAuthReqDTO;
|
import cn.iocoder.yudao.module.iot.core.enums.modbus.IotModbusFrameFormatEnum;
|
import cn.iocoder.yudao.module.iot.core.util.IotDeviceAuthUtils;
|
import cn.iocoder.yudao.module.iot.gateway.protocol.modbus.common.utils.IotModbusCommonUtils;
|
import cn.iocoder.yudao.module.iot.gateway.protocol.modbus.tcpserver.codec.IotModbusFrame;
|
import cn.iocoder.yudao.module.iot.gateway.protocol.modbus.tcpserver.codec.IotModbusFrameDecoder;
|
import cn.iocoder.yudao.module.iot.gateway.protocol.modbus.tcpserver.codec.IotModbusFrameEncoder;
|
import io.vertx.core.Vertx;
|
import io.vertx.core.buffer.Buffer;
|
import io.vertx.core.net.NetClient;
|
import io.vertx.core.net.NetClientOptions;
|
import io.vertx.core.net.NetSocket;
|
import io.vertx.core.parsetools.RecordParser;
|
import lombok.extern.slf4j.Slf4j;
|
import org.junit.jupiter.api.AfterAll;
|
import org.junit.jupiter.api.BeforeAll;
|
import org.junit.jupiter.api.Disabled;
|
import org.junit.jupiter.api.Test;
|
|
import java.util.concurrent.CompletableFuture;
|
import java.util.concurrent.TimeUnit;
|
|
import static org.junit.jupiter.api.Assertions.assertEquals;
|
|
/**
|
* IoT Modbus TCP Server 协议集成测试 — MODBUS_RTU 帧格式（手动测试）
|
*
|
* <p>测试场景：设备（TCP Client）连接到网关（TCP Server），使用 MODBUS_RTU（CRC16）帧格式通信
|
*
|
* <p>使用步骤：
|
* <ol>
|
* <li>启动 yudao-module-iot-gateway 服务（需开启 modbus-tcp-server 协议，默认端口 503）</li>
|
* <li>确保数据库有对应的 Modbus 设备配置（mode=1, frameFormat=modbus_rtu）</li>
|
* <li>运行以下测试方法：
|
* <ul>
|
* <li>{@link #testAuth()} - 自定义功能码认证</li>
|
* <li>{@link #testPollingResponse()} - 轮询响应</li>
|
* <li>{@link #testPropertySetWrite()} - 属性设置（接收写指令）</li>
|
* </ul>
|
* </li>
|
* </ol>
|
*
|
* @author 芋道源码
|
*/
|
@Slf4j
|
@Disabled
|
public class IotModbusTcpServerRtuIntegrationTest {
|
|
private static final String SERVER_HOST = "127.0.0.1";
|
private static final int SERVER_PORT = 503;
|
private static final int TIMEOUT_MS = 5000;
|
|
private static final int CUSTOM_FC = 65;
|
private static final int SLAVE_ID = 1;
|
|
private static Vertx vertx;
|
private static NetClient netClient;
|
|
// ===================== 编解码器 =====================
|
|
private static final IotModbusFrameDecoder FRAME_DECODER = new IotModbusFrameDecoder(CUSTOM_FC);
|
private static final IotModbusFrameEncoder FRAME_ENCODER = new IotModbusFrameEncoder(CUSTOM_FC);
|
|
// ===================== 设备信息（根据实际情况修改，从 iot_device 表查询） =====================
|
|
private static final String PRODUCT_KEY = "modbus_tcp_server_product_demo";
|
private static final String DEVICE_NAME = "modbus_tcp_server_device_demo_rtu";
|
private static final String DEVICE_SECRET = "af01c55eb8e3424bb23fc6c783936b2e";
|
|
@BeforeAll
|
static void setUp() {
|
vertx = Vertx.vertx();
|
NetClientOptions options = new NetClientOptions()
|
.setConnectTimeout(TIMEOUT_MS)
|
.setIdleTimeout(TIMEOUT_MS);
|
netClient = vertx.createNetClient(options);
|
}
|
|
@AfterAll
|
static void tearDown() {
|
if (netClient != null) {
|
netClient.close();
|
}
|
if (vertx != null) {
|
vertx.close();
|
}
|
}
|
|
// ===================== 认证测试 =====================
|
|
/**
|
* 认证测试：发送自定义功能码 FC65 认证帧（RTU 格式），验证认证成功响应
|
*/
|
@Test
|
public void testAuth() throws Exception {
|
NetSocket socket = connect().get(TIMEOUT_MS, TimeUnit.MILLISECONDS);
|
try {
|
// 1. 构造并发送认证帧
|
IotModbusFrame response = authenticate(socket);
|
|
// 2. 验证响应
|
log.info("[testAuth][认证响应帧: slaveId={}, FC={}, customData={}]",
|
response.getSlaveId(), response.getFunctionCode(), response.getCustomData());
|
JSONObject json = JSONUtil.parseObj(response.getCustomData());
|
assertEquals(0, json.getInt("code"));
|
log.info("[testAuth][认证结果: code={}, message={}]", json.getInt("code"), json.getStr("message"));
|
} finally {
|
socket.close();
|
}
|
}
|
|
// ===================== 轮询响应测试 =====================
|
|
/**
|
* 轮询响应测试：认证后持续监听网关下发的读请求（RTU 格式），每次收到都自动构造读响应帧发回
|
*/
|
@Test
|
public void testPollingResponse() throws Exception {
|
NetSocket socket = connect().get(TIMEOUT_MS, TimeUnit.MILLISECONDS);
|
try {
|
// 1. 先认证
|
IotModbusFrame authResponse = authenticate(socket);
|
log.info("[testPollingResponse][认证响应: {}]", authResponse.getCustomData());
|
JSONObject authJson = JSONUtil.parseObj(authResponse.getCustomData());
|
assertEquals(0, authJson.getInt("code"));
|
|
// 2. 设置持续监听：每收到一个读请求，自动回复
|
log.info("[testPollingResponse][开始持续监听网关下发的读请求...]");
|
CompletableFuture<Void> done = new CompletableFuture<>();
|
// 注意：使用 requestMode=true，因为设备端收到的是网关下发的读请求（非响应）
|
RecordParser parser = FRAME_DECODER.createRecordParser((frame, frameFormat) -> {
|
log.info("[testPollingResponse][收到请求: slaveId={}, FC={}]",
|
frame.getSlaveId(), frame.getFunctionCode());
|
// 解析读请求中的起始地址和数量
|
byte[] pdu = frame.getPdu();
|
int startAddress = ((pdu[0] & 0xFF) << 8) | (pdu[1] & 0xFF);
|
int quantity = ((pdu[2] & 0xFF) << 8) | (pdu[3] & 0xFF);
|
log.info("[testPollingResponse][读请求参数: startAddress={}, quantity={}]", startAddress, quantity);
|
|
// 构造读响应帧（模拟寄存器数据，RTU 格式）
|
int[] registerValues = new int[quantity];
|
for (int i = 0; i < quantity; i++) {
|
registerValues[i] = 100 + i * 100; // 模拟值: 100, 200, 300, ...
|
}
|
byte[] responseData = buildReadResponse(frame.getSlaveId(),
|
frame.getFunctionCode(), registerValues);
|
socket.write(Buffer.buffer(responseData));
|
log.info("[testPollingResponse][已发送读响应, registerValues={}]", registerValues);
|
}, true);
|
socket.handler(parser);
|
|
// 3. 持续等待（200 秒），期间会自动回复所有收到的读请求
|
Thread.sleep(200000);
|
} finally {
|
socket.close();
|
}
|
}
|
|
// ===================== 属性设置测试 =====================
|
|
/**
|
* 属性设置测试：认证后等待接收网关下发的 FC06/FC16 写请求（RTU 格式）
|
* <p>
|
* 注意：需手动在平台触发 property.set
|
*/
|
@Test
|
public void testPropertySetWrite() throws Exception {
|
NetSocket socket = connect().get(TIMEOUT_MS, TimeUnit.MILLISECONDS);
|
try {
|
// 1. 先认证
|
IotModbusFrame authResponse = authenticate(socket);
|
log.info("[testPropertySetWrite][认证响应: {}]", authResponse.getCustomData());
|
|
// 2. 等待网关下发写请求（需手动在平台触发 property.set）
|
log.info("[testPropertySetWrite][等待网关下发写请求（请在平台触发 property.set）...]");
|
IotModbusFrame writeRequest = waitForRequest(socket);
|
log.info("[testPropertySetWrite][收到写请求: slaveId={}, FC={}, pdu={}]",
|
writeRequest.getSlaveId(), writeRequest.getFunctionCode(),
|
HexUtil.encodeHexStr(writeRequest.getPdu()));
|
} finally {
|
socket.close();
|
}
|
}
|
|
// ===================== 辅助方法 =====================
|
|
/**
|
* 建立 TCP 连接
|
*/
|
private CompletableFuture<NetSocket> connect() {
|
CompletableFuture<NetSocket> future = new CompletableFuture<>();
|
netClient.connect(SERVER_PORT, SERVER_HOST)
|
.onSuccess(future::complete)
|
.onFailure(future::completeExceptionally);
|
return future;
|
}
|
|
/**
|
* 执行认证并返回响应帧
|
*/
|
private IotModbusFrame authenticate(NetSocket socket) throws Exception {
|
IotDeviceAuthReqDTO authInfo = IotDeviceAuthUtils.getAuthInfo(PRODUCT_KEY, DEVICE_NAME, DEVICE_SECRET);
|
authInfo.setClientId("");
|
byte[] authFrame = buildAuthFrame(authInfo.getClientId(), authInfo.getUsername(), authInfo.getPassword());
|
return sendAndReceive(socket, authFrame);
|
}
|
|
/**
|
* 发送帧并等待响应（使用 IotModbusFrameDecoder 自动检测帧格式并解码）
|
*/
|
private IotModbusFrame sendAndReceive(NetSocket socket, byte[] frameData) throws Exception {
|
CompletableFuture<IotModbusFrame> responseFuture = new CompletableFuture<>();
|
// 使用 FrameDecoder 创建拆包器（自动检测帧格式 + 解码，直接回调 IotModbusFrame）
|
RecordParser parser = FRAME_DECODER.createRecordParser(
|
(frame, frameFormat) -> {
|
try {
|
log.info("[sendAndReceive][检测到帧格式: {}]", frameFormat);
|
responseFuture.complete(frame);
|
} catch (Exception e) {
|
responseFuture.completeExceptionally(e);
|
}
|
});
|
socket.handler(parser);
|
|
// 发送请求
|
log.info("[sendAndReceive][发送帧, 长度={}]", frameData.length);
|
socket.write(Buffer.buffer(frameData));
|
|
// 等待响应
|
return responseFuture.get(TIMEOUT_MS, TimeUnit.MILLISECONDS);
|
}
|
|
/**
|
* 等待接收网关下发的请求帧（不发送，只等待接收）
|
*/
|
private IotModbusFrame waitForRequest(NetSocket socket) throws Exception {
|
CompletableFuture<IotModbusFrame> requestFuture = new CompletableFuture<>();
|
// 使用 FrameDecoder 创建拆包器（直接回调 IotModbusFrame）
|
RecordParser parser = FRAME_DECODER.createRecordParser(
|
(frame, frameFormat) -> {
|
try {
|
log.info("[waitForRequest][检测到帧格式: {}]", frameFormat);
|
requestFuture.complete(frame);
|
} catch (Exception e) {
|
requestFuture.completeExceptionally(e);
|
}
|
});
|
socket.handler(parser);
|
|
// 等待（超时 30 秒，因为轮询间隔可能比较长）
|
return requestFuture.get(30000, TimeUnit.MILLISECONDS);
|
}
|
|
/**
|
* 构造认证帧（MODBUS_RTU 格式）
|
* <p>
|
* JSON: {"method":"auth","params":{"clientId":"...","username":"...","password":"..."}}
|
* <p>
|
* RTU 帧格式：[SlaveId(1)] [FC=0x41(1)] [ByteCount(1)] [JSON(N)] [CRC16(2)]
|
*/
|
private byte[] buildAuthFrame(String clientId, String username, String password) {
|
JSONObject params = new JSONObject();
|
params.set("clientId", clientId);
|
params.set("username", username);
|
params.set("password", password);
|
JSONObject json = new JSONObject();
|
json.set("method", "auth");
|
json.set("params", params);
|
return FRAME_ENCODER.encodeCustomFrame(SLAVE_ID, json.toString(),
|
IotModbusFrameFormatEnum.MODBUS_RTU, 0);
|
}
|
|
/**
|
* 构造 FC03/FC01-04 读响应帧（MODBUS_RTU 格式）
|
* <p>
|
* RTU 帧格式：[SlaveId(1)] [FC(1)] [ByteCount(1)] [RegisterData(N*2)] [CRC16(2)]
|
*/
|
private byte[] buildReadResponse(int slaveId, int functionCode, int[] registerValues) {
|
int byteCount = registerValues.length * 2;
|
// 帧长度：SlaveId(1) + FC(1) + ByteCount(1) + Data(N*2) + CRC(2)
|
int totalLength = 1 + 1 + 1 + byteCount + 2;
|
byte[] frame = new byte[totalLength];
|
frame[0] = (byte) slaveId;
|
frame[1] = (byte) functionCode;
|
frame[2] = (byte) byteCount;
|
for (int i = 0; i < registerValues.length; i++) {
|
frame[3 + i * 2] = (byte) ((registerValues[i] >> 8) & 0xFF);
|
frame[3 + i * 2 + 1] = (byte) (registerValues[i] & 0xFF);
|
}
|
// 计算 CRC16
|
int crc = IotModbusCommonUtils.calculateCrc16(frame, totalLength - 2);
|
frame[totalLength - 2] = (byte) (crc & 0xFF); // CRC Low
|
frame[totalLength - 1] = (byte) ((crc >> 8) & 0xFF); // CRC High
|
return frame;
|
}
|
|
}
|
