package com.zy.acs.charge.protocol;
|
|
import com.ghgande.j2mod.modbus.ModbusException;
|
import com.ghgande.j2mod.modbus.io.ModbusTCPTransaction;
|
import com.ghgande.j2mod.modbus.msg.*;
|
import com.ghgande.j2mod.modbus.net.TCPMasterConnection;
|
import com.ghgande.j2mod.modbus.procimg.SimpleRegister;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.beans.factory.annotation.Value;
|
import org.springframework.stereotype.Component;
|
|
import javax.annotation.PostConstruct;
|
import javax.annotation.PreDestroy;
|
import java.net.InetAddress;
|
import java.net.UnknownHostException;
|
import java.util.concurrent.Executors;
|
import java.util.concurrent.ScheduledExecutorService;
|
import java.util.concurrent.TimeUnit;
|
|
/**
|
* 读取Modbus 协议工具类
|
*/
|
@Slf4j
|
@Component
|
public class ModbusAdapter {
|
|
@Value("${charger.modbus.host}")
|
private String host;
|
|
@Value("${charger.modbus.port}")
|
private int port;
|
|
@Value("${charger.modbus.unit-id}")
|
private int unitId;
|
|
@Value("${charger.modbus.connect-timeout:3000}")
|
private int connectTimeout;
|
|
@Value("${charger.modbus.transaction-timeout:5000}")
|
private int transactionTimeout;
|
|
@Value("${charger.modbus.heartbeat.enabled:false}")
|
private boolean heartbeatEnabled;
|
|
@Value("${charger.modbus.heartbeat.interval:30000}")
|
private long heartbeatInterval;
|
|
private TCPMasterConnection connection;
|
private ModbusTCPTransaction transaction;
|
private volatile boolean connected = false;
|
private ScheduledExecutorService heartbeatScheduler;
|
|
@PostConstruct
|
public void init() {
|
try {
|
InetAddress address = InetAddress.getByName(host);
|
connection = new TCPMasterConnection(address);
|
connection.setPort(port);
|
connection.setTimeout(connectTimeout);
|
} catch (UnknownHostException e) {
|
throw new RuntimeException("Invalid Modbus host: " + host, e);
|
}
|
}
|
|
/**
|
* 建立连接
|
*/
|
public synchronized void connect() throws Exception {
|
if (connected) {
|
return;
|
}
|
if (connection == null) {
|
throw new IllegalStateException("Modbus connection not initialized");
|
}
|
connection.connect();
|
transaction = new ModbusTCPTransaction(connection);
|
connected = true;
|
log.info("Modbus TCP connected to {}:{}", host, port);
|
|
if (heartbeatEnabled) {
|
startHeartbeat();
|
}
|
}
|
|
/**
|
* 断开连接
|
*/
|
public synchronized void disconnect() {
|
if (heartbeatScheduler != null && !heartbeatScheduler.isShutdown()) {
|
heartbeatScheduler.shutdownNow();
|
}
|
if (connection != null && connection.isConnected()) {
|
connection.close();
|
}
|
connected = false;
|
log.info("Modbus TCP disconnected");
|
}
|
|
/**
|
* 确保连接可用（内部自动重连）
|
*/
|
private void ensureConnected() throws Exception {
|
if (!connected) {
|
connect();
|
}
|
}
|
|
/**
|
* 读取线圈（功能码01）
|
*/
|
public boolean readCoil(int address) throws Exception {
|
return executeWithRetry(() -> {
|
ensureConnected();
|
ReadCoilsRequest request = new ReadCoilsRequest(address, 1);
|
request.setUnitID(unitId);
|
transaction.setRequest(request);
|
transaction.execute();
|
ReadCoilsResponse response = (ReadCoilsResponse) transaction.getResponse();
|
return response.getCoilStatus(0);
|
});
|
}
|
|
/**
|
* 批量读取线圈（功能码01）
|
*
|
* @param startAddress 起始地址
|
* @param quantity 数量（1~2000）
|
* @return boolean数组，索引从0开始对应起始地址的线圈
|
*/
|
public boolean[] readCoils(int startAddress, int quantity) throws Exception {
|
return executeWithRetry(() -> {
|
ensureConnected();
|
ReadCoilsRequest request = new ReadCoilsRequest(startAddress, quantity);
|
request.setUnitID(unitId);
|
transaction.setRequest(request);
|
transaction.execute();
|
ReadCoilsResponse response = (ReadCoilsResponse) transaction.getResponse();
|
boolean[] result = new boolean[quantity];
|
for (int i = 0; i < quantity; i++) {
|
result[i] = response.getCoilStatus(i);
|
}
|
return result;
|
});
|
}
|
|
|
/**
|
* 写入单个线圈（功能码05）
|
*/
|
public void writeCoil(int address, boolean state) throws Exception {
|
executeWithRetry(() -> {
|
ensureConnected();
|
WriteCoilRequest request = new WriteCoilRequest(address, state);
|
request.setUnitID(unitId);
|
transaction.setRequest(request);
|
transaction.execute();
|
return null;
|
});
|
}
|
|
/**
|
* 读取保持寄存器（功能码03）
|
*/
|
public int readHoldingRegister(int address) throws Exception {
|
return executeWithRetry(() -> {
|
ensureConnected();
|
ReadMultipleRegistersRequest request = new ReadMultipleRegistersRequest(address, 1);
|
request.setUnitID(unitId);
|
transaction.setRequest(request);
|
transaction.execute();
|
ReadMultipleRegistersResponse response = (ReadMultipleRegistersResponse) transaction.getResponse();
|
return response.getRegister(0).getValue();
|
});
|
}
|
|
/**
|
* 写入单个寄存器（功能码06）
|
*/
|
public void writeHoldingRegister(int address, int value) throws Exception {
|
executeWithRetry(() -> {
|
ensureConnected();
|
WriteSingleRegisterRequest request = new WriteSingleRegisterRequest(address, new SimpleRegister(value));
|
request.setUnitID(unitId);
|
transaction.setRequest(request);
|
transaction.execute();
|
return null;
|
});
|
}
|
|
/**
|
* 批量读取多个寄存器
|
*/
|
public int[] readHoldingRegisters(int address, int quantity) throws Exception {
|
return executeWithRetry(() -> {
|
ensureConnected();
|
ReadMultipleRegistersRequest request = new ReadMultipleRegistersRequest(address, quantity);
|
request.setUnitID(unitId);
|
transaction.setRequest(request);
|
transaction.execute();
|
ReadMultipleRegistersResponse response = (ReadMultipleRegistersResponse) transaction.getResponse();
|
int[] values = new int[quantity];
|
for (int i = 0; i < quantity; i++) {
|
values[i] = response.getRegister(i).getValue();
|
}
|
return values;
|
});
|
}
|
|
/**
|
* 带重试的执行器（自动处理网络异常并重连重试）
|
*/
|
private <T> T executeWithRetry(Operation<T> operation) throws Exception {
|
Exception lastException = null;
|
int maxRetries = 3;
|
for (int i = 0; i < maxRetries; i++) {
|
try {
|
return operation.execute();
|
} catch (Exception e) {
|
lastException = e;
|
if (isNetworkException(e)) {
|
log.warn("Modbus network error, retrying {}/{}", i + 1, maxRetries);
|
tryReconnect();
|
} else {
|
// 非网络异常不重试
|
throw e;
|
}
|
try {
|
Thread.sleep(1000);
|
} catch (InterruptedException ignored) {
|
Thread.currentThread().interrupt();
|
throw new Exception("Retry interrupted", e);
|
}
|
}
|
}
|
throw new Exception("Modbus operation failed after " + maxRetries + " retries", lastException);
|
}
|
|
private boolean isNetworkException(Exception e) {
|
return e instanceof java.net.SocketTimeoutException ||
|
e instanceof java.io.IOException ||
|
(e instanceof ModbusException && e.getMessage().toLowerCase().contains("timeout"));
|
}
|
|
private synchronized void tryReconnect() {
|
try {
|
disconnect();
|
connect();
|
} catch (Exception e) {
|
log.error("Reconnect failed", e);
|
}
|
}
|
|
/**
|
* 心跳保活
|
*/
|
private void startHeartbeat() {
|
heartbeatScheduler = Executors.newSingleThreadScheduledExecutor();
|
heartbeatScheduler.scheduleAtFixedRate(() -> {
|
try {
|
// 读取一个无副作用的寄存器，如充电机编号（地址113）
|
int chargerId = readHoldingRegister(113);
|
log.debug("Heartbeat success, chargerId={}", chargerId);
|
} catch (Exception e) {
|
log.warn("Heartbeat failed", e);
|
tryReconnect();
|
}
|
}, heartbeatInterval, heartbeatInterval, TimeUnit.MILLISECONDS);
|
}
|
|
@PreDestroy
|
public void destroy() {
|
disconnect();
|
}
|
|
@FunctionalInterface
|
private interface Operation<T> {
|
T execute() throws Exception;
|
}
|
}
|
