package com.mes.plc.client.impl;
|
|
import com.fasterxml.jackson.core.type.TypeReference;
|
import com.fasterxml.jackson.databind.ObjectMapper;
|
import com.mes.connect.modbus.ModbusTcpClient;
|
import com.mes.device.entity.DeviceConfig;
|
import com.mes.device.util.ConfigJsonHelper;
|
import com.mes.plc.client.PlcClient;
|
import lombok.extern.slf4j.Slf4j;
|
|
import java.io.IOException;
|
import java.util.*;
|
|
/**
|
* Modbus协议PLC客户端实现
|
* <p>
|
* 基于项目中已有的Modbus实现
|
* </p>
|
*
|
* @author huang
|
* @date 2025/12/19
|
*/
|
@Slf4j
|
public class ModbusPlcClient implements PlcClient {
|
|
// PLC IP地址
|
private final String plcIp;
|
|
// PLC端口
|
private final int plcPort;
|
|
// 从站地址
|
private final int unitId;
|
|
// 设备配置
|
private final DeviceConfig device;
|
|
// Modbus客户端实例
|
private ModbusTcpClient modbusClient;
|
|
// 连接状态
|
private boolean connected = false;
|
|
// 超时时间（毫秒）
|
private int timeout = 5000;
|
|
// ObjectMapper用于JSON解析
|
private final ObjectMapper objectMapper = new ObjectMapper();
|
|
// 地址映射缓存：字段名 -> Modbus地址
|
private Map<String, String> addressMappingCache;
|
|
/**
|
* 构造函数
|
*
|
* @param device 设备配置
|
*/
|
public ModbusPlcClient(DeviceConfig device) {
|
this.device = device;
|
this.plcIp = device.getPlcIp();
|
this.plcPort = device.getPlcPort() != null ? device.getPlcPort() : 502;
|
|
// 从配置中获取从站地址，默认1
|
int unitIdValue = 1;
|
try {
|
Map<String, Object> extraParams = parseExtraParams(device.getExtraParams());
|
if (extraParams != null) {
|
Object unitIdObj = extraParams.get("unitId");
|
if (unitIdObj instanceof Number) {
|
unitIdValue = ((Number) unitIdObj).intValue();
|
} else if (unitIdObj instanceof String) {
|
unitIdValue = Integer.parseInt((String) unitIdObj);
|
}
|
}
|
} catch (Exception e) {
|
log.warn("解析unitId失败，使用默认值1: deviceId={}", device.getId(), e);
|
}
|
this.unitId = unitIdValue;
|
|
// 初始化地址映射
|
this.addressMappingCache = loadAddressMapping();
|
}
|
|
/**
|
* 解析设备的extraParams
|
*
|
* @param extraParamsJson extraParams的JSON字符串
|
* @return 解析后的Map
|
*/
|
private Map<String, Object> parseExtraParams(String extraParamsJson) {
|
if (extraParamsJson == null || extraParamsJson.isEmpty()) {
|
return new HashMap<>();
|
}
|
|
try {
|
TypeReference<Map<String, Object>> typeRef = new TypeReference<Map<String, Object>>() {};
|
return objectMapper.readValue(extraParamsJson, typeRef);
|
} catch (Exception e) {
|
log.error("解析extraParams失败: {}", extraParamsJson, e);
|
return new HashMap<>();
|
}
|
}
|
|
/**
|
* 加载地址映射配置（从configJson或extraParams.addressMapping）
|
*
|
* @return 字段名 -> Modbus地址的映射
|
*/
|
private Map<String, String> loadAddressMapping() {
|
Map<String, String> mapping = new HashMap<>();
|
|
try {
|
// 1. 优先从configJson获取
|
Map<String, Object> configParams = ConfigJsonHelper.parseToMap(device.getConfigJson(), objectMapper);
|
if (!configParams.isEmpty()) {
|
for (Map.Entry<String, Object> entry : configParams.entrySet()) {
|
String fieldName = entry.getKey();
|
Object addressObj = entry.getValue();
|
if (addressObj != null) {
|
mapping.put(fieldName, String.valueOf(addressObj));
|
}
|
}
|
if (!mapping.isEmpty()) {
|
log.info("从configJson加载Modbus地址映射成功: deviceId={}, count={}", device.getId(), mapping.size());
|
return mapping;
|
}
|
}
|
|
// 2. 从extraParams.addressMapping获取
|
Map<String, Object> extraParams = parseExtraParams(device.getExtraParams());
|
Object addressMappingObj = extraParams.get("addressMapping");
|
if (addressMappingObj != null) {
|
if (addressMappingObj instanceof Map) {
|
@SuppressWarnings("unchecked")
|
Map<String, Object> addrMap = (Map<String, Object>) addressMappingObj;
|
for (Map.Entry<String, Object> entry : addrMap.entrySet()) {
|
mapping.put(entry.getKey(), String.valueOf(entry.getValue()));
|
}
|
} else if (addressMappingObj instanceof String) {
|
// 如果是JSON字符串，解析它
|
TypeReference<Map<String, Object>> typeRef = new TypeReference<Map<String, Object>>() {};
|
Map<String, Object> addrMap = objectMapper.readValue((String) addressMappingObj, typeRef);
|
for (Map.Entry<String, Object> entry : addrMap.entrySet()) {
|
mapping.put(entry.getKey(), String.valueOf(entry.getValue()));
|
}
|
}
|
if (!mapping.isEmpty()) {
|
log.info("从extraParams.addressMapping加载Modbus地址映射成功: deviceId={}, count={}", device.getId(), mapping.size());
|
return mapping;
|
}
|
}
|
|
log.warn("未找到Modbus地址映射配置: deviceId={}", device.getId());
|
} catch (Exception e) {
|
log.error("加载Modbus地址映射失败: deviceId={}", device.getId(), e);
|
}
|
|
return mapping;
|
}
|
|
/**
|
* 获取字段对应的Modbus地址
|
*
|
* @param fieldName 字段名
|
* @return Modbus地址（格式：功能码.寄存器地址，如 "3.40001"）
|
*/
|
private String getModbusAddress(String fieldName) {
|
String address = addressMappingCache.get(fieldName);
|
if (address == null || address.isEmpty()) {
|
log.warn("字段 {} 未找到Modbus地址映射: deviceId={}", fieldName, device.getId());
|
return null;
|
}
|
return address;
|
}
|
|
/**
|
* 推断数据类型（根据字段名或值）
|
*/
|
private String inferDataType(String fieldName, Object value) {
|
if (value == null) {
|
// 根据字段名推断
|
String lowerName = fieldName.toLowerCase();
|
if (lowerName.contains("float") || lowerName.contains("real")) {
|
return "float";
|
} else if (lowerName.contains("string") || lowerName.contains("str") || lowerName.contains("id")) {
|
return "string";
|
}
|
return "int"; // 默认int
|
}
|
|
// 根据值类型推断
|
if (value instanceof Float || value instanceof Double) {
|
return "float";
|
} else if (value instanceof String) {
|
return "string";
|
} else if (value instanceof Number) {
|
return "int";
|
}
|
return "int";
|
}
|
|
@Override
|
public boolean connect() {
|
try {
|
if (modbusClient != null && isConnected()) {
|
return true;
|
}
|
|
// 创建Modbus客户端实例
|
this.modbusClient = new ModbusTcpClient(this.plcIp, this.plcPort, this.unitId);
|
|
// 连接PLC
|
this.modbusClient.connect();
|
this.connected = true;
|
log.info("Modbus PLC连接成功: {}:{}，从站地址: {}", this.plcIp, this.plcPort, this.unitId);
|
return true;
|
} catch (Exception e) {
|
log.error("Modbus PLC连接失败: {}:{}", this.plcIp, this.plcPort, e);
|
this.connected = false;
|
return false;
|
}
|
}
|
|
@Override
|
public void disconnect() {
|
try {
|
if (this.modbusClient != null) {
|
this.modbusClient.disconnect();
|
log.info("Modbus PLC断开连接: {}:{}", this.plcIp, this.plcPort);
|
}
|
} catch (Exception e) {
|
log.error("Modbus PLC断开连接失败: {}:{}", this.plcIp, this.plcPort, e);
|
} finally {
|
this.connected = false;
|
this.modbusClient = null;
|
}
|
}
|
|
@Override
|
public Map<String, Object> readAllData() {
|
if (!isConnected() && !connect()) {
|
log.error("Modbus PLC未连接，无法读取数据: {}:{}", this.plcIp, this.plcPort);
|
return Collections.emptyMap();
|
}
|
|
try {
|
if (addressMappingCache.isEmpty()) {
|
log.warn("Modbus地址映射为空，无法读取所有数据: deviceId={}", device.getId());
|
return Collections.emptyMap();
|
}
|
|
// 读取所有配置的字段
|
Map<String, Object> result = new HashMap<>();
|
for (String fieldName : addressMappingCache.keySet()) {
|
try {
|
Object value = readFieldValue(fieldName);
|
if (value != null) {
|
result.put(fieldName, value);
|
}
|
} catch (Exception e) {
|
log.warn("读取字段失败: fieldName={}, deviceId={}, error={}", fieldName, device.getId(), e.getMessage());
|
}
|
}
|
|
log.info("Modbus读取所有数据成功: deviceId={}, fieldCount={}", device.getId(), result.size());
|
return result;
|
} catch (Exception e) {
|
log.error("Modbus PLC读取所有数据失败: {}:{}", this.plcIp, this.plcPort, e);
|
this.connected = false;
|
return Collections.emptyMap();
|
}
|
}
|
|
@Override
|
public Map<String, Object> readData(String... fields) {
|
if (!isConnected() && !connect()) {
|
log.error("Modbus PLC未连接，无法读取数据: {}:{}", this.plcIp, this.plcPort);
|
return Collections.emptyMap();
|
}
|
|
if (fields == null || fields.length == 0) {
|
return readAllData();
|
}
|
|
try {
|
Map<String, Object> result = new HashMap<>();
|
for (String fieldName : fields) {
|
if (fieldName == null || fieldName.isEmpty()) {
|
continue;
|
}
|
try {
|
Object value = readFieldValue(fieldName);
|
if (value != null) {
|
result.put(fieldName, value);
|
}
|
} catch (Exception e) {
|
log.warn("读取字段失败: fieldName={}, deviceId={}, error={}", fieldName, device.getId(), e.getMessage());
|
}
|
}
|
|
log.info("Modbus读取指定字段数据成功: deviceId={}, fields={}, resultCount={}",
|
device.getId(), Arrays.toString(fields), result.size());
|
return result;
|
} catch (Exception e) {
|
log.error("Modbus PLC读取数据失败: {}:{}", this.plcIp, this.plcPort, e);
|
this.connected = false;
|
return Collections.emptyMap();
|
}
|
}
|
|
/**
|
* 读取单个字段的值
|
*/
|
private Object readFieldValue(String fieldName) throws IOException {
|
String address = getModbusAddress(fieldName);
|
if (address == null) {
|
return null;
|
}
|
|
// 根据字段名推断数据类型（优先从配置中获取）
|
String dataType = inferDataType(fieldName, null);
|
|
// 从extraParams中获取字段的数据类型配置
|
Map<String, Object> extraParams = parseExtraParams(device.getExtraParams());
|
@SuppressWarnings("unchecked")
|
Map<String, Object> fieldConfigs = (Map<String, Object>) extraParams.get("fieldConfigs");
|
if (fieldConfigs != null) {
|
@SuppressWarnings("unchecked")
|
Map<String, Object> fieldConfig = (Map<String, Object>) fieldConfigs.get(fieldName);
|
if (fieldConfig != null && fieldConfig.get("dataType") != null) {
|
dataType = String.valueOf(fieldConfig.get("dataType"));
|
}
|
}
|
|
// 根据数据类型读取
|
switch (dataType.toLowerCase()) {
|
case "float":
|
case "real":
|
return modbusClient.readFloat(address);
|
case "string":
|
case "str":
|
// 字符串需要指定长度，默认32字符
|
int stringLength = 32;
|
if (fieldConfigs != null) {
|
@SuppressWarnings("unchecked")
|
Map<String, Object> fieldConfig = (Map<String, Object>) fieldConfigs.get(fieldName);
|
if (fieldConfig != null && fieldConfig.get("length") != null) {
|
stringLength = ((Number) fieldConfig.get("length")).intValue();
|
}
|
}
|
return modbusClient.readString(address, stringLength);
|
case "int":
|
case "integer":
|
case "word":
|
default:
|
return modbusClient.readRegister(address);
|
}
|
}
|
|
@Override
|
public boolean writeData(Map<String, Object> data) {
|
if (!isConnected() && !connect()) {
|
log.error("Modbus PLC未连接，无法写入数据: {}:{}", this.plcIp, this.plcPort);
|
return false;
|
}
|
|
if (data == null || data.isEmpty()) {
|
log.warn("写入数据为空，跳过操作: deviceId={}", device.getId());
|
return true;
|
}
|
|
try {
|
int successCount = 0;
|
int failCount = 0;
|
|
for (Map.Entry<String, Object> entry : data.entrySet()) {
|
String fieldName = entry.getKey();
|
Object value = entry.getValue();
|
|
if (value == null) {
|
continue; // 跳过null值
|
}
|
|
try {
|
writeFieldValue(fieldName, value);
|
successCount++;
|
} catch (Exception e) {
|
log.error("写入字段失败: fieldName={}, value={}, deviceId={}, error={}",
|
fieldName, value, device.getId(), e.getMessage());
|
failCount++;
|
}
|
}
|
|
if (failCount > 0) {
|
log.warn("Modbus写入数据部分失败: deviceId={}, success={}, fail={}",
|
device.getId(), successCount, failCount);
|
return false;
|
}
|
|
log.info("Modbus写入数据成功: deviceId={}, fieldCount={}", device.getId(), successCount);
|
return true;
|
} catch (Exception e) {
|
log.error("Modbus PLC写入数据失败: {}:{}", this.plcIp, this.plcPort, e);
|
this.connected = false;
|
return false;
|
}
|
}
|
|
/**
|
* 写入单个字段的值
|
*/
|
private void writeFieldValue(String fieldName, Object value) throws IOException {
|
String address = getModbusAddress(fieldName);
|
if (address == null) {
|
throw new IllegalArgumentException("字段 " + fieldName + " 未找到Modbus地址映射");
|
}
|
|
// 根据值类型推断数据类型
|
String dataType = inferDataType(fieldName, value);
|
|
// 从extraParams中获取字段的数据类型配置
|
Map<String, Object> extraParams = parseExtraParams(device.getExtraParams());
|
@SuppressWarnings("unchecked")
|
Map<String, Object> fieldConfigs = (Map<String, Object>) extraParams.get("fieldConfigs");
|
if (fieldConfigs != null) {
|
@SuppressWarnings("unchecked")
|
Map<String, Object> fieldConfig = (Map<String, Object>) fieldConfigs.get(fieldName);
|
if (fieldConfig != null && fieldConfig.get("dataType") != null) {
|
dataType = String.valueOf(fieldConfig.get("dataType"));
|
}
|
}
|
|
// 根据数据类型写入
|
switch (dataType.toLowerCase()) {
|
case "float":
|
case "real":
|
float floatValue;
|
if (value instanceof Number) {
|
floatValue = ((Number) value).floatValue();
|
} else {
|
floatValue = Float.parseFloat(String.valueOf(value));
|
}
|
modbusClient.writeFloat(address, floatValue);
|
break;
|
case "string":
|
case "str":
|
String stringValue = String.valueOf(value);
|
modbusClient.writeString(address, stringValue);
|
break;
|
case "int":
|
case "integer":
|
case "word":
|
default:
|
int intValue;
|
if (value instanceof Number) {
|
intValue = ((Number) value).intValue();
|
} else {
|
intValue = Integer.parseInt(String.valueOf(value));
|
}
|
modbusClient.writeRegister(address, intValue);
|
break;
|
}
|
}
|
|
@Override
|
public boolean isConnected() {
|
try {
|
if (!this.connected || this.modbusClient == null) {
|
return false;
|
}
|
// 检查连接状态
|
return this.modbusClient.isConnected();
|
} catch (Exception e) {
|
this.connected = false;
|
return false;
|
}
|
}
|
|
@Override
|
public String getPlcType() {
|
return "MODBUS";
|
}
|
|
@Override
|
public int getTimeout() {
|
return this.timeout;
|
}
|
|
@Override
|
public void setTimeout(int timeout) {
|
this.timeout = timeout;
|
}
|
}
|
