基于Java和Spring Boot的Modbus TCP从站模拟器开发

暗茧

1. Modbus TCP从站模拟器概述

在工业自动化领域，Modbus协议是最常用的通信协议之一。作为一名长期从事工业控制系统开发的工程师，我经常需要测试和验证Modbus主站设备的通信功能。为此，我开发了一个基于Java和Spring Boot的Modbus TCP从站模拟器，它可以在同一个端口上模拟多个不同从站ID的设备。

这个模拟器的主要特点包括：

完全遵循Modbus TCP协议规范
支持在同一端口上模拟多个从站设备
与Spring Boot深度集成，支持自动启动和停止
提供REST API接口进行动态管理
完善的日志记录和错误处理机制

2. 项目架构设计

2.1 技术选型与依赖配置

项目采用以下核心技术栈：

Netty：高性能网络通信框架，处理TCP连接和协议解析
Spring Boot：提供依赖注入、配置管理和生命周期控制
Lombok：简化Java代码编写（虽然示例中未展示，但实际项目中推荐使用）

在pom.xml中需要添加以下关键依赖：

xml复制<dependency>
    <groupId>io.netty</groupId>
    <artifactId>netty-all</artifactId>
    <version>4.1.68.Final</version>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>

2.2 配置管理实现

通过Spring Boot的@ConfigurationProperties实现灵活的配置管理：

java复制@ConfigurationProperties(prefix = "modbus.slave")
public class ModbusSlaveProperties {
    private int port = 502;
    private boolean enabled = true;
    private Map<Integer, Integer> slaves = new HashMap<>();
    // getters and setters
}

对应的application.yml配置示例：

yaml复制modbus:
  slave:
    enabled: true
    port: 502
    slaves:
      1: 100
      2: 50
      3: 200

3. 核心功能实现

3.1 Modbus服务启动与停止

服务类使用Spring的生命周期注解管理Netty服务器的启动和停止：

java复制@PostConstruct
public void init() {
    if (!properties.isEnabled()) return;
    
    // 初始化从站设备
    initSlaveDevices();
    
    // 启动Netty服务器
    startModbusServer();
}

@PreDestroy
public void stop() {
    // 优雅关闭Netty资源
    if (serverChannel != null) serverChannel.close();
    if (bossGroup != null) bossGroup.shutdownGracefully();
    if (workerGroup != null) workerGroup.shutdownGracefully();
}

3.2 从站设备管理

模拟器使用ConcurrentHashMap管理多个从站设备，确保线程安全：

java复制private final Map<Integer, SlaveDevice> slaveDevices = new ConcurrentHashMap<>();

public void addSlaveDevice(int slaveId, SlaveDevice device) {
    if (slaveId < 1 || slaveId > 247) {
        throw new IllegalArgumentException("从站ID必须在1-247之间");
    }
    slaveDevices.put(slaveId, device);
}

3.3 Modbus协议处理

核心的协议处理逻辑在ModbusServerHandler中实现：

java复制@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) {
    ByteBuf in = (ByteBuf) msg;
    try {
        // 解析Modbus TCP报文头
        int transactionId = in.readUnsignedShort();
        int protocolId = in.readUnsignedShort();
        int length = in.readUnsignedShort();
        int unitId = in.readUnsignedByte();
        
        // 处理Modbus请求
        byte[] response = processModbusRequest(unitId, functionCode, requestData);
        
        // 发送响应
        if (response != null) {
            sendResponse(ctx, transactionId, unitId, functionCode, response);
        }
    } finally {
        ReferenceCountUtil.release(msg);
    }
}

4. 从站设备实现

4.1 简单从站设备

SimpleSlaveDevice实现了基本的保持寄存器读写功能：

java复制public static class SimpleSlaveDevice implements SlaveDevice {
    private final short[] holdingRegisters;
    
    public SimpleSlaveDevice(int slaveId, int registerCount) {
        this.holdingRegisters = new short[registerCount];
        // 初始化示例数据
        for (int i = 0; i < registerCount; i++) {
            holdingRegisters[i] = (short) (i * 10);
        }
    }
    
    @Override
    public byte[] processRequest(int slaveId, int functionCode, byte[] data) {
        switch (functionCode) {
            case 0x03: return readHoldingRegisters(data);
            case 0x06: return writeSingleRegister(data);
            case 0x10: return writeMultipleRegisters(data);
            default: return createErrorResponse(functionCode, 0x01);
        }
    }
}

4.2 寄存器读写实现

保持寄存器的读写操作实现细节：

java复制private byte[] readHoldingRegisters(byte[] data) {
    int startAddress = ((data[0] & 0xFF) << 8) | (data[1] & 0xFF);
    int quantity = ((data[2] & 0xFF) << 8) | (data[3] & 0xFF);
    
    ByteBuffer buffer = ByteBuffer.allocate(1 + quantity * 2);
    buffer.put((byte) (quantity * 2));
    
    for (int i = 0; i < quantity; i++) {
        buffer.putShort(holdingRegisters[startAddress + i]);
    }
    
    return buffer.array();
}

5. REST管理接口

5.1 控制器设计

提供REST API用于动态管理从站设备：

java复制@RestController
@RequestMapping("/api/modbus")
public class ModbusController {
    @Autowired
    private ModusTcpSlaveService modbusService;
    
    @GetMapping("/slaves")
    public ResponseEntity<Map<String, Object>> getSlaves() {
        // 返回所有从站信息
    }
    
    @PostMapping("/slave")
    public ResponseEntity<Map<String, Object>> addSlave(
            @RequestParam int slaveId,
            @RequestParam int registerCount) {
        // 添加新从站
    }
    
    @DeleteMapping("/slave/{slaveId}")
    public ResponseEntity<Map<String, Object>> removeSlave(
            @PathVariable int slaveId) {
        // 移除从站
    }
}

5.2 服务管理接口

提供Modbus服务的启停管理：

java复制@PostMapping("/restart")
public ResponseEntity<Map<String, Object>> restart() {
    modbusService.restart();
    return ResponseEntity.ok(Collections.singletonMap("message", "Modbus服务重启成功"));
}