在我最近的项目中,我需要与PLC(可编程逻辑控制器)进行交互,使用的是Modbus TCP协议。这种协议广泛用于工业自动化领域,因为它的结构简单且稳定。在开发过程中,我之前用过的是一个静态工具类来处理与PLC的通信。然而,我发现这种静态工具类在使用过程中不够灵活,尤其是在处理需要长时间维持的TCP连接时。
为了改善这个问题,我决定将工具类重新封装成一个Spring Bean。这样做的好处是可以更好地集成到我的Spring应用中,利用Spring的生命周期管理和依赖注入等特性来增强模块的管理和可维护性。
在TCP通信中,粘包和拆包是常见的问题,这可能会导致数据传输中的错误解析。幸运的是,Modbus TCP协议的报文结构帮助我较容易地解决了这些问题。每个Modbus报文都有一个固定长度的头部,包含了重要的控制信息,如事务标识符、协议标识符和长度字段,这些都是处理粘包和拆包问题时的关键。
总的来说,通过将通信工具类封装为Spring Bean,并解决了TCP通信中的粘包和拆包问题,能够更高效地实现与PLC的稳定通信。
Modbus4J的jar包阿里云镜像仓库中没有我们采用最原生的导包方式:
pom.xml 文件
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.ljh</groupId>
<artifactId>modbus</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>modbus</name>
<description>modbus</description>
<properties>
<java.version>1.8</java.version>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<spring-boot.version>2.3.12.RELEASE</spring-boot.version>
</properties>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.3.12.RELEASE</version>
<relativePath/>
</parent>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
<dependency>
<groupId>com.infiniteautomation</groupId>
<artifactId>modbus4j</artifactId>
<version>3.0.3</version>
<scope>system</scope>
<systemPath>${project.basedir}/lib/modbus4j-3.0.3.jar</systemPath>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.12.0</version>
</dependency>
</dependencies>
<build>
<finalName>${project.artifactId}</finalName>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<excludes>
<exclude>
<groupId>org.project lombok</groupId>
<artifactId>lombok</artifactId>
</exclude>
</excludes>
</configuration>
</plugin>
</plugins>
</build>
</project>
ModbusService
package com.ljh.modbus.service;
import com.serotonin.modbus4j.BatchRead;
import com.serotonin.modbus4j.BatchResults;
import com.serotonin.modbus4j.ModbusFactory;
import com.serotonin.modbus4j.ModbusMaster;
import com.serotonin.modbus4j.code.DataType;
import com.serotonin.modbus4j.exception.ErrorResponseException;
import com.serotonin.modbus4j.exception.ModbusInitException;
import com.serotonin.modbus4j.exception.ModbusTransportException;
import com.serotonin.modbus4j.ip.IpParameters;
import com.serotonin.modbus4j.locator.BaseLocator;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import java.util.ArrayList;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
/**
* @Author: ljh
* @Date: 2024/04/12 11:04:00
* @Description: Modbus客户端
**/
@Service
@Slf4j
public class ModbusService {
private ModbusMaster master;
private ScheduledExecutorService scheduledExecutorService = Executors.newSingleThreadScheduledExecutor();
private Integer count = 0;
private Integer time = 10;
/**
* Modbus服务器地址
*/
@Value("${modbus.host}")
private String host;
/**
* Modbus服务器端口号
*/
@Value("${modbus.port}")
private int port;
/**
* 初始化连接
*/
@PostConstruct
public void init() {
setupMaster();
scheduleConnectionCheck();
}
/**
* 获得执行的ModbusMaster对象并赋值给成员变量master
*/
private void setupMaster() {
ModbusFactory factory = new ModbusFactory();
IpParameters parameters = new IpParameters();
parameters.setHost(host);
parameters.setPort(port);
master = factory.createTcpMaster(parameters, true);
master.setTimeout(5000);
master.setRetries(0);
try {
master.init();
time = 10;
count = 0;
log.info("与Modbus服务器的连接初始化成功");
} catch (ModbusInitException e) {
log.error("初始化连接失败", e.getMessage());
}
}
/**
* 心跳包
*/
private void scheduleConnectionCheck() {
// 这里使用了一个定时任务来每分钟检查一次Modbus连接是否正常,如果出现异常则尝试重新初始化连接
scheduledExecutorService.scheduleWithFixedDelay(() -> {
try {
// 这里使用了一个假定的从站ID为1,寄存器地址为0的读取操作作为连接检查
master.getValue(BaseLocator.holdingRegister(1, 0, DataType.TWO_BYTE_INT_UNSIGNED));
} catch (Exception e) {
if (count >= 20) {
log.error("超过连接次数,退出");
return;
}
count++;
time = time + 20;
log.error("连接检查失败,尝试重新连接");
setupMaster();
}
}, 0, time, TimeUnit.SECONDS);
}
/**
* 程序关闭关闭连接
*/
@PreDestroy
public void close() {
if (master != null) {
master.destroy();
}
scheduledExecutorService.shutdown();
log.info("Modbus 连接关闭");
}
/**
* 单个寄存器读取
*
* @param slaveId 站点
* @param offset 位置
* @param dataType 数据类型
* @return
*/
public Number readSingleRegister(int slaveId, int offset, int dataType) {
BaseLocator<Number> locator = BaseLocator.holdingRegister(slaveId, offset, dataType);
try {
return master.getValue(locator);
} catch (ModbusTransportException | ErrorResponseException e) {
e.printStackTrace();
return null;
}
}
/**
* 单个寄存器写入
*
* @param slaveId 站点
* @param offset 位置
* @param value 值
*/
public boolean writeSingleRegister(int slaveId, int offset, int value, int dataType) {
try {
master.setValue(BaseLocator.holdingRegister(slaveId, offset, dataType), value);
return true;
} catch (ModbusTransportException | ErrorResponseException e) {
e.printStackTrace();
return false;
}
}
/**
* 批量读取多个寄存器
*
* @param slaveId 站点
* @param startOffset 开始位置
* @param count 读取数量
* @return
*/
public ArrayList<Integer> readMultipleRegisters(int slaveId, int startOffset, int count, int dataType) {
BatchRead<Integer> batch = new BatchRead<>();
if (dataType == DataType.TWO_BYTE_INT_UNSIGNED) {
// 如果数据类型是2字节的,每个整数占用一个寄存器
for (int i = 0; i < count; i++) {
batch.addLocator(i, BaseLocator.holdingRegister(slaveId, startOffset + i, dataType));
}
} else if (dataType == DataType.FOUR_BYTE_INT_UNSIGNED) {
// 如果数据类型是4字节的,每个整数占用两个寄存器
for (int i = 0; i < count; i++) {
batch.addLocator(2 * i, BaseLocator.holdingRegister(slaveId, startOffset + 2 * i, DataType.TWO_BYTE_INT_UNSIGNED));
batch.addLocator(2 * i + 1, BaseLocator.holdingRegister(slaveId, startOffset + 2 * i + 1, DataType.TWO_BYTE_INT_UNSIGNED));
}
}
try {
BatchResults<Integer> results = master.send(batch);
ArrayList<Integer> integers = new ArrayList<>();
if (dataType == DataType.TWO_BYTE_INT_UNSIGNED) {
for (int i = 0; i < count; i++) {
int value = (int) results.getValue(i);
integers.add(value);
}
} else if (dataType == DataType.FOUR_BYTE_INT_UNSIGNED) {
for (int i = 0; i < count; i++) {
int high = (int) results.getValue(2 * i + 1);
int low = (int) results.getValue(2 * i);
integers.add((high << 16) | (low & 0xFFFF));
}
}
return integers;
} catch (ModbusTransportException | ErrorResponseException e) {
e.printStackTrace();
return null;
}
}
}
Controller 层
package com.ljh.modbus.controller;
import com.ljh.modbus.service.ModbusService;
import com.serotonin.modbus4j.code.DataType;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
/**
* @Author: ljh
* @Date: 2024/4/12 12:11
* @Description:
**/
@RestController
@RequestMapping("/modbus")
public class ModbusTest {
private final ModbusService modbusService;
public ModbusTest(ModbusService modbusService) {
this.modbusService = modbusService;
}
@PostMapping("/single-read")
public Integer singleRead() {
Number number = modbusService.readSingleRegister(1, 0, DataType.TWO_BYTE_INT_UNSIGNED);
System.out.println(number);
return number.intValue();
}
@PostMapping("/single-write")
public boolean singleWrite() {
return modbusService.writeSingleRegister(1, 0, 100, DataType.TWO_BYTE_INT_UNSIGNED);
}
@PostMapping("/multiple-read")
public List<Integer> multipleRead() {
return modbusService.readMultipleRegisters(1, 0, 3, DataType.TWO_BYTE_INT_UNSIGNED);
}
}