代码优化

taphole-iron/src/main/java/com/sckj/iron/service/impl/TIronVisualScreenServiceImpl.java

@@ -753,7 +753,7 @@ public class TIronVisualScreenServiceImpl {
 
                     double value = cycleTotal.setScale(scale, RoundingMode.HALF_UP).doubleValue();
                     log.info("[出铁周期结束] 结束于: " + time + ", 本周期铁水总净重: " + value);
-                    arr.add(java.util.Arrays.asList(time, value));
+                    arr.add(java.util.Arrays.asList(time, 0));
                     inTappingCycle = false;
                     cycleTotal = BigDecimal.ZERO;
                     lastValue = BigDecimal.ZERO;

taphole-iron/src/main/java/com/sckj/iron/socketio/DeviceEventListener.java

@@ -17,7 +17,10 @@ import com.sckj.common.util.LocalDateUtils;
 import com.sckj.common.util.RedisUtils;
 import com.sckj.common.util.ToolUtils;
 import com.sckj.iron.constant.*;
-import com.sckj.iron.dto.*;
+import com.sckj.iron.dto.IronStepDTO;
+import com.sckj.iron.dto.IronTestItem;
+import com.sckj.iron.dto.IronTimeNoDTO;
+import com.sckj.iron.dto.RealtimeData;
 import com.sckj.iron.entity.*;
 import com.sckj.iron.service.impl.*;
 import com.sckj.iron.vo.IronStepVO;
@@ -59,6 +62,7 @@ import java.time.LocalDateTime;
 import java.time.format.DateTimeFormatter;
 import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentSkipListMap;
 import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
@@ -242,7 +246,7 @@ public class DeviceEventListener extends AbstractEventListener { //
     private TIronData mTIronData;
 
     //连续计数
-    private Map<String, Integer> mWarnCountMap = new ConcurrentHashMap<>();
+    private Map<String, Integer> mWarnCountMap = new ConcurrentSkipListMap<>();
 
 
     // 定时任务统一管理
@@ -308,7 +312,7 @@ public class DeviceEventListener extends AbstractEventListener { //
                 scheduledTaskManager.addTask(opcdasubscribe.getName(), opcdasubscribe.getDelay(), opcdasubscribe.getPeriod(), TimeUnit.SECONDS, () -> {
                     if ("prod".equals(activeProfiles)) {
                         log.info("HDC subscribe available");
-                        hdService.subscribeAvailable();
+                       // hdService.subscribeAvailable();
                     } else if ("test".equals(activeProfiles)) {
                         log.info("DA subscribe available");
                         opcuaService.subscribeAvailable();
@@ -701,10 +705,11 @@ public class DeviceEventListener extends AbstractEventListener { //
                                 //铁量差 = 理论出铁量 - 实际出铁量
                                 TL2Data tl2Data1Last = latest2DataList.get(0);
 
+//                                铁量差=出铁量-理论铁量
 
                                 BigDecimal theoryWeightLast = BigDecimal.valueOf(tl2Data1Last.getTheoryWeight()).setScale(2, RoundingMode.HALF_UP);
                                 BigDecimal ironWeightLast = BigDecimal.valueOf(tl2Data1Last.getCalcWeight()).setScale(2, RoundingMode.HALF_UP);
-                                BigDecimal tlcLast = theoryWeightLast.subtract(ironWeightLast).setScale(2, RoundingMode.HALF_UP);
+                                BigDecimal tlcLast = ironWeightLast.subtract(theoryWeightLast).setScale(2, RoundingMode.HALF_UP);
 
                                 TL2DataTlcDTO dtoLast = new TL2DataTlcDTO();
                                 BeanUtils.copyProperties(tl2Data1Last, dtoLast);
@@ -716,7 +721,7 @@ public class DeviceEventListener extends AbstractEventListener { //
                                 TL2Data tl2Data1Grand = latest2DataList.get(1);
                                 BigDecimal theoryWeightGrand = BigDecimal.valueOf(tl2Data1Grand.getTheoryWeight()).setScale(2, RoundingMode.HALF_UP);
                                 BigDecimal ironWeightGrand = BigDecimal.valueOf(tl2Data1Grand.getCalcWeight()).setScale(2, RoundingMode.HALF_UP);
-                                BigDecimal tlcGrand = theoryWeightGrand.subtract(ironWeightGrand).setScale(2, RoundingMode.HALF_UP);
+                                BigDecimal tlcGrand = ironWeightGrand.subtract(theoryWeightGrand).setScale(2, RoundingMode.HALF_UP);
 
                                 TL2DataTlcDTO dtoGrand = new TL2DataTlcDTO();
                                 BeanUtils.copyProperties(tl2Data1Grand, dtoGrand);
@@ -836,23 +841,24 @@ public class DeviceEventListener extends AbstractEventListener { //
 
         //最大出铁标准量
         double stdIronWeightMax = Double.parseDouble(mContext.lookupVariable(ExpressionConstants.stdIronWeightMax).toString());
+        double stdIronSpeedMin = Double.parseDouble(mContext.lookupVariable(ExpressionConstants.stdSpeedMin).toString());
+        double stdIronSpeedMax = Double.parseDouble(mContext.lookupVariable(ExpressionConstants.stdSpeedMax).toString());
         //实时总铁量
         // BigDecimal totalWeight = rtTotalWeight;
         //平均流速
         BigDecimal avgSpeed = totalWeight.divide(BigDecimal.valueOf(ironElapsedMinute), 2, RoundingMode.HALF_UP);
+
+        if(avgSpeed.doubleValue() < stdIronSpeedMin || avgSpeed.doubleValue() > stdIronSpeedMax){
+            log.warn("平均流速{}不在速度阈值范围内({}-{}), 不计算剩余时间", avgSpeed,stdIronSpeedMin,stdIronSpeedMax);
+            return;
+        }
+
         //剩余重量
         BigDecimal diffWeight = BigDecimal.valueOf(Math.max(stdIronWeightMax - totalWeight.doubleValue(), 0));
 
         log.info("剩余时间计算参数: 标准最大铁量={}吨, 当前总铁量={}吨, 平均流速={}吨/分钟, 剩余铁量={}吨",
                 stdIronWeightMax, totalWeight, avgSpeed, diffWeight);
 
-        if (avgSpeed.compareTo(BigDecimal.ZERO) <= 0) {
-            log.warn("平均流速小于等于0 ({}/分钟), 无法计算剩余时间, 设置剩余时间为0", avgSpeed);
-            realtimeData.setValue(diffCloseTime);
-            PushData.send2CloseTime(realtimeData);
-            log.info("推送剩余出铁时间数据完成, 剩余时间: {}分钟", diffCloseTime);
-            return;
-        }
 
         //计算剩余时间
         diffCloseTime = diffWeight.divide(avgSpeed, 2, RoundingMode.HALF_UP).intValue();
@@ -861,7 +867,7 @@ public class DeviceEventListener extends AbstractEventListener { //
         int stdIronTimeMax = Integer.parseInt(mContext.lookupVariable(ExpressionConstants.stdIronTimeMax).toString()) + 50;
         log.info("标准最大出铁时间: {}分钟,是否超过最大时间:{},为true则设置为标准最大出铁时间", stdIronTimeMax,diffCloseTime > stdIronTimeMax);
 
-        diffCloseTime = Math.max(diffCloseTime, stdIronTimeMax);
+        diffCloseTime = Math.min(diffCloseTime, stdIronTimeMax);
 
         realtimeData.setValue(diffCloseTime);
         PushData.send2CloseTime(realtimeData);
@@ -1145,9 +1151,9 @@ public class DeviceEventListener extends AbstractEventListener { //
 
             // 时间检查
             if (actualTime < stdIronTimeMin) {
-                log.warn("⚠️ 出铁时间过短: 实际{}分钟 < 标准{}分钟", actualTime, stdIronTimeMin);
+                log.warn("⚠️ 出铁时间偏短: 实际{}分钟 < 标准{}分钟", actualTime, stdIronTimeMin);
                 taskExecutor.submit(() -> {
-                    log.info("📝 记录出铁时间过短异常...");
+                    log.info("📝 记录出铁时间偏短异常...");
                     PushData.send2Warn(audioMap.get(ExceptionTypeEnum.IRON_TIME_SHORT.getCode()));
                     saveException(ExceptionTypeEnum.IRON_TIME_SHORT,
                             String.format("出铁时间%s分钟", actualTime));
@@ -1155,7 +1161,7 @@ public class DeviceEventListener extends AbstractEventListener { //
                     log.info("✅ 异常已记录并推送");
                 });
             } else if (actualTime > stdIronTimeMax) {
-                log.warn("⚠️ 出铁时间过长: 实际{}分钟 > 标准{}分钟", actualTime, stdIronTimeMax);
+                log.warn("⚠️ 出铁时间偏长: 实际{}分钟 > 标准{}分钟", actualTime, stdIronTimeMax);
                 // 已注释掉，但保留日志
                 //log.info("⏰ 出铁时间超过标准上限，但异常记录已注释");
             } else {
@@ -1164,9 +1170,9 @@ public class DeviceEventListener extends AbstractEventListener { //
 
             // 重量检查
             if (actualWeight < stdIronWeightMin) {
-                log.warn("⚠️ 出铁量过少: 实际{}吨 < 标准{}吨", actualWeight, stdIronWeightMin);
+                log.warn("⚠️ 出铁量偏少: 实际{}吨 < 标准{}吨", actualWeight, stdIronWeightMin);
                 taskExecutor.submit(() -> {
-                    log.info("📝 记录出铁量过少异常...");
+                    log.info("📝 记录出铁量偏少异常...");
                     PushData.send2Warn(audioMap.get(ExceptionTypeEnum.IRON_WEIGHT_FEW.getCode()));
                     saveException(ExceptionTypeEnum.IRON_WEIGHT_FEW,
                             String.format("出铁量%s吨", actualWeight));
@@ -1174,7 +1180,7 @@ public class DeviceEventListener extends AbstractEventListener { //
                     log.info("✅ 异常已记录并推送");
                 });
             } else if (actualWeight > stdIronWeightMax) {
-                log.warn("⚠️ 出铁量过多: 实际{}吨 > 标准{}吨", actualWeight, stdIronWeightMax);
+                log.warn("⚠️ 出铁量偏多: 实际{}吨 > 标准{}吨", actualWeight, stdIronWeightMax);
                 // 已注释掉，但保留日志
                 log.info("⚖️ 出铁量超过标准上限，但异常记录已注释");
             } else {
@@ -1243,7 +1249,7 @@ public class DeviceEventListener extends AbstractEventListener { //
 
                             taskExecutor.submit(() -> {
                                 PushData.send2Warn(audioMap.get(ExceptionTypeEnum.CLOSURE1.getCode()));
-                                saveException(ExceptionTypeEnum.NEED_CLOSURE, String.format("流速过大,建议将当前铁口堵口"));
+                                saveException(ExceptionTypeEnum.NEED_CLOSURE, String.format("流速偏大,建议将当前铁口堵口"));
                                 //推送预警列表
                                 getExceptionList();
                             });
@@ -1272,7 +1278,7 @@ public class DeviceEventListener extends AbstractEventListener { //
 
                             taskExecutor.submit(() -> {
                                 PushData.send2Warn(audioMap.get(ExceptionTypeEnum.CLOSURE2.getCode()));
-                                saveException(ExceptionTypeEnum.NEED_CLOSURE, String.format("流速过小,但其它铁口正在出铁,请将当前铁口堵口"));
+                                saveException(ExceptionTypeEnum.NEED_CLOSURE, String.format("流速偏小,但其它铁口正在出铁,请将当前铁口堵口"));
                                 //推送预警列表
                                 getExceptionList();
                             });
@@ -1301,7 +1307,7 @@ public class DeviceEventListener extends AbstractEventListener { //
                             log.warn("模型3触发堵口告警3");
                             taskExecutor.submit(() -> {
                                 PushData.send2Warn(audioMap.get(ExceptionTypeEnum.CLOSURE3.getCode()));
-                                saveException(ExceptionTypeEnum.NEED_CLOSURE, String.format("流速过小且其他铁口均未出铁,请先将其它铁口打开,再进行堵口"));
+                                saveException(ExceptionTypeEnum.NEED_CLOSURE, String.format("流速偏小且其他铁口均未出铁,请先将其它铁口打开,再进行堵口"));
                                 //推送预警列表
                                 getExceptionList();
                             });
@@ -1736,12 +1742,12 @@ public class DeviceEventListener extends AbstractEventListener { //
 
                 // 出铁时间诊断
                 if (actualIronTime < stdIronTimeMin) {
-                    sb.append(ironTimeTip).append("过短,");
-                    ironTime.status(0).desc(ironTimeTip + "过短");
+                    sb.append(ironTimeTip).append("偏短,");
+                    ironTime.status(0).desc(ironTimeTip + "偏短");
                     log.warn("⚠️ 出铁时间异常: 实际 {} 分钟 < 标准最小 {} 分钟", actualIronTime, stdIronTimeMin);
                 } else if (actualIronTime > stdIronTimeMax) {
-                    sb.append(ironTimeTip).append("过长,");
-                    ironTime.status(0).desc(ironTimeTip + "过长");
+                    sb.append(ironTimeTip).append("偏长,");
+                    ironTime.status(0).desc(ironTimeTip + "偏长");
                     log.warn("⚠️ 出铁时间异常: 实际 {} 分钟 > 标准最大 {} 分钟", actualIronTime, stdIronTimeMax);
                 } else {
                     sb.append(ironTimeTip).append("正常,");
@@ -1752,12 +1758,12 @@ public class DeviceEventListener extends AbstractEventListener { //
 
                 // 出铁重量诊断
                 if (actualIronWeight < stdIronWeightMin) {
-                    sb.append(ironWeightTip).append("过少,");
-                    ironWeight.status(0).desc(ironWeightTip + "过少");
+                    sb.append(ironWeightTip).append("偏少,");
+                    ironWeight.status(0).desc(ironWeightTip + "偏少");
                     log.warn("⚠️ 出铁重量异常: 实际 {} 吨 < 标准最小 {} 吨", actualIronWeight, stdIronWeightMin);
                 } else if (actualIronWeight > stdIronWeightMax) {
-                    sb.append(ironWeightTip).append("过多,");
-                    ironWeight.status(0).desc(ironWeightTip + "过多");
+                    sb.append(ironWeightTip).append("偏多,");
+                    ironWeight.status(0).desc(ironWeightTip + "偏多");
                     log.warn("⚠️ 出铁重量异常: 实际 {} 吨 > 标准最大 {} 吨", actualIronWeight, stdIronWeightMax);
                 } else {
                     sb.append(ironWeightTip).append("正常,");
@@ -1768,13 +1774,13 @@ public class DeviceEventListener extends AbstractEventListener { //
 
                 // 铁水流速诊断
                 if (actualIronSpeed < stdIronSpeedMin) {
-                    sb.append(ironSpeedTip).append("过慢,");
-                    ironSpeed.status(0).desc(ironSpeedTip + "过慢");
+                    sb.append(ironSpeedTip).append("偏慢,");
+                    ironSpeed.status(0).desc(ironSpeedTip + "偏慢");
                     log.warn("⚠️ 铁水流速异常: 实际 {} t/min < 标准最小 {} t/min",
                             String.format("%.2f", actualIronSpeed), stdIronSpeedMin);
                 } else if (actualIronSpeed > stdIronSpeedMax) {
-                    sb.append(ironSpeedTip).append("过快,");
-                    ironSpeed.status(0).desc(ironSpeedTip + "过快");
+                    sb.append(ironSpeedTip).append("偏快,");
+                    ironSpeed.status(0).desc(ironSpeedTip + "偏快");
                     log.warn("⚠️ 铁水流速异常: 实际 {} t/min > 标准最大 {} t/min",
                             String.format("%.2f", actualIronSpeed), stdIronSpeedMax);
                 } else {
@@ -1786,12 +1792,12 @@ public class DeviceEventListener extends AbstractEventListener { //
 
                 // 铁水温度诊断
                 if (avgTemp < stdTempMin) {
-                    sb.append(ironTempTip).append("过低。");
-                    ironTemp.status(0).desc(ironTempTip + "过低");
+                    sb.append(ironTempTip).append("偏低。");
+                    ironTemp.status(0).desc(ironTempTip + "偏低");
                     log.warn("⚠️ 铁水温度异常: 实际 {} ℃ < 标准最小 {} ℃", avgTemp, stdTempMin);
                 } else if (avgTemp > stdTempMax) {
-                    sb.append(ironTempTip).append("过高。");
-                    ironTemp.status(0).desc(ironTempTip + "过高");
+                    sb.append(ironTempTip).append("偏高。");
+                    ironTemp.status(0).desc(ironTempTip + "偏高");
                     log.warn("⚠️ 铁水温度异常: 实际 {} ℃ > 标准最大 {} ℃", avgTemp, stdTempMax);
                 } else {
                     sb.append(ironTempTip).append("正常。");
@@ -2198,54 +2204,54 @@ public class DeviceEventListener extends AbstractEventListener { //
                 if (tempNow < stdTempMin) {
                     int count = mWarnCountMap.getOrDefault("tempMinWarn", 0) + 1;
                     mWarnCountMap.put("tempMinWarn", count);
-                    log.warn("检测到温度过低 - 当前: {}℃, 标准最低: {}℃, 连续异常次数: {}", tempNow, stdTempMin, count);
+                    log.warn("检测到温度偏低 - 当前: {}℃, 标准最低: {}℃, 连续异常次数: {}", tempNow, stdTempMin, count);
 
                     if (count >= StandardConstans.WARN_COUNT) {
-                        log.error("温度过低预警触发 - 连续3次异常，当前温度: {}℃", tempNow);
+                        log.error("温度偏低预警触发 - 连续3次异常，当前温度: {}℃", tempNow);
                         taskExecutor.submit(() -> {
                             try {
                                 String exceptionMsg = String.format("温度%s℃", tempNow);
                                 PushData.send2Warn(audioMap.get(ExceptionTypeEnum.IRON_TEMP_HIGH.getCode()));
                                 saveException(ExceptionTypeEnum.IRON_TEMP_HIGH, exceptionMsg);
-                                log.warn("已记录温度过低异常: {}", exceptionMsg);
+                                log.warn("已记录温度偏低异常: {}", exceptionMsg);
 
                                 getExceptionList();
                                 log.info("已推送温度预警列表更新");
 
                             } catch (Exception e) {
-                                log.error("处理温度过低异常时发生错误", e);
+                                log.error("处理温度偏低异常时发生错误", e);
                             }
                         });
                         mWarnCountMap.put("tempMinWarn", 0);
                         mIronTempLowCount.incrementAndGet();
-                        log.info("重置温度过低计数器，低温异常次数+1");
+                        log.info("重置温度偏低计数器，低温异常次数+1");
                         return;
                     }
 
                 } else if (tempNow > stdTempMax) {
                     int count = mWarnCountMap.getOrDefault("tempMaxWarn", 0) + 1;
                     mWarnCountMap.put("tempMaxWarn", count);
-                    log.warn("检测到温度过高 - 当前: {}℃, 标准最高: {}℃, 连续异常次数: {}", tempNow, stdTempMax, count);
+                    log.warn("检测到温度偏高 - 当前: {}℃, 标准最高: {}℃, 连续异常次数: {}", tempNow, stdTempMax, count);
 
                     if (count >= StandardConstans.WARN_COUNT) {
-                        log.error("温度过高预警触发 - 连续3次异常，当前温度: {}℃", tempNow);
+                        log.error("温度偏高预警触发 - 连续3次异常，当前温度: {}℃", tempNow);
                         taskExecutor.submit(() -> {
                             try {
                                 String exceptionMsg = String.format("温度%s℃", tempNow);
                                 PushData.send2Warn(audioMap.get(ExceptionTypeEnum.IRON_TEMP_LOW.getCode()));
                                 saveException(ExceptionTypeEnum.IRON_TEMP_LOW, exceptionMsg);
-                                log.warn("已记录温度过高异常: {}", exceptionMsg);
+                                log.warn("已记录温度偏高异常: {}", exceptionMsg);
 
                                 getExceptionList();
                                 log.info("已推送温度预警列表更新");
 
                             } catch (Exception e) {
-                                log.error("处理温度过高异常时发生错误", e);
+                                log.error("处理温度偏高异常时发生错误", e);
                             }
                         });
                         mWarnCountMap.put("tempMaxWarn", 0);
                         mIronTempHighCount.incrementAndGet();
-                        log.info("重置温度过高计数器，高温异常次数+1");
+                        log.info("重置温度偏高计数器，高温异常次数+1");
                         return;
                     }
 
@@ -2310,15 +2316,15 @@ public class DeviceEventListener extends AbstractEventListener { //
 
                     //采用实时速度方法
                     if (rtIronSpeed < stdSpeedMin) {
-                        log.warn("流速过低: {} < {}", rtIronSpeed, stdSpeedMin);
+                        log.warn("流速偏低: {} < {}", rtIronSpeed, stdSpeedMin);
                         //铁水流速低
                         int count = mWarnCountMap.getOrDefault("speedMinWarn", 0) + 1;
                         mWarnCountMap.put("speedMinWarn", count);
-                        log.info("流速过低计数: {}/3", count);
+                        log.info("流速偏低计数: {}/3", count);
 
                         if (count >= StandardConstans.WARN_COUNT) {
                             PushData.send2Warn(audioMap.get(ExceptionTypeEnum.IRON_SPEED_SLOW.getCode()));
-                            log.error("触发流速过低预警");
+                            log.info("触发流速偏低预警");
                             saveException(ExceptionTypeEnum.IRON_SPEED_SLOW, String.format("流速%s吨/分钟", mMaxSpeed.get()));
                             //推送预警列表
                             getExceptionList();
@@ -2326,15 +2332,15 @@ public class DeviceEventListener extends AbstractEventListener { //
 
                         }
                     } else if (rtIronSpeed > stdSpeedMax) {
-                        log.warn("流速过高: {} > {}", rtIronSpeed, stdSpeedMax);
+                        log.warn("流速偏高: {} > {}", rtIronSpeed, stdSpeedMax);
                         //铁水流速高
                         int count = mWarnCountMap.getOrDefault("speedMaxWarn", 0) + 1;
                         mWarnCountMap.put("speedMaxWarn", count);
-                        log.info("流速过高计数: {}/3", count);
+                        log.info("流速偏高计数: {}/3", count);
                         if (count >= StandardConstans.WARN_COUNT) {
-                            log.error("触发流速过高预警");
+                            log.info("触发流速偏高预警");
                             PushData.send2Warn(audioMap.get(ExceptionTypeEnum.IRON_SPEED_FAST.getCode()));
-                            saveException(ExceptionTypeEnum.IRON_SPEED_FAST, String.format("流速%s吨/分钟", mMaxSpeed.get()));
+                            saveException(ExceptionTypeEnum.IRON_SPEED_FAST, String.format("连续3次偏小:%st/min、%st/min、%st/min，低于%st/min,流速偏大,建议将当前铁口堵口", mMaxSpeed.get()));
                             //推送预警列表
                             getExceptionList();
                             mWarnCountMap.put("speedMaxWarn", 0);