代码优化

taphole-iron/src/main/java/com/sckj/iron/entity/TIronTest.java

@@ -12,7 +12,6 @@ import io.swagger.annotations.ApiModelProperty;
 import lombok.Data;
 
 import java.io.Serializable;
-import java.time.LocalDateTime;
 
 @Data
 @ApiModel("出铁诊断实体")
@@ -67,6 +66,12 @@ public class TIronTest implements Serializable {
     @ColumnWidth(30)
     private String ironWeight;
 
+
+    @ApiModelProperty(value = "预测打泥量")
+    @ExcelProperty("预测打泥量(L)")
+    @ColumnWidth(30)
+    private String predictedMud;
+
     @ApiModelProperty(value = "出铁时间")
     @ExcelProperty("出铁时间(min)")
     @ColumnWidth(25)

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

@@ -1129,12 +1129,6 @@ public class DeviceEventListener extends AbstractEventListener { //
             PushData.send2CancelWarn(new TAudioDTO());
             log.info("✅ 预警信息已取消");
 
-            // 5. 清空打泥量
-            log.info("🧹 清空打泥量计算结果...");
-            mCalcHitMud = "";
-            PushData.send2IronHitMud(mCalcHitMud);
-            log.info("✅ 打泥量已清空");
-
             // 6. 出铁时间和重量检查
             log.info("🔍 开始出铁时间和重量检查...");
 
@@ -1200,6 +1194,7 @@ public class DeviceEventListener extends AbstractEventListener { //
                 log.info("⏭️ 出铁诊断模型未启用");
             }
 
+
             log.info("🎉 ====== taphole1End - 出铁结束处理完成 ======");
         }
     }
@@ -1315,26 +1310,6 @@ public class DeviceEventListener extends AbstractEventListener { //
         };
     }
 
-    //堵口时间预测
-//    @NotNull
-//    private Runnable runnableClosurePredict(ClosurePredictInfo mClosurePredictInfo) {
-//        return () -> {
-//            if (mMaxSpeed.get() > 0 && ironLoading1.get() > 0) {
-//                if (this.mLastSpeed.get() == 0) {
-//
-//                } else if (mMaxSpeed.get() > this.mLastSpeed.get()) {
-//                    //当前流速大于以前的流速
-//                    mDiffCloseTime.set(mDiffCloseTime.get() + mClosurePredictInfo.getDecrMinute());
-//                } else if (mMaxSpeed.get() < this.mLastSpeed.get()) {
-//                    //当前流速小于以前的流速
-//                    mDiffCloseTime.set(mDiffCloseTime.get() - mClosurePredictInfo.getIncrMinute());
-//                }
-//                this.mLastSpeed.set(mMaxSpeed.get());
-//                RedisUtils.addFixedElement(RedisConstants.DIFF_CLOSE_TIME, mDiffCloseTime.get());
-//            }
-//
-//        };
-//    }
 
     //打泥量预测
     @NotNull
@@ -1479,96 +1454,144 @@ public class DeviceEventListener extends AbstractEventListener { //
     @NotNull
     private Runnable runnableTappingWarn() {
         return () -> {
-            log.info("开始执行急需出铁预警检查 - 当前出铁状态: {}", ironLoading1.get());
+            log.info("[急需出铁预警] ===================================== 开始执行预警检查 =====================================");
+            log.info("[急需出铁预警] 执行时间: {}", LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS")));
+            log.info("[急需出铁预警] 当前线程: {}", Thread.currentThread().getName());
+            log.info("[急需出铁预警] 当前出铁状态: {} (1=出铁中, 0=未出铁)", ironLoading1.get());
 
             if (ironLoading1.get() > 0) {
-                log.info("当前正在出铁中，跳过急需出铁预警检查");
+                log.info("[急需出铁预警] 检测到正在出铁中(状态={})，跳过本次预警检查", ironLoading1.get());
+                log.info("[急需出铁预警] ===================================== 预警检查结束 =====================================");
                 return;
             }
 
             TIronModel modelTappingWarn = mModelMap.get(ModelConstants.tapping_warn);
+            log.info("[急需出铁预警] 检索预警模型配置 - 模型标识: {}", ModelConstants.tapping_warn);
+            log.info("[急需出铁预警] 模型检索结果: {}", modelTappingWarn != null ? "找到" : "未找到");
             if (modelTappingWarn == null) {
-                log.warn("未找到急需出铁预警模型配置: {}", ModelConstants.tapping_warn);
+                log.error("[急需出铁预警] 未找到预警模型配置，无法执行预警检查！模型标识: {}", ModelConstants.tapping_warn);
+                log.info("[急需出铁预警] ===================================== 预警检查结束 =====================================");
                 return;
             }
 
-            log.info("获取到急需出铁预警模型: {}", modelTappingWarn.getModelName());
+            log.info("[急需出铁预警] 模型基本信息 - ID: {}, 名称: {}, 状态: {}, 描述: {}",
+                    modelTappingWarn.getId(),
+                    modelTappingWarn.getModelName(),
+                    "1".equals(modelTappingWarn.getStatus()) ? "启用" : "禁用",
+                    modelTappingWarn.getModelDesc());
+            log.info("[急需出铁预警] 模型参数配置 - 表达式: {}", modelTappingWarn.getModelExpression());
 
             String modelExpression = modelTappingWarn.getModelExpression();
-            if (ObjectUtils.isNotEmpty(modelExpression) && "1".equals(modelTappingWarn.getStatus())) {
-                log.info("开始执行预警表达式: {}", modelExpression);
+            if (ObjectUtils.isEmpty(modelExpression)) {
+                log.error("[急需出铁预警] 模型表达式为空，无法执行预警检查！模型名称: {}", modelTappingWarn.getModelName());
+                log.info("[急需出铁预警] ===================================== 预警检查结束 =====================================");
+                return;
+            }
 
-                try {
-                    Expression expression = mParser.parseExpression(modelExpression);
-                    Boolean result = expression.getValue(mContext, Boolean.class);
+            if (!"1".equals(modelTappingWarn.getStatus())) {
+                log.warn("[急需出铁预警] 模型当前状态为禁用，跳过预警检查！模型名称: {}", modelTappingWarn.getModelName());
+                log.info("[急需出铁预警] ===================================== 预警检查结束 =====================================");
+                return;
+            }
 
-                    log.info("急需出铁预警表达式执行结果: {}", result);
+            log.info("[急需出铁预警] 开始执行预警表达式计算");
+            log.info("[急需出铁预警] 表达式内容: {}", modelExpression);
 
-                    String modelKey = modelTappingWarn.getModelName();
-                    int triggerCount = modelTappingWarn.getTriggerCondCount() != null ? modelTappingWarn.getTriggerCondCount() : 1;
+            log.info("开始执行急需出铁预警表达式: {}", modelExpression);
 
-                    List<Object> warnData = mWarnCountMap.getOrDefault(modelKey, new ArrayList<>());
-                    int count = warnData.isEmpty() ? 0 : ((Number) warnData.get(0)).intValue();
+            try {
+                Expression expression = mParser.parseExpression(modelExpression);
+                long startTime = System.currentTimeMillis();
+                Boolean result = expression.getValue(mContext, Boolean.class);
+                long executionTime = System.currentTimeMillis() - startTime;
 
-                    log.info("触发阈值: {}, 当前计数: {}", triggerCount, count);
+                log.info("[急需出铁预警] 表达式执行完成 - 结果: {}, 执行时间: {}ms", result, executionTime);
+                log.info("[急需出铁预警] 上下文变量快照 - 压差(yc): {}, 标准阈值: {}kPa",
+                        mContext.lookupVariable("yc"),
+                        mContext.lookupVariable(ExpressionConstants.stdPressureDiff));
 
-                    if (Boolean.TRUE.equals(result)) {
-                        // 增加计数并保存当前数据
-                        count++;
-                        warnData.clear();
-                        warnData.add(count);
-                        // 保存当前压差数据
-                        warnData.add(mContext.lookupVariable(ExpressionConstants.stdPressureDiff));
-                        mWarnCountMap.put(modelKey, warnData);
+                String modelKey = modelTappingWarn.getModelName();
+                int triggerCount = StandardConstans.WARN_COUNT;
 
-                        log.info("预警条件满足，当前计数: {}/{}", count, triggerCount);
 
-                        if (count >= triggerCount) {
-                            log.warn("触发急需出铁告警，压差超过阈值: {}", mContext.lookupVariable(ExpressionConstants.stdPressureDiff));
+                if (Boolean.TRUE.equals(result)) {
+                    log.warn("[急需出铁预警] ⚠️ 表达式结果为真，满足预警条件");
 
-                            StringBuilder tempValues = new StringBuilder();
-                            for (int i = 1; i < warnData.size(); i++) {
-                                if (i > 1) tempValues.append("、");
-                                tempValues.append(warnData.get(i)).append("kPa");
-                            }
+                    List<Object> warnData = mWarnCountMap.getOrDefault(modelKey, new ArrayList<>());
+                    int count = warnData.isEmpty() ? 0 : ((Number) warnData.get(0)).intValue();
+                    log.info("[急需出铁预警] 当前计数状态 - 当前: {}/{}次, 历史数据: {}",
+                            count, triggerCount, formatWarnData(warnData,"kPa"));
 
-                            // 构建异常消息，包含所有记录的数据
-                            StringBuilder msgBuilder = new StringBuilder("压差:");
-                            msgBuilder.append(tempValues.toString());
-                            msgBuilder.append("连续超过阈值" + StandardConstans.STANDARD_PRESSURE_DIFF + "kPa");
-                            // 这里可以添加具体的异常数据
+                    // 增加计数并保存当前数据
+                    count++;
+                    // 保留最新的不超过触发次数的数据
+                    if (warnData.size() > 1) {
+                        warnData = warnData.subList(0, 1); // 保留计数位置
+                    }
+                    warnData.set(0, count);
+                    // 保存当前压差数据
+                    warnData.add(mContext.lookupVariable("yc"));
+                    mWarnCountMap.put(modelKey, warnData);
 
-                            //触发次数超过配置的次数后发出预警
-                            PushData.send2Warn(mAudioMap.get(ExceptionTypeEnum.NEED_TAPHOLE.getCode()));
-                            saveException(ExceptionTypeEnum.NEED_TAPHOLE, String.format("%s,请降低送风流量,并操作出铁", msgBuilder));
+                    log.info("[急需出铁预警] 计数更新完成 - 新计数: {}/{}次", count, triggerCount);
 
-                            // 重置计数
-                            mWarnCountMap.put(modelKey, new ArrayList<>());
+                    if (count >= StandardConstans.WARN_COUNT) {
+                        log.warn("触发急需出铁告警，压差超过阈值: {}", mContext.lookupVariable(ExpressionConstants.stdPressureDiff));
+
+                        // 构建异常消息，包含所有记录的数据
+                        String msg = String.format("压差:%skPa,连续超过阈值%skPa", formatWarnData(warnData,"kPa"), StandardConstans.STANDARD_PRESSURE_DIFF);
+                        log.info("[急需出铁预警] 告警消息内容: {}", msg);
+                        //触发次数超过配置的次数后发出预警
+                        TAudioDTO audioDTO = mAudioMap.get(ExceptionTypeEnum.NEED_TAPHOLE.getCode());
+                        if (audioDTO != null) {
+                            log.info("[急需出铁预警] 发送音频告警 - 名称: {}, URL: {}", audioDTO.getName(), audioDTO.getAlarmUrl());
+                            PushData.send2Warn(audioDTO);
+                        } else {
+                            log.warn("[急需出铁预警] 未找到对应的告警音频配置 - 异常类型: {}", ExceptionTypeEnum.NEED_TAPHOLE.getCode());
+                        }
+                        log.info("[急需出铁预警] 保存异常记录 - 类型: {}, 描述: {}", ExceptionTypeEnum.NEED_TAPHOLE.getCode(), msg);
+                        saveException(ExceptionTypeEnum.NEED_TAPHOLE, String.format("%s,请降低送风流量,并操作出铁", msg));
 
-                            //推送预警列表
-                            getExceptionList();
+                        //推送预警列表
+                        log.info("[急需出铁预警] 推送预警列表更新");
+                        getExceptionList();
 
-                            log.info("急需出铁告警已发送，计数器已重置");
-                        }
-                    } else {
-                        if (count > 0) {
-                            log.info("预警条件不满足，重置计数器，原计数: {}", count);
-                        }
+                        // 重置计数
+                        mWarnCountMap.put(modelKey, new ArrayList<>());
+                        log.info("急需出铁告警已发送，计数器已重置");
+                    }
+                } else {
+                    log.info("[急需出铁预警] ✅ 表达式结果为假，不满足预警条件");
+                    List<Object> warnData = mWarnCountMap.getOrDefault(modelKey, new ArrayList<>());
+                    int oldCount = warnData.isEmpty() ? 0 : ((Number) warnData.get(0)).intValue();
+                    if (!warnData.isEmpty()) {
+                        oldCount = ((Number) warnData.get(0)).intValue();
+                    }
+
+                    if (oldCount > 0) {
+                        log.info("[急需出铁预警] 重置预警计数器 - 原计数: {}/{}次", oldCount, triggerCount);
                         mWarnCountMap.put(modelKey, new ArrayList<>());
                         PushData.send2CancelWarn(new TAudioDTO());
+                    } else {
+                        log.info("[急需出铁预警] 预警计数器已为0，无需重置");
                     }
-                } catch (Exception e) {
-                    log.error("执行急需出铁预警表达式时发生异常", e);
                 }
-            } else {
-                log.info("急需出铁预警模型未启用或表达式为空，状态: {}, 表达式: {}",
-                        modelTappingWarn.getStatus(), modelExpression);
+            } catch (Exception e) {
+                e.printStackTrace();
             }
-
-            log.info("急需出铁预警检查完成");
+            log.info("[急需出铁预警] ===================================== 预警检查结束 =====================================");
         };
     }
 
+    private String formatWarnData(List<Object> warnData,String unit) {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 1; i < warnData.size(); i++) {
+            if (i > 1) sb.append("、");
+            sb.append(warnData.get(i)).append(unit);
+        }
+        return sb.toString();
+    }
+
     @NotNull
     private Runnable runnableTappingTest() {
         return () -> {
@@ -1706,6 +1729,10 @@ public class DeviceEventListener extends AbstractEventListener { //
                 ironTest.setAvgTemp(avgTemp + "");
                 ironTest.setIronWeight(actualIronWeight + "");
                 ironTest.setIronCosttime(actualIronTime);
+                if (ObjectUtils.isNotEmpty(mCalcHitMud)) {
+                    //预测打泥量
+                    ironTest.setPredictedMud(mCalcHitMud);
+                }
                 if (ObjectUtils.isNotEmpty(mTIronData)) {
                     ironTest.setIronDataId(mTIronData.getId());
                 }
@@ -1745,6 +1772,12 @@ public class DeviceEventListener extends AbstractEventListener { //
             } finally {
                 scheduledTaskManager.cancelTask(mScheduleMap.get(TaskNameConstants.TASKNAME_TAPPING_TEST).getName());
                 log.info("⏹️ 出铁诊断定时任务已取消");
+
+                // 5. 清空打泥量
+                log.info("🧹 清空打泥量计算结果...");
+                mCalcHitMud = "";
+                PushData.send2IronHitMud(mCalcHitMud);
+                log.info("✅ 打泥量已清空");
             }
         };
     }
@@ -2112,13 +2145,8 @@ public class DeviceEventListener extends AbstractEventListener { //
                         log.error("温度偏低预警触发 - 连续{}次异常", StandardConstans.WARN_COUNT);
                         try {
                             // 构建包含所有异常数据的消息
-                            StringBuilder tempValues = new StringBuilder();
-                            for (int i = 1; i < warnData.size(); i++) {
-                                if (i > 1) tempValues.append("、");
-                                tempValues.append(warnData.get(i)).append("℃");
-                            }
                             String exceptionMsg = String.format("温度连续%d次偏低:%s，低于%d℃",
-                                    StandardConstans.WARN_COUNT, tempValues.toString(), stdTempMin);
+                                    StandardConstans.WARN_COUNT,formatWarnData(warnData,"℃"), stdTempMin);
 
                             PushData.send2Warn(mAudioMap.get(ExceptionTypeEnum.IRON_TEMP_HIGH.getCode()));
                             saveException(ExceptionTypeEnum.IRON_TEMP_HIGH, exceptionMsg);
@@ -2153,13 +2181,8 @@ public class DeviceEventListener extends AbstractEventListener { //
                         log.error("温度偏高预警触发 - 连续{}次异常", StandardConstans.WARN_COUNT);
                         try {
                             // 构建包含所有异常数据的消息
-                            StringBuilder tempValues = new StringBuilder();
-                            for (int i = 1; i < warnData.size(); i++) {
-                                if (i > 1) tempValues.append("、");
-                                tempValues.append(warnData.get(i)).append("℃");
-                            }
                             String exceptionMsg = String.format("温度连续%d次偏高:%s，高于%d℃",
-                                    StandardConstans.WARN_COUNT, tempValues.toString(), stdTempMax);
+                                    StandardConstans.WARN_COUNT, formatWarnData(warnData,"℃"), stdTempMax);
 
                             PushData.send2Warn(mAudioMap.get(ExceptionTypeEnum.IRON_TEMP_LOW.getCode()));
                             saveException(ExceptionTypeEnum.IRON_TEMP_LOW, exceptionMsg);
@@ -2213,142 +2236,193 @@ public class DeviceEventListener extends AbstractEventListener { //
                 }
 
             } else if (opcData.getPointName().contains(SubscribeTagConstants.TAG_CAR11(opcData.getServerType())) || opcData.getPointName().contains(SubscribeTagConstants.TAG_CAR12(opcData.getServerType()))) {
-                //1TH-1号车受铁速度、1TH-2号车受铁速度、
+                //1TH-1号车受铁速度、1TH-2号车受铁速度
+                log.info("╔══════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╗");
+                log.info("║                                              【铁水流速数据处理开始】                                                                                                     ║");
+                log.info("╚══════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╝");
+
                 double speed = Double.parseDouble(opcData.getData().toString());
+                log.info("📊 【流速数据基础信息】");
+                log.info("   ├─ 数据源点: {}", opcData.getPointName());
+                log.info("   ├─ 流速值: {}t/min", speed);
+                log.info("   ├─ 数据时间: {}", LocalDateUtils.formatDate(opcData.getSourceTime()));
+                log.info("   └─ 处理时间: {}", LocalDateTime.now());
 
                 String serverTime = LocalDateUtils.formatDate(opcData.getServerTime(), DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:00"));
+                log.info("🕒 【时间处理信息】");
+                log.info("   ├─ 格式化后的时间: {}", serverTime);
 
                 if (ironSpeedMap.containsKey(serverTime)) {
                     Double oldValue = ironSpeedMap.getOrDefault(serverTime, 0D);
+                    log.info("   ├─ 时间点已有数据: 旧值={}t/min", oldValue);
                     if (oldValue < speed) {
                         ironSpeedMap.put(serverTime, speed);
+                        log.info("   └─ 更新流速值: 从{}t/min更新为{}t/min", oldValue, speed);
                     } else {
                         speed = oldValue;
+                        log.info("   └─ 保留原有流速值: {}t/min", speed);
                     }
                 } else {
                     ironSpeedMap.put(serverTime, speed);
+                    log.info("   └─ 新增流速记录: 时间={}, 流速={}t/min", serverTime, speed);
                 }
 
+                double oldMaxSpeed = mMaxSpeed.get();
                 mMaxSpeed.set(speed);
+                if (speed != oldMaxSpeed) {
+                    log.info("📈 【最大流速更新】");
+                    log.info("   └─ 从{}t/min更新为{}t/min", oldMaxSpeed, speed);
+                }
 
                 RealtimeData realtimeData = new RealtimeData();
                 realtimeData.setValue(speed);
                 realtimeData.setUnit("t/min");
                 realtimeData.setDesc("铁水流速");
+                log.info("📋 【实时数据构建】");
+                log.info("   ├─ 流速值: {}t/min", speed);
+                log.info("   ├─ 单位: t/min");
+                log.info("   └─ 描述: 铁水流速");
 
-//
                 mContext.setVariable(ExpressionConstants.rtIronSpeed, speed);
+                log.info("🔧 【上下文变量设置】");
+                log.info("   └─ 设置rtIronSpeed变量值为: {}t/min", speed);
 
                 mRealtimeData.put(IRON_SPEED, realtimeData);
+                log.info("🚀 【数据推送准备】");
+                log.info("   └─ 铁水流速数据已放入实时数据容器");
 
                 if (ironLoading1.get() > 0) {
-                    double stdSpeedMin = Double.parseDouble(mContext.lookupVariable(ExpressionConstants.stdSpeedMin).toString());
-                    double stdSpeedMax = Double.parseDouble(mContext.lookupVariable(ExpressionConstants.stdSpeedMax).toString());
-                    double rtIronSpeed = speed;
-
-                    //采用实时速度方法
-                    if (rtIronSpeed < stdSpeedMin) {
-                        log.warn("流速偏低: {} < {}", rtIronSpeed, stdSpeedMin);
-                        //铁水流速低
-                        List<Object> warnData = mWarnCountMap.getOrDefault("speedMinWarn", new ArrayList<>());
-                        int count = warnData.isEmpty() ? 0 : ((Number) warnData.get(0)).intValue();
-                        count++;
-
-                        // 保留最新的不超过触发次数的数据
-                        if (warnData.size() > 1) {
-                            warnData = warnData.subList(0, 1); // 保留计数位置
-                        }
-                        warnData.set(0, count);
-                        warnData.add(rtIronSpeed); // 添加当前流速数据
+                    log.info("🛠️ 【出铁中流速处理逻辑】");
+                    log.info("   └─ 1号铁口出铁状态: 正在出铁");
 
-                        mWarnCountMap.put("speedMinWarn", warnData);
-                        log.info("流速偏低计数: {}/3", count);
-
-                        if (count >= StandardConstans.WARN_COUNT) {
-                            // 构建包含所有异常数据的消息
-                            StringBuilder speedValues = new StringBuilder();
-                            for (int i = 1; i < warnData.size(); i++) {
-                                if (i > 1) speedValues.append("、");
-                                speedValues.append(String.format("%st/min", warnData.get(i)));
+                    try {
+                        double stdSpeedMin = Double.parseDouble(mContext.lookupVariable(ExpressionConstants.stdSpeedMin).toString());
+                        double stdSpeedMax = Double.parseDouble(mContext.lookupVariable(ExpressionConstants.stdSpeedMax).toString());
+                        double rtIronSpeed = speed;
+                        log.info("📊 【流速标准与实时对比】");
+                        log.info("   ├─ 标准流速范围: {}-{}t/min", stdSpeedMin, stdSpeedMax);
+                        log.info("   └─ 当前实际流速: {}t/min", rtIronSpeed);
+
+                        //采用实时速度方法
+                        if (rtIronSpeed < stdSpeedMin) {
+                            log.warn("⚠️ 【流速异常检测】");
+                            log.warn("   └─ 流速偏低: {} < {}", rtIronSpeed, stdSpeedMin);
+                            //铁水流速低
+                            List<Object> warnData = mWarnCountMap.getOrDefault("speedMinWarn", new ArrayList<>());
+                            int count = warnData.isEmpty() ? 0 : ((Number) warnData.get(0)).intValue();
+                            count++;
+
+                            // 保留最新的不超过触发次数的数据
+                            if (warnData.size() > 1) {
+                                warnData = warnData.subList(0, 1); // 保留计数位置
                             }
-
-                            PushData.send2Warn(mAudioMap.get(ExceptionTypeEnum.NEED_CLOSURE.getCode()));
-                            log.info("触发流速偏低预警");
-                            //推送预警列表
-                            getExceptionList();
-                            mWarnCountMap.put("speedMinWarn", new ArrayList<>());
-
-                            if (ironLoading2.get() > 0 || ironLoading3.get() > 0 || ironLoading4.get() > 0) {
-                                //堵口2
-                                saveException(ExceptionTypeEnum.NEED_CLOSURE,
-                                        String.format("铁水流速连续%d次偏低:%st，低于%st/min,但其它铁口正在出铁,请将当前铁口堵口",
-                                                StandardConstans.WARN_COUNT, speedValues.toString(), stdSpeedMin));
-                            } else {
-                                //堵口3
+                            warnData.set(0, count);
+                            warnData.add(rtIronSpeed); // 添加当前流速数据
+
+                            mWarnCountMap.put("speedMinWarn", warnData);
+                            log.info("📉 【流速偏低计数更新】");
+                            log.info("   └─ 计数: {}/{}", count, StandardConstans.WARN_COUNT);
+
+                            if (count >= StandardConstans.WARN_COUNT) {
+                                log.error("🚨 【流速偏低预警触发】");
+                                // 构建包含所有异常数据的消息
+                                PushData.send2Warn(mAudioMap.get(ExceptionTypeEnum.NEED_CLOSURE.getCode()));
+                                log.info("   ├─ 已发送流速偏低预警音频");
+                                //推送预警列表
+                                getExceptionList();
+                                log.info("   ├─ 已推送预警列表更新");
+                                mWarnCountMap.put("speedMinWarn", new ArrayList<>());
+                                log.info("   ├─ 已重置流速偏低计数器");
+
+                                if (ironLoading2.get() > 0 || ironLoading3.get() > 0 || ironLoading4.get() > 0) {
+                                    //堵口2
+                                    log.info("   ├─ 其他铁口状态: 有铁口正在出铁");
+                                    saveException(ExceptionTypeEnum.NEED_CLOSURE,
+                                            String.format("铁水流速连续%d次偏低:%st，低于%st/min,但其它铁口正在出铁,请将当前铁口堵口",
+                                                    StandardConstans.WARN_COUNT,formatWarnData(warnData,"t/min"), stdSpeedMin));
+                                    log.info("   └─ 已保存异常记录: 类型=NEED_CLOSURE");
+                                } else {
+                                    //堵口3
+                                    log.info("   ├─ 其他铁口状态: 无铁口正在出铁");
+                                    saveException(ExceptionTypeEnum.NEED_CLOSURE,
+                                            String.format("铁水流速连续%d次偏低:%s，低于%st/min,其他铁口均未出铁,请先将其它铁口打开,再进行堵口",
+                                                    StandardConstans.WARN_COUNT, formatWarnData(warnData,"t/min"), stdSpeedMin));
+                                    log.info("   └─ 已保存异常记录: 类型=NEED_CLOSURE");
+                                }
+                            }
+                        } else if (rtIronSpeed > stdSpeedMax) {
+                            log.warn("⚠️ 【流速异常检测】");
+                            log.warn("   └─ 流速偏高: {} > {}", rtIronSpeed, stdSpeedMax);
+                            //铁水流速高
+                            List<Object> warnData = mWarnCountMap.getOrDefault("speedMaxWarn", new ArrayList<>());
+                            int count = warnData.isEmpty() ? 0 : ((Number) warnData.get(0)).intValue();
+                            count++;
+
+                            // 保留最新的不超过触发次数的数据
+                            if (warnData.size() > 1) {
+                                warnData = warnData.subList(0, 1); // 保留计数位置
+                            }
+                            warnData.set(0, count);
+                            warnData.add(rtIronSpeed); // 添加当前流速数据
+
+                            mWarnCountMap.put("speedMaxWarn", warnData);
+                            log.info("📈 【流速偏高计数更新】");
+                            log.info("   └─ 计数: {}/{}", count, StandardConstans.WARN_COUNT);
+
+                            if (count >= StandardConstans.WARN_COUNT) {
+                                log.error("🚨 【流速偏高预警触发】");
+                                // 构建包含所有异常数据的消息
+                                PushData.send2Warn(mAudioMap.get(ExceptionTypeEnum.NEED_CLOSURE.getCode()));
+                                log.info("   ├─ 已发送流速偏高预警音频");
                                 saveException(ExceptionTypeEnum.NEED_CLOSURE,
-                                        String.format("铁水流速连续%d次偏低:%s，低于%st/min,其他铁口均未出铁,请先将其它铁口打开,再进行堵口",
-                                                StandardConstans.WARN_COUNT, speedValues.toString(), stdSpeedMin));
+                                        String.format("铁水流速连续%d次偏高:%s，高于%st/min,建议将当前铁口堵口",
+                                                StandardConstans.WARN_COUNT, formatWarnData(warnData,"t/min"), stdSpeedMax));
+                                log.info("   ├─ 已保存异常记录: 类型=NEED_CLOSURE");
+                                //推送预警列表
+                                getExceptionList();
+                                log.info("   ├─ 已推送预警列表更新");
+                                mWarnCountMap.put("speedMaxWarn", new ArrayList<>());
+                                log.info("   └─ 已重置流速偏高计数器");
                             }
-                        }
-                    } else if (rtIronSpeed > stdSpeedMax) {
-                        log.warn("流速偏高: {} > {}", rtIronSpeed, stdSpeedMax);
-                        //铁水流速高
-                        List<Object> warnData = mWarnCountMap.getOrDefault("speedMaxWarn", new ArrayList<>());
-                        int count = warnData.isEmpty() ? 0 : ((Number) warnData.get(0)).intValue();
-                        count++;
-
-                        // 保留最新的不超过触发次数的数据
-                        if (warnData.size() > 1) {
-                            warnData = warnData.subList(0, 1); // 保留计数位置
-                        }
-                        warnData.set(0, count);
-                        warnData.add(rtIronSpeed); // 添加当前流速数据
-
-                        mWarnCountMap.put("speedMaxWarn", warnData);
-                        log.info("流速偏高计数: {}/3", count);
+                        } else {
+                            // 流速正常，重置异常计数
+                            int oldMinCount = 0;
+                            int oldMaxCount = 0;
 
-                        if (count >= StandardConstans.WARN_COUNT) {
-                            // 构建包含所有异常数据的消息
-                            StringBuilder speedValues = new StringBuilder();
-                            for (int i = 1; i < warnData.size(); i++) {
-                                if (i > 1) speedValues.append("、");
-                                speedValues.append(String.format("%st/min", warnData.get(i)));
+                            List<Object> minWarnData = mWarnCountMap.getOrDefault("speedMinWarn", new ArrayList<>());
+                            if (!minWarnData.isEmpty()) {
+                                oldMinCount = ((Number) minWarnData.get(0)).intValue();
                             }
 
-                            log.info("触发流速偏高预警");
-                            PushData.send2Warn(mAudioMap.get(ExceptionTypeEnum.NEED_CLOSURE.getCode()));
-                            saveException(ExceptionTypeEnum.NEED_CLOSURE,
-                                    String.format("铁水流速连续%d次偏高:%s，高于%st/min,建议将当前铁口堵口",
-                                            StandardConstans.WARN_COUNT, speedValues.toString(), stdSpeedMax));
-                            //推送预警列表
-                            getExceptionList();
-                            mWarnCountMap.put("speedMaxWarn", new ArrayList<>());
-                        }
-                    } else {
-                        // 温度或流速正常，重置异常计数
-                        int oldMinCount = 0;
-                        int oldMaxCount = 0;
-
-                        List<Object> minWarnData = mWarnCountMap.getOrDefault("speedMinWarn", new ArrayList<>());
-                        if (!minWarnData.isEmpty()) {
-                            oldMinCount = ((Number) minWarnData.get(0)).intValue();
-                        }
+                            List<Object> maxWarnData = mWarnCountMap.getOrDefault("speedMaxWarn", new ArrayList<>());
+                            if (!maxWarnData.isEmpty()) {
+                                oldMaxCount = ((Number) maxWarnData.get(0)).intValue();
+                            }
 
-                        List<Object> maxWarnData = mWarnCountMap.getOrDefault("speedMaxWarn", new ArrayList<>());
-                        if (!maxWarnData.isEmpty()) {
-                            oldMaxCount = ((Number) maxWarnData.get(0)).intValue();
-                        }
+                            if (oldMinCount > 0 || oldMaxCount > 0) {
+                                log.info("✅ 【流速恢复正常】");
+                                log.info("   ├─ 当前流速: {}t/min", rtIronSpeed);
+                                log.info("   ├─ 重置异常计数器 - 偏低计数: {}, 偏高计数: {}", oldMinCount, oldMaxCount);
+                            } else {
+                                log.info("✅ 【流速正常】");
+                                log.info("   └─ 当前流速: {}t/min 在 {}-{}t/min 范围内", rtIronSpeed, stdSpeedMin, stdSpeedMax);
+                            }
 
-                        if (oldMinCount > 0 || oldMaxCount > 0) {
-                            log.info("速度恢复正常 - 当前: {}t/min，重置异常计数器", rtIronSpeed);
+                            mWarnCountMap.put("speedMinWarn", new ArrayList<>());
+                            mWarnCountMap.put("speedMaxWarn", new ArrayList<>());
                         }
-
-                        log.info("流速正常: {} 在 {}-{} 范围内", rtIronSpeed, stdSpeedMin, stdSpeedMax);
-                        mWarnCountMap.put("speedMinWarn", new ArrayList<>());
-                        mWarnCountMap.put("speedMaxWarn", new ArrayList<>());
+                    } catch (Exception e) {
+                        log.error("❌ 【流速处理异常】", e);
+                        e.printStackTrace();
                     }
-
+                } else {
+                    log.info("💤 【非出铁状态流速处理】");
+                    log.info("   └─ 1号铁口未处于出铁状态，跳过异常检测逻辑");
                 }
+
+                log.info("╔══════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╗");
+                log.info("║                                              【铁水流速数据处理完成】                                                                                                     ║");
+                log.info("╚══════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╝");
             } else if (opcData.getPointName().contains(SubscribeTagConstants.TAG_TAPHOLE2_STATUS(opcData.getServerType()))) {
                 ironLoading2.set(Integer.parseInt(opcData.getData().toString()));
                 //  mContext.setVariable(ExpressionConstants.rtIronState2, ironLoading2.get());