1 换了新程序后 写时间 失效问题调整

zhmes-agecal-system/src/main/java/com/zehong/system/domain/vo/WriteCurrentTimeVo.java

+package com.zehong.system.domain.vo;
+
+/**
+ * @author lenovo
+ * @date 2025/12/26
+ * @description 给板子写时间的的vo
+ */
+public class WriteCurrentTimeVo {
+
+    private int year;
+
+    private int month;
+
+    private int day;
+
+    private int hour;
+
+    private int minute;
+
+    public WriteCurrentTimeVo() {
+    }
+
+    public WriteCurrentTimeVo(int year, int month, int day, int hour, int minute) {
+        this.year = year;
+        this.month = month;
+        this.day = day;
+        this.hour = hour;
+        this.minute = minute;
+    }
+
+    public int getYear() {
+        return year;
+    }
+
+    public void setYear(int year) {
+        this.year = year;
+    }
+
+    public int getMonth() {
+        return month;
+    }
+
+    public void setMonth(int month) {
+        this.month = month;
+    }
+
+    public int getDay() {
+        return day;
+    }
+
+    public void setDay(int day) {
+        this.day = day;
+    }
+
+    public int getHour() {
+        return hour;
+    }
+
+    public void setHour(int hour) {
+        this.hour = hour;
+    }
+
+    public int getMinute() {
+        return minute;
+    }
+
+    public void setMinute(int minute) {
+        this.minute = minute;
+    }
+}

zhmes-agecal-system/src/main/java/com/zehong/system/modbus/util/Modbus4jUtils.java

@@ -12,6 +12,7 @@ import com.serotonin.modbus4j.ip.IpParameters;
 import com.serotonin.modbus4j.ip.tcp.TcpMaster;
 import com.serotonin.modbus4j.locator.BaseLocator;
 import com.serotonin.modbus4j.msg.*;
+import com.zehong.system.domain.vo.WriteCurrentTimeVo;
 import com.zehong.system.modbus.handler.ModbusResultHandler;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -955,7 +956,7 @@ public class Modbus4jUtils {
             // 读取 第1个 pcba 板子的数据
             modbusMaster = createModbusMaster("192.168.2.1", 501);
 //            writeCurrentTimeUseWriteRegisters(modbusMaster, 1);
-            writeCurrentTimeToDeviceEnhanced(modbusMaster,1);
+//            writeCurrentTimeToDeviceEnhanced(modbusMaster,1);
 //            writeTimeRegisters(modbusMaster, 1);
         } catch (Exception e) {
             e.printStackTrace();
@@ -1114,14 +1115,14 @@ public class Modbus4jUtils {
     /**
      * 增强版：写入并实时验证每个字段
      */
-    public static void writeCurrentTimeToDeviceEnhanced(ModbusMaster master, int deviceId) {
+    public static boolean writeCurrentTimeToDeviceEnhanced(ModbusMaster master, int deviceId, WriteCurrentTimeVo writeCurrentTimeVo) {
         try {
-            Calendar cal = Calendar.getInstance();
-            int year = cal.get(Calendar.YEAR);
-            int month = cal.get(Calendar.MONTH) + 1;
-            int day = cal.get(Calendar.DATE);
-            int hour = cal.get(Calendar.HOUR_OF_DAY);
-            int minute = cal.get(Calendar.MINUTE);
+
+            int year = writeCurrentTimeVo.getYear();
+            int month = writeCurrentTimeVo.getMonth();
+            int day = writeCurrentTimeVo.getDay();
+            int hour = writeCurrentTimeVo.getHour();
+            int minute = writeCurrentTimeVo.getMinute();
 
             log.info("开始设置设备{}时间: {}-{}-{} {}:{}",
                     deviceId, year, month, day, hour, minute);
@@ -1131,22 +1132,22 @@ public class Modbus4jUtils {
 
             // 写入并验证年份
             allSuccess &= writeAndVerifyField(master, deviceId, 4, (short) year, "年份", year);
-            Thread.sleep(200);
+            Thread.sleep(500);
 
             // 写入并验证月份
             allSuccess &= writeAndVerifyField(master, deviceId, 5, (short) month, "月份", month);
-            Thread.sleep(200);
+            Thread.sleep(500);
 
             allSuccess &= writeAndVerifyField(master, deviceId, 6, (short) day, "日期", day);
-            Thread.sleep(200);
+            Thread.sleep(500);
 
             // 写入并验证小时
             allSuccess &= writeAndVerifyField(master, deviceId, 7, (short) hour, "小时", hour);
-            Thread.sleep(200);
+            Thread.sleep(500);
 
             // 写入并验证分钟
             allSuccess &= writeAndVerifyField(master, deviceId, 8, (short) minute, "分钟", minute);
-            Thread.sleep(200);
+            Thread.sleep(500);
 
             if (allSuccess) {
                 // 最终整体验证
@@ -1155,54 +1156,78 @@ public class Modbus4jUtils {
 
                 if (verifyTimeRegisters(ints, year, month, day, hour, minute)) {
                     log.info("设备{}时间设置全部完成且验证通过", deviceId);
+                    return true;
                 } else {
                     log.warn("设备{}时间设置完成，但最终验证失败", deviceId);
+                    return false;
                 }
             } else {
                 log.error("设备{}时间设置过程中出现失败", deviceId);
+                return false;
             }
 
         } catch (Exception e) {
             log.error("设备{}时间写入异常", deviceId, e);
+            return false;
         }
     }
 
     /**
-     * 写入并验证单个字段
+     * 写入并验证单个字段（带重试机制）
      */
     private static boolean writeAndVerifyField(ModbusMaster master, int deviceId,
                                                int address, short value,
                                                String fieldName, int expectedValue) {
+        // 最大重试次数
+        int maxRetry = 3;
+
+        // 进行最多3次尝试
+        for (int retry = 1; retry <= maxRetry; retry++) {
             try {
-            log.info("开始写入{}: {} (地址={})", fieldName, expectedValue, address);
+                log.info("第{}次尝试写入{}: {} (地址={})",
+                        retry, fieldName, expectedValue, address);
 
-            // 写入
-            boolean success = Modbus4jUtils.writeRegister(master, deviceId, address, value);
+                // 1. 写入操作
+                boolean writeSuccess = Modbus4jUtils.writeRegister(master, deviceId, address, value);
 
-            if (!success) {
-                log.error("写入{}失败", fieldName);
-                return false;
+                if (!writeSuccess) {
+                    log.warn("第{}次写入{}失败", retry, fieldName);
+                    continue; // 继续下一次重试
                 }
 
-            // 等待设备处理
-            Thread.sleep(100);
+                // 2. 等待设备处理（保持原有逻辑）
+                Thread.sleep(2000);
 
-            // 读取验证
+                // 3. 读取验证
                 int[] ints = readDeviceRegisters(master, deviceId);
                 if (ints.length > address && ints[address] == expectedValue) {
                     log.info("{}验证通过，写入值: {}", fieldName, expectedValue);
-                return true;
+                    return true; // 成功，直接返回
                 } else {
-                log.warn("{}验证失败，期望: {}，实际: {}",
-                        fieldName, expectedValue,
-                        ints.length > address ? ints[address] : "N/A");
-                return false;
+                    int actualValue = ints.length > address ? ints[address] : -1;
+                    log.warn("第{}次{}验证失败，期望: {}，实际: {}",
+                            retry, fieldName, expectedValue, actualValue);
+                    // 验证失败，继续下一次重试
                 }
 
             } catch (Exception e) {
-            log.error("写入{}时发生异常", fieldName, e);
-            return false;
+                log.error("第{}次写入{}时发生异常", retry, fieldName, e);
             }
+
+            // 如果不是最后一次重试，可以稍作等待再尝试（可选）
+            if (retry < maxRetry) {
+                try {
+                    Thread.sleep(500); // 重试间隔
+                } catch (InterruptedException e) {
+                    Thread.currentThread().interrupt();
+                    break;
+                }
+            }
+        }
+
+        // 所有重试都失败了
+        log.error("{}写入失败，已达到最大重试次数{}", fieldName, maxRetry);
+        return false;
     }
 
     /**

zhmes-agecal-system/src/main/java/com/zehong/system/modbus/util/WriteCurrentTimeUtil.java

+package com.zehong.system.modbus.util;
+
+import com.zehong.system.domain.vo.WriteCurrentTimeVo;
+
+import java.util.Calendar;
+
+/**
+ * @author lenovo
+ * @date 2025/12/26
+ * @description 日期对象生成类
+ */
+public class WriteCurrentTimeUtil {
+
+    public static WriteCurrentTimeVo generateWriteCurrentTimeVo(){
+
+        Calendar cal = Calendar.getInstance();
+        int year = cal.get(Calendar.YEAR);
+        int month = cal.get(Calendar.MONTH) + 1;
+        int day = cal.get(Calendar.DATE);
+        int hour = cal.get(Calendar.HOUR_OF_DAY);
+        int minute = cal.get(Calendar.MINUTE);
+
+        WriteCurrentTimeVo writeCurrentTimeVo = new WriteCurrentTimeVo();
+        writeCurrentTimeVo.setYear(year);
+        writeCurrentTimeVo.setMonth(month);
+        writeCurrentTimeVo.setDay(day);
+        writeCurrentTimeVo.setHour(hour);
+        writeCurrentTimeVo.setMinute(minute);
+        return writeCurrentTimeVo;
+    }
+}

zhmes-agecal-system/src/main/java/com/zehong/system/task/AgingStageOneProcessJob.java

 package com.zehong.system.task;
 
 import com.serotonin.modbus4j.ModbusMaster;
+import com.sun.org.apache.xpath.internal.operations.Mod;
 import com.zehong.system.domain.PalletDeviceBinding;
 import com.zehong.system.domain.TEquipmentAlarmData;
 import com.zehong.system.domain.TStoreyInfo;
+import com.zehong.system.domain.vo.WriteCurrentTimeVo;
 import com.zehong.system.mapper.PalletDeviceBindingMapper;
 import com.zehong.system.mapper.TStoreyInfoMapper;
 import com.zehong.system.modbus.util.Modbus4jUtils;
+import com.zehong.system.modbus.util.WriteCurrentTimeUtil;
 import com.zehong.system.service.ITEquipmentAlarmDataService;
 import org.apache.commons.lang3.StringUtils;
 import org.quartz.DisallowConcurrentExecution;
@@ -161,7 +164,22 @@ public class AgingStageOneProcessJob implements Job {
                 master = Modbus4jUtils.createModbusMaster(ip, port);
                 // 4. 条件写入时间
                 if (result[1] == 1 || result[1] == 3 || result[1] == 4) {
-                    writeCurrentTimeToDevice(master, deviceId, binding);
+//                    writeCurrentTimeToDevice(master, deviceId, binding);
+                    WriteCurrentTimeVo writeCurrentTimeVo = WriteCurrentTimeUtil.generateWriteCurrentTimeVo();
+                    boolean allSuccess = Modbus4jUtils.writeCurrentTimeToDeviceEnhanced(master, deviceId,writeCurrentTimeVo);
+                    if (!allSuccess) {
+                        log.warn("设备{}写入时间失败: ip={}, port={}", deviceId, ip, port);
+                        binding.setWriteTimeStatus("0");
+                        palletDeviceBindingMapper.updatePalletDeviceBinding(binding);
+                        errorCount.incrementAndGet();
+                        return false;
+                    }
+                    binding.setRecordYear(String.valueOf(writeCurrentTimeVo.getYear()));
+                    binding.setRecordMonth(String.valueOf(writeCurrentTimeVo.getMonth()));
+                    binding.setRecordDate(String.valueOf(writeCurrentTimeVo.getDay()));
+                    binding.setRecordHour(String.valueOf(writeCurrentTimeVo.getHour()));
+                    binding.setRecordMinute(String.valueOf(writeCurrentTimeVo.getMinute()));
+                    binding.setWriteTimeStatus("1");
                 }
                 // 5. 写入自检让设备开始自检，跟 上面的状态没关系
                 writeSelfCheckStatus(master, deviceId, binding);
@@ -275,6 +293,7 @@ public class AgingStageOneProcessJob implements Job {
         }
     }
 
+
     // -------------------------- 辅助方法（日志/告警）--------------------------
     /**
      * 从JobContext中获取fStoreyId（失败返回unknown）

zhmes-agecal-system/src/main/java/com/zehong/system/task/AgingStageThreeProcessJob.java

@@ -6,10 +6,12 @@ import com.zehong.system.domain.PalletDeviceBinding;
 import com.zehong.system.domain.SysRealTimeAdRange;
 import com.zehong.system.domain.TEquipmentAlarmData;
 import com.zehong.system.domain.TStoreyInfo;
+import com.zehong.system.domain.vo.WriteCurrentTimeVo;
 import com.zehong.system.mapper.PalletDeviceBindingMapper;
 import com.zehong.system.mapper.SysRealTimeAdRangeMapper;
 import com.zehong.system.mapper.TStoreyInfoMapper;
 import com.zehong.system.modbus.util.Modbus4jUtils;
+import com.zehong.system.modbus.util.WriteCurrentTimeUtil;
 import com.zehong.system.service.ITEquipmentAlarmDataService;
 import org.apache.commons.lang3.StringUtils;
 import org.quartz.DisallowConcurrentExecution;
@@ -296,7 +298,7 @@ public class AgingStageThreeProcessJob implements Job {
                 handleTimeConsistent(deviceId, binding);
             } else {
                 // 时间不一致
-                handleTimeInconsistent(master, deviceId, binding, systemCal);
+                handleTimeInconsistent(master, deviceId, binding);
             }
 
         } catch (ModbusTransportException e) {
@@ -347,48 +349,29 @@ public class AgingStageThreeProcessJob implements Job {
      * 处理时间不一致的情况 - 更新设备时间
      */
     private void handleTimeInconsistent(ModbusMaster master, int deviceId,
-                                        PalletDeviceBinding binding, Calendar systemCal) {
+                                        PalletDeviceBinding binding) {
         log.info("设备{}时间与系统时间不一致，开始更新时间", deviceId);
         try {
 
             // 1 如果时间状态为空，则写入时间
             if(binding.getWriteTimeStatus() == null) {
-                int year = systemCal.get(Calendar.YEAR);
-                int month = systemCal.get(Calendar.MONTH) + 1;
-                int day = systemCal.get(Calendar.DATE);
-                int hour = systemCal.get(Calendar.HOUR_OF_DAY);
-                int minute = systemCal.get(Calendar.MINUTE);
-
-                // 写入时间寄存器
-                boolean success;
-                success = Modbus4jUtils.writeRegister(master, deviceId, 4, (short) year);
-                success = success && Modbus4jUtils.writeRegister(master, deviceId, 5, (short) month);
-                success = success && Modbus4jUtils.writeRegister(master, deviceId, 6, (short) day);
-                success = success && Modbus4jUtils.writeRegister(master, deviceId, 7, (short) hour);
-                success = success && Modbus4jUtils.writeRegister(master, deviceId, 8, (short) minute);
-
-                if (success) {
-                    int[] ints = Modbus4jUtils.readDeviceRegisters(master, deviceId);
-                    if(ints[4] == year && ints[5] == month && ints[6] == day && ints[7] == hour && ints[8] == minute) {
-                        binding.setRecordYear(String.valueOf(year));
-                        binding.setRecordMonth(String.valueOf(month));
-                        binding.setRecordDate(String.valueOf(day));
-                        binding.setRecordHour(String.valueOf(hour));
-                        binding.setRecordMinute(String.valueOf(minute));
+                WriteCurrentTimeVo writeCurrentTimeVo = WriteCurrentTimeUtil.generateWriteCurrentTimeVo();
+                boolean allSuccess = Modbus4jUtils.writeCurrentTimeToDeviceEnhanced(master, deviceId,writeCurrentTimeVo);
+                if (allSuccess) {
+                    binding.setRecordYear(String.valueOf(writeCurrentTimeVo.getYear()));
+                    binding.setRecordMonth(String.valueOf(writeCurrentTimeVo.getMonth()));
+                    binding.setRecordDate(String.valueOf(writeCurrentTimeVo.getDay()));
+                    binding.setRecordHour(String.valueOf(writeCurrentTimeVo.getHour()));
+                    binding.setRecordMinute(String.valueOf(writeCurrentTimeVo.getMinute()));
                     binding.setWriteTimeStatus("1");
                     binding.setRunTimeStatus("1");
                     log.info("设备{}时间写入成功", deviceId);
                 } else {
-                        log.info("设备{}时间写入失败: year={}, month={}, day={}, hour={}, minute={}",deviceId,ints[4], ints[5], ints[6], ints[7], ints[8]);
                     binding.setWriteTimeStatus("0");
                     binding.setRunTimeStatus("0");
+                    log.error("设备{}时间写入失败", deviceId);
                     recordAlarmByBinding(binding, "设备时间写入失败");
                 }
-                } else {
-                    binding.setRunTimeStatus("0");
-                    log.info("设备{}时间更新失败", deviceId);
-                    recordAlarmByBinding(binding, "设备时间更新失败");
-                }
                 // 2. 如果时间状态为1，则更新 时间运行状态  为异常 状态
             } else if("1".equals(binding.getWriteTimeStatus())) {
                 log.info("设备{}时间状态为1，则更新 时间运行状态  为异常 状态", deviceId);