1 使用 modbus4j + juc 实现 读取老化柜和老化层状态--测试中

zhmes-agecal-admin/src/main/java/com/zehong/web/controller/equipment/TestTaskController.java

+package com.zehong.web.controller.equipment;
+
+import com.serotonin.modbus4j.ModbusMaster;
+import com.serotonin.modbus4j.exception.ErrorResponseException;
+import com.serotonin.modbus4j.exception.ModbusInitException;
+import com.serotonin.modbus4j.exception.ModbusTransportException;
+import com.zehong.framework.modbus4j.Modbus4jUtils;
+import com.zehong.system.domain.TEquipmentAlarmData;
+import com.zehong.system.domain.TEquipmentInfo;
+import com.zehong.system.domain.modbus.ModbusDeviceData;
+import com.zehong.system.service.ITEquipmentAlarmDataService;
+import com.zehong.system.service.ITEquipmentInfoService;
+import com.zehong.web.task.AgingCabinetInspectionAndPowerCheckTask;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.context.request.async.DeferredResult;
+
+import javax.annotation.Resource;
+import java.util.*;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.stream.Collectors;
+
+/**
+ * @author lenovo
+ * @date 2025/6/11
+ * @description 测试定时任务的接口，每次调用都能实时显示
+ */
+@RestController
+@RequestMapping("/testTaskController")
+public class TestTaskController {
+
+    private static final Logger log = LoggerFactory.getLogger(AgingCabinetInspectionAndPowerCheckTask.class);
+    private final ExecutorService executor = Executors.newFixedThreadPool(10);
+    @Resource
+    private ITEquipmentInfoService tEquipmentInfoService;
+
+    @Resource
+    private ITEquipmentAlarmDataService tEquipmentAlarmDataService;
+
+    /**
+     * 五分钟一次
+     * 1.老化柜、标定柜巡查
+     * 2.老化层断电
+     * 这种方式先注释掉
+     * //            for (TEquipmentInfo equipmentInfo : equipmentInfos) {
+     * //                Future<Map<Integer, Object>> future = executor.submit(new ModbusTcpTask(equipmentInfo, registerOffset));
+     * //                futures.add(future);
+     * //            }
+     * //            List<ModbusDeviceData> results = new ArrayList<>();
+     * //
+     * //            for (int i = 0; i < futures.size(); i++) {
+     * //                Map<Integer, Object> data = futures.get(i).get();
+     * //                ModbusDeviceData deviceData = new ModbusDeviceData();
+     * //                deviceData.setDeviceId(equipmentInfos.get(i).getfEquipmentId().toString());
+     * //                deviceData.setRegisterValues(data.entrySet().stream()
+     * //                        .collect(Collectors.toMap(Map.Entry::getKey, e -> e.getValue().toString())));
+     * //                results.add(deviceData);
+     * //            }
+     */
+    @GetMapping("/getAgingCabinetAndPowerCheck")
+    public DeferredResult<List<ModbusDeviceData>> getAgingCabinetAndPowerCheck() {
+
+        List<String> type = new ArrayList<>();
+        type.add("1");
+        type.add("2");
+        List<TEquipmentInfo> equipmentInfos = tEquipmentInfoService.selectTEquipmentList(type);
+
+        DeferredResult<List<ModbusDeviceData>> deferredResult = new DeferredResult<>();
+        TEquipmentAlarmData alarmData = new TEquipmentAlarmData();
+
+        try {
+            if (equipmentInfos.size() == 0) {
+                log.error("设备列表查询结果为空");
+                throw new Exception("无设备信息！");
+            }
+            List<CompletableFuture<ModbusDeviceData>> futures = equipmentInfos.stream().map(equipmentInfo -> CompletableFuture.supplyAsync(() -> {
+                ModbusMaster master = null;
+                // 构造结果对象
+                ModbusDeviceData deviceData;
+                // 10 层
+                List<Integer> registerOffsets = Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
+                try {
+                    master = Modbus4jUtils.getMaster(equipmentInfo.getfIp(), equipmentInfo.getfPort());
+                    Map<Integer, Object> integerObjectMap = Modbus4jUtils.batchReadAgingCabinetStatus(master, registerOffsets);
+
+                    // 返回结果
+                    return createErrorData(equipmentInfo,"","",integerObjectMap);
+
+                } catch (ModbusInitException e) {
+                    // 记录异常数据
+                    alarmData.setfAlarmType("01"); //01.老化柜 02.机械臂 03.老化层 04.点位
+                    alarmData.setfEquipmentCode(equipmentInfo.getfEquipmentCode());
+                    alarmData.setfAlarmData("定时任务巡检:Modbus初始化失败");
+                    tEquipmentAlarmDataService.insertTEquipmentAlarmData(alarmData);
+                    // 更新老化柜状态（“0”空闲，“1”运行，“2”故障）
+                    equipmentInfo.setfStatus("2");
+                    tEquipmentInfoService.updateTEquipmentInfo(equipmentInfo);
+
+                    // 返回错误信息
+                    Map<Integer, Object> errorMap = new HashMap<>();
+                    // 返回结果
+                    return createErrorData(equipmentInfo,"2","Modbus初始化失败",errorMap);
+                    // 层有错误返回 柜可能连不上也在这个报错里面
+                } catch (ModbusTransportException e) {
+                    // 网线没插好通讯不上
+                    if(e.getMessage().equals("java.net.SocketTimeoutException: connect timed out")) {
+                        // 记录异常数据
+                        alarmData.setfAlarmType("01"); //01.老化柜 02.机械臂 03.老化层 04.点位
+                        alarmData.setfEquipmentCode(equipmentInfo.getfEquipmentCode());
+                        alarmData.setfAlarmData("定时任务巡检:老化柜网线没插好");
+                    // 线接错误
+                    } else {
+                        // 记录异常数据
+                        alarmData.setfAlarmType("01"); //01.老化柜 02.机械臂 03.老化层 04.点位
+                        alarmData.setfEquipmentCode(equipmentInfo.getfEquipmentCode());
+                        alarmData.setfAlarmData("定时任务巡检:老化柜通信线路没接好");
+                    }
+                    tEquipmentAlarmDataService.insertTEquipmentAlarmData(alarmData);
+                    // 更新老化柜状态（“0”空闲，“1”运行，“2”故障）
+                    equipmentInfo.setfStatus("2");
+                    tEquipmentInfoService.updateTEquipmentInfo(equipmentInfo);
+
+                    Map<Integer, Object> errorMap = new HashMap<>();
+                    // 网线没插好通讯不上
+                    // 返回结果
+                    if(e.getMessage().equals("java.net.SocketTimeoutException: connect timed out")) {
+                        return createErrorData(equipmentInfo,"2","网线没插好",errorMap);
+                    } else {
+                        // 线接错误
+                        // 返回结果
+                        return createErrorData(equipmentInfo,"2","通信线路没接好",errorMap);
+                    }
+                } catch (ErrorResponseException e) {
+                    Map<Integer, Object> errorMap = new HashMap<>();
+                    // 返回结果
+                    return createErrorData(equipmentInfo,"2","ErrorResponseException",errorMap);
+                } finally {
+                    if (master != null) {
+                        master.destroy();
+                    }
+                }
+            }, executor)).collect(Collectors.toList());
+
+            // 等待所有任务完成并收集结果
+            CompletableFuture<List<ModbusDeviceData>> listCompletableFuture = CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]))
+                    .thenApply(v -> futures.stream()
+                            .map(CompletableFuture::join)
+                            .collect(Collectors.toList()));
+            // 处理 老化柜 是 运行 开始 空闲
+            CompletableFuture<List<ModbusDeviceData>> processedFuture = listCompletableFuture.thenApply(this::processDeviceData);
+
+            processedFuture.whenComplete((result, ex) -> {
+                if (ex != null) {
+                    deferredResult.setErrorResult(Collections.singletonList(createErrorData(ex)));
+                } else {
+                    deferredResult.setResult(result);
+                }
+            });
+
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return deferredResult;
+    }
+
+    private ModbusDeviceData createErrorData(TEquipmentInfo equipmentInfo,String status,
+                                             String errorReason,Map<Integer, Object> integerObjectMap) {
+        ModbusDeviceData deviceData = new ModbusDeviceData();
+        deviceData.setfIp(equipmentInfo.getfIp());
+        deviceData.setfPort(equipmentInfo.getfPort());
+        deviceData.setDeviceCode(equipmentInfo.getfEquipmentCode());
+        deviceData.setDeviceStatus(status);
+        deviceData.setErrorReason(errorReason);
+        if(integerObjectMap != null){
+            deviceData.setRegisterValues(integerObjectMap.entrySet().stream()
+                    .collect(Collectors.toMap(
+                            Map.Entry::getKey,
+                            e -> e.getValue() != null ? e.getValue().toString() : "NULL"
+                    )));
+        }
+        return deviceData;
+    }
+
+    //  处理 老化柜 是 运行 开始 空闲
+    private List<ModbusDeviceData> processDeviceData(List<ModbusDeviceData> deviceDataList) {
+        for (ModbusDeviceData modbusDeviceData : deviceDataList) {
+            Map<Integer, String> registerValues = modbusDeviceData.getRegisterValues();
+            boolean isRun = false;
+            for (Map.Entry<Integer, String> entry : registerValues.entrySet()) {
+                Integer registerOffset = entry.getKey();
+                String registerValue = entry.getValue();
+                if ("true".equals(registerValue)) {
+                    isRun = true;
+                    // 要给这个 层 发断电的  指令
+                } else {
+                    try {
+                        ModbusMaster master = Modbus4jUtils.getMaster(modbusDeviceData.getfIp(), modbusDeviceData.getfPort());
+                        Modbus4jUtils.writeCoil(master, 1, registerOffset, false);
+                    } catch (ModbusInitException | ModbusTransportException e) {
+                        throw new RuntimeException(e);
+                    }
+                }
+            }
+            if(isRun) {
+                modbusDeviceData.setDeviceStatus("1");
+            } else {
+                modbusDeviceData.setDeviceStatus("0");
+            }
+        }
+        return deviceDataList;
+    }
+
+    private ModbusDeviceData createErrorData(Throwable ex) {
+        ModbusDeviceData errorData = new ModbusDeviceData();
+        errorData.setDeviceCode("error");
+        errorData.setRegisterValues(Collections.singletonMap(0, "系统错误：" + ex.getMessage()));
+        return errorData;
+    }
+}

zhmes-agecal-admin/src/main/java/com/zehong/web/task/AgingCabinetInspectionAndPowerCheckTask.java

@@ -61,23 +61,23 @@ public class AgingCabinetInspectionAndPowerCheckTask {
         type.add("2");
         List<TEquipmentInfo> equipmentInfos = tEquipmentInfoService.selectTEquipmentList(type);
 
-        try {
-            if (equipmentInfos.size() == 0) {
-                log.error("设备列表查询结果为空");
-                throw new Exception("无设备信息！");
-            }
-
-            // 10 层
+//        try {
+//            if (equipmentInfos.size() == 0) {
+//                log.error("设备列表查询结果为空");
+//                throw new Exception("无设备信息！");
+//            }
+//
+//            // 10 层
 //            List<Integer> registerOffset = Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
 //
 //            List<CompletableFuture<ModbusDeviceData>> futures = equipmentInfos.stream().map(equipmentInfo -> CompletableFuture.supplyAsync(() -> {
 //                ModbusMaster master = null;
 //                try {
 //                    master = Modbus4jUtils.getMaster(equipmentInfo.getfIp(), equipmentInfo.getfPort());
-//                    Map<Integer, Object> integerObjectMap = Modbus4jUtils.batchReadAgingCabinet(master, registerOffset);
+//                    Map<Integer, Object> integerObjectMap = Modbus4jUtils.batchReadAgingCabinetStatus(master, registerOffset);
 //                    // 构造结果对象
 //                    ModbusDeviceData deviceData = new ModbusDeviceData();
-//                    deviceData.setDeviceId(equipmentInfo.getfEquipmentId().toString());
+//                    deviceData.setDeviceCode(equipmentInfo.getfEquipmentCode());
 //                    deviceData.setRegisterValues(integerObjectMap.entrySet().stream()
 //                            .collect(Collectors.toMap(
 //                                    Map.Entry::getKey,
@@ -92,7 +92,7 @@ public class AgingCabinetInspectionAndPowerCheckTask {
 //                    Map<Integer, String> errorMap = new HashMap<>();
 //
 //                    ModbusDeviceData deviceData = new ModbusDeviceData();
-//                    deviceData.setDeviceId("");
+//                    deviceData.setDeviceCode("");
 //                    deviceData.setRegisterValues(errorMap);
 //
 //                    return deviceData;
@@ -102,7 +102,7 @@ public class AgingCabinetInspectionAndPowerCheckTask {
 //                    registerOffset.forEach(offset -> errorMap.put(offset, "ERROR: " + e.getMessage()));
 //
 //                    ModbusDeviceData deviceData = new ModbusDeviceData();
-//                    deviceData.setDeviceId(equipmentInfo.getfEquipmentId().toString());
+//                    deviceData.setDeviceCode(equipmentInfo.getfEquipmentCode());
 //                    deviceData.setRegisterValues(errorMap);
 //
 //                    return deviceData;
@@ -128,15 +128,15 @@ public class AgingCabinetInspectionAndPowerCheckTask {
 //                    deferredResult.setResult(result);
 //                }
 //            });
-
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
+//
+//        } catch (Exception e) {
+//            e.printStackTrace();
+//        }
     }
 
     private ModbusDeviceData createErrorData(Throwable ex) {
         ModbusDeviceData errorData = new ModbusDeviceData();
-        errorData.setDeviceId("error");
+        errorData.setDeviceCode("error");
         errorData.setRegisterValues(Collections.singletonMap(0, "系统错误：" + ex.getMessage()));
         return errorData;
     }

zhmes-agecal-framework/src/main/java/com/zehong/framework/modbus4j/Modbus4jUtils.java

@@ -14,6 +14,7 @@ import com.serotonin.modbus4j.msg.*;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import java.util.Arrays;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -22,6 +23,7 @@ import java.util.Map;
  * modbus通讯工具类,采用modbus4j实现
  *
  */
+@SuppressWarnings(value = "all")
 public class Modbus4jUtils {
 
     private static final Logger log = LoggerFactory.getLogger(Modbus4jUtils.class);
@@ -196,10 +198,32 @@ public class Modbus4jUtils {
             throws ModbusTransportException, ErrorResponseException, ModbusInitException {
         // 04 Input Registers类型数据读取
         BaseLocator<Number> loc = BaseLocator.inputRegister(slaveId, offset, dataType);
-        Number value = getMaster().getValue(loc);
+        Number value = master.getValue(loc);
         return value;
     }
 
+    /**
+     * 读老化柜的 10层数据
+     * @param master
+     * @return
+     * @throws ModbusTransportException
+     * @throws ErrorResponseException
+     * @throws ModbusInitException
+     */
+    public static Map<Integer, Object>  readInputRegistersForAgeng(ModbusMaster master)
+            throws ModbusTransportException, ErrorResponseException {
+        // 10 层
+        List<Integer> registerOffsets = Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
+        Map<Integer, Object> result = new HashMap<>();
+        for (Integer registerOffset : registerOffsets) {
+            // 04 Input Registers类型数据读取
+            BaseLocator<Number> loc = BaseLocator.inputRegister(1, registerOffset, DataType.TWO_BYTE_INT_UNSIGNED);
+            Number value = master.getValue(loc);
+            result.put(registerOffset, value);
+        }
+        return result;
+    }
+
     /**
      * 批量读取使用方法
      *
@@ -229,18 +253,18 @@ public class Modbus4jUtils {
      * @throws ErrorResponseException e
      * @throws ModbusInitException m
      */
-    public static Map<Integer, Object> batchReadAgingCabinet(ModbusMaster master, List<Integer> registerOffsets) throws ModbusTransportException, ErrorResponseException {
+    public static Map<Integer, Object> batchReadAgingCabinetStatus(ModbusMaster master, List<Integer> registerOffsets) throws ModbusInitException, ModbusTransportException, ErrorResponseException {
 
         BatchRead<Integer> batch = new BatchRead<Integer>();
         for (Integer registerOffset : registerOffsets) {
-            batch.addLocator(registerOffset, BaseLocator.holdingRegister(1, registerOffset, DataType.FOUR_BYTE_FLOAT));
+            batch.addLocator(registerOffset, BaseLocator.inputStatus(1, registerOffset));
         }
 
         // 非连续地址也支持
-        batch.setContiguousRequests(false);
+        batch.setContiguousRequests(true);
 
         BatchResults<Integer> send = master.send(batch);
-
+//
         Map<Integer, Object> result = new HashMap<>();
         for (Integer registerOffset : registerOffsets) {
             result.put(registerOffset, send.getValue(registerOffset));
@@ -276,6 +300,27 @@ public class Modbus4jUtils {
         }
     }
 
+    /**
+     * 写[01 Coil Status(0x)] 写一个 function ID = 5
+     * @param master
+     * @param slaveId
+     * @param writeOffset
+     * @param writeValue
+     * @return
+     * @throws ModbusTransportException
+     */
+    public static boolean writeCoil(ModbusMaster master, int slaveId, int writeOffset, boolean writeValue) throws ModbusTransportException {
+        // 创建请求
+        WriteCoilRequest request = new WriteCoilRequest(slaveId, writeOffset, writeValue);
+        // 发送请求并获取响应对象
+        WriteCoilResponse response = (WriteCoilResponse) master.send(request);
+        if (response.isException()) {
+            return false;
+        } else {
+            return true;
+        }
+    }
+
     /**
      * 写[01 Coil Status(0x)] 写多个 function ID = 15
      *

zhmes-agecal-framework/src/main/java/com/zehong/framework/modbus4j/ModbusTcpTask.java

@@ -29,7 +29,7 @@ public class ModbusTcpTask implements Callable<Map<Integer, Object>> {
         ModbusMaster master = null;
         try {
             master = Modbus4jUtils.getMaster(equipmentInfo.getfIp(), equipmentInfo.getfPort());
-            return Modbus4jUtils.batchReadAgingCabinet(master,registerOffsets);
+            return Modbus4jUtils.batchReadAgingCabinetStatus(master,registerOffsets);
         } catch (ModbusInitException e) {
             Map<Integer, Object> errorMap = new HashMap<>();
             errorMap.put(1,-1);

zhmes-agecal-system/src/main/java/com/zehong/system/domain/modbus/ModbusDeviceData.java

@@ -5,18 +5,35 @@ import java.util.Map;
 /**
  * @author lenovo
  * @date 2025/6/9
- * @description TODO
+ * @description modbus设备数据
  */
 public class ModbusDeviceData {
-    private String deviceId;
+    private String deviceCode;
+
+    /** IP地址 */
+    private String fIp;
+
+    /** 端口号 */
+    private Integer fPort;
+
+    /**
+     * 0空闲，1运行，2故障
+     */
+    private String deviceStatus;
+
+    /**
+     * 故障原因
+     */
+    private String errorReason;
+
     private Map<Integer, String> registerValues; // key: 寄存器地址, value: 读取结果
 
-    public String getDeviceId() {
-        return deviceId;
+    public String getDeviceCode() {
+        return deviceCode;
     }
 
-    public void setDeviceId(String deviceId) {
-        this.deviceId = deviceId;
+    public void setDeviceCode(String deviceCode) {
+        this.deviceCode = deviceCode;
     }
 
     public Map<Integer, String> getRegisterValues() {
@@ -26,4 +43,36 @@ public class ModbusDeviceData {
     public void setRegisterValues(Map<Integer, String> registerValues) {
         this.registerValues = registerValues;
     }
+
+    public String getDeviceStatus() {
+        return deviceStatus;
+    }
+
+    public void setDeviceStatus(String deviceStatus) {
+        this.deviceStatus = deviceStatus;
+    }
+
+    public String getErrorReason() {
+        return errorReason;
+    }
+
+    public void setErrorReason(String errorReason) {
+        this.errorReason = errorReason;
+    }
+
+    public String getfIp() {
+        return fIp;
+    }
+
+    public void setfIp(String fIp) {
+        this.fIp = fIp;
+    }
+
+    public Integer getfPort() {
+        return fPort;
+    }
+
+    public void setfPort(Integer fPort) {
+        this.fPort = fPort;
+    }
 }

zhmes-agecal-web/src/api/testScheduledTasks/testTasks.js

+import request from '@/utils/request'
+
+
+// 查询用户列表
+export function getAgingCabinetAndPowerCheck() {
+  return request({
+    url: '/testTaskController/getAgingCabinetAndPowerCheck',
+    method: 'get'
+  })
+}

zhmes-agecal-web/src/views/testScheduledTasks/index.vue

+<template>
+  <div class="app-container">
+    <el-row :gutter="10" class="mb8">
+      <el-col :span="1.5">
+        <el-button
+          type="primary"
+          plain
+          size="mini"
+          @click="testAgingCabinetAndPowerCheck"
+        >测试老化柜状态获取
+        </el-button>
+      </el-col>
+    </el-row>
+    <el-input
+      type="textarea"
+      :rows="25"
+      placeholder="返回内容信息"
+      v-model="textarea">
+    </el-input>
+  </div>
+</template>
+
+<script>
+
+import {getAgingCabinetAndPowerCheck} from "@/api/testScheduledTasks/testTasks";
+
+export default {
+  name: "TestScheduledTasks",
+  data() {
+    return {
+      textarea: null
+    };
+  },
+  created() {
+  },
+  methods: {
+    testAgingCabinetAndPowerCheck() {
+      getAgingCabinetAndPowerCheck().then(response => {
+        this.textarea = "";
+          if (response.length > 0) {
+            for (let i = 0; i < response.length; i++) {
+              let item = response[i];
+              let deviceCode = item.deviceCode;
+              let registerValues = item.registerValues;
+              let deviceStatus = item.deviceStatus;
+              for (let i = 0; i < 10; i++) {
+                let registerValue = registerValues[i];
+                this.textarea += "设备编号：" + deviceCode + "状态是：" + deviceStatus + "  寄存器编号：" + i + "  寄存器值：" + registerValue + "\n";
+              }
+            }
+          }
+        }
+      );
+    }
+  }
+};
+</script>