代码优化

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

@@ -184,16 +184,16 @@ public class DeviceEventListener extends AbstractEventListener { //
 
     //1:出铁中,0:出铁结束
     //1号铁口出铁状态
-    private AtomicDouble ironLoading1 = new AtomicDouble(-1);
+    private AtomicInteger ironLoading1 = new AtomicInteger(-1);
     //2号铁口出铁状态
-    private AtomicDouble ironLoading2 = new AtomicDouble(-1);
+    private AtomicInteger ironLoading2 = new AtomicInteger(-1);
     //3号铁口出铁状态
-    private AtomicDouble ironLoading3 = new AtomicDouble(-1);
+    private AtomicInteger ironLoading3 = new AtomicInteger(-1);
     //4号铁口出铁状态
-    private AtomicDouble ironLoading4 = new AtomicDouble(-1);
+    private AtomicInteger ironLoading4 = new AtomicInteger(-1);
 
     //上次1号铁口出铁状态
-    private AtomicDouble lastIronLoading1 = new AtomicDouble(-1);
+    private AtomicInteger lastIronLoading1 = new AtomicInteger(-1);
 
     //出铁步骤
     private List<IronStepVO> mSteps;
@@ -324,7 +324,7 @@ public class DeviceEventListener extends AbstractEventListener { //
      * 更新模型
      */
     private void getModels() {
-        modelMap = ironModelService.lambdaQuery().list().stream().collect(Collectors.toMap(
+        modelMap = ironModelService.lambdaQuery().eq(TIronModel::getStatus, "1").list().stream().collect(Collectors.toMap(
                 TIronModel::getModelName, // 键映射函数
                 model -> model, // 值映射函数
                 (existing, replacement) -> existing // 合并函数
@@ -431,19 +431,59 @@ public class DeviceEventListener extends AbstractEventListener { //
      * 开始新的出铁
      * @param opcData
      */
+    /***
+     * 开始新的出铁
+     * @param opcData
+     */
     private void initIronData(OPCData opcData) {
+        log.info("=== 开始新的出铁流程 ===");
+        log.info("接收到OPC数据触发出铁开始 - 数据点: {}, 数值: {}, 时间戳: {}",
+                opcData.getPointName(),
+                opcData.getData(),
+                LocalDateUtils.formatDate(opcData.getSourceTime()));
+
         //开始出铁
         mTIronData = new TIronData();
-        mTIronData.setId(ToolUtils.makeUUID());
+        String ironDataId = ToolUtils.makeUUID();
+        mTIronData.setId(ironDataId);
         mTIronData.setIronStarttime(LocalDateUtils.formatDate(opcData.getSourceTime()));
+        log.info("创建新的出铁记录 - 铁次ID: {}, 开始时间: {}",
+                ironDataId,
+                mTIronData.getIronStarttime());
+
         TL2Data latestData = tl2DataService.getLatestData();
-        long newIronNo = latestData.getIronNo() + 1;
         if (ObjectUtils.isNotEmpty(latestData)) {
+            long newIronNo = latestData.getIronNo() + 1;
             mTIronData.setIronNo(newIronNo);
+            log.info("获取最新铁次信息成功 - 上一铁次号: {}, 新铁次号: {}, 上一铁次理论重量: {}吨, 实际重量: {}吨",
+                    latestData.getIronNo(),
+                    newIronNo,
+                    latestData.getTheoryWeight(),
+                    latestData.getIronWeight());
+        } else {
+            log.warn("未获取到历史铁次数据，使用默认铁次号: 1");
+            mTIronData.setIronNo(1L);
         }
-        ironDataService.saveOrUpdate(mTIronData);
+
+        log.info("准备保存出铁数据 - 铁次详情: ID={}, 铁次号={}, 开始时间={}",
+                mTIronData.getId(),
+                mTIronData.getIronNo(),
+                mTIronData.getIronStarttime());
+
+        boolean saveResult = ironDataService.saveOrUpdate(mTIronData);
+        log.info("出铁数据保存{} - 影响记录数: {}", saveResult ? "成功" : "失败", saveResult ? 1 : 0);
+
         opcData.setIronDataId(mTIronData.getId());
-        opcDataService.save(opcData);
+        boolean opcSaveResult = opcDataService.save(opcData);
+        log.info("OPC数据关联保存{} - OPC数据ID: {}, 关联铁次ID: {}",
+                opcSaveResult ? "成功" : "失败",
+                opcData.getId(),
+                opcData.getIronDataId());
+
+        log.info("=== 新的出铁流程初始化完成 === 铁次号: {}, 铁次ID: {}, 开始时间: {}",
+                mTIronData.getIronNo(),
+                mTIronData.getId(),
+                mTIronData.getIronStarttime());
     }
 
     private double mLastSpeed;
@@ -735,76 +775,129 @@ public class DeviceEventListener extends AbstractEventListener { //
      * 2. 开启定时任务 -> 出铁诊断(执行一次)、出铁预警、开口预警
      * 3. 清空出铁总量
      */
+    /**
+     * 1号铁口结束出铁的操作项目(由 1-> 0 表明1号铁口结束出铁)
+     * 处理出铁开始事件
+     * 1. 关闭定时任务 -> 出铁超时报警、堵口预警、打泥量选择计算、出铁计时
+     * 2. 开启定时任务 -> 出铁诊断(执行一次)、出铁预警、开口预警
+     * 3. 清空出铁总量
+     */
     private void taphole1End() {
+        log.info("🛑 ====== 开始执行 taphole1End - 出铁结束处理 ======");
+
         synchronized (scheduledTaskManager) {
-            // 关闭所有相关定时任务
+            // 记录当前出铁统计信息
+            log.info("📊 出铁结束统计: 总时长={}分钟, 总重量={}吨",
+                    getIronElapsedMinute(),
+                    mTotalWeight.get().doubleValue());
+
+            // 记录标准参数
+            try {
+                int stdIronTimeMin = Integer.parseInt(mContext.lookupVariable(ExpressionConstants.stdIronTimeMin).toString());
+                int stdIronTimeMax = Integer.parseInt(mContext.lookupVariable(ExpressionConstants.stdIronTimeMax).toString());
+                double stdIronWeightMin = Double.parseDouble(mContext.lookupVariable(ExpressionConstants.stdIronWeightMin).toString());
+                double stdIronWeightMax = Double.parseDouble(mContext.lookupVariable(ExpressionConstants.stdIronWeightMax).toString());
+
+                log.info("📋 标准参数: 时间范围={}-{}分钟, 重量范围={}-{}吨",
+                        stdIronTimeMin, stdIronTimeMax, stdIronWeightMin, stdIronWeightMax);
+            } catch (Exception e) {
+                log.warn("⚠️ 获取标准参数失败: {}", e.getMessage());
+            }
+
+            // 1. 关闭所有相关定时任务
+            log.info("🔒 正在关闭所有相关定时任务...");
             cancelTappingTasks();
+            log.info("✅ 定时任务已关闭");
 
-            //重置开始出铁计时
+            // 2. 重置前端显示
+            log.info("🔄 重置前端显示数据...");
             PushData.send2CostTime(new RealtimeData());
-            //重置预计堵口时间
             PushData.send2CloseTime(new RealtimeData());
+            log.info("✅ 前端显示已重置");
 
-            //尝试重新获取一次新的铁次号码
-            //getIronTimeNo();
+            // 3. 重新加载步骤数据
+            log.info("📂 重新加载步骤数据...");
             mSteps = ironStepService.getTreeSteps();
+            log.info("✅ 步骤数据已重新加载, 共{}个步骤", mSteps.size());
 
-            //开口
-            //PushData.send2CancelWarn(WarnData.warnOpen("", ""));
-            //堵口
+            // 4. 取消相关预警
+            log.info("🚨 取消相关预警信息...");
             PushData.send2CancelWarn(WarnData.warnClose("出铁结束", ""));
-            //出铁预警
             PushData.send2CancelWarn(WarnData.warnTapping("出铁结束", ""));
-            //清空打泥量
+            log.info("✅ 预警信息已取消");
+
+            // 5. 清空打泥量
+            log.info("🧹 清空打泥量计算结果...");
             mCalcHitMud = "";
             PushData.send2IronHitMud(mCalcHitMud);
+            log.info("✅ 打泥量已清空");
+
+            // 6. 出铁时间和重量检查
+            log.info("🔍 开始出铁时间和重量检查...");
 
-            //出铁时间长短告警
             int stdIronTimeMin = Integer.parseInt(mContext.lookupVariable(ExpressionConstants.stdIronTimeMin).toString());
             int stdIronTimeMax = Integer.parseInt(mContext.lookupVariable(ExpressionConstants.stdIronTimeMax).toString());
+            double stdIronWeightMin = Double.parseDouble(mContext.lookupVariable(ExpressionConstants.stdIronWeightMin).toString());
+            double stdIronWeightMax = Double.parseDouble(mContext.lookupVariable(ExpressionConstants.stdIronWeightMax).toString());
+
+            int actualTime = getIronElapsedMinute();
+            double actualWeight = mTotalWeight.get().doubleValue();
+
+            log.info("📈 实际数据: 时间={}分钟, 重量={}吨", actualTime, actualWeight);
 
-            if (getIronElapsedMinute() < stdIronTimeMin) {
+            // 时间检查
+            if (actualTime < stdIronTimeMin) {
+                log.warn("⚠️ 出铁时间过短: 实际{}分钟 < 标准{}分钟", actualTime, stdIronTimeMin);
                 taskExecutor.submit(() -> {
-                    saveException(ExceptionTypeEnum.CHU_TIE_SHI_JIAN_TAI_DUAN, String.format("出铁时间:%s分钟", getIronElapsedMinute()));
-                    //推送预警列表
+                    log.info("📝 记录出铁时间过短异常...");
+                    saveException(ExceptionTypeEnum.CHU_TIE_SHI_JIAN_TAI_DUAN,
+                            String.format("出铁时间:%s分钟", actualTime));
                     getExceptionList();
+                    log.info("✅ 异常已记录并推送");
                 });
-            } else if (getIronElapsedMinute() > stdIronTimeMax) {
-//                taskExecutor.submit(() -> {
-//                    saveException(ExceptionTypeEnum.CHU_TIE_SHI_JIAN_TAI_CHANG, String.format("出铁时间:%s分钟", getIronElapsedMinute()));
-//                    //推送预警列表
-//                    getExceptionList();
-//                });
+            } else if (actualTime > stdIronTimeMax) {
+                log.warn("⚠️ 出铁时间过长: 实际{}分钟 > 标准{}分钟", actualTime, stdIronTimeMax);
+                // 已注释掉，但保留日志
+                log.info("⏰ 出铁时间超过标准上限，但异常记录已注释");
+            } else {
+                log.info("✅ 出铁时间正常: {}分钟", actualTime);
             }
 
-            //出铁量多少告警
-            double stdIronWeightMin = Double.parseDouble(mContext.lookupVariable(ExpressionConstants.stdIronWeightMin).toString());
-            double stdIronWeightMax = Double.parseDouble(mContext.lookupVariable(ExpressionConstants.stdIronWeightMax).toString());
-
-            if (mTotalWeight.get().doubleValue() < stdIronWeightMin) {
+            // 重量检查
+            if (actualWeight < stdIronWeightMin) {
+                log.warn("⚠️ 出铁量过少: 实际{}吨 < 标准{}吨", actualWeight, stdIronWeightMin);
                 taskExecutor.submit(() -> {
-                    PushData.send2Warn(WarnData.warnTapping("出铁量过少", audioMap.get(ExceptionTypeEnum.CHU_TIE_LIANG_TAI_SHAO.getCode())));
-                    saveException(ExceptionTypeEnum.CHU_TIE_LIANG_TAI_SHAO, String.format("出铁量%s吨", mTotalWeight));
-                    //推送预警列表
+                    log.info("📝 记录出铁量过少异常...");
+                    PushData.send2Warn(WarnData.warnTapping("出铁量过少",
+                            audioMap.get(ExceptionTypeEnum.CHU_TIE_LIANG_TAI_SHAO.getCode())));
+                    saveException(ExceptionTypeEnum.CHU_TIE_LIANG_TAI_SHAO,
+                            String.format("出铁量%s吨", actualWeight));
                     getExceptionList();
+                    log.info("✅ 异常已记录并推送");
                 });
-            } else if (mTotalWeight.get().doubleValue() > stdIronWeightMax) {
-//                taskExecutor.submit(() -> {
-//                    PushData.send2Warn(WarnData.warnTapping("出铁量过多", audioMap.get(ExceptionTypeEnum.CHU_TIE_LIANG_TAI_DUO.getCode())));
-//                    saveException(ExceptionTypeEnum.CHU_TIE_LIANG_TAI_DUO, String.format("出铁量%s吨", mTotalWeight));
-//                    //推送预警列表
-//                    getExceptionList();
-//                });
+            } else if (actualWeight > stdIronWeightMax) {
+                log.warn("⚠️ 出铁量过多: 实际{}吨 > 标准{}吨", actualWeight, stdIronWeightMax);
+                // 已注释掉，但保留日志
+                log.info("⚖️ 出铁量超过标准上限，但异常记录已注释");
+            } else {
+                log.info("✅ 出铁重量正常: {}吨", actualWeight);
             }
 
-
-            // 出铁诊断模型
+            // 7. 启动出铁诊断模型
             TIronSchedule tappingTest = scheduleMap.get(TaskNameConstants.TASKNAME_TAPPING_TEST);
             if (tappingTest != null && "1".equals(tappingTest.getStatus())) {
-                scheduledTaskManager.addTask(tappingTest.getName(), tappingTest.getDelay(), tappingTest.getPeriod(), TimeUnit.SECONDS, runnableTappingTest());
+                log.info("🔬 启动出铁诊断模型...");
+                scheduledTaskManager.addTask(tappingTest.getName(),
+                        tappingTest.getDelay(),
+                        tappingTest.getPeriod(),
+                        TimeUnit.SECONDS,
+                        runnableTappingTest());
+                log.info("✅ 出铁诊断模型已启动");
+            } else {
+                log.info("⏭️ 出铁诊断模型未启用");
             }
 
-
+            log.info("🎉 ====== taphole1End - 出铁结束处理完成 ======");
         }
     }
 
@@ -996,6 +1089,7 @@ public class DeviceEventListener extends AbstractEventListener { //
             }
         };
     }
+
     @NotNull
     private Runnable runnableTappingWeightout() {
         return () -> {
@@ -1219,122 +1313,176 @@ public class DeviceEventListener extends AbstractEventListener { //
     @NotNull
     private Runnable runnableTappingTest() {
         return () -> {
-            //堵口预警
-            log.info("出铁结束,定时任务:{},出铁诊断", TaskNameConstants.TASKNAME_TAPPING_TEST);
+            log.info("🔬 ====== 开始执行出铁诊断分析 ======");
+            log.info("诊断任务触发时间: {}", LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
+            log.info("关联铁次ID: {}", mTIronData != null ? mTIronData.getId() : "无");
+
             try {
-                //出铁时间
+                // 获取诊断标准参数
+                log.info("📊 获取诊断标准参数...");
                 int stdIronTimeMin = Integer.parseInt(mContext.lookupVariable(ExpressionConstants.stdIronTimeMin).toString());
                 int stdIronTimeMax = Integer.parseInt(mContext.lookupVariable(ExpressionConstants.stdIronTimeMax).toString());
-                //出铁量
                 double stdIronWeightMin = Double.parseDouble(mContext.lookupVariable(ExpressionConstants.stdIronWeightMin).toString());
                 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());
-                //铁水温度
                 double stdTempMin = Double.parseDouble(mContext.lookupVariable(ExpressionConstants.stdTempMin).toString());
                 double stdTempMax = Double.parseDouble(mContext.lookupVariable(ExpressionConstants.stdTempMax).toString());
+
+                log.info("✅ 标准参数获取完成:");
+                log.info("   出铁时间范围: {}-{} 分钟", stdIronTimeMin, stdIronTimeMax);
+                log.info("   出铁重量范围: {}-{} 吨", stdIronWeightMin, stdIronWeightMax);
+                log.info("   铁水流速范围: {}-{} t/min", stdIronSpeedMin, stdIronSpeedMax);
+                log.info("   铁水温度范围: {}-{} ℃", stdTempMin, stdTempMax);
+
+                // 计算实际数据
+                int actualIronTime = getIronElapsedMinute();
+                double actualIronWeight = mTotalWeight.get().setScale(2, RoundingMode.DOWN).doubleValue();
+                double actualIronSpeed = actualIronTime == 0 ? 0 : actualIronWeight / actualIronTime;
+
+                OptionalDouble averageTemp = tempList.stream()
+                        .mapToInt(Integer::intValue)
+                        .average();
+                int avgTemp = averageTemp.isPresent() ? (int) averageTemp.getAsDouble() : 0;
+
+                log.info("📈 实际出铁数据统计:");
+                log.info("   出铁时长: {} 分钟", actualIronTime);
+                log.info("   总出铁量: {} 吨", actualIronWeight);
+                log.info("   平均流速: {} t/min", String.format("%.2f", actualIronSpeed));
+                log.info("   平均温度: {} ℃", avgTemp);
+                log.info("   温度采样点数: {} 个", tempList.size());
+
+                // 诊断分析
                 int ironNormalCount = 0;
                 StringBuilder sb = new StringBuilder();
-                OptionalDouble averageTemp = tempList.stream()
-                        .mapToInt(Integer::intValue)  // 转换为IntStream
-                        .average();                   // 计算平均值
-                int avgTemp = 0;
-                // 处理计算结果
-                if (averageTemp.isPresent()) {
-                    avgTemp = (int) averageTemp.getAsDouble();
-                }
                 final String ironTimeTip = "出铁时间";
                 final String ironWeightTip = "出铁量";
                 final String ironSpeedTip = "铁水平均流速";
                 final String ironTempTip = "铁水平均温度";
 
-                IronTestItem.IronTestItemBuilder ironTime = IronTestItem.builder().unit("min").typeName(ironTimeTip).status(1).value(getIronElapsedMinute()).desc(ironTimeTip + "正常");
-                IronTestItem.IronTestItemBuilder ironWeight = IronTestItem.builder().unit("t").typeName(ironWeightTip).status(1).value(mTotalWeight.get().setScale(2, RoundingMode.DOWN).doubleValue()).desc(ironWeightTip + "正常");
-                IronTestItem.IronTestItemBuilder ironSpeed = IronTestItem.builder().unit("t/min").typeName(ironSpeedTip).status(1).value(getIronElapsedMinute() == 0 ? 0 : mTotalWeight.get().setScale(2, RoundingMode.DOWN).doubleValue() / getIronElapsedMinute()).desc(ironSpeedTip + "正常");
-                IronTestItem.IronTestItemBuilder ironTemp = IronTestItem.builder().unit("℃").typeName(ironTempTip).status(1).value(avgTemp).desc(ironTempTip + "正常");
-                if (getIronElapsedMinute() < stdIronTimeMin) {
-                    sb.append(ironTimeTip + "过短,");
+                IronTestItem.IronTestItemBuilder ironTime = IronTestItem.builder()
+                        .unit("min").typeName(ironTimeTip).status(1)
+                        .value(actualIronTime).desc(ironTimeTip + "正常");
+                IronTestItem.IronTestItemBuilder ironWeight = IronTestItem.builder()
+                        .unit("t").typeName(ironWeightTip).status(1)
+                        .value(actualIronWeight).desc(ironWeightTip + "正常");
+                IronTestItem.IronTestItemBuilder ironSpeed = IronTestItem.builder()
+                        .unit("t/min").typeName(ironSpeedTip).status(1)
+                        .value(actualIronSpeed).desc(ironSpeedTip + "正常");
+                IronTestItem.IronTestItemBuilder ironTemp = IronTestItem.builder()
+                        .unit("℃").typeName(ironTempTip).status(1)
+                        .value(avgTemp).desc(ironTempTip + "正常");
+
+                // 出铁时间诊断
+                if (actualIronTime < stdIronTimeMin) {
+                    sb.append(ironTimeTip).append("过短,");
                     ironTime.status(0).desc(ironTimeTip + "过短");
-                } else if (getIronElapsedMinute() > stdIronTimeMax) {
-                    sb.append(ironTimeTip + "过长,");
+                    log.warn("⚠️ 出铁时间异常: 实际 {} 分钟 < 标准最小 {} 分钟", actualIronTime, stdIronTimeMin);
+                } else if (actualIronTime > stdIronTimeMax) {
+                    sb.append(ironTimeTip).append("过长,");
                     ironTime.status(0).desc(ironTimeTip + "过长");
+                    log.warn("⚠️ 出铁时间异常: 实际 {} 分钟 > 标准最大 {} 分钟", actualIronTime, stdIronTimeMax);
                 } else {
-                    sb.append(ironTimeTip + "正常,");
+                    sb.append(ironTimeTip).append("正常,");
                     ironTime.status(1).desc(ironTimeTip + "正常");
                     ironNormalCount++;
+                    log.info("✅ 出铁时间正常: {} 分钟", actualIronTime);
                 }
-                if (mTotalWeight.get().doubleValue() < stdIronWeightMin) {
-                    sb.append(ironWeightTip + "过少,");
+
+                // 出铁重量诊断
+                if (actualIronWeight < stdIronWeightMin) {
+                    sb.append(ironWeightTip).append("过少,");
                     ironWeight.status(0).desc(ironWeightTip + "过少");
-                } else if (mTotalWeight.get().doubleValue() > stdIronWeightMax) {
-                    sb.append(ironWeightTip + "过多,");
+                    log.warn("⚠️ 出铁重量异常: 实际 {} 吨 < 标准最小 {} 吨", actualIronWeight, stdIronWeightMin);
+                } else if (actualIronWeight > stdIronWeightMax) {
+                    sb.append(ironWeightTip).append("过多,");
                     ironWeight.status(0).desc(ironWeightTip + "过多");
+                    log.warn("⚠️ 出铁重量异常: 实际 {} 吨 > 标准最大 {} 吨", actualIronWeight, stdIronWeightMax);
                 } else {
-                    sb.append(ironWeightTip + "正常,");
+                    sb.append(ironWeightTip).append("正常,");
                     ironWeight.status(1).desc(ironWeightTip + "正常");
                     ironNormalCount++;
+                    log.info("✅ 出铁重量正常: {} 吨", actualIronWeight);
                 }
-                double avgIronSpeed = getIronElapsedMinute() == 0 ? 0 : (mTotalWeight.get().divide(new BigDecimal(getIronElapsedMinute())).setScale(2, RoundingMode.DOWN)).doubleValue();
-                if (avgIronSpeed < stdIronSpeedMin) {
-                    sb.append(ironSpeedTip + "过慢,");
+
+                // 铁水流速诊断
+                if (actualIronSpeed < stdIronSpeedMin) {
+                    sb.append(ironSpeedTip).append("过慢,");
                     ironSpeed.status(0).desc(ironSpeedTip + "过慢");
-                } else if (avgIronSpeed > stdIronSpeedMax) {
-                    sb.append(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 + "过快");
+                    log.warn("⚠️ 铁水流速异常: 实际 {} t/min > 标准最大 {} t/min",
+                            String.format("%.2f", actualIronSpeed), stdIronSpeedMax);
                 } else {
-                    sb.append(ironSpeedTip + "正常,");
+                    sb.append(ironSpeedTip).append("正常,");
                     ironSpeed.status(1).desc(ironSpeedTip + "正常");
                     ironNormalCount++;
+                    log.info("✅ 铁水流速正常: {} t/min", String.format("%.2f", actualIronSpeed));
                 }
+
+                // 铁水温度诊断
                 if (avgTemp < stdTempMin) {
-                    sb.append(ironTempTip + "过低。");
+                    sb.append(ironTempTip).append("过低。");
                     ironTemp.status(0).desc(ironTempTip + "过低");
+                    log.warn("⚠️ 铁水温度异常: 实际 {} ℃ < 标准最小 {} ℃", avgTemp, stdTempMin);
                 } else if (avgTemp > stdTempMax) {
-                    sb.append(ironTempTip + "过高。");
+                    sb.append(ironTempTip).append("过高。");
                     ironTemp.status(0).desc(ironTempTip + "过高");
+                    log.warn("⚠️ 铁水温度异常: 实际 {} ℃ > 标准最大 {} ℃", avgTemp, stdTempMax);
                 } else {
-                    sb.append(ironTempTip + "正常。");
+                    sb.append(ironTempTip).append("正常。");
                     ironTemp.status(1).desc(ironTempTip + "正常");
                     ironNormalCount++;
+                    log.info("✅ 铁水温度正常: {} ℃", avgTemp);
                 }
+
+                // 生成诊断结果
                 TL2Data latestData = tl2DataService.getLatestData();
                 TIronTest ironTest = new TIronTest();
-                //铁口编号
                 ironTest.setTapholeId("1");
+
                 String testStatus = (ironNormalCount >= 4) ? "1" : "0";
                 ironTest.setTestStatus(testStatus);
                 ironTest.setTestDesc(sb.toString());
+
                 if (ObjectUtils.isNotEmpty(latestData)) {
-                    ironTest.setIronNo(String.valueOf(latestData.getIronNo() + 1));
+                    long ironNo = latestData.getIronNo() + 1;
+                    ironTest.setIronNo(String.valueOf(ironNo));
+                    log.info("📋 关联铁次号: {}", ironNo);
                 }
-                List<IronTestItem> ironTestList = new ArrayList();
+
+                List<IronTestItem> ironTestList = new ArrayList<>();
                 ironTestList.add(ironWeight.build());
                 ironTestList.add(ironTime.build());
                 ironTestList.add(ironSpeed.build());
                 ironTestList.add(ironTemp.build());
-                ironTest.setIronDetail(GsonUtils.toJson(ironTestList));
 
-                iTIronTestService.save(ironTest);
-                log.info("出铁诊断结果:{}", sb.toString());
+                String ironDetailJson = GsonUtils.toJson(ironTestList);
+                ironTest.setIronDetail(ironDetailJson);
+
+                log.info("📊 诊断结果汇总:");
+                log.info("   正常指标数: {}/4", ironNormalCount);
+                log.info("   整体状态: {}", "1".equals(testStatus) ? "优秀" : "异常");
+                log.info("   详细诊断: {}", sb.toString());
+
+                boolean saveResult = iTIronTestService.save(ironTest);
+                log.info("💾 诊断结果保存{} - 记录ID: {}", saveResult ? "成功" : "失败", ironTest.getId());
+
+                log.info("🔬 ====== 出铁诊断分析完成 ======");
+
             } catch (Exception e) {
+                log.error("❌ 出铁诊断分析异常", e);
                 e.printStackTrace();
             } finally {
                 scheduledTaskManager.cancelTask(scheduleMap.get(TaskNameConstants.TASKNAME_TAPPING_TEST).getName());
+                log.info("⏹️ 出铁诊断定时任务已取消");
             }
         };
     }
 
-    //出铁后，记录炉次、开口时间、鱼雷罐车车号、铁口深度、铁水流速
-    private void recordAfter() {
-        ironAfterService.add(null);
-    }
-
-    //堵口后，记录堵口时间、出铁量，打泥量、是否喷溅、是否跑泥
-    private void recordBlock() {
-        ironBlockService.add(null);
-    }
-
     /***
      * 设置实时数据值和状态
      */
@@ -1347,18 +1495,20 @@ public class DeviceEventListener extends AbstractEventListener { //
         //WI5402.PV  1TH-2号车TPC总重
         if (ObjectUtils.isNotEmpty(opcData)) {
             if (opcData.getPointName().contains(SubscribeTagConstants.TAG_TAPHOLE1_STATUS(opcData.getServerType()))) {
-                //将上一个出铁状态保存
-                lastIronLoading1.set(ironLoading1.get());
-                double currentIronState1 = Double.parseDouble(opcData.getData().toString());
+                //
+                int currentIronState1 = Integer.parseInt(opcData.getData().toString());
                 ironLoading1.set(currentIronState1);
 
+                // 在setRealtimeDataAndStatus方法中添加周期性验证日志
+                log.info("周期性出铁状态检查 - 当前状态: {}, 上次状态: {}, 周期时间: {}",
+                        currentIronState1, lastIronLoading1.get(), LocalDateTime.now());
+
                 if (currentIronState1 > 0) {
                     //正在出铁出铁状态
                     log.info("准备调用taphole1Start()");
                     log.info("开始出铁，设置lastIronLoading1=1，当前出铁状态: {}", currentIronState1);
                     taphole1Start();
                     if (firstGetTappingStatus.get()) {
-                        //lastIronLoading1.set(currentIronState1);
                         //查询数据库中最新的1号铁口状态
                         OPCData tappingInfo = opcDataService.lambdaQuery().eq(OPCData::getPointName, opcData.getPointName()).orderByDesc(OPCData::getSourceTime).last("limit 1").one();
                         if (ObjectUtils.isNotEmpty(tappingInfo) && Double.parseDouble(tappingInfo.getData().toString()) > 0 && "prod".equals(activeProfiles)) {
@@ -1402,7 +1552,14 @@ public class DeviceEventListener extends AbstractEventListener { //
                         //开始新的出铁
                         initIronData(opcData);
                     }
-                } else{
+                } else {
+                    log.info("结束出铁，保存结束出铁信息: 实时出铁编号={}, 出铁时长={}分钟, 总重量={}吨, 结束时间={}, 状态变化:{}→{}",
+                            mTIronData.getId(),
+                            getIronElapsedMinute(),
+                            mTotalWeight.get().doubleValue(),
+                            LocalDateUtils.formatDate(opcData.getSourceTime()),
+                            lastIronLoading1.get(),
+                            ironLoading1.get());
                     //未出铁状态
                     if (null != mTIronData) {
                         mTIronData.setIronCosttime(getIronElapsedMinute());
@@ -1435,6 +1592,9 @@ public class DeviceEventListener extends AbstractEventListener { //
                 realtimeData.setDesc("出铁状态");
                 realtimeData.setExtra(opcData.getData());
                 mRealtimeStatus.put(IRON_STATUS, realtimeData);
+
+                changeLastLoading1Status();
+
             } else if (opcData.getPointName().contains(SubscribeTagConstants.TAG_IRON_TEMP(opcData.getServerType()))) {
                 RealtimeData realtimeData = new RealtimeData();
                 realtimeData.setValue(opcData.getData());
@@ -1616,13 +1776,13 @@ public class DeviceEventListener extends AbstractEventListener { //
                     }
                 }
             } else if (opcData.getPointName().contains(SubscribeTagConstants.TAG_TAPHOLE2_STATUS(opcData.getServerType()))) {
-                ironLoading2.set(Double.parseDouble(opcData.getData().toString()));
+                ironLoading2.set(Integer.parseInt(opcData.getData().toString()));
                 //  mContext.setVariable(ExpressionConstants.rtIronState2, ironLoading2.get());
             } else if (opcData.getPointName().contains(SubscribeTagConstants.TAG_TAPHOLE3_STATUS(opcData.getServerType()))) {
-                ironLoading3.set(Double.parseDouble(opcData.getData().toString()));
+                ironLoading3.set(Integer.parseInt(opcData.getData().toString()));
                 //  mContext.setVariable(ExpressionConstants.rtIronState3, ironLoading3.get());
             } else if (opcData.getPointName().contains(SubscribeTagConstants.TAG_TAPHOLE4_STATUS(opcData.getServerType()))) {
-                ironLoading4.set(Double.parseDouble(opcData.getData().toString()));
+                ironLoading4.set(Integer.parseInt(opcData.getData().toString()));
                 // mContext.setVariable(ExpressionConstants.rtIronState4, ironLoading4.get());
             } else if (opcData.getPointName().contains(SubscribeTagConstants.TAG_IRON_WEIGHT11(opcData.getServerType()))
                     || opcData.getPointName().contains(SubscribeTagConstants.TAG_IRON_WEIGHT12(opcData.getServerType()))
@@ -1645,7 +1805,6 @@ public class DeviceEventListener extends AbstractEventListener { //
                     ironWeight1Pre = bigDecimalNew;
 
 
-
                 } else {
                     realtimeData.setValue(0);
                 }
@@ -1838,6 +1997,32 @@ public class DeviceEventListener extends AbstractEventListener { //
         PushData.send2RealtimeStatus(mRealtimeStatus);
     }
 
+    private void changeLastLoading1Status(){
+        //从正在出铁(1)变为出铁结束(0)
+        if (lastIronLoading1.get() > 0 && ironLoading1.get() == 0) {
+            log.info("出铁状态变化：从出铁状态变为非出铁状态，重置所有步骤结果为0，lastIronLoading1从1变为0");
+            setAllStepPassResult(mSteps, 0);
+            lastIronLoading1.set(ironLoading1.get());
+            log.info("状态同步完成，lastIronLoading1已更新为: {}", lastIronLoading1.get());
+            return;
+        }
+        //获取最后一个步骤为是否通过
+        IronStepVO lastStep = null;
+        if (ObjectUtils.isNotEmpty(mSteps)) {
+            lastStep = mSteps.get(mSteps.size() - 1);
+        }
+        // 1. 如果最后一个步骤为 lnct(确认出铁) 且passResult为1，并且ironLoading1为1，则所有步骤passResult都保持为1
+        if (lastStep != null && StepConstans.STEP_LNCT.equals(lastStep.getIdentifier()) && lastStep.getPassResult() == 1 && ironLoading1.get() > 0) {
+            log.info("保持所有步骤通过状态，lastIronLoading1同步为: {}", ironLoading1.get());
+            setAllStepPassResult(mSteps, 1);
+            lastIronLoading1.set(ironLoading1.get());
+            log.info("状态同步完成，lastIronLoading1已更新为: {}", lastIronLoading1.get());
+            return;
+        }
+        log.info("常规状态同步，lastIronLoading1从 {} 更新为 {}", lastIronLoading1.get(), ironLoading1.get());
+        lastIronLoading1.set(ironLoading1.get());
+    }
+
     private synchronized void operate() {
         setStepResult(mSteps);
         PushData.send2Operation(mSteps, ironLoading1.get());
@@ -1863,29 +2048,6 @@ public class DeviceEventListener extends AbstractEventListener { //
             foundFalsePass = isFoundFalsePass(stepDTO, foundFalsePass);
         }
 
-        //从正在出铁(1)变为出铁结束(0)
-        if (lastIronLoading1.get() > 0 && ironLoading1.get() == 0) {
-            log.info("出铁状态变化：从出铁状态变为非出铁状态，重置所有步骤结果为0，lastIronLoading1从1变为0");
-            setAllStepPassResult(mSteps, 0);
-//            lastIronLoading1.set(ironLoading1.get());
-            log.info("状态同步完成，lastIronLoading1已更新为: {}", lastIronLoading1.get());
-            return;
-        }
-        //获取最后一个步骤为是否通过
-        IronStepVO lastStep = null;
-        if (ObjectUtils.isNotEmpty(mSteps)) {
-            lastStep = mSteps.get(mSteps.size() - 1);
-        }
-        // 1. 如果最后一个步骤为 lnct(确认出铁) 且passResult为1，并且ironLoading1为1，则所有步骤passResult都保持为1
-        if (lastStep != null && StepConstans.STEP_LNCT.equals(lastStep.getIdentifier()) && lastStep.getPassResult() == 1 && ironLoading1.get() > 0) {
-            log.info("保持所有步骤通过状态，lastIronLoading1同步为: {}", ironLoading1.get());
-            setAllStepPassResult(mSteps, 1);
-            // lastIronLoading1.set(ironLoading1.get());
-            log.info("状态同步完成，lastIronLoading1已更新为: {}", lastIronLoading1.get());
-            return;
-        }
-        //log.info("常规状态同步，lastIronLoading1从 {} 更新为 {}", lastIronLoading1.get(), ironLoading1.get());
-        //lastIronLoading1.set(ironLoading1.get());
     }
 
     //递归设置所有步骤的passResult
@@ -2014,7 +2176,7 @@ public class DeviceEventListener extends AbstractEventListener { //
         String userId;
         if (ObjectUtils.isEmpty(client) || ObjectUtils.isEmpty(userId = SocketUtil.clientUserIds.get(client))) {
             log.info("该客户已下线");
-            PushData.send2Operation("该客户已下线", 0.0);
+            PushData.send2Operation("该客户已下线", 0);
             return null;
         }
         return userId;
@@ -2035,7 +2197,7 @@ public class DeviceEventListener extends AbstractEventListener { //
 
         if (ObjectUtils.isEmpty(message)) {
             log.info("请求数据为空");
-            PushData.send2Operation("请求数据为空", 0.0);
+            PushData.send2Operation("请求数据为空", 0);
             return;
         }
 

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

@@ -144,7 +144,7 @@ public class PushData {
      * @param message 发送的消息内容
      * @param isStopSendMsg  是否停止发送信息
      */
-    public static void send2Operation(Object message, Double isStopSendMsg) {
+    public static void send2Operation(Object message, Integer isStopSendMsg) {
         if (SocketUtil.connectMap.isEmpty()) {//|| isStopSendMsg
             return;
         }

taphole-l2/src/main/java/com/sckj/l2/entity/TL2Data.java

@@ -85,9 +85,12 @@ public class TL2Data implements Serializable {
     private Double openDepth;
 
     @ApiModelProperty(value = "开始时间")
+    @ExcelProperty("开始时间")
+    @ColumnWidth(25)
     private String ironStarttime;
 
     @ExcelProperty("结束时间")
+    @ColumnWidth(25)
     private String ironEndtime;
 
     @ApiModelProperty(value = "碳")
@@ -95,6 +98,8 @@ public class TL2Data implements Serializable {
     private String elementC;
 
     @ApiModelProperty(value = "硅")
+    @ExcelProperty("硅")
+    @ColumnWidth(25)
     private String elementSi;
 
     @ApiModelProperty(value = "锰")
@@ -106,6 +111,8 @@ public class TL2Data implements Serializable {
     private String elementP;
 
     @ApiModelProperty(value = "硫")
+    @ExcelProperty("硫")
+    @ColumnWidth(25)
     private String elementS;
 
     @ApiModelProperty(value = "钛")