微调

# Conflicts:
#	detection/src/main/java/com/njcn/gather/detection/util/socket/FormalTestManager.java

detection/src/main/java/com/njcn/gather/detection/controller/PreDetectionController.java

@@ -10,6 +10,7 @@ import com.njcn.gather.detection.pojo.param.ContrastDetectionParam;
 import com.njcn.gather.detection.pojo.param.PreDetectionParam;
 import com.njcn.gather.detection.pojo.param.SimulateDetectionParam;
 import com.njcn.gather.detection.service.PreDetectionService;
+import com.njcn.gather.detection.util.socket.CnSocketUtil;
 import com.njcn.web.controller.BaseController;
 import com.njcn.web.utils.HttpResultUtil;
 import io.swagger.annotations.Api;
@@ -155,4 +156,47 @@ public class PreDetectionController extends BaseController {
         LogUtil.njcnDebug(log, "{}", methodDescribe);
         preDetectionService.exportAlignData();
     }
+
+    @OperateInfo(info = LogEnum.SYSTEM_COMMON)
+    @GetMapping("/canCoefficient")
+    @ApiOperation("比对模式是否能够进行系数校验")
+    public HttpResult<Boolean> canCoefficient() {
+        String methodDescribe = getMethodDescribe("canCoefficient");
+        LogUtil.njcnDebug(log, "{}", methodDescribe);
+
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, preDetectionService.getCanCoefficient(), methodDescribe);
+    }
+
+    @OperateInfo(info = LogEnum.SYSTEM_COMMON)
+    @GetMapping("/startCoefficient")
+    @ApiOperation("比对模式开启系数校验")
+    public HttpResult<String> startCoefficient() {
+        String methodDescribe = getMethodDescribe("startCoefficient");
+        LogUtil.njcnDebug(log, "{}", methodDescribe);
+
+        preDetectionService.startCoefficient();
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
+    }
+
+    @OperateInfo(info = LogEnum.SYSTEM_COMMON)
+    @GetMapping("/startFreqConverter")
+    @ApiOperation("开启变频器测试")
+    public HttpResult<String> startFreqConverter(@RequestParam("userId") String userId, @RequestParam("converterId") String converterId, @RequestParam("monitorId") String monitorId, @RequestParam("reset") Boolean reset) {
+        String methodDescribe = getMethodDescribe("startFreqConverter");
+        LogUtil.njcnDebug(log, "{}", methodDescribe);
+
+        preDetectionService.startFreqConverter(userId, converterId, monitorId,reset);
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
+    }
+
+    @OperateInfo(info = LogEnum.SYSTEM_COMMON)
+    @GetMapping("/stopFreqConverter")
+    @ApiOperation("关闭变频器测试")
+    public HttpResult<String> stopFreqConverter(@RequestParam("userId") String userId) {
+        String methodDescribe = getMethodDescribe("stopFreqConverter");
+        LogUtil.njcnDebug(log, "{}", methodDescribe);
+
+        preDetectionService.stopFreqConverter(userId + CnSocketUtil.FREQ_CONVERTER_TAG, userId + CnSocketUtil.DEV_TAG);
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
+    }
 }

detection/src/main/java/com/njcn/gather/detection/handler/SocketContrastResponseService.java

@@ -11,7 +11,9 @@ import cn.hutool.core.util.StrUtil;
 import com.alibaba.fastjson.JSON;
 import com.alibaba.fastjson.serializer.SerializerFeature;
 import com.google.common.collect.HashBiMap;
+import com.njcn.common.pojo.enums.common.DataStateEnum;
 import com.njcn.common.pojo.exception.BusinessException;
+import com.njcn.gather.detection.pojo.dto.DevXiNumData;
 import com.njcn.gather.detection.pojo.dto.WaveCommandDTO;
 import com.njcn.gather.detection.pojo.dto.WaveResultDTO;
 import com.njcn.gather.detection.pojo.enums.*;
@@ -24,15 +26,17 @@ import com.njcn.gather.detection.pojo.vo.*;
 import com.njcn.gather.detection.service.IAdPariService;
 import com.njcn.gather.detection.service.impl.DetectionServiceImpl;
 import com.njcn.gather.detection.util.DetectionUtil;
-import com.njcn.gather.detection.util.socket.CnSocketUtil;
+import com.njcn.gather.detection.util.socket.*;
-import com.njcn.gather.detection.util.socket.FormalTestManager;
-import com.njcn.gather.detection.util.socket.MsgUtil;
-import com.njcn.gather.detection.util.socket.SocketManager;
 import com.njcn.gather.detection.util.socket.websocket.WebServiceManager;
 import com.njcn.gather.device.pojo.enums.PatternEnum;
+import com.njcn.gather.device.pojo.po.PqStandardDevGain;
+import com.njcn.gather.device.pojo.po.PqStandardDevGainRecord;
 import com.njcn.gather.device.pojo.vo.PreDetection;
 import com.njcn.gather.device.service.IPqDevService;
+import com.njcn.gather.device.service.IPqStandardDevGainRecordService;
+import com.njcn.gather.device.service.IPqStandardDevGainService;
 import com.njcn.gather.device.service.IPqStandardDevService;
+import com.njcn.gather.monitor.pojo.po.PqMonitor;
 import com.njcn.gather.monitor.service.IPqMonitorService;
 import com.njcn.gather.plan.pojo.enums.DataSourceEnum;
 import com.njcn.gather.plan.service.IAdPlanService;
@@ -62,6 +66,7 @@ import java.io.IOException;
 import java.io.InputStream;
 import java.lang.reflect.Field;
 import java.math.BigDecimal;
+import java.math.RoundingMode;
 import java.text.DecimalFormat;
 import java.time.LocalDateTime;
 import java.time.format.DateTimeFormatter;
@@ -92,6 +97,8 @@ public class SocketContrastResponseService {
     private final IAdPariService adPairService;
     private final ICompareWaveService compareWaveService;
     private final IAdPlanTestConfigService adPlanTestConfigService;
+    private final IPqStandardDevGainService pqStandardDevGainService;
+    private final IPqStandardDevGainRecordService pqStandardDevGainRecordService;
 
 
     /**
@@ -185,6 +192,7 @@ public class SocketContrastResponseService {
         FormalTestManager.isXu = param.getPhaseCheck() == 1 ? true : false;
 //        FormalTestManager.isXu = true;
         FormalTestManager.nonWaveDataSourceEnum = null;
+        DetectionServiceImpl.vAndIResultMap = new HashMap<>();
 
         String[] datasourceIds = FormalTestManager.currentTestPlan.getDatasourceId().split(",");
         for (String datasourceId : datasourceIds) {
@@ -377,6 +385,10 @@ public class SocketContrastResponseService {
             case RECORD_WAVE_STEP1:
                 this.recordWave(param, socketDataMsg);
                 break;
+            //系数校验
+            case Coefficient_Check:
+                this.coefficient(param, socketDataMsg);
+                break;
             //退出关闭
             case QUITE:
                 quitDeal(socketDataMsg, param);
@@ -1405,6 +1417,28 @@ public class SocketContrastResponseService {
                                                 pqDevService.updateResult(id1.split(CnSocketUtil.SPLIT_TAG)[0], param.getUserId());
                                             });
                                             FormalTestManager.isTesting = false;
+
+                                            if (CollUtil.isNotEmpty(DetectionServiceImpl.vAndIResultMap)) {
+                                                // 是否进行系数校准
+                                                //万一录波了这里就进不来了，但是在误差处理的时候DetectionServiceImpl.vAndIResultMap该集合会保留不符合的结果
+
+                                                XiNumberManager.xiDevList.clear();
+                                                XiNumberManager.devXiNumDataMap.clear();
+                                                List<String> stdIpList = DetectionServiceImpl.vAndIResultMap.values().stream().map(DetectionServiceImpl.VAndIResult::getIp).collect(Collectors.toList());
+                                                XiNumberManager.xiDevList = FormalTestManager.standardDevList.stream().filter(d -> stdIpList.contains(d.getDevIP())).collect(Collectors.toList());
+                                                // 逐一设备向通讯模块要原始系数
+                                                SocketMsg<String> socketMsg = new SocketMsg<>();
+                                                socketMsg.setRequestId(SourceOperateCodeEnum.Coefficient_Check.getValue());
+                                                socketMsg.setOperateCode(SourceOperateCodeEnum.DATA_CHNFACTOR$01.getValue());
+                                                PreDetection preDetection = XiNumberManager.xiDevList.get(0);
+                                                Map<String, Object> map = new HashMap<>();
+                                                map.put("devIP", preDetection.getDevIP());
+                                                map.put("chnNum", preDetection.getDevChns());
+                                                socketMsg.setData(JSON.toJSONString(map));
+                                                SocketManager.sendMsg(param.getUserPageId() + CnSocketUtil.CONTRAST_DEV_TAG, JSON.toJSONString(socketMsg));
+
+                                                FormalTestManager.currentStep = SourceOperateCodeEnum.Coefficient_Check;
+                                            }
                                         }
                                     } else {
                                         // 配对关系入库
@@ -1682,6 +1716,160 @@ public class SocketContrastResponseService {
         }
     }
 
+    private void coefficient(PreDetectionParam param, SocketDataMsg socketDataMsg) {
+        SourceOperateCodeEnum sourceOperateCodeEnum = SourceOperateCodeEnum.getDictDataEnumByCode(socketDataMsg.getOperateCode());
+        SourceResponseCodeEnum dictDataEnumByCode = SourceResponseCodeEnum.getDictDataEnumByCode(socketDataMsg.getCode());
+        SocketMsg<String> xiSocket = new SocketMsg<>();
+        xiSocket.setRequestId(SourceOperateCodeEnum.Coefficient_Check.getValue());
+
+        switch (Objects.requireNonNull(sourceOperateCodeEnum)) {
+            case DATA_CHNFACTOR$01:
+                //获取系数
+                switch (Objects.requireNonNull(dictDataEnumByCode)) {
+                    case SUCCESS:
+                        if (CollUtil.isNotEmpty(XiNumberManager.xiDevList)) {
+                            List<DevXiNumData.GF> gfList = JSON.parseArray(socketDataMsg.getData(), DevXiNumData.GF.class);
+                            DevXiNumData devXiNumData = new DevXiNumData();
+                            String ip = XiNumberManager.xiDevList.get(0).getDevIP();
+                            devXiNumData.setDevIP(ip);
+                            //String stdMonitorId = DetectionServiceImpl.vAndIResultMap.keySet().stream().filter(key -> key.contains(ip)).findFirst().get();
+
+                            List<PqStandardDevGain> pqStandardDevGainList = new ArrayList<>();
+                            List<PqStandardDevGainRecord> recordList = new ArrayList<>();
+                            for (int i = 0; i < gfList.size(); i++) {
+                                DevXiNumData.GF gf = gfList.get(i);
+                                String stdDevMonitorId = FormalTestManager.devIdMapComm.get(ip) + CnSocketUtil.SPLIT_TAG + (gf.getUMonitorPoint() + 1);
+                                String devMonitorId = FormalTestManager.pairsIdMap.inverse().get(stdDevMonitorId);
+                                PqStandardDevGain pqStandardDevGain = new PqStandardDevGain();
+                                pqStandardDevGain.setStdDevMonitorId(stdDevMonitorId);
+
+                                DevXiNumData.F f = gf.getF();
+                                pqStandardDevGain.setUaGain(f.getUa_gain());
+                                pqStandardDevGain.setUbGain(f.getUb_gain());
+                                pqStandardDevGain.setUcGain(f.getUc_gain());
+                                pqStandardDevGain.setU0Gain(f.getU0_gain());
+                                pqStandardDevGain.setIaGain(f.getIa_gain());
+                                pqStandardDevGain.setIbGain(f.getIb_gain());
+                                pqStandardDevGain.setIcGain(f.getIc_gain());
+                                pqStandardDevGain.setI0Gain(f.getI0_gain());
+                                pqStandardDevGain.setUabGain(f.getUab_gain());
+                                pqStandardDevGain.setUbcGain(f.getUbc_gain());
+                                pqStandardDevGain.setUcaGain(f.getUca_gain());
+                                pqStandardDevGain.setState(DataStateEnum.ENABLE.getCode());
+                                pqStandardDevGainList.add(pqStandardDevGain);
+                                DetectionServiceImpl.VAndIResult vAndIResult = DetectionServiceImpl.vAndIResultMap.get(ip + CnSocketUtil.SPLIT_TAG + (gf.getUMonitorPoint() + 1));
+                                if (ObjectUtil.isNotNull(vAndIResult)) {
+                                    int maxNum = pqStandardDevGainRecordService.getMaxNum(stdDevMonitorId, devMonitorId);
+                                    PqStandardDevGainRecord record = new PqStandardDevGainRecord();
+                                    record.setStdDevMonitorId(stdDevMonitorId);
+                                    record.setDevMonitorId(devMonitorId);
+                                    record.setNum(maxNum + 1);
+                                    recordList.add(record);
+                                    updateGfList(f, vAndIResult, stdDevMonitorId, maxNum);
+                                }
+                            }
+
+                            xiSocket.setOperateCode(SourceOperateCodeEnum.DATA_CHNFACTOR$02.getValue());
+                            devXiNumData.setGf(gfList);
+                            xiSocket.setData(JSON.toJSONString(devXiNumData));
+                            SocketManager.sendMsg(param.getUserPageId() + CnSocketUtil.CONTRAST_DEV_TAG, JSON.toJSONString(xiSocket));
+
+                            // 原始系数入库
+                            pqStandardDevGainService.add(pqStandardDevGainList);
+                            pqStandardDevGainRecordService.addOrUpdate(recordList);
+                        }
+                        break;
+                    case UNPROCESSED_BUSINESS:
+                        break;
+                    case NORMAL_RESPONSE:
+                        break;
+                    case DATA_RESOLVE:
+                        break;
+                    case COMMUNICATION_ERR:
+                        break;
+                    default:
+                        break;
+                }
+
+                break;
+            case DATA_CHNFACTOR$02:
+                //系数下发后的响应
+                switch (Objects.requireNonNull(dictDataEnumByCode)) {
+                    case SUCCESS:
+                        //单台装置系数下发后，需要删除集合中存在的当前装置
+                        XiNumberManager.xiDevList.remove(0);
+                        //继续下发每台装置系数，只到集合为空
+                        if (CollUtil.isNotEmpty(XiNumberManager.xiDevList)) {
+                            xiSocket.setOperateCode(SourceOperateCodeEnum.DATA_CHNFACTOR$01.getValue());
+                            xiSocket.setData(JSON.toJSONString(XiNumberManager.devXiNumDataMap.get(XiNumberManager.xiDevList.get(0))));
+                            PreDetection preDetection = XiNumberManager.xiDevList.get(0);
+                            Map<String, Object> map = new HashMap<>();
+                            map.put("devIP", preDetection.getDevIP());
+                            map.put("chnNum", preDetection.getDevChns());
+                            xiSocket.setData(JSON.toJSONString(map));
+                            SocketManager.sendMsg(param.getUserPageId() + CnSocketUtil.CONTRAST_DEV_TAG, JSON.toJSONString(xiSocket));
+                        } else {
+                            //{"requestId":"Coefficient_Check","operateCode":"DATA_CHNFACTOR$02","data":"end","code":10200}
+                            // 通知前端全部下发系数完成
+                        }
+                        break;
+                    case UNPROCESSED_BUSINESS:
+                        break;
+                    case NORMAL_RESPONSE:
+                        break;
+                    case DATA_RESOLVE:
+                        //quitSend(param);
+                        break;
+                    case COMMUNICATION_ERR:
+                        break;
+                    default:
+                        break;
+                }
+                break;
+//            case DEV_DATA_REQUEST_02:
+//                //实时采集申请
+//                String data = socketDataMsg.getData();
+//                DevData devData = JSON.parseObject(data, DevData.class);
+//                if (ObjectUtil.isNotNull(dictDataEnumByCode)) {
+//                    switch (dictDataEnumByCode) {
+//                        case SUCCESS:
+//                            if (devData.getResult()) {
+//                                FormalTestManager.realDataXiList.add(devData);
+//                                successComm.add(devData.getId());
+//                                System.out.println(successComm.size() + " ==" + FormalTestManager.monitorIdListComm.size() + "FormalTestManager.realDataXiList:" + FormalTestManager.realDataXiList.size() + "当前步骤" + XiNumberManager.stepNumber);
+//                                if (successComm.size() == FormalTestManager.monitorIdListComm.size()) {
+//                                    processData(param, xiSocket);
+//                                }
+//                            } else {
+//                                System.out.println("系数校准抛除数据" + devData);
+//                            }
+//                            break;
+//                        case UNPROCESSED_BUSINESS:
+//                            WebServiceManager.sendMsg(param.getUserPageId(), JSON.toJSONString(socketDataMsg));
+//                            break;
+//                        case NORMAL_RESPONSE:
+//                            if (devData.getResult()) {
+//                                FormalTestManager.realDataXiList.add(devData);
+//                            } else {
+//                                System.out.println("系数校准抛除数据" + devData);
+//                            }
+//                            break;
+//                        default:
+//                            xiSocket.setRequestId(socketDataMsg.getRequestId());
+//                            xiSocket.setOperateCode(socketDataMsg.getOperateCode());
+//                            xiSocket.setData(dictDataEnumByCode.getMessage());
+//                            WebServiceManager.sendMsg(param.getUserPageId(), JSON.toJSONString(xiSocket));
+//                            break;
+//                    }
+//                }
+//                break;
+            default:
+                WebServiceManager.sendUnknownErrorMessage(param.getUserPageId());
+                break;
+        }
+
+    }
+
 
     /**
      * 退出检测返回
@@ -1856,13 +2044,13 @@ public class SocketContrastResponseService {
      */
     private Integer getTargetCount() {
         if (FormalTestManager.isPstData) {
-            return FormalTestManager.curretntTestPlanConfig.getFlicker();
+            return FormalTestManager.curretntTestPlanConfig.getFlicker() * 2;
         }
         if (ObjectUtil.isNotNull(FormalTestManager.nonWaveDataSourceEnum)) {
             if (FormalTestManager.nonWaveDataSourceEnum == DataSourceEnum.REAL_DATA) {
-                return FormalTestManager.curretntTestPlanConfig.getRealTime();
+                return FormalTestManager.curretntTestPlanConfig.getRealTime() * 2;
             } else {
-                return FormalTestManager.curretntTestPlanConfig.getStatistics();
+                return FormalTestManager.curretntTestPlanConfig.getStatistics() * 2;
             }
         }
         return -1;
@@ -1948,8 +2136,13 @@ public class SocketContrastResponseService {
                         isStar = true;
                         isDelta = false;
                     } else {
-                        isStar = false;
+                        if (DetectionCodeEnum.STAR.getCode().equals(monitorListDTO.getConnection())) {
-                        isDelta = true;
+                            isStar = true;
+                            isDelta = false;
+                        } else {
+                            isStar = false;
+                            isDelta = true;
+                        }
                     }
                 }
 
@@ -2052,8 +2245,13 @@ public class SocketContrastResponseService {
                         isStar = true;
                         isDelta = false;
                     } else {
-                        isStar = false;
+                        if (DetectionCodeEnum.STAR.getCode().equals(monitorListDTO.getConnection())) {
-                        isDelta = true;
+                            isStar = true;
+                            isDelta = false;
+                        } else {
+                            isStar = false;
+                            isDelta = true;
+                        }
                     }
                 }
 
@@ -2273,8 +2471,13 @@ public class SocketContrastResponseService {
                 isStar = true;
                 isDelta = false;
             } else {
-                isStar = false;
+                if (DetectionCodeEnum.STAR.getCode().equals(monitorListDTO.getConnection())) {
-                isDelta = true;
+                    isStar = true;
+                    isDelta = false;
+                } else {
+                    isStar = false;
+                    isDelta = true;
+                }
             }
         }
 
@@ -2592,18 +2795,30 @@ public class SocketContrastResponseService {
                     devInfo = pqDevService.getDevInfo(Collections.singletonList(devId));
                 }
                 Integer usePhaseIndex = devInfo.get(0).getUsePhaseIndex();
-
                 List<String> allDesc = data.getSqlData().stream().map(x -> x.getDesc()).collect(Collectors.toList());
                 allDesc.addAll(data.getSqlDataHarm().stream().map(x -> x.getDesc()).collect(Collectors.toList()));
 
+                String bzDevId = devId;
+                if (isStdDev) {
+                    String s = FormalTestManager.pairsIdMap.inverse().get(devId + CnSocketUtil.SPLIT_TAG + splitArr[1]);
+                    bzDevId = s.split(CnSocketUtil.SPLIT_TAG)[0];
+                }
+                PqMonitor monitor = pqMonitorService.getByDevIdAndNum(bzDevId, Integer.parseInt(splitArr[1]));
+                DictData dictData = dictDataService.getById(monitor.getConnection());
                 for (DevData.SqlDataDTO sqlDataDTO : data.getSqlData()) {
                     if (usePhaseIndex.equals(1)) {
                         if (DetectionCodeEnum.PVRMS.getCode().equals(sqlDataDTO.getDesc()) || DetectionCodeEnum.PU1.getCode().equals(sqlDataDTO.getDesc())) {
                             continue;
                         }
                     } else {
-                        if (DetectionCodeEnum.VRMS.getCode().equals(sqlDataDTO.getDesc()) || DetectionCodeEnum.U1.getCode().equals(sqlDataDTO.getDesc())) {
+                        if (DetectionCodeEnum.STAR.getCode().equals(dictData.getCode())) {
-                            continue;
+                            if (DetectionCodeEnum.PVRMS.getCode().equals(sqlDataDTO.getDesc()) || DetectionCodeEnum.PU1.getCode().equals(sqlDataDTO.getDesc())) {
+                                continue;
+                            }
+                        } else {
+                            if ((DetectionCodeEnum.VRMS.getCode().equals(sqlDataDTO.getDesc()) || DetectionCodeEnum.U1.getCode().equals(sqlDataDTO.getDesc()))) {
+                                continue;
+                            }
                         }
                     }
 
@@ -2651,8 +2866,14 @@ public class SocketContrastResponseService {
                             continue;
                         }
                     } else {
-                        if (DetectionCodeEnum.V2_50.getCode().equals(sqlDataDTO.getDesc()) || DetectionCodeEnum.SV_1_49.getCode().equals(sqlDataDTO.getDesc())) {
+                        if (DetectionCodeEnum.STAR.getCode().equals(dictData.getCode())) {
-                            continue;
+                            if (DetectionCodeEnum.PV2_50.getCode().equals(sqlDataDTO.getDesc()) || DetectionCodeEnum.PSV_1_49.getCode().equals(sqlDataDTO.getDesc())) {
+                                continue;
+                            }
+                        } else {
+                            if (DetectionCodeEnum.V2_50.getCode().equals(sqlDataDTO.getDesc()) || DetectionCodeEnum.SV_1_49.getCode().equals(sqlDataDTO.getDesc())) {
+                                continue;
+                            }
                         }
                     }
 
@@ -3289,4 +3510,46 @@ public class SocketContrastResponseService {
         devData.setSqlDataHarm(sqlDataHarmDTOS);
         return devData;
     }
+
+    /**
+     * 修改通道系数
+     *
+     * @param f
+     */
+    private void updateGfList(DevXiNumData.F f, DetectionServiceImpl.VAndIResult vAndIResult, String stdDevMonitorId, int maxNum) {
+        DevXiNumData.F originF = BeanUtil.copyProperties(f, DevXiNumData.F.class);
+        if (maxNum != 0) {
+            PqStandardDevGain pqStandardDevGain = pqStandardDevGainService.get(stdDevMonitorId);
+            originF.setUa_gain(pqStandardDevGain.getUaGain());
+            originF.setUb_gain(pqStandardDevGain.getUbGain());
+            originF.setUc_gain(pqStandardDevGain.getUcGain());
+            originF.setU0_gain(pqStandardDevGain.getU0Gain());
+            originF.setIa_gain(pqStandardDevGain.getIaGain());
+            originF.setIb_gain(pqStandardDevGain.getIbGain());
+            originF.setIc_gain(pqStandardDevGain.getIcGain());
+            originF.setI0_gain(pqStandardDevGain.getI0Gain());
+            originF.setUab_gain(pqStandardDevGain.getUabGain());
+            originF.setUbc_gain(pqStandardDevGain.getUbcGain());
+            originF.setUca_gain(pqStandardDevGain.getUcaGain());
+        }
+
+        if (vAndIResult.getVa() && NumberUtil.isIn(BigDecimal.valueOf(vAndIResult.getVaXi() * 10000), BigDecimal.valueOf(originF.getUa_gain() * 0.95), BigDecimal.valueOf(originF.getUa_gain() * 1.05))) {
+            f.setUa_gain(BigDecimal.valueOf(f.getUa_gain()).multiply(BigDecimal.valueOf(vAndIResult.getVaXi())).setScale(0, RoundingMode.HALF_UP).intValue());
+        }
+        if (vAndIResult.getVb() && NumberUtil.isIn(BigDecimal.valueOf(vAndIResult.getVbXi() * 10000), BigDecimal.valueOf(originF.getUb_gain() * 0.95), BigDecimal.valueOf(originF.getUb_gain() * 1.05))) {
+            f.setUb_gain(BigDecimal.valueOf(f.getUb_gain()).multiply(BigDecimal.valueOf(vAndIResult.getVbXi())).setScale(0, RoundingMode.HALF_UP).intValue());
+        }
+        if (vAndIResult.getVc() && NumberUtil.isIn(BigDecimal.valueOf(vAndIResult.getVcXi() * 10000), BigDecimal.valueOf(originF.getUc_gain() * 0.95), BigDecimal.valueOf(originF.getUc_gain() * 1.05))) {
+            f.setUc_gain(BigDecimal.valueOf(f.getUc_gain()).multiply(BigDecimal.valueOf(vAndIResult.getVcXi())).setScale(0, RoundingMode.HALF_UP).intValue());
+        }
+        if (vAndIResult.getIa() && NumberUtil.isIn(BigDecimal.valueOf(vAndIResult.getIaXi() * 10000), BigDecimal.valueOf(originF.getIa_gain() * 0.95), BigDecimal.valueOf(originF.getIa_gain() * 1.05))) {
+            f.setIa_gain(BigDecimal.valueOf(f.getIa_gain()).multiply(BigDecimal.valueOf(vAndIResult.getIaXi())).setScale(0, RoundingMode.HALF_UP).intValue());
+        }
+        if (vAndIResult.getIb() && NumberUtil.isIn(BigDecimal.valueOf(vAndIResult.getIbXi() * 10000), BigDecimal.valueOf(originF.getIb_gain() * 0.95), BigDecimal.valueOf(originF.getIb_gain() * 1.05))) {
+            f.setIb_gain(BigDecimal.valueOf(f.getIb_gain()).multiply(BigDecimal.valueOf(vAndIResult.getIbXi())).setScale(0, RoundingMode.HALF_UP).intValue());
+        }
+        if (vAndIResult.getIc() && NumberUtil.isIn(BigDecimal.valueOf(vAndIResult.getIcXi() * 10000), BigDecimal.valueOf(originF.getIc_gain() * 0.95), BigDecimal.valueOf(originF.getIc_gain() * 1.05))) {
+            f.setIc_gain(BigDecimal.valueOf(f.getIc_gain()).multiply(BigDecimal.valueOf(vAndIResult.getIcXi())).setScale(0, RoundingMode.HALF_UP).intValue());
+        }
+    }
 }

detection/src/main/java/com/njcn/gather/detection/handler/SocketFreqConverterDevService.java

@@ -0,0 +1,369 @@
+package com.njcn.gather.detection.handler;
+
+import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.collection.ListUtil;
+import cn.hutool.core.util.IdUtil;
+import cn.hutool.core.util.StrUtil;
+import com.alibaba.fastjson.JSON;
+import com.njcn.db.mybatisplus.handler.DynamicTableNameHandler;
+import com.njcn.gather.detection.pojo.enums.DetectionCodeEnum;
+import com.njcn.gather.detection.pojo.enums.SourceOperateCodeEnum;
+import com.njcn.gather.detection.pojo.enums.SourceResponseCodeEnum;
+import com.njcn.gather.detection.pojo.param.DevPhaseSequenceParam;
+import com.njcn.gather.detection.pojo.po.DevData;
+import com.njcn.gather.detection.pojo.vo.SocketDataMsg;
+import com.njcn.gather.detection.pojo.vo.SocketMsg;
+import com.njcn.gather.detection.util.socket.CnSocketUtil;
+import com.njcn.gather.detection.util.socket.FormalTestManager;
+import com.njcn.gather.detection.util.socket.MsgUtil;
+import com.njcn.gather.detection.util.socket.SocketManager;
+import com.njcn.gather.detection.util.socket.cilent.NettyClient;
+import com.njcn.gather.detection.util.socket.cilent.NettyFreqConverterDevClientHandler;
+import com.njcn.gather.detection.util.socket.config.SocketConnectionConfig;
+import com.njcn.gather.detection.util.socket.websocket.WebServiceManager;
+import com.njcn.gather.device.pojo.po.PqDev;
+import com.njcn.gather.device.pojo.vo.PreDetection;
+import com.njcn.gather.device.service.IPqDevService;
+import com.njcn.gather.dip.pojo.po.PqDipData;
+import com.njcn.gather.dip.service.IPqDipDataService;
+import com.njcn.gather.freqConverter.config.FreqConverterConfig;
+import com.njcn.gather.freqConverter.pojo.po.FreqConverterStatus;
+import com.njcn.gather.freqConverter.pojo.po.PqFreqConverterTestRes;
+import com.njcn.gather.freqConverter.service.IFreqConverterService;
+import com.njcn.gather.freqConverter.service.IPqFreqConverterTestResService;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+import java.time.LocalDateTime;
+import java.util.*;
+import java.util.concurrent.CompletableFuture;
+import java.util.stream.Collectors;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class SocketFreqConverterDevService {
+
+    private final SocketConnectionConfig socketConnectionConfig;
+    private final IPqDevService pqDevService;
+    private final IPqDipDataService pqDipDataService;
+    private final IFreqConverterService freqConverterService;
+    private final IPqFreqConverterTestResService pqFreqConverterTestResService;
+    private final FreqConverterConfig freqConverterConfig;
+    private String monitorId;
+    private String userId;
+
+    public static final String DIP_DATA_SUFFIX = "&&VOLTAGE";
+
+    /**
+     * 连接设备Socket
+     *
+     * @param devTag 设备Channel唯一标识符
+     */
+    public void connectSocket(String devTag) {
+        if (SocketManager.isChannelActive(devTag)) {
+            return;
+        }
+        String ip = socketConnectionConfig.getDevice().getIp();
+        Integer port = socketConnectionConfig.getDevice().getPort();
+
+        NettyFreqConverterDevClientHandler handler = new NettyFreqConverterDevClientHandler(devTag, this);
+        CompletableFuture.runAsync(() -> {
+            NettyClient.commonConnect(ip, port, devTag, handler);
+        });
+    }
+
+    private void init(String userId, String converterId, String monitorId, Boolean reset) {
+        FormalTestManager.freqConverterDevStep = null;
+//        FormalTestManager.stopFlag = false;
+        FormalTestManager.isRemoveSocket = false;
+        FormalTestManager.pendingDipTaskMap.clear();
+        if (reset) {
+            pqDipDataService.clearAllData(FormalTestManager.freqConverterTableSuffix);
+            pqFreqConverterTestResService.clearAllData(FormalTestManager.freqConverterTableSuffix);
+        }
+        this.userId = userId;
+        this.monitorId = monitorId;
+    }
+
+    /**
+     * 连接设备
+     */
+    public void connectionDev(String userId, String devTag, String converterId, String monitorId, Boolean reset) {
+        this.init(userId, converterId, monitorId, reset);
+
+        String payload = buildSingleMonitorPayload(monitorId);
+        if (StrUtil.isBlank(payload)) {
+            return;
+        }
+
+        SocketMsg<String> socketMsg = new SocketMsg<>();
+        socketMsg.setRequestId(SourceOperateCodeEnum.YJC_SBTXJY.getValue());
+        socketMsg.setOperateCode(SourceOperateCodeEnum.DEV_INIT_GATHER_03.getValue());
+        socketMsg.setData(payload);
+        SocketManager.sendMsg(devTag, JSON.toJSONString(socketMsg));
+        FormalTestManager.freqConverterDevStep = SourceOperateCodeEnum.YJC_SBTXJY;
+    }
+
+    public void handleRead(String devTag, String msg) {
+        SocketDataMsg socketDataMsg = MsgUtil.socketDataMsg(msg);
+
+        switch (FormalTestManager.freqConverterDevStep) {
+            case YJC_SBTXJY:
+                handleYjcSbtxjy(devTag, socketDataMsg);
+                break;
+            case FORMAL_REAL:
+                handleFormalReal(devTag, socketDataMsg);
+                break;
+            case QUITE:
+                handleQuit(devTag, socketDataMsg);
+                break;
+        }
+    }
+
+    private void handleYjcSbtxjy(String devTag, SocketDataMsg socketDataMsg) {
+        SourceResponseCodeEnum responseCodeEnum = SourceResponseCodeEnum.getDictDataEnumByCode(socketDataMsg.getCode());
+        switch (Objects.requireNonNull(responseCodeEnum)) {
+            case UNPROCESSED_BUSINESS:
+                break;
+            case RE_OPERATE:
+                WebServiceManager.sendMsg(this.userId, JSON.toJSONString(socketDataMsg));
+                break;
+            case SUCCESS:
+                // 暂态协议触发后等待5秒，将装置历史缓存的暂态数据给抛掉
+                CompletableFuture.runAsync(() -> {
+                    try {
+                        Thread.sleep(5000);
+                        this.sendGetDipDataMsg(devTag);
+                        FormalTestManager.freqConverterDevStep = SourceOperateCodeEnum.FORMAL_REAL;
+                    } catch (InterruptedException e) {
+                        Thread.currentThread().interrupt();
+                        log.error("异步调用sendGetDipDataMsg被中断", e);
+                    }
+                });
+                break;
+            default:
+                log.warn("设备响应异常，devTag={}, operateCode={}, code={}, data={}", devTag, socketDataMsg.getOperateCode(), socketDataMsg.getCode(), socketDataMsg.getData());
+                break;
+        }
+    }
+
+    private void handleFormalReal(String devTag, SocketDataMsg socketDataMsg) {
+        SourceResponseCodeEnum responseCodeEnum = SourceResponseCodeEnum.getDictDataEnumByCode(socketDataMsg.getCode());
+
+        switch (responseCodeEnum) {
+            case UNPROCESSED_BUSINESS:
+                break;
+            case SUCCESS:
+            case NORMAL_RESPONSE:
+                DevData devData = JSON.parseObject(socketDataMsg.getData(), DevData.class);
+                // 如果变频器不是处于 “故障中” 状态，就保存数据，反之，这段时期内的数据不保存
+//                if (!FormalTestManager.stopFlag) {
+//                    saveDipData(devData);
+//                }
+                saveDipData(devData);
+                break;
+            case DEV_ERROR:
+            case DEV_TARGET:
+            case COMMUNICATION_ERR:
+            case DATA_RESOLVE:
+            case NO_INIT_DEV:
+            default:
+                log.warn("设备响应异常，devTag={}, operateCode={}, code={}, data={}", devTag, socketDataMsg.getOperateCode(), socketDataMsg.getCode(), socketDataMsg.getData());
+                break;
+        }
+    }
+
+    private void handleQuit(String devTag, SocketDataMsg socketDataMsg) {
+        SourceResponseCodeEnum responseCodeEnum = SourceResponseCodeEnum.getDictDataEnumByCode(socketDataMsg.getCode());
+
+        switch (responseCodeEnum) {
+            case UNPROCESSED_BUSINESS:
+                break;
+            case SUCCESS:
+                cleanup(devTag);
+                break;
+            default:
+                log.warn("设备关闭响应失败，devTag={}, operateCode={}, code={}, data={}", devTag, socketDataMsg.getOperateCode(), socketDataMsg.getCode(), socketDataMsg.getData());
+                break;
+        }
+    }
+
+    public void stopTest(String converterTag, String devTag) {
+        FormalTestManager.freqConverterDevStep = SourceOperateCodeEnum.QUITE;
+        sendQuitMsg(devTag, SourceOperateCodeEnum.QUIT_INIT_03);
+    }
+
+
+    private String buildSingleMonitorPayload(String monitorId) {
+        String[] split = monitorId.split(CnSocketUtil.SPLIT_TAG);
+        if (split.length < 2 || StrUtil.isBlank(split[0]) || StrUtil.isBlank(split[1])) {
+            return null;
+        }
+
+        List<PreDetection> preDetections = pqDevService.getDevInfo(Collections.singletonList(split[0]));
+        if (CollUtil.isEmpty(preDetections)) {
+            return null;
+        }
+
+        PreDetection preDetection = preDetections.get(0);
+        List<PreDetection.MonitorListDTO> monitorList = preDetection.getMonitorList();
+        if (CollUtil.isEmpty(monitorList)) {
+            return null;
+        }
+
+        List<PreDetection.MonitorListDTO> matchedMonitorList = monitorList.stream()
+                .filter(item -> split[1].equals(StrUtil.EMPTY + item.getLine()))
+                .collect(Collectors.toList());
+        if (CollUtil.isEmpty(matchedMonitorList)) {
+            return null;
+        }
+
+        preDetection.setMonitorList(matchedMonitorList);
+        Map<String, List<PreDetection>> payload = new HashMap<>(1);
+        payload.put("deviceList", Collections.singletonList(preDetection));
+        return JSON.toJSONString(payload);
+    }
+
+    private void sendGetDipDataMsg(String devTag) {
+        SocketMsg<String> socketMsg = new SocketMsg<>();
+        socketMsg.setRequestId(SourceOperateCodeEnum.FORMAL_REAL.getValue() + DIP_DATA_SUFFIX);
+        socketMsg.setOperateCode(SourceOperateCodeEnum.OPER_GATHER.getValue());
+
+        DevPhaseSequenceParam phaseSequenceParam = new DevPhaseSequenceParam();
+        String[] split = this.monitorId.split(String.valueOf(StrUtil.C_UNDERLINE));
+        PqDev dev = pqDevService.getById(split[0]);
+
+        // 设置监测点ID列表
+        phaseSequenceParam.setMoniterIdList(ListUtil.of(dev.getIp() + StrUtil.C_UNDERLINE + split[1]));
+
+        // 设置数据类型列表
+        phaseSequenceParam.setDataType(ListUtil.of("avg$MAG", "avg$DUR"));
+        // 设置读取次数
+        phaseSequenceParam.setReadCount(0);
+        // 设置忽略次数
+        phaseSequenceParam.setIgnoreCount(0);
+        socketMsg.setData(JSON.toJSONString(phaseSequenceParam));
+        socketMsg.setOperateCode(SourceOperateCodeEnum.DEV_DATA_REQUEST_03.getValue());
+        SocketManager.sendMsg(devTag, JSON.toJSONString(socketMsg));
+    }
+
+    private void sendQuitMsg(String devTag, SourceOperateCodeEnum operateCodeEnum) {
+        SocketMsg<String> socketMsg = new SocketMsg<>();
+        socketMsg.setRequestId(SourceOperateCodeEnum.QUITE.getValue());
+        socketMsg.setOperateCode(operateCodeEnum.getValue());
+        SocketManager.sendMsg(devTag, JSON.toJSONString(socketMsg));
+    }
+
+    private void saveDipData(DevData devData) {
+        if (Objects.isNull(devData) || CollUtil.isEmpty(devData.getSqlData())) {
+            return;
+        }
+
+        Double residualVoltage = null;
+        Integer durationMs = null;
+        for (DevData.SqlDataDTO sqlDataDTO : devData.getSqlData()) {
+            if (Objects.isNull(sqlDataDTO) || Objects.isNull(sqlDataDTO.getList())) {
+                continue;
+            }
+
+            Double value = getSqlDataValue(sqlDataDTO.getList());
+            if (Objects.isNull(value)) {
+                continue;
+            }
+
+            if (DetectionCodeEnum.MAG.getCode().equalsIgnoreCase(sqlDataDTO.getDesc())) {
+                residualVoltage = value;
+            } else if (DetectionCodeEnum.DUR.getCode().equalsIgnoreCase(sqlDataDTO.getDesc())) {
+                durationMs = (int) Math.round(value * 1000);
+            }
+        }
+
+        PqDipData pqDipData = new PqDipData();
+        pqDipData.setId(IdUtil.fastSimpleUUID());
+        pqDipData.setStartTime(LocalDateTime.parse(devData.getTime()));
+        pqDipData.setResidualVoltage(residualVoltage);
+        pqDipData.setDurationMs(durationMs);
+        DynamicTableNameHandler.setTableName("pq_dip_data_" + FormalTestManager.freqConverterTableSuffix);
+        pqDipDataService.save(pqDipData);
+        DynamicTableNameHandler.remove();
+
+        this.initDipTestRes(pqDipData);
+    }
+
+    private void initDipTestRes(PqDipData pqDipData) {
+        Integer suffix = FormalTestManager.freqConverterTableSuffix;
+        FreqConverterStatus lastStatusData = freqConverterService.getLastStatusData(suffix, pqDipData.getStartTime());
+        if (Objects.isNull(lastStatusData)) {
+            return;
+        }
+
+        List<FreqConverterStatus> statusList = freqConverterService.getDipDurationStatusData(suffix, lastStatusData.getTimestamp(), pqDipData.getStartTime().plusNanos(pqDipData.getDurationMs() * 1000_000L));
+        Integer originalTolerant = (lastStatusData.getStatusWord1() == freqConverterConfig.getTolerant()) ? 1 : 0;
+        LocalDateTime targetEndTime = pqDipData.getStartTime()
+                .plusNanos(pqDipData.getDurationMs() * 1000_000L)
+                .plusNanos(freqConverterConfig.getDt() * 1000_000L);
+
+        if (CollUtil.isNotEmpty(statusList)) {
+            FreqConverterStatus status = statusList.get(statusList.size() - 1);
+            PqFreqConverterTestRes testRes = new PqFreqConverterTestRes();
+            testRes.setId(IdUtil.fastSimpleUUID());
+            testRes.setTolerant(originalTolerant == 1 ?
+                    (status.getStatusWord1() == freqConverterConfig.getTolerant() ? 1 : 0)
+                    : 0);
+            testRes.setDurationMs(pqDipData.getDurationMs());
+            testRes.setResidualVoltage(pqDipData.getResidualVoltage());
+            testRes.setTime(LocalDateTime.now());
+
+            FormalTestManager.pendingDipTaskMap.put(testRes.getId(), new FormalTestManager.PendingDipTask(
+                    pqDipData,
+                    targetEndTime,
+                    originalTolerant
+            ));
+
+            pqFreqConverterTestResService.saveTestRes(suffix, Collections.singletonList(testRes));
+        }
+    }
+
+    private Double getSqlDataValue(DevData.SqlDataDTO.ListDTO listDTO) {
+        if (Objects.nonNull(listDTO.getA())) {
+            return listDTO.getA();
+        }
+        if (Objects.nonNull(listDTO.getB())) {
+            return listDTO.getB();
+        }
+        if (Objects.nonNull(listDTO.getC())) {
+            return listDTO.getC();
+        }
+        return listDTO.getT();
+    }
+
+    public void cleanup(String devTag) {
+        String currentUserId = this.userId;
+        FormalTestManager.freqConverterDevStep = null;
+        FormalTestManager.isRemoveSocket = true;
+        SocketManager.removeUser(devTag);
+        clearStateIfStopped(currentUserId);
+        this.userId = null;
+        this.monitorId = null;
+    }
+
+    /**
+     * 如果设备已停止，则清除共享的运行时状态
+     *
+     * @param currentUserId 当前用户ID
+     */
+    private void clearStateIfStopped(String currentUserId) {
+        if (StrUtil.isBlank(currentUserId)) {
+            FormalTestManager.clearFreqConverterRuntimeState();
+            return;
+        }
+        String freqConverterTag = currentUserId + CnSocketUtil.FREQ_CONVERTER_TAG;
+        // 避免过早把 freqConverterTableSuffix 等全局值清掉，造成变频器无法使用全局变量
+        if (!SocketManager.isChannelActive(freqConverterTag)) {
+            FormalTestManager.freqConverterStep = null;
+            FormalTestManager.clearFreqConverterRuntimeState();
+        }
+    }
+}

detection/src/main/java/com/njcn/gather/detection/handler/SocketFreqConverterService.java

@@ -0,0 +1,433 @@
+package com.njcn.gather.detection.handler;
+
+import cn.hutool.core.util.IdUtil;
+import cn.hutool.core.util.ObjectUtil;
+import cn.hutool.core.util.StrUtil;
+import cn.hutool.json.JSONObject;
+import cn.hutool.json.JSONUtil;
+import com.alibaba.fastjson.JSON;
+import com.njcn.gather.detection.pojo.dto.FreqConverterRespDTO;
+import com.njcn.gather.detection.pojo.enums.SourceOperateCodeEnum;
+import com.njcn.gather.detection.pojo.vo.SocketDataMsg;
+import com.njcn.gather.detection.pojo.vo.SocketMsg;
+import com.njcn.gather.detection.util.socket.CnSocketUtil;
+import com.njcn.gather.detection.util.socket.FormalTestManager;
+import com.njcn.gather.detection.util.socket.SocketManager;
+import com.njcn.gather.detection.util.socket.cilent.NettyClient;
+import com.njcn.gather.detection.util.socket.cilent.NettyFreqConverterClientHandler;
+import com.njcn.gather.detection.util.socket.config.SocketConnectionConfig;
+import com.njcn.gather.detection.util.socket.websocket.WebServiceManager;
+import com.njcn.gather.freqConverter.config.FreqConverterConfig;
+import com.njcn.gather.freqConverter.pojo.po.FreqConverterStatus;
+import com.njcn.gather.freqConverter.pojo.po.PqFreqConverterConfig;
+import com.njcn.gather.freqConverter.pojo.po.PqFreqConverterTestRes;
+import com.njcn.gather.freqConverter.pojo.vo.TolerantPointVO;
+import com.njcn.gather.freqConverter.service.IFreqConverterService;
+import com.njcn.gather.freqConverter.service.IPqFreqConverterConfigService;
+import com.njcn.gather.freqConverter.service.IPqFreqConverterTestResService;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+import java.time.LocalDateTime;
+import java.util.*;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * @author czh
+ * @version 1.0
+ */
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class SocketFreqConverterService {
+    private final IFreqConverterService freqConverterService;
+
+    private final SocketConnectionConfig socketConnectionConfig;
+
+    private final IPqFreqConverterConfigService pqFreqConverterConfigService;
+    private final IPqFreqConverterTestResService pqFreqConverterTestResService;
+    private String userId;
+    /**
+     * 上一个暂降点耐受检测结果
+     */
+    private TolerantPointVO lastTolerancePoint;
+    private final FreqConverterConfig freqConverterConfig;
+
+    /**
+     * 连接变频器Socket
+     *
+     * @param converterChannelTag 变频器Channel唯一标识符
+     */
+    public void connectSocket(String converterChannelTag) {
+        if (SocketManager.isChannelActive(converterChannelTag)) {
+            return;
+        }
+        String ip = socketConnectionConfig.getFreqConverter().getIp();
+        Integer port = socketConnectionConfig.getFreqConverter().getPort();
+
+        NettyFreqConverterClientHandler handler = new NettyFreqConverterClientHandler(converterChannelTag, this);
+
+        CompletableFuture.runAsync(() -> {
+            NettyClient.commonConnect(ip, port, converterChannelTag, handler);
+        });
+    }
+
+    /**
+     * 重连
+     *
+     * @param converterChannelTag
+     */
+    public void reconnect(String converterChannelTag) {
+        SocketManager.removeUser(converterChannelTag);
+
+        String ip = socketConnectionConfig.getFreqConverter().getIp();
+        Integer port = socketConnectionConfig.getFreqConverter().getPort();
+
+        NettyFreqConverterClientHandler handler = new NettyFreqConverterClientHandler(converterChannelTag, this);
+
+        CompletableFuture.runAsync(() -> {
+            NettyClient.commonConnect(ip, port, converterChannelTag, handler);
+        });
+    }
+
+    /**
+     * 重试连接成功，重新开启定时任务，获取变频器状态数据
+     *
+     * @param converterChannelTag
+     */
+    public void onReconnectSuccess(String converterChannelTag) {
+        log.info("变频器重连成功，恢复数据采集，converterChannelTag={}", converterChannelTag);
+
+//        FormalTestManager.stopFlag = false;
+
+        if (FormalTestManager.scheduler == null) {
+            FormalTestManager.scheduler = Executors.newScheduledThreadPool(1);
+            FormalTestManager.scheduledFuture = FormalTestManager.scheduler.scheduleAtFixedRate(() -> {
+                this.sendGetDeviceStatusMsg(converterChannelTag);
+            }, 0l, 200l, TimeUnit.MILLISECONDS);
+        }
+    }
+
+    public void init(String userId, String converterId, String monitorId, Boolean reset) {
+        this.lastTolerancePoint = null;
+        this.userId = userId;
+        FormalTestManager.freqConverterStep = null;
+        FormalTestManager.currentFreqConverterId = converterId;
+        Integer suffix = pqFreqConverterConfigService.getSuffix(converterId);
+        if (reset) {
+            freqConverterService.clearAllData(suffix);
+        }
+        FormalTestManager.freqConverterTableSuffix = suffix;
+        FormalTestManager.isRemoveSocket = false;
+        FormalTestManager.pendingDipTaskMap.clear();
+        pqFreqConverterConfigService.updateTestStatus(converterId, 0);
+        clearScheduleTask();
+    }
+
+    /**
+     * 连接变频器
+     */
+    public void connectionFreqConverter(String userId, String freqConverterTag, String converterId, String monitorId, Boolean reset) {
+        this.init(userId, converterId, monitorId, reset);
+
+        SocketMsg<Map<String, Object>> socketMsg = new SocketMsg<>();
+        socketMsg.setOperateCode(SourceOperateCodeEnum.CMD_INIT_SERIAL.getValue());
+        String requestId = IdUtil.fastSimpleUUID();
+        socketMsg.setRequestId(requestId);
+
+        PqFreqConverterConfig freqConverterConfig = pqFreqConverterConfigService.getById(converterId);
+
+        Map<String, Object> map = new HashMap<>();
+        map.put("portName", freqConverterConfig.getPortName());
+        map.put("slaveAddress", freqConverterConfig.getSlaveAddress());
+        map.put("baudRate", freqConverterConfig.getBaudRate());
+        map.put("parity", freqConverterConfig.getParity());
+        map.put("dataBits", freqConverterConfig.getDataBits());
+        map.put("stopBits", freqConverterConfig.getStopBits());
+        map.put("timeoutMs", freqConverterConfig.getTimeoutMs());
+        socketMsg.setData(map);
+
+        SocketManager.sendMsg(freqConverterTag, JSON.toJSONString(socketMsg));
+        FormalTestManager.freqConverterStep = SourceOperateCodeEnum.CMD_INIT_SERIAL;
+    }
+
+    public void handleRead(String converterChannelTag, String msg) {
+        FreqConverterRespDTO respDTO = JSON.parseObject(msg, FreqConverterRespDTO.class);
+
+        if (respDTO.getCode() != 0) {
+            SocketDataMsg socketDataMsg = new SocketDataMsg();
+            socketDataMsg.setRequestId(FormalTestManager.freqConverterStep.getValue());
+            socketDataMsg.setCode(respDTO.getCode());
+            WebServiceManager.sendMsg(this.userId, JSON.toJSONString(socketDataMsg));
+        } else {
+            switch (FormalTestManager.freqConverterStep) {
+                case CMD_INIT_SERIAL:
+                    handleInitSerial(converterChannelTag, respDTO);
+                    break;
+                case CMD_GET_DEVICE_STATUS:
+                    handleGetDeviceStatus(converterChannelTag, respDTO);
+                    break;
+                case CMD_CLOSE_SERIAL:
+                    handleCloseSerial(converterChannelTag, respDTO);
+                    break;
+            }
+        }
+    }
+
+    public void stopTest(String converterTag, String devTag) {
+        FormalTestManager.freqConverterStep = SourceOperateCodeEnum.CMD_CLOSE_SERIAL;
+        this.sendClose(converterTag);
+    }
+
+    public void cleanup(String converterChannelTag) {
+        String currentUserId = this.userId;
+        clearScheduleTask();
+        FormalTestManager.freqConverterStep = null;
+//        FormalTestManager.stopFlag = false;
+        FormalTestManager.isRemoveSocket = true;
+        SocketManager.removeUser(converterChannelTag);
+        updateCurrentTestStatus();
+        clearStateIfStopped(currentUserId);
+        this.userId = null;
+        this.lastTolerancePoint = null;
+    }
+
+    private void handleInitSerial(String converterChannelTag, FreqConverterRespDTO respDTO) {
+        if (respDTO.getCode() == 0 && respDTO.getSuccess()) {
+            FormalTestManager.freqConverterStep = SourceOperateCodeEnum.CMD_GET_DEVICE_STATUS;
+
+            if (Objects.isNull(FormalTestManager.scheduler)) {
+                FormalTestManager.scheduler = Executors.newScheduledThreadPool(1);
+                FormalTestManager.scheduledFuture = FormalTestManager.scheduler.scheduleAtFixedRate(() -> {
+                    this.sendGetDeviceStatusMsg(converterChannelTag);
+                }, 0l, freqConverterConfig.getSchedulePeriod(), TimeUnit.MILLISECONDS);
+            }
+        } else {
+            log.warn("变频器初始化串口失败，converterChannelTag={}, converterId={}, converterTag={}, msg={}", converterChannelTag, converterChannelTag, converterChannelTag, respDTO.getMessage());
+        }
+    }
+
+    private void handleGetDeviceStatus(String converterChannelTag, FreqConverterRespDTO respDTO) {
+        JSONObject obj = JSONUtil.parseObj(respDTO.getData().toString());
+        String timestamp = (String) obj.get("Timestamp");
+        timestamp = timestamp.replace("+08:00", StrUtil.EMPTY);
+        obj.set("Timestamp", timestamp);
+
+        FreqConverterStatus freqConverterStatus = JSON.parseObject(obj.toString(), FreqConverterStatus.class);
+        // 变频器故障中，移除这段时期内的设备数据
+//        if (freqConverterStatus.getStatusWord1() == freqConverterConfig.getNoTolerant()) {
+//            FormalTestManager.stopFlag = true;
+//        } else {
+//            FormalTestManager.stopFlag = false;
+//        }
+        this.consumePendingDipTasks(freqConverterStatus);
+        freqConverterService.saveFreqConverterStatus(FormalTestManager.freqConverterTableSuffix, freqConverterStatus);
+    }
+
+    private void handleCloseSerial(String converterChannelTag, FreqConverterRespDTO respDTO) {
+        if (respDTO.getCode() == 0 && respDTO.getSuccess()) {
+            if (FormalTestManager.currentFreqConverterId != null) {
+                pqFreqConverterConfigService.updateTestStatus(FormalTestManager.currentFreqConverterId, 1);
+            }
+            cleanup(converterChannelTag);
+        } else {
+            this.sendClose(converterChannelTag);
+        }
+    }
+
+
+    private void sendGetDeviceStatusMsg(String converterId) {
+        SocketMsg<Map<String, Object>> socketMsg = new SocketMsg<>();
+        socketMsg.setOperateCode(SourceOperateCodeEnum.CMD_GET_DEVICE_STATUS.getValue());
+        String requestId = IdUtil.fastSimpleUUID();
+        socketMsg.setRequestId(requestId);
+
+        Map<String, Object> map = new HashMap<>();
+        socketMsg.setData(map);
+        SocketManager.sendMsg(converterId, JSON.toJSONString(socketMsg));
+    }
+
+    private void sendClose(String converterTag) {
+        SocketMsg<Map<String, Object>> socketMsg = new SocketMsg<>();
+        socketMsg.setOperateCode(SourceOperateCodeEnum.CMD_CLOSE_SERIAL.getValue());
+        String requestId = IdUtil.fastSimpleUUID();
+        socketMsg.setRequestId(requestId);
+
+        Map<String, Object> map = new HashMap<>();
+        socketMsg.setData(map);
+        SocketManager.sendMsg(converterTag, JSON.toJSONString(socketMsg));
+    }
+
+
+    private void clearScheduleTask() {
+        if (FormalTestManager.scheduledFuture != null) {
+            FormalTestManager.scheduledFuture.cancel(true);
+            FormalTestManager.scheduledFuture = null;
+        }
+        if (FormalTestManager.scheduler != null) {
+            FormalTestManager.scheduler.shutdown();
+            FormalTestManager.scheduler = null;
+        }
+    }
+
+    private void updateCurrentTestStatus() {
+        if (StrUtil.isNotBlank(FormalTestManager.currentFreqConverterId)) {
+            pqFreqConverterConfigService.updateTestStatus(FormalTestManager.currentFreqConverterId, 1);
+        }
+    }
+
+    /**
+     * 如果变频器已停止，则清除共享的运行时状态
+     *
+     * @param currentUserId 当前用户ID
+     */
+    private void clearStateIfStopped(String currentUserId) {
+        if (StrUtil.isBlank(currentUserId)) {
+            FormalTestManager.clearFreqConverterRuntimeState();
+            return;
+        }
+        String devTag = currentUserId + CnSocketUtil.DEV_TAG;
+        // 避免过早把 freqConverterTableSuffix 等全局值清掉，造成设备无法使用全局变量
+        if (!SocketManager.isChannelActive(devTag)) {
+            FormalTestManager.freqConverterDevStep = null;
+            FormalTestManager.clearFreqConverterRuntimeState();
+        }
+    }
+
+    private void consumePendingDipTasks(FreqConverterStatus freqConverterStatus) {
+        if (FormalTestManager.pendingDipTaskMap.isEmpty()) {
+            return;
+        }
+
+        Integer suffix = FormalTestManager.freqConverterTableSuffix;
+        List<String> finishedTestResIdList = new ArrayList<>();
+        List<PqFreqConverterTestRes> saveTestResList = new ArrayList<>();
+        List<PqFreqConverterTestRes> updateTestResList = new ArrayList<>();
+
+        FormalTestManager.pendingDipTaskMap.forEach((key, task) -> {
+            if (freqConverterStatus.getTimestamp().isAfter(task.getTargetEndTime())) {
+                PqFreqConverterTestRes testRes = new PqFreqConverterTestRes();
+                testRes.setId(key);
+                testRes.setDurationMs(task.getPqDipData().getDurationMs());
+                testRes.setResidualVoltage(task.getPqDipData().getResidualVoltage());
+                testRes.setTolerant(task.getOriginalTolerant() & (freqConverterStatus.getStatusWord1() == freqConverterConfig.getTolerant() ? 1 : 0));
+
+                finishedTestResIdList.add(key);
+
+                SocketDataMsg socketDataMsg = new SocketDataMsg();
+                socketDataMsg.setRequestId(SourceOperateCodeEnum.FORMAL_REAL + SocketFreqConverterDevService.DIP_DATA_SUFFIX);
+
+                TolerantPointVO newTolerantPointVO = new TolerantPointVO();
+                newTolerantPointVO.setResidualVoltage(task.getPqDipData().getResidualVoltage());
+                newTolerantPointVO.setDurationMs(task.getPqDipData().getDurationMs());
+                newTolerantPointVO.setTolerant(testRes.getTolerant());
+                socketDataMsg.setData(JSON.toJSONString(newTolerantPointVO));
+                WebServiceManager.sendMsg(this.userId, JSON.toJSONString(socketDataMsg));
+
+                if (testRes.getTolerant() == 0) {
+                    if (ObjectUtil.isNotNull(this.lastTolerancePoint) && this.lastTolerancePoint.getTolerant() == 1) {
+                        TolerantPointVO featurePointVO = new TolerantPointVO();
+
+                        featurePointVO.setResidualVoltage(Math.round((task.getPqDipData().getResidualVoltage() + this.lastTolerancePoint.getResidualVoltage()) / 2D * 100) / 100D);
+                        featurePointVO.setDurationMs(Integer.valueOf((task.getPqDipData().getDurationMs().intValue() + this.lastTolerancePoint.getDurationMs().intValue()) / 2));
+                        featurePointVO.setTolerant(2);
+                        socketDataMsg.setData(JSON.toJSONString(featurePointVO));
+                        WebServiceManager.sendMsg(this.userId, JSON.toJSONString(socketDataMsg));
+
+                        PqFreqConverterTestRes featureTestRes = new PqFreqConverterTestRes();
+                        featureTestRes.setId(IdUtil.fastSimpleUUID());
+                        featureTestRes.setDurationMs(featurePointVO.getDurationMs());
+                        featureTestRes.setResidualVoltage(featurePointVO.getResidualVoltage());
+                        featureTestRes.setTolerant(2);
+                        featureTestRes.setTime(LocalDateTime.now());
+                        saveTestResList.add(featureTestRes);
+                    }
+
+                    // 从数据库按照列查询距离该暂降点最近的一个暂降点
+                    if (freqConverterConfig.getDirection() == 0) {
+                        PqFreqConverterTestRes lastByDuration = pqFreqConverterTestResService.getLastByDuration(suffix, key, task.getPqDipData().getDurationMs());
+                        if (ObjectUtil.isNotNull(lastByDuration) && lastByDuration.getTolerant() == 1) {
+                            TolerantPointVO featurePointVO = new TolerantPointVO();
+
+                            featurePointVO.setResidualVoltage(Math.round((task.getPqDipData().getResidualVoltage() + lastByDuration.getResidualVoltage()) / 2D * 100) / 100D);
+                            featurePointVO.setDurationMs(Integer.valueOf((task.getPqDipData().getDurationMs().intValue() + lastByDuration.getDurationMs().intValue()) / 2));
+                            featurePointVO.setTolerant(2);
+                            socketDataMsg.setData(JSON.toJSONString(featurePointVO));
+                            WebServiceManager.sendMsg(this.userId, JSON.toJSONString(socketDataMsg));
+
+                            PqFreqConverterTestRes featureTestRes = new PqFreqConverterTestRes();
+                            featureTestRes.setId(IdUtil.fastSimpleUUID());
+                            featureTestRes.setDurationMs(featurePointVO.getDurationMs());
+                            featureTestRes.setResidualVoltage(featurePointVO.getResidualVoltage());
+                            featureTestRes.setTolerant(2);
+                            featureTestRes.setTime(LocalDateTime.now());
+                            saveTestResList.add(featureTestRes);
+                        }
+                    }
+                    // 从数据库按照行查询距离该暂降点最近的一个暂降点
+                    if (freqConverterConfig.getDirection() == 1) {
+                        PqFreqConverterTestRes lastByResidualVoltage = pqFreqConverterTestResService.getLastByResidualVoltage(suffix, key, task.getPqDipData().getResidualVoltage());
+                        if (ObjectUtil.isNotNull(lastByResidualVoltage) && lastByResidualVoltage.getTolerant() == 1) {
+                            TolerantPointVO featurePointVO = new TolerantPointVO();
+
+                            featurePointVO.setResidualVoltage(Math.round((task.getPqDipData().getResidualVoltage() + lastByResidualVoltage.getResidualVoltage()) / 2D * 100) / 100D);
+                            featurePointVO.setDurationMs(Integer.valueOf((task.getPqDipData().getDurationMs().intValue() + lastByResidualVoltage.getDurationMs().intValue()) / 2));
+                            featurePointVO.setTolerant(2);
+                            socketDataMsg.setData(JSON.toJSONString(featurePointVO));
+                            WebServiceManager.sendMsg(this.userId, JSON.toJSONString(socketDataMsg));
+
+                            PqFreqConverterTestRes featureTestRes = new PqFreqConverterTestRes();
+                            featureTestRes.setId(IdUtil.fastSimpleUUID());
+                            featureTestRes.setDurationMs(featurePointVO.getDurationMs());
+                            featureTestRes.setResidualVoltage(featurePointVO.getResidualVoltage());
+                            featureTestRes.setTolerant(2);
+                            featureTestRes.setTime(LocalDateTime.now());
+                            saveTestResList.add(featureTestRes);
+                        }
+                    }
+                }
+                this.lastTolerancePoint = newTolerantPointVO;
+                updateTestResList.add(testRes);
+            }
+        });
+
+        if (!saveTestResList.isEmpty()) {
+            pqFreqConverterTestResService.saveTestRes(suffix, saveTestResList);
+        }
+        if (!updateTestResList.isEmpty()) {
+            pqFreqConverterTestResService.updateTestRes(suffix, updateTestResList);
+        }
+
+        for (String dipId : finishedTestResIdList) {
+            FormalTestManager.pendingDipTaskMap.remove(dipId);
+        }
+    }
+
+    /**
+     * 判断是否为新的一组测试脚本
+     *
+     * @param lastTolerancePoint 上一个暂降点
+     * @param newTolerantPointVO 最新的暂降点
+     * @return
+     */
+    private boolean isNewGroup(TolerantPointVO lastTolerancePoint, TolerantPointVO newTolerantPointVO) {
+        // 横向分组
+        if (freqConverterConfig.getDirection() == 0) {
+            return lastTolerancePoint.getDurationMs() - newTolerantPointVO.getDurationMs() >= 10;
+        }
+        // 纵向分租
+        if (freqConverterConfig.getDirection() == 1) {
+            return lastTolerancePoint.getResidualVoltage() - newTolerantPointVO.getResidualVoltage() <= -2;
+        }
+
+//        if (Math.abs(lastTolerancePoint.getDurationMs() - newTolerantPointVO.getDurationMs()) >= 10 && Math.abs(lastTolerancePoint.getResidualVoltage() - newTolerantPointVO.getResidualVoltage()) >= 2) {
+//            return true;
+//        }
+        return false;
+    }
+}
+
+

detection/src/main/java/com/njcn/gather/detection/pojo/dto/FreqConverterRespDTO.java

@@ -0,0 +1,41 @@
+package com.njcn.gather.detection.pojo.dto;
+
+import com.fasterxml.jackson.annotation.JsonAlias;
+import lombok.Data;
+
+/**
+ * @author caozehui
+ * @data 2026-04-08
+ */
+@Data
+public class FreqConverterRespDTO {
+    /**
+     * 请求编号
+     */
+    @JsonAlias({"RequestId"})
+    private String requestId;
+
+    /**
+     * 是否成功
+     */
+    @JsonAlias({"Success"})
+    private Boolean success;
+
+    /**
+     * 状态码
+     */
+    @JsonAlias({"Code"})
+    private Integer code;
+
+    /**
+     * 消息
+     */
+    @JsonAlias({"Message"})
+    private String message;
+
+    /**
+     * 数据
+     */
+    @JsonAlias({"Data"})
+    private Object data;
+}

detection/src/main/java/com/njcn/gather/detection/pojo/enums/DetectionResponseEnum.java

@@ -19,7 +19,8 @@ public enum DetectionResponseEnum {
 
 
     SCRIPT_CHECK_DATA_NOT_EXIST("A020040","测试脚本项暂无配置" ),
-    EXCEED_MAX_TIME("A020041","检测次数超出最大限制！" );
+    EXCEED_MAX_TIME("A020041","检测次数超出最大限制！" ),
+    SOCKET_CONNECT_TIMEOUT("A020042","socket连接超时！");
 
     private final String code;
     private final String message;

detection/src/main/java/com/njcn/gather/detection/pojo/enums/SourceOperateCodeEnum.java

@@ -52,7 +52,7 @@ public enum SourceOperateCodeEnum {
     YJC_MXYZXJY("yjc_mxyzxjy", "模型一致性校验"),
     FORMAL_REAL("formal_real","正式检测"),
     RECORD_WAVE_STEP1("record_wave_step1","启动录波_step1"),
-//    RECORD_WAVE_STEP2("record_wave_step2","启动录波_step2"),
+    //    RECORD_WAVE_STEP2("record_wave_step2","启动录波_step2"),
 //    SIMULATE_REAL("simulate_real","模拟检测"),
     Coefficient_Check("Coefficient_Check","系数校验"),
     QUITE("quit","关闭设备通讯初始化"),
@@ -70,9 +70,6 @@ public enum SourceOperateCodeEnum {
     FLICKER_DATA_CHECK("flicker_data_check","闪变数据校验"),
 
 
-
-
-
     /**
      *
      */
@@ -100,12 +97,17 @@ public enum SourceOperateCodeEnum {
     small_comp_start("small_comp_start","小电压校准开始"),
     small_comp_end("small_comp_end","小电压校准结束"),
 
-
     /**
      * ftp文件传送指令
      */
     FTP_SEND_01("FTP_SEND$01", "发送文件"),
-    RDRE$01("RDRE$01", "启动录波");
+    RDRE$01("RDRE$01", "启动录波"),
+
+    CMD_PING("ping", "检查 TCP 服务是否在线"),
+    CMD_INIT_SERIAL("initSerial", "初始化并打开串口连接"),
+    CMD_GET_SERIAL_CONFIG("getSerialConfig", "获取当前串口配置"),
+    CMD_GET_DEVICE_STATUS("getDeviceStatus", "读取变频器运行状态"),
+    CMD_CLOSE_SERIAL("closeSerial", "关闭串口"),;
 
     private final String value;
     private final String msg;

detection/src/main/java/com/njcn/gather/detection/service/PreDetectionService.java

@@ -4,8 +4,6 @@ import com.njcn.gather.detection.pojo.param.ContrastDetectionParam;
 import com.njcn.gather.detection.pojo.param.PreDetectionParam;
 import com.njcn.gather.detection.pojo.param.SimulateDetectionParam;
 
-import java.util.Map;
-
 
 /**
  * @author wr
@@ -54,7 +52,6 @@ public interface PreDetectionService {
     void closeTestSimulate(SimulateDetectionParam param);
 
     /**
-     *
      * @param param
      */
     void startContrastTest(ContrastDetectionParam param);
@@ -63,4 +60,12 @@ public interface PreDetectionService {
      * 导出实时数据对齐过程中的数据
      */
     void exportAlignData();
+
+    boolean getCanCoefficient();
+
+    void startCoefficient();
+
+    void startFreqConverter(String userId, String converterId, String monitorId,Boolean reset);
+
+    void stopFreqConverter(String converterId, String monitorId);
 }

detection/src/main/java/com/njcn/gather/detection/service/impl/DetectionServiceImpl.java

@@ -16,8 +16,10 @@ import com.njcn.gather.detection.pojo.vo.DetectionData;
 import com.njcn.gather.detection.pojo.vo.DevLineTestResult;
 import com.njcn.gather.detection.util.DetectionUtil;
 import com.njcn.gather.detection.util.socket.CnSocketUtil;
+import com.njcn.gather.detection.util.socket.FormalTestManager;
 import com.njcn.gather.device.pojo.vo.PreDetection;
 import com.njcn.gather.device.service.IPqDevService;
+import com.njcn.gather.device.service.IPqStandardDevGainRecordService;
 import com.njcn.gather.err.pojo.param.PqErrSysParam;
 import com.njcn.gather.err.pojo.po.PqErrSysDtls;
 import com.njcn.gather.err.pojo.vo.ErrDtlsCheckDataVO;
@@ -36,7 +38,10 @@ import com.njcn.gather.system.cfg.pojo.po.SysTestConfig;
 import com.njcn.gather.system.cfg.service.ISysTestConfigService;
 import com.njcn.gather.system.dictionary.pojo.enums.DictDataEnum;
 import com.njcn.gather.util.StorageUtil;
+import lombok.AllArgsConstructor;
+import lombok.Data;
 import lombok.RequiredArgsConstructor;
+import lombok.extern.log4j.Log4j;
 import org.apache.commons.collections4.CollectionUtils;
 import org.springframework.stereotype.Service;
 
@@ -56,6 +61,7 @@ import java.util.stream.Stream;
  * @description
  * @date 2024/12/20 13:52
  */
+@Log4j
 @Service
 @RequiredArgsConstructor
 public class DetectionServiceImpl {
@@ -66,6 +72,7 @@ public class DetectionServiceImpl {
     private final ISysTestConfigService sysTestConfigService;
     private final IPqMonitorService pqMonitorService;
     private final IPqDevService pqDevService;
+    private final IPqStandardDevGainRecordService pqStandardDevGainRecordService;
 
     public static final String TYPE_A = "A";
     public static final String TYPE_B = "B";
@@ -82,6 +89,44 @@ public class DetectionServiceImpl {
     private static final Integer INHARMONIC_FLAG = 1;
     private static final Integer HARMONIC_FLAG = 2;
 
+//    @Value("${error.removeCount:14}")
+//    private Integer removeErrorValueCount;
+
+    @Data
+    @AllArgsConstructor
+    public static class VAndIResult {
+        private String ip;
+        private Integer chnNum;
+        private Boolean va;
+        private Boolean vb;
+        private Boolean vc;
+        private Boolean ia;
+        private Boolean ib;
+        private Boolean ic;
+        private Double vaXi;
+        private Double vbXi;
+        private Double vcXi;
+        private Double iaXi;
+        private Double ibXi;
+        private Double icXi;
+        // 皮尔逊相关系数
+        private BigDecimal pearsonCorrelationCoefficientVa;
+        private BigDecimal pearsonCorrelationCoefficientVb;
+        private BigDecimal pearsonCorrelationCoefficientVc;
+        private BigDecimal pearsonCorrelationCoefficientIa;
+        private BigDecimal pearsonCorrelationCoefficientIb;
+        private BigDecimal pearsonCorrelationCoefficientIc;
+        // 比值一致性 CV 系数
+        private BigDecimal cVCoefficientVa;
+        private BigDecimal cVCoefficientVb;
+        private BigDecimal cVCoefficientVc;
+        private BigDecimal cVCoefficientIa;
+        private BigDecimal cVCoefficientIb;
+        private BigDecimal cVCoefficientIc;
+    }
+
+    public static Map<String, VAndIResult> vAndIResultMap = null;
+
 
     /**
      * 开始处理指标类型
@@ -1572,6 +1617,23 @@ public class DetectionServiceImpl {
         if (CollUtil.isNotEmpty(devDataList) && CollUtil.isNotEmpty(standardDevDataList) && CollUtil.isNotEmpty(testItemCodeList)) {
             devDataList = devDataList.stream().sorted(Comparator.comparing(DevData::getTime)).collect(Collectors.toList());
             standardDevDataList = standardDevDataList.stream().sorted(Comparator.comparing(DevData::getTime)).collect(Collectors.toList());
+
+            boolean isRemoveMaxElement = ObjectUtil.isNotNull(waveNum) ? false : true;
+//            List<Double> freqStdDevData = standardDevDataList.stream().flatMap(standardDevData -> standardDevData.getSqlData().stream())
+//                    .filter(sqlDataDTO -> DetectionCodeEnum.FREQ.getCode().equals(sqlDataDTO.getDesc()))
+//                    .map(sqlDataDTO -> sqlDataDTO.getList().getT()).collect(Collectors.toList());
+
+//            Double maxFreq = CollUtil.isNotEmpty(freqStdDevData) ? CollUtil.max(freqStdDevData) : null;
+//            Double minFreq = CollUtil.isNotEmpty(freqStdDevData) ? CollUtil.min(freqStdDevData) : null;
+
+//            if (maxFreq != null && minFreq != null) {
+//                isRemoveMaxElement = DictDataEnum.AVG_VALUE.equals(dataRule);
+//                double freqErrorValue = maxFreq - minFreq;
+//                if (NumberUtil.isGreaterOrEqual(BigDecimal.valueOf(freqErrorValue), BigDecimal.valueOf(0.02))) {
+//                    isRemoveMaxElement = isRemoveMaxElement && true;
+//                }
+//            }
+
             // 处理谐波数据
             SysTestConfig oneConfig = sysTestConfigService.getOneConfig();
             String[] split1 = devDataList.get(0).getId().split("_");
@@ -1618,12 +1680,12 @@ public class DetectionServiceImpl {
 //                                sqlData.setList(listDTO);
 //                            }));
 //                        }
-                        resultMap.put(PowerIndexEnum.FREQ.getKey(), isQualified(devDataList, standardDevDataList, devIdMapComm, pqErrSysDtls, true, fHz, DetectionCodeEnum.FREQ.getCode(), dataRule, num, code, oneConfig.getScale(), waveNum, dataSourceEnum));
+                        resultMap.put(PowerIndexEnum.FREQ.getKey(), isQualified(devDataList, standardDevDataList, devIdMapComm, pqErrSysDtls, true, fHz, DetectionCodeEnum.FREQ.getCode(), dataRule, num, code, oneConfig.getScale(), waveNum, dataSourceEnum, isRemoveMaxElement));
                         break;
                     case VRMS:
                     case PVRMS:
                         // 如果是角型接法且存在角型接法的一些指标，则不进行使用角型接线的指标。反之，则使用相别的指标。
-                        resultMap.put(PowerIndexEnum.V.getKey(), isQualified(devDataList, standardDevDataList, devIdMapComm, pqErrSysDtls, true, fUn, (isDelta && isExitDelta ? DetectionCodeEnum.PVRMS.getCode() : DetectionCodeEnum.VRMS.getCode()), dataRule, num, code, oneConfig.getScale(), waveNum, dataSourceEnum));
+                        resultMap.put(PowerIndexEnum.V.getKey(), isQualified(devDataList, standardDevDataList, devIdMapComm, pqErrSysDtls, true, fUn, (isDelta && isExitDelta ? DetectionCodeEnum.PVRMS.getCode() : DetectionCodeEnum.VRMS.getCode()), dataRule, num, code, oneConfig.getScale(), waveNum, dataSourceEnum, isRemoveMaxElement));
                         break;
                     case IRMS:
 //                        if (ObjectUtil.isNotNull(waveNum) && (waveNum.equals(2) || waveNum.equals(5))) {
@@ -1634,33 +1696,33 @@ public class DetectionServiceImpl {
 //                                sqlData.setList(listDTO);
 //                            }));
 //                        }
-                        resultMap.put(PowerIndexEnum.I.getKey(), isQualified(devDataList, standardDevDataList, devIdMapComm, pqErrSysDtls, true, fIn, DetectionCodeEnum.IRMS.getCode(), dataRule, num, code, oneConfig.getScale(), waveNum, dataSourceEnum));
+                        resultMap.put(PowerIndexEnum.I.getKey(), isQualified(devDataList, standardDevDataList, devIdMapComm, pqErrSysDtls, true, fIn, DetectionCodeEnum.IRMS.getCode(), dataRule, num, code, oneConfig.getScale(), waveNum, dataSourceEnum, isRemoveMaxElement));
                         break;
                     case V_UNBAN:
-                        resultMap.put(PowerIndexEnum.IMBV.getKey(), isQualified(devDataList, standardDevDataList, devIdMapComm, pqErrSysDtls, false, fUn, DetectionCodeEnum.V_UNBAN.getCode(), dataRule, num, code, oneConfig.getScale(), waveNum, dataSourceEnum));
+                        resultMap.put(PowerIndexEnum.IMBV.getKey(), isQualified(devDataList, standardDevDataList, devIdMapComm, pqErrSysDtls, false, fUn, DetectionCodeEnum.V_UNBAN.getCode(), dataRule, num, code, oneConfig.getScale(), waveNum, dataSourceEnum, isRemoveMaxElement));
                         break;
                     case I_UNBAN:
-                        resultMap.put(PowerIndexEnum.IMBA.getKey(), isQualified(devDataList, standardDevDataList, devIdMapComm, pqErrSysDtls, false, fIn, DetectionCodeEnum.I_UNBAN.getCode(), dataRule, num, code, oneConfig.getScale(), waveNum, dataSourceEnum));
+                        resultMap.put(PowerIndexEnum.IMBA.getKey(), isQualified(devDataList, standardDevDataList, devIdMapComm, pqErrSysDtls, false, fIn, DetectionCodeEnum.I_UNBAN.getCode(), dataRule, num, code, oneConfig.getScale(), waveNum, dataSourceEnum, isRemoveMaxElement));
                         break;
                     case V2_50:
                     case PV2_50:
-                        resultMap.put(PowerIndexEnum.HV.getKey(), isHarmQualified(devDataList, standardDevDataList, devIdMapComm, pqErrSysDtls, U, fUn, HARMONIC_FLAG, isDelta && isExitDelta, dataRule, num, code, oneConfig.getScale(), waveNum, dataSourceEnum));
+                        resultMap.put(PowerIndexEnum.HV.getKey(), isHarmQualified(devDataList, standardDevDataList, devIdMapComm, pqErrSysDtls, U, fUn, HARMONIC_FLAG, isDelta && isExitDelta, dataRule, num, code, oneConfig.getScale(), waveNum, dataSourceEnum, isRemoveMaxElement));
                         break;
                     case I2_50:
-                        resultMap.put(PowerIndexEnum.HI.getKey(), isHarmQualified(devDataList, standardDevDataList, devIdMapComm, pqErrSysDtls, I, fIn, HARMONIC_FLAG, isDelta && isExitDelta, dataRule, num, code, oneConfig.getScale(), waveNum, dataSourceEnum));
+                        resultMap.put(PowerIndexEnum.HI.getKey(), isHarmQualified(devDataList, standardDevDataList, devIdMapComm, pqErrSysDtls, I, fIn, HARMONIC_FLAG, isDelta && isExitDelta, dataRule, num, code, oneConfig.getScale(), waveNum, dataSourceEnum, isRemoveMaxElement));
                         break;
                     case P2_50:
-                        resultMap.put(PowerIndexEnum.HP.getKey(), isHarmQualified(devDataList, standardDevDataList, devIdMapComm, pqErrSysDtls, HP, fUn * fIn, HARMONIC_FLAG, isDelta && isExitDelta, dataRule, num, code, oneConfig.getScale(), waveNum, dataSourceEnum));
+                        resultMap.put(PowerIndexEnum.HP.getKey(), isHarmQualified(devDataList, standardDevDataList, devIdMapComm, pqErrSysDtls, HP, fUn * fIn, HARMONIC_FLAG, isDelta && isExitDelta, dataRule, num, code, oneConfig.getScale(), waveNum, dataSourceEnum, isRemoveMaxElement));
                         break;
                     case SV_1_49:
                     case PSV_1_49:
-                        resultMap.put(PowerIndexEnum.HSV.getKey(), isHarmQualified(devDataList, standardDevDataList, devIdMapComm, pqErrSysDtls, U, fUn, INHARMONIC_FLAG, isDelta && isExitDelta, dataRule, num, code, oneConfig.getScale(), waveNum, dataSourceEnum));
+                        resultMap.put(PowerIndexEnum.HSV.getKey(), isHarmQualified(devDataList, standardDevDataList, devIdMapComm, pqErrSysDtls, U, fUn, INHARMONIC_FLAG, isDelta && isExitDelta, dataRule, num, code, oneConfig.getScale(), waveNum, dataSourceEnum, isRemoveMaxElement));
                         break;
                     case SI_1_49:
-                        resultMap.put(PowerIndexEnum.HSI.getKey(), isHarmQualified(devDataList, standardDevDataList, devIdMapComm, pqErrSysDtls, I, fIn, INHARMONIC_FLAG, isDelta && isExitDelta, dataRule, num, code, oneConfig.getScale(), waveNum, dataSourceEnum));
+                        resultMap.put(PowerIndexEnum.HSI.getKey(), isHarmQualified(devDataList, standardDevDataList, devIdMapComm, pqErrSysDtls, I, fIn, INHARMONIC_FLAG, isDelta && isExitDelta, dataRule, num, code, oneConfig.getScale(), waveNum, dataSourceEnum, isRemoveMaxElement));
                         break;
                     case PST:
-                        resultMap.put(PowerIndexEnum.F.getKey(), isQualified(devDataList, standardDevDataList, devIdMapComm, pqErrSysDtls, true, fUn, DetectionCodeEnum.PST.getCode(), dataRule, num, code, oneConfig.getScale(), waveNum, DataSourceEnum.MINUTE_STATISTICS_AVG));
+                        resultMap.put(PowerIndexEnum.F.getKey(), isQualified(devDataList, standardDevDataList, devIdMapComm, pqErrSysDtls, true, fUn, DetectionCodeEnum.PST.getCode(), dataRule, num, code, oneConfig.getScale(), waveNum, DataSourceEnum.MINUTE_STATISTICS_AVG, isRemoveMaxElement));
                         break;
                     case UNKNOWN_ERROR:
                         break;
@@ -1734,22 +1796,29 @@ public class DetectionServiceImpl {
                                 String code,
                                 Integer scale,
                                 Integer waveNum,
-                                DataSourceEnum dataSourceEnum) {
+                                DataSourceEnum dataSourceEnum,
+                                boolean isRemoveMaxElement) {
         List<ContrastNonHarmonicResult> info = new ArrayList<>();
         if (CollUtil.isNotEmpty(devDataList) && CollUtil.isNotEmpty(standardDevDataList) && CollUtil.isNotEmpty(errSysDtls)) {
 
-            Map<String, List<List<Double>>> map = devListMap(devDataList, standardDevDataList, desc, dataRule);
+            Map<String, List<List<Double>>> phaseValueList = this.getPhaseValueList(devDataList, standardDevDataList, desc);
+            Map<String, List<List<Double>>> map = devListMap(phaseValueList, dataRule, isRemoveMaxElement);
             if (ObjectUtil.isNull(map)) {
                 return 4;
             }
             ContrastNonHarmonicResult result = new ContrastNonHarmonicResult();
             result.setWaveNum(waveNum);
 
-            String[] split1 = devDataList.get(0).getId().split(CnSocketUtil.SPLIT_TAG);
+            String devId = devDataList.get(0).getId();
-            String[] split2 = standardDevDataList.get(0).getId().split(CnSocketUtil.SPLIT_TAG);
+            String stdId = standardDevDataList.get(0).getId();
+
+            String[] split1 = devId.split(CnSocketUtil.SPLIT_TAG);
+            String[] split2 = stdId.split(CnSocketUtil.SPLIT_TAG);
             result.setNum(num);
-            result.setDevMonitorId(devIdMapComm.get(split1[0]) + "_" + split1[1]);
+            String devMonitorId = devIdMapComm.get(split1[0]) + "_" + split1[1];
-            result.setStdDevMonitorId(devIdMapComm.get(split2[0]) + "_" + split2[1]);
+            result.setDevMonitorId(devMonitorId);
+            String stdDevMonitorId = devIdMapComm.get(split2[0]) + "_" + split2[1];
+            result.setStdDevMonitorId(stdDevMonitorId);
             result.setAdType(errSysDtls.get(0).getScriptType());
             result.setDataType(dataSourceEnum.getValue());
             if (ObjectUtil.isNotNull(waveNum)) {
@@ -1790,6 +1859,78 @@ public class DetectionServiceImpl {
                     List<DetectionData> phaseList = rangeComparisonList(map.get(phase).get(0), map.get(phase).get(1), errSysDtls, fData, scale, dataRule);
                     this.setValidGroupNum(phaseList, validGroupNum);
                     resultFlag.addAll(phaseList);
+                    if (FormalTestManager.isTesting && ObjectUtil.isNull(waveNum)) { //只有“正式检测并且不是录波数据”的时候才能进入这段代码，重新计算、切换误差体系额操作不会进入这段代码，提升效率。
+//                    if (true) { //只有“正式检测并且不是录波数据”的时候才能进入这段代码，重新计算、切换误差体系额操作不会进入这段代码，提升效率。
+                        if (DetectionCodeEnum.PVRMS.getCode().equals(desc) || DetectionCodeEnum.VRMS.getCode().equals(desc) || DetectionCodeEnum.IRMS.getCode().equals(desc)) {
+                            Integer phaseResultFlag = setResultFlag(phaseList);
+                            boolean b = phaseResultFlag == 2 ? true : false;
+
+                            SysTestConfig oneConfig = sysTestConfigService.getOneConfig();
+                            if (b && oneConfig.getCoefficient() == 1) {
+                                BigDecimal pearsonCorrelationCoefficient = DetectionUtil.getPearsonCorrelationCoefficient(phaseValueList.get(phase).get(0), phaseValueList.get(phase).get(1));
+                                if (NumberUtil.isGreaterOrEqual(pearsonCorrelationCoefficient, BigDecimal.valueOf(0.8))) {
+                                    BigDecimal cvCoefficient = DetectionUtil.getCvCoefficient(phaseValueList.get(phase).get(0), phaseValueList.get(phase).get(1));
+                                    if (NumberUtil.isLess(cvCoefficient, BigDecimal.valueOf(0.05))) {
+                                        int maxNum = pqStandardDevGainRecordService.getMaxNum(stdDevMonitorId, devMonitorId);
+                                        // 如果没有超出次数限制
+                                        if (maxNum + 1 <= 5) {
+                                            VAndIResult vAndIResult = vAndIResultMap.getOrDefault(stdId, new VAndIResult(split2[0], Integer.valueOf(split2[1]), false, false, false, false, false, false,
+                                                    1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
+                                                    BigDecimal.ZERO, BigDecimal.ZERO, BigDecimal.ZERO, BigDecimal.ZERO, BigDecimal.ZERO, BigDecimal.ZERO,
+                                                    BigDecimal.valueOf(0.2), BigDecimal.valueOf(0.2), BigDecimal.valueOf(0.2), BigDecimal.valueOf(0.2), BigDecimal.valueOf(0.2), BigDecimal.valueOf(0.2)));
+
+                                            Double newXi = DetectionUtil.getNewXi(map.get(phase).get(0), map.get(phase).get(1));
+                                            switch (phase) {
+                                                case TYPE_A:
+                                                    if (DetectionCodeEnum.IRMS.getCode().equals(desc)) {
+                                                        vAndIResult.setIa(b);
+                                                        vAndIResult.setIaXi(newXi);
+                                                        vAndIResult.setPearsonCorrelationCoefficientIa(pearsonCorrelationCoefficient);
+                                                        vAndIResult.setCVCoefficientIa(cvCoefficient);
+                                                    } else {
+                                                        vAndIResult.setVa(b);
+                                                        vAndIResult.setVaXi(newXi);
+                                                        vAndIResult.setPearsonCorrelationCoefficientVa(pearsonCorrelationCoefficient);
+                                                        vAndIResult.setCVCoefficientVa(cvCoefficient);
+                                                    }
+                                                    break;
+                                                case TYPE_B:
+                                                    if (DetectionCodeEnum.IRMS.getCode().equals(desc)) {
+                                                        vAndIResult.setIb(b);
+                                                        vAndIResult.setIbXi(newXi);
+                                                        vAndIResult.setPearsonCorrelationCoefficientIb(pearsonCorrelationCoefficient);
+                                                        vAndIResult.setCVCoefficientIb(cvCoefficient);
+                                                    } else {
+                                                        vAndIResult.setVb(b);
+                                                        vAndIResult.setVbXi(newXi);
+                                                        vAndIResult.setPearsonCorrelationCoefficientVb(pearsonCorrelationCoefficient);
+                                                        vAndIResult.setCVCoefficientVb(cvCoefficient);
+                                                    }
+                                                    break;
+                                                case TYPE_C:
+                                                    if (DetectionCodeEnum.IRMS.getCode().equals(desc)) {
+                                                        vAndIResult.setIc(b);
+                                                        vAndIResult.setIcXi(newXi);
+                                                        vAndIResult.setPearsonCorrelationCoefficientIc(pearsonCorrelationCoefficient);
+                                                        vAndIResult.setCVCoefficientIc(cvCoefficient);
+                                                    } else {
+                                                        vAndIResult.setVc(b);
+                                                        vAndIResult.setVcXi(newXi);
+                                                        vAndIResult.setPearsonCorrelationCoefficientVc(pearsonCorrelationCoefficient);
+                                                        vAndIResult.setCVCoefficientVc(cvCoefficient);
+                                                    }
+                                                    break;
+                                                default:
+                                                    break;
+                                            }
+
+                                            vAndIResultMap.put(stdId, vAndIResult);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
                     BiConsumer<ContrastNonHarmonicResult, List<DetectionData>> setter = setters.get(phase);
                     setter.accept(result, phaseList);
                 }
@@ -1999,7 +2140,8 @@ public class DetectionServiceImpl {
                                    String code,
                                    Integer scale,
                                    Integer waveNum,
-                                   DataSourceEnum dataSourceEnum) {
+                                   DataSourceEnum dataSourceEnum,
+                                   boolean isRemoveMaxElement) {
         List<ContrastHarmonicResult> info = new ArrayList<>();
         if (CollUtil.isNotEmpty(devDataList) && CollUtil.isNotEmpty(standardDevDataList) && CollUtil.isNotEmpty(errSysDtls)) {
             String fundCode = "";
@@ -2034,7 +2176,7 @@ public class DetectionServiceImpl {
                 harmCode = DetectionCodeEnum.P2_50.getCode();
             }
 
-            Map<String, List<Map<Double, List<Double>>>> devMap = devHarmListMap(devDataList, standardDevDataList, fundCode, harmCode, harmonicFlag, dataRule);
+            Map<String, List<Map<Double, List<Double>>>> devMap = devHarmListMap(devDataList, standardDevDataList, fundCode, harmCode, harmonicFlag, dataRule, isRemoveMaxElement);
             if (ObjectUtil.isNull(devMap)) {
                 return 4;
             }
@@ -2141,14 +2283,285 @@ public class DetectionServiceImpl {
     /**
      * 处理非谐波类取值
      *
-     * @param dev         被检设备原始数据
+     * @param dataRule 数据处理原则
-     * @param standardDev 与之对齐的标准设备原始数据
-     * @param desc        检测项
-     * @param dataRule    数据处理原则
      */
-    public Map<String, List<List<Double>>> devListMap(List<DevData> dev, List<DevData> standardDev, String desc, DictDataEnum dataRule) {
+    public Map<String, List<List<Double>>> devListMap(Map<String, List<List<Double>>> phaseValueList, DictDataEnum dataRule, boolean isRemoveMaxElement) {
         Map<String, List<List<Double>>> resultMap = new HashMap<>(3);
 
+        List<Double> aDev = new ArrayList<>();
+        List<Double> aStandardDev = new ArrayList<>();
+
+        if (phaseValueList.containsKey(TYPE_A)) {
+            if (phaseValueList.get(TYPE_A).size() >= 1) {
+                aDev.addAll(BeanUtil.copyToList(phaseValueList.get(TYPE_A).get(0), Double.class));
+                aStandardDev.addAll(BeanUtil.copyToList(phaseValueList.get(TYPE_A).get(1), Double.class));
+            } else {
+                log.error("数据异常，phaseValueList.get(TYPE_A).size()=" + phaseValueList.get(TYPE_A).size());
+            }
+        } else {
+            log.equals("数据异常，phaseValueList.containsKey(TYPE_A)=" + phaseValueList.containsKey(TYPE_A));
+        }
+
+        List<Double> bDev = new ArrayList<>();
+        List<Double> bStandardDev = new ArrayList<>();
+
+        if (phaseValueList.containsKey(TYPE_B)) {
+            if (phaseValueList.get(TYPE_B).size() >= 1) {
+                bDev.addAll(BeanUtil.copyToList(phaseValueList.get(TYPE_B).get(0), Double.class));
+                bStandardDev.addAll(BeanUtil.copyToList(phaseValueList.get(TYPE_B).get(1), Double.class));
+            } else {
+                log.error("数据异常，phaseValueList.get(TYPE_B).size()=" + phaseValueList.get(TYPE_B).size());
+            }
+        } else {
+            log.equals("数据异常，phaseValueList.containsKey(TYPE_B)=" + phaseValueList.containsKey(TYPE_B));
+        }
+
+        List<Double> cDev = new ArrayList<>();
+        List<Double> cStandardDev = new ArrayList<>();
+        if (phaseValueList.containsKey(TYPE_C)) {
+            if (phaseValueList.get(TYPE_C).size() >= 1) {
+                cDev.addAll(BeanUtil.copyToList(phaseValueList.get(TYPE_C).get(0), Double.class));
+                cStandardDev.addAll(BeanUtil.copyToList(phaseValueList.get(TYPE_C).get(1), Double.class));
+            } else {
+                log.error("数据异常，phaseValueList.get(TYPE_C).size()=" + phaseValueList.get(TYPE_C).size());
+            }
+        } else {
+            log.equals("数据异常，phaseValueList.containsKey(TYPE_C)=" + phaseValueList.containsKey(TYPE_C));
+        }
+
+        List<Double> tDev = new ArrayList<>();
+        List<Double> tStandardDev = new ArrayList<>();
+        if (phaseValueList.containsKey(TYPE_T)) {
+            if (phaseValueList.get(TYPE_T).size() >= 1) {
+                tDev.addAll(BeanUtil.copyToList(phaseValueList.get(TYPE_T).get(0), Double.class));
+                tStandardDev.addAll(BeanUtil.copyToList(phaseValueList.get(TYPE_T).get(1), Double.class));
+            } else {
+                log.error("数据异常，phaseValueList.get(TYPE_T).size()=" + phaseValueList.get(TYPE_T).size());
+            }
+        } else {
+            log.equals("数据异常，phaseValueList.containsKey(TYPE_T)=" + phaseValueList.containsKey(TYPE_T));
+        }
+
+        if (isRemoveMaxElement) {
+            List<Double> aErrorValueList = new ArrayList<>();
+            List<Double> bErrorValueList = new ArrayList<>();
+            List<Double> cErrorValueList = new ArrayList<>();
+            List<Double> tErrorValueList = new ArrayList<>();
+            for (int i = 0; i < aStandardDev.size(); i++) {
+                aErrorValueList.add(Math.abs(aStandardDev.get(i) - aDev.get(i)));
+            }
+            for (int i = 0; i < bStandardDev.size(); i++) {
+                bErrorValueList.add(Math.abs(bStandardDev.get(i) - bDev.get(i)));
+            }
+            for (int i = 0; i < cStandardDev.size(); i++) {
+                cErrorValueList.add(Math.abs(cStandardDev.get(i) - cDev.get(i)));
+            }
+            for (int i = 0; i < tStandardDev.size(); i++) {
+                tErrorValueList.add(Math.abs(tStandardDev.get(i) - tDev.get(i)));
+            }
+            List<Integer> aErrorValueIdxs = DetectionUtil.sort(aErrorValueList, false);
+            List<Integer> bErrorValueIdxs = DetectionUtil.sort(bErrorValueList, false);
+            List<Integer> cErrorValueIdxs = DetectionUtil.sort(cErrorValueList, false);
+            List<Integer> tErrorValueIdxs = DetectionUtil.sort(tErrorValueList, false);
+
+            int removeCount = aErrorValueIdxs.size() / 2;
+            List<Double> newArray = DetectionUtil.getNewArray(aStandardDev, aErrorValueIdxs.subList(removeCount, aErrorValueIdxs.size()));
+            aStandardDev.clear();
+            aStandardDev.addAll(newArray);
+            newArray = DetectionUtil.getNewArray(aDev, aErrorValueIdxs.subList(removeCount, aErrorValueIdxs.size()));
+            aDev.clear();
+            aDev.addAll(newArray);
+
+            removeCount = bErrorValueIdxs.size() / 2;
+            newArray = DetectionUtil.getNewArray(bStandardDev, bErrorValueIdxs.subList(removeCount, bErrorValueIdxs.size()));
+            bStandardDev.clear();
+            bStandardDev.addAll(newArray);
+            newArray = DetectionUtil.getNewArray(bDev, bErrorValueIdxs.subList(removeCount, bErrorValueIdxs.size()));
+            bDev.clear();
+            bDev.addAll(newArray);
+
+            removeCount = cErrorValueIdxs.size() / 2;
+            newArray = DetectionUtil.getNewArray(cStandardDev, cErrorValueIdxs.subList(removeCount, cErrorValueIdxs.size()));
+            cStandardDev.clear();
+            cStandardDev.addAll(newArray);
+            newArray = DetectionUtil.getNewArray(cDev, cErrorValueIdxs.subList(removeCount, cErrorValueIdxs.size()));
+            cDev.clear();
+            cDev.addAll(newArray);
+
+            removeCount = tErrorValueIdxs.size() / 2;
+            newArray = DetectionUtil.getNewArray(tStandardDev, tErrorValueIdxs.subList(removeCount, tErrorValueIdxs.size()));
+            tStandardDev.clear();
+            tStandardDev.addAll(newArray);
+            newArray = DetectionUtil.getNewArray(tDev, tErrorValueIdxs.subList(removeCount, tErrorValueIdxs.size()));
+            tDev.clear();
+            tDev.addAll(newArray);
+        }
+
+        switch (dataRule) {
+            case SECTION_VALUE: {
+                List<Integer> aIdxs = DetectionUtil.sort(aStandardDev, false);
+                List<Integer> bIdxs = DetectionUtil.sort(bStandardDev, false);
+                List<Integer> cIdxs = DetectionUtil.sort(cStandardDev, false);
+                List<Integer> tIdxs = DetectionUtil.sort(tStandardDev, false);
+                if (aStandardDev.size() > 2) {
+                    aStandardDev.remove(0);
+                    aStandardDev.remove(aStandardDev.size() - 1);
+                    List<Double> newArray = DetectionUtil.getNewArray(aDev, aIdxs.subList(1, aIdxs.size() - 1));
+                    aDev.clear();
+                    aDev.addAll(newArray);
+                }
+                if (bStandardDev.size() > 2) {
+                    bStandardDev.remove(0);
+                    bStandardDev.remove(bStandardDev.size() - 1);
+                    List<Double> newArray = DetectionUtil.getNewArray(bDev, bIdxs.subList(1, bIdxs.size() - 1));
+                    bDev.clear();
+                    bDev.addAll(newArray);
+                }
+                if (cStandardDev.size() > 2) {
+                    cStandardDev.remove(0);
+                    cStandardDev.remove(cStandardDev.size() - 1);
+                    List<Double> newArray = DetectionUtil.getNewArray(cDev, cIdxs.subList(1, cIdxs.size() - 1));
+                    cDev.clear();
+                    cDev.addAll(newArray);
+                }
+                if (tStandardDev.size() > 2) {
+                    tStandardDev.remove(0);
+                    tStandardDev.remove(tStandardDev.size() - 1);
+                    List<Double> newArray = DetectionUtil.getNewArray(tDev, tIdxs.subList(1, tIdxs.size() - 1));
+                    tDev.clear();
+                    tDev.addAll(newArray);
+                }
+            }
+            break;
+            case CP95_VALUE: {
+                List<Integer> aIdxs = DetectionUtil.sort(aStandardDev, false);
+                List<Integer> bIdxs = DetectionUtil.sort(bStandardDev, false);
+                List<Integer> cIdxs = DetectionUtil.sort(cStandardDev, false);
+                List<Integer> tIdxs = DetectionUtil.sort(tStandardDev, false);
+                if (CollUtil.isNotEmpty(aStandardDev)) {
+                    int cp95Idx = DetectionUtil.getCP95Idx(aStandardDev);
+                    aStandardDev = Collections.singletonList(aStandardDev.get(cp95Idx));
+                    aDev = Collections.singletonList(aDev.get(aIdxs.get(cp95Idx)));
+                }
+                if (CollUtil.isNotEmpty(bStandardDev)) {
+                    int cp95Idx = DetectionUtil.getCP95Idx(bStandardDev);
+                    bStandardDev = Collections.singletonList(bStandardDev.get(cp95Idx));
+                    bDev = Collections.singletonList(bDev.get(bIdxs.get(cp95Idx)));
+                }
+                if (CollUtil.isNotEmpty(cStandardDev)) {
+                    int cp95Idx = DetectionUtil.getCP95Idx(cStandardDev);
+                    cStandardDev = Collections.singletonList(cStandardDev.get(cp95Idx));
+                    cDev = Collections.singletonList(cDev.get(cIdxs.get(cp95Idx)));
+                }
+                if (CollUtil.isNotEmpty(tStandardDev)) {
+                    int cp95Idx = DetectionUtil.getCP95Idx(tStandardDev);
+                    tStandardDev = Collections.singletonList(tStandardDev.get(cp95Idx));
+                    tDev = Collections.singletonList(tDev.get(tIdxs.get(cp95Idx)));
+                }
+            }
+            break;
+            case AVG_VALUE:
+                aDev = DetectionUtil.getAvgDoubles(aDev);
+                bDev = DetectionUtil.getAvgDoubles(bDev);
+                cDev = DetectionUtil.getAvgDoubles(cDev);
+                tDev = DetectionUtil.getAvgDoubles(tDev);
+
+                aStandardDev = DetectionUtil.getAvgDoubles(aStandardDev);
+                bStandardDev = DetectionUtil.getAvgDoubles(bStandardDev);
+                cStandardDev = DetectionUtil.getAvgDoubles(cStandardDev);
+                tStandardDev = DetectionUtil.getAvgDoubles(tStandardDev);
+                break;
+            case Own_value:
+                break;
+            case AT_WILL_VALUE:
+                if (isRemoveMaxElement) {
+                    if (CollUtil.isNotEmpty(aStandardDev) && CollUtil.isNotEmpty(aDev)) {
+                        aStandardDev = aStandardDev.subList(aStandardDev.size() - 1, aStandardDev.size());
+                        aDev = aDev.subList(aDev.size() - 1, aDev.size());
+                    }
+                    if (CollUtil.isNotEmpty(bStandardDev) && CollUtil.isNotEmpty(bDev)) {
+                        bStandardDev = bStandardDev.subList(bStandardDev.size() - 1, bStandardDev.size());
+                        bDev = bDev.subList(bDev.size() - 1, bDev.size());
+                    }
+                    if (CollUtil.isNotEmpty(cStandardDev) && CollUtil.isNotEmpty(cDev)) {
+                        cStandardDev = cStandardDev.subList(cStandardDev.size() - 1, cStandardDev.size());
+                        cDev = cDev.subList(cDev.size() - 1, cDev.size());
+                    }
+                    if (CollUtil.isNotEmpty(tStandardDev) && CollUtil.isNotEmpty(tDev)) {
+                        tStandardDev = tStandardDev.subList(tStandardDev.size() - 1, tStandardDev.size());
+                        tDev = tDev.subList(tDev.size() - 1, tDev.size());
+                    }
+                } else {
+                    List<Double> aErrorValueList = new ArrayList<>();
+                    List<Double> bErrorValueList = new ArrayList<>();
+                    List<Double> cErrorValueList = new ArrayList<>();
+                    List<Double> tErrorValueList = new ArrayList<>();
+                    for (int i = 0; i < aStandardDev.size(); i++) {
+                        aErrorValueList.add(Math.abs(aStandardDev.get(i) - aDev.get(i)));
+                    }
+                    for (int i = 0; i < bStandardDev.size(); i++) {
+                        bErrorValueList.add(Math.abs(bStandardDev.get(i) - bDev.get(i)));
+                    }
+                    for (int i = 0; i < cStandardDev.size(); i++) {
+                        cErrorValueList.add(Math.abs(cStandardDev.get(i) - cDev.get(i)));
+                    }
+                    for (int i = 0; i < tStandardDev.size(); i++) {
+                        tErrorValueList.add(Math.abs(tStandardDev.get(i) - tDev.get(i)));
+                    }
+                    List<Integer> aErrorValueIdxs = DetectionUtil.sort(aErrorValueList, true);
+                    List<Integer> bErrorValueIdxs = DetectionUtil.sort(bErrorValueList, true);
+                    List<Integer> cErrorValueIdxs = DetectionUtil.sort(cErrorValueList, true);
+                    List<Integer> tErrorValueIdxs = DetectionUtil.sort(tErrorValueList, true);
+
+                    if (CollUtil.isNotEmpty(aStandardDev) && CollUtil.isNotEmpty(aDev)) {
+                        Double v = aStandardDev.get(aErrorValueIdxs.get(0));
+                        aStandardDev.clear();
+                        aStandardDev.add(v);
+                        v = aDev.get(aErrorValueIdxs.get(0));
+                        aDev.clear();
+                        aDev.add(v);
+                    }
+
+                    if (CollUtil.isNotEmpty(bStandardDev) && CollUtil.isNotEmpty(bDev)) {
+                        Double v = bStandardDev.get(bErrorValueIdxs.get(0));
+                        bStandardDev.clear();
+                        bStandardDev.add(v);
+                        v = bDev.get(bErrorValueIdxs.get(0));
+                        bDev.clear();
+                        bDev.add(v);
+                    }
+
+                    if (CollUtil.isNotEmpty(cStandardDev) && CollUtil.isNotEmpty(cDev)) {
+                        Double v = cStandardDev.get(cErrorValueIdxs.get(0));
+                        cStandardDev.clear();
+                        cStandardDev.add(v);
+                        v = cDev.get(cErrorValueIdxs.get(0));
+                        cDev.clear();
+                        cDev.add(v);
+                    }
+
+                    if (CollUtil.isNotEmpty(tStandardDev) && CollUtil.isNotEmpty(tDev)) {
+                        Double v = tStandardDev.get(tErrorValueIdxs.get(0));
+                        tStandardDev.clear();
+                        tStandardDev.add(v);
+                        v = tDev.get(tErrorValueIdxs.get(0));
+                        tDev.clear();
+                        tDev.add(v);
+                    }
+                }
+                break;
+        }
+        resultMap.put(TYPE_A, Arrays.asList(aDev, aStandardDev));
+        resultMap.put(TYPE_B, Arrays.asList(bDev, bStandardDev));
+        resultMap.put(TYPE_C, Arrays.asList(cDev, cStandardDev));
+        if (CollUtil.isNotEmpty(tDev)) {
+            resultMap.put(TYPE_T, Arrays.asList(tDev, tStandardDev));
+        }
+        return resultMap;
+    }
+
+    private Map<String, List<List<Double>>> getPhaseValueList(List<DevData> dev, List<DevData> standardDev, String desc) {
+        Map<String, List<List<Double>>> resultMap = new HashMap<>(3);
         List<Double> aDev = new ArrayList<>();
         List<Double> aStandardDev = new ArrayList<>();
         List<Double> bDev = new ArrayList<>();
@@ -2202,87 +2615,12 @@ public class DetectionServiceImpl {
                     .map(x -> x.getT().doubleValue())
                     .collect(Collectors.toList()));
         }
-        List<Integer> aIdxs = DetectionUtil.sort(aStandardDev, false);
-        List<Integer> bIdxs = DetectionUtil.sort(bStandardDev, false);
-        List<Integer> cIdxs = DetectionUtil.sort(cStandardDev, false);
-        List<Integer> tIdxs = DetectionUtil.sort(tStandardDev, false);
-        switch (dataRule) {
-            case SECTION_VALUE:
-                if (aStandardDev.size() > 2) {
-                    aStandardDev.remove(0);
-                    aStandardDev.remove(aStandardDev.size() - 1);
-                    List<Double> newArray = DetectionUtil.getNewArray(aDev, aIdxs.subList(1, aIdxs.size() - 1));
-                    aDev.clear();
-                    aDev.addAll(newArray);
-                }
 
-                if (bStandardDev.size() > 2) {
-                    bStandardDev.remove(0);
-                    bStandardDev.remove(bStandardDev.size() - 1);
-                    List<Double> newArray = DetectionUtil.getNewArray(bDev, bIdxs.subList(1, bIdxs.size() - 1));
-                    bDev.clear();
-                    bDev.addAll(newArray);
-                }
-
-                if (cStandardDev.size() > 2) {
-                    cStandardDev.remove(0);
-                    cStandardDev.remove(cStandardDev.size() - 1);
-                    List<Double> newArray = DetectionUtil.getNewArray(cDev, cIdxs.subList(1, cIdxs.size() - 1));
-                    cDev.clear();
-                    cDev.addAll(newArray);
-                }
-
-                if (tStandardDev.size() > 2) {
-                    tStandardDev.remove(0);
-                    tStandardDev.remove(tStandardDev.size() - 1);
-                    List<Double> newArray = DetectionUtil.getNewArray(tDev, tIdxs.subList(1, tIdxs.size() - 1));
-                    tDev.clear();
-                    tDev.addAll(newArray);
-                }
-                break;
-            case CP95_VALUE:
-                if (CollUtil.isNotEmpty(aStandardDev)) {
-                    int cp95Idx = DetectionUtil.getCP95Idx(aStandardDev);
-                    aStandardDev = Collections.singletonList(aStandardDev.get(cp95Idx));
-                    aDev = Collections.singletonList(aDev.get(aIdxs.get(cp95Idx)));
-                }
-                if (CollUtil.isNotEmpty(bStandardDev)) {
-                    int cp95Idx = DetectionUtil.getCP95Idx(bStandardDev);
-                    bStandardDev = Collections.singletonList(bStandardDev.get(cp95Idx));
-                    bDev = Collections.singletonList(bDev.get(bIdxs.get(cp95Idx)));
-                }
-
-                if (CollUtil.isNotEmpty(cStandardDev)) {
-                    int cp95Idx = DetectionUtil.getCP95Idx(cStandardDev);
-                    cStandardDev = Collections.singletonList(cStandardDev.get(cp95Idx));
-                    cDev = Collections.singletonList(cDev.get(cIdxs.get(cp95Idx)));
-                }
-
-                if (CollUtil.isNotEmpty(tStandardDev)) {
-                    int cp95Idx = DetectionUtil.getCP95Idx(tStandardDev);
-                    tStandardDev = Collections.singletonList(tStandardDev.get(cp95Idx));
-                    tDev = Collections.singletonList(tDev.get(tIdxs.get(cp95Idx)));
-                }
-
-                break;
-            case AVG_VALUE:
-                aDev = DetectionUtil.getAvgDoubles(aDev);
-                bDev = DetectionUtil.getAvgDoubles(bDev);
-                cDev = DetectionUtil.getAvgDoubles(cDev);
-                tDev = DetectionUtil.getAvgDoubles(tDev);
-
-                aStandardDev = DetectionUtil.getAvgDoubles(aStandardDev);
-                bStandardDev = DetectionUtil.getAvgDoubles(bStandardDev);
-                cStandardDev = DetectionUtil.getAvgDoubles(cStandardDev);
-                tStandardDev = DetectionUtil.getAvgDoubles(tStandardDev);
-                break;
-        }
         resultMap.put(TYPE_A, Arrays.asList(aDev, aStandardDev));
         resultMap.put(TYPE_B, Arrays.asList(bDev, bStandardDev));
         resultMap.put(TYPE_C, Arrays.asList(cDev, cStandardDev));
-        if (CollUtil.isNotEmpty(tDev)) {
+        resultMap.put(TYPE_T, Arrays.asList(tDev, tStandardDev));
-            resultMap.put(TYPE_T, Arrays.asList(tDev, tStandardDev));
+
-        }
         return resultMap;
     }
 
@@ -2302,8 +2640,7 @@ public class DetectionServiceImpl {
                                                                        String fundCode,
                                                                        String harmCode,
                                                                        Integer harmonicFlag,
-                                                                       DictDataEnum dataRule) {
+                                                                       DictDataEnum dataRule, boolean isRemoveMaxElement) {
-        System.out.println("aaa" + dev.size() + "  " + standardDev.size());
         Map<String, List<Map<Double, List<Double>>>> resultMap = new HashMap<>(3);
 
         // key为相别、value{key为谐波次数，value为按数据处理原则处理后的数据}
@@ -2328,27 +2665,6 @@ public class DetectionServiceImpl {
                 first1 = devSqlData.stream().filter(j -> fundCode.equals(j.getDesc())).collect(Collectors.toList()).stream().findFirst();
                 first2 = standardDevSqlData.stream().filter(j -> fundCode.equals(j.getDesc())).collect(Collectors.toList()).stream().findFirst();
             }
-//            // 如果角型接法中，不存在线电压谐波电压基波有效值，则取相电压谐波电压基波有效值进行计算
-//            if (!first1.isPresent()) {
-//                if (DetectionCodeEnum.PU1.getCode().equals(fundCode)) {
-//                    first1 = devSqlData.stream().filter(j -> DetectionCodeEnum.U1.getCode().equals(j.getDesc())).collect(Collectors.toList()).stream().findFirst();
-//                }
-//            } else {
-//                // 防止出现有PU1而没有PV2_50、SV_1_49的情况
-//                if ((DetectionCodeEnum.PV2_50.getCode().equals(harmCode) || DetectionCodeEnum.PSV_1_49.getCode().equals(harmCode)) && DetectionCodeEnum.PU1.getCode().equals(fundCode)) {
-//                    first1 = devSqlData.stream().filter(j -> DetectionCodeEnum.U1.getCode().equals(j.getDesc())).collect(Collectors.toList()).stream().findFirst();
-//                }
-//            }
-//            if (!first2.isPresent()) {
-//                if (DetectionCodeEnum.PU1.getCode().equals(fundCode)) {
-//                    first2 = devSqlData.stream().filter(j -> DetectionCodeEnum.U1.getCode().equals(j.getDesc())).collect(Collectors.toList()).stream().findFirst();
-//                }
-//            } else {
-//                // 防止出现有PU1而没有PV2_50、SV_1_49的情况
-//                if ((DetectionCodeEnum.PV2_50.getCode().equals(harmCode) || DetectionCodeEnum.PSV_1_49.getCode().equals(harmCode)) && DetectionCodeEnum.PU1.getCode().equals(fundCode)) {
-//                    first2 = devSqlData.stream().filter(j -> DetectionCodeEnum.U1.getCode().equals(j.getDesc())).collect(Collectors.toList()).stream().findFirst();
-//                }
-//            }
 
             DevData.SqlDataDTO fund1 = null;
             DevData.SqlDataDTO fund2 = null;
@@ -2365,23 +2681,6 @@ public class DetectionServiceImpl {
             if (CollUtil.isEmpty(devHarmList) || CollUtil.isEmpty(stdDevHarmList)) {
                 return null;
             }
-//            // 如果角型接法中，不存在线电压谐波电压含有率，则取相电压谐波电压含有率进行计算
-//            if (CollUtil.isEmpty(devHarmList)) {
-//                if (DetectionCodeEnum.PV2_50.getCode().equals(harmCode)) {
-//                    devHarmList = dev.get(i).getSqlDataHarm().stream().filter(x -> DetectionCodeEnum.V2_50.getCode().equals(x.getDesc())).collect(Collectors.toList());
-//                }
-//                if (DetectionCodeEnum.PSV_1_49.getCode().equals(harmCode)) {
-//                    devHarmList = dev.get(i).getSqlDataHarm().stream().filter(x -> DetectionCodeEnum.SV_1_49.getCode().equals(x.getDesc())).collect(Collectors.toList());
-//                }
-//            }
-//            if (CollUtil.isEmpty(stdDevHarmList)) {
-//                if (DetectionCodeEnum.PV2_50.getCode().equals(harmCode)) {
-//                    stdDevHarmList = standardDev.get(i).getSqlDataHarm().stream().filter(x -> DetectionCodeEnum.V2_50.getCode().equals(x.getDesc())).collect(Collectors.toList());
-//                }
-//                if (DetectionCodeEnum.PSV_1_49.getCode().equals(harmCode)) {
-//                    stdDevHarmList = standardDev.get(i).getSqlDataHarm().stream().filter(x -> DetectionCodeEnum.SV_1_49.getCode().equals(x.getDesc())).collect(Collectors.toList());
-//                }
-//            }
 
             if (CollUtil.isNotEmpty(devHarmList) && CollUtil.isNotEmpty(stdDevHarmList)) {
                 DevData.SqlDataHarmDTO devHarm = devHarmList.get(0);
@@ -2403,38 +2702,87 @@ public class DetectionServiceImpl {
                 }
             }
         }
-        standardDevMap.forEach((typeKey, typeValue) -> {
+        standardDevMap.forEach((phase, harmonicMap) -> {
-            typeValue.forEach((key, value) -> {
+            harmonicMap.forEach((harmonicNum, value) -> {
+                List<Double> devPhaseHarmData = devMap.get(phase).get(harmonicNum);
+                if (isRemoveMaxElement) {
+                    List<Double> errorValueList = new ArrayList<>();
+                    for (int i = 0; i < value.size(); i++) {
+                        errorValueList.add(Math.abs(value.get(i) - devPhaseHarmData.get(i)));
+                    }
+
+                    List<Integer> idxErrorValueList = DetectionUtil.sort(errorValueList, false);
+                    int removeCount = idxErrorValueList.size() / 2;
+                    List<Double> newArray = DetectionUtil.getNewArray(value, idxErrorValueList.subList(removeCount, idxErrorValueList.size()));
+                    value.clear();
+                    value.addAll(newArray);
+                    newArray = DetectionUtil.getNewArray(devPhaseHarmData, idxErrorValueList.subList(removeCount, idxErrorValueList.size()));
+                    devPhaseHarmData.clear();
+                    devPhaseHarmData.addAll(newArray);
+                }
+
                 if (CollUtil.isNotEmpty(value)) {
-                    List<Integer> idx = DetectionUtil.sort(value, false);
+
                     switch (dataRule) {
-                        case SECTION_VALUE:
+                        case SECTION_VALUE: {
+                            List<Integer> idx = DetectionUtil.sort(value, false);
                             if (value.size() > 2) {
                                 value.remove(0);
                                 value.remove(value.size() - 1);
-                                List<Double> newArray = DetectionUtil.getNewArray(devMap.get(typeKey).get(key), idx.subList(1, idx.size() - 1));
+                                List<Double> newArray = DetectionUtil.getNewArray(devPhaseHarmData, idx.subList(1, idx.size() - 1));
-                                devMap.get(typeKey).get(key).clear();
+                                devPhaseHarmData.clear();
-                                devMap.get(typeKey).get(key).addAll(newArray);
+                                devPhaseHarmData.addAll(newArray);
                             }
-                            break;
+                        }
+                        break;
                         case CP95_VALUE:
                             if (CollUtil.isNotEmpty(value)) {
+                                List<Integer> idx = DetectionUtil.sort(value, false);
                                 int cp95Idx = DetectionUtil.getCP95Idx(value);
                                 List<Double> newValue = Collections.singletonList(value.get(cp95Idx));
                                 value.clear();
                                 value.addAll(newValue);
-                                Double devCP95Data = devMap.get(typeKey).get(key).get(idx.get(cp95Idx));
+                                Double devCP95Data = devPhaseHarmData.get(idx.get(cp95Idx));
-                                devMap.get(typeKey).get(key).clear();
+                                devPhaseHarmData.clear();
-                                devMap.get(typeKey).get(key).add(devCP95Data);
+                                devPhaseHarmData.add(devCP95Data);
                             }
                             break;
                         case AVG_VALUE:
                             List<Double> avgDoubles = DetectionUtil.getAvgDoubles(value);
                             value.clear();
                             value.addAll(avgDoubles);
-                            List<Double> devAvgData = DetectionUtil.getAvgDoubles(devMap.get(typeKey).get(key));
+                            List<Double> devAvgData = DetectionUtil.getAvgDoubles(devMap.get(phase).get(harmonicNum));
-                            devMap.get(typeKey).get(key).clear();
+                            devPhaseHarmData.clear();
-                            devMap.get(typeKey).get(key).addAll(devAvgData);
+                            devPhaseHarmData.addAll(devAvgData);
+                            break;
+                        case Own_value:
+                            break;
+                        case AT_WILL_VALUE:
+                            if (isRemoveMaxElement) {
+                                if (CollUtil.isNotEmpty(value)) {
+                                    Double v = value.get(value.size() - 1);
+                                    value.clear();
+                                    value.add(v);
+                                }
+                                if (CollUtil.isNotEmpty(devPhaseHarmData)) {
+                                    Double v = devPhaseHarmData.get(devPhaseHarmData.size() - 1);
+                                    devPhaseHarmData.clear();
+                                    devPhaseHarmData.add(v);
+                                }
+                            } else {
+                                List<Double> errorValueList = new ArrayList<>();
+                                for (int i = 0; i < value.size(); i++) {
+                                    errorValueList.add(Math.abs(value.get(i) - devPhaseHarmData.get(i)));
+                                }
+
+                                List<Integer> idxErrorValueList = DetectionUtil.sort(errorValueList, true);
+                                Double v = value.get(idxErrorValueList.get(0));
+                                value.clear();
+                                value.add(v);
+                                v = devPhaseHarmData.get(idxErrorValueList.get(0));
+                                devPhaseHarmData.clear();
+                                devPhaseHarmData.add(v);
+                            }
                             break;
                     }
                 }

detection/src/main/java/com/njcn/gather/detection/service/impl/PreDetectionServiceImpl.java

@@ -6,9 +6,7 @@ import cn.hutool.core.util.ObjectUtil;
 import com.alibaba.fastjson.JSON;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.njcn.common.pojo.exception.BusinessException;
-import com.njcn.gather.detection.handler.SocketContrastResponseService;
+import com.njcn.gather.detection.handler.*;
-import com.njcn.gather.detection.handler.SocketDevResponseService;
-import com.njcn.gather.detection.handler.SocketSourceResponseService;
 import com.njcn.gather.detection.pojo.constant.DetectionCommunicateConstant;
 import com.njcn.gather.detection.pojo.enums.DetectionResponseEnum;
 import com.njcn.gather.detection.pojo.enums.SourceOperateCodeEnum;
@@ -21,6 +19,8 @@ import com.njcn.gather.detection.util.business.DetectionCommunicateUtil;
 import com.njcn.gather.detection.util.socket.CnSocketUtil;
 import com.njcn.gather.detection.util.socket.FormalTestManager;
 import com.njcn.gather.detection.util.socket.SocketManager;
+import com.njcn.gather.detection.util.socket.XiNumberManager;
+import com.njcn.gather.detection.util.socket.cilent.NettyContrastClientHandler;
 import com.njcn.gather.detection.util.socket.websocket.WebServiceManager;
 import com.njcn.gather.device.pojo.po.PqDev;
 import com.njcn.gather.device.pojo.vo.PreDetection;
@@ -38,6 +38,7 @@ import com.njcn.gather.script.service.IPqScriptCheckDataService;
 import com.njcn.gather.script.service.IPqScriptDtlsService;
 import com.njcn.gather.source.pojo.po.SourceInitialize;
 import com.njcn.gather.source.service.IPqSourceService;
+import com.njcn.gather.system.cfg.service.ISysTestConfigService;
 import com.njcn.gather.system.dictionary.pojo.enums.DictDataEnum;
 import com.njcn.gather.system.dictionary.service.IDictDataService;
 import com.njcn.web.utils.HttpServletUtil;
@@ -73,8 +74,12 @@ public class PreDetectionServiceImpl implements PreDetectionService {
     private final SocketDevResponseService socketDevResponseService;
     private final SocketSourceResponseService socketSourceResponseService;
     private final SocketContrastResponseService socketContrastResponseService;
+    private final SocketFreqConverterService socketFreqConverterService;
+    private final SocketFreqConverterDevService socketFreqConverterDevService;
     private final IPqScriptCheckDataService iPqScriptCheckDataService;
     private final SocketManager socketManager;
+    private final ISysTestConfigService sysTestConfigService;
+
 
     @Value("${report.reportDir}")
     private String alignDataFilePath;
@@ -358,6 +363,68 @@ public class PreDetectionServiceImpl implements PreDetectionService {
         }
     }
 
+    @Override
+    public boolean getCanCoefficient() {
+        return CollUtil.isNotEmpty(DetectionServiceImpl.vAndIResultMap);
+    }
+
+    @Override
+    public void startCoefficient() {
+        if (CollUtil.isNotEmpty(DetectionServiceImpl.vAndIResultMap)) {
+            // 是否进行系数校准
+            //万一录波了这里就进不来了，但是在误差处理的时候DetectionServiceImpl.vAndIResultMap该集合会保留不符合的结果
+
+            XiNumberManager.xiDevList.clear();
+            XiNumberManager.devXiNumDataMap.clear();
+            List<String> stdIpList = DetectionServiceImpl.vAndIResultMap.values().stream().map(DetectionServiceImpl.VAndIResult::getIp).collect(Collectors.toList());
+            XiNumberManager.xiDevList = FormalTestManager.standardDevList.stream().filter(d -> stdIpList.contains(d.getDevIP())).collect(Collectors.toList());
+            // 逐一设备向通讯模块要原始系数
+            SocketMsg<String> socketMsg = new SocketMsg<>();
+            socketMsg.setRequestId(SourceOperateCodeEnum.Coefficient_Check.getValue());
+            socketMsg.setOperateCode(SourceOperateCodeEnum.DATA_CHNFACTOR$01.getValue());
+            PreDetection preDetection = XiNumberManager.xiDevList.get(0);
+            Map<String, Object> map = new HashMap<>();
+            map.put("devIP", preDetection.getDevIP());
+            map.put("chnNum", preDetection.getDevChns());
+            socketMsg.setData(JSON.toJSONString(map));
+            SocketManager.sendMsg(NettyContrastClientHandler.param.getUserPageId() + CnSocketUtil.CONTRAST_DEV_TAG, JSON.toJSONString(socketMsg));
+
+            FormalTestManager.currentStep = SourceOperateCodeEnum.Coefficient_Check;
+        }
+    }
+
+    @Override
+    public void startFreqConverter(String userId, String converterId, String monitorId, Boolean reset) {
+        String freqConverterTag = userId + CnSocketUtil.FREQ_CONVERTER_TAG;
+        String devTag = userId + CnSocketUtil.DEV_TAG;
+//        socketFreqConverterService.init(userId, converterId, monitorId);
+        socketFreqConverterService.connectSocket(freqConverterTag);
+        socketFreqConverterDevService.connectSocket(devTag);
+
+        long startTime = System.currentTimeMillis();
+        long timeout = 3000; // 3秒超时时间
+        while (true) {
+            if (SocketManager.isChannelActive(freqConverterTag) && SocketManager.isChannelActive(devTag)) {
+//            if (SocketManager.isChannelActive(devTag)) {
+                socketFreqConverterService.connectionFreqConverter(userId, freqConverterTag, converterId, monitorId, reset);
+                socketFreqConverterDevService.connectionDev(userId, devTag, converterId, monitorId,reset);
+                break;
+            }
+
+            // 检查是否超时
+            if (System.currentTimeMillis() - startTime > timeout) {
+                throw new BusinessException(DetectionResponseEnum.SOCKET_CONNECT_TIMEOUT);
+            }
+        }
+
+    }
+
+    @Override
+    public void stopFreqConverter(String converterTag, String devTag) {
+        socketFreqConverterService.stopTest(converterTag, devTag);
+        socketFreqConverterDevService.stopTest(converterTag, devTag);
+    }
+
     /**
      * 比对式-与通信模块进行连接
      *
@@ -416,4 +483,4 @@ public class PreDetectionServiceImpl implements PreDetectionService {
         }
     }
 
-}
+}

detection/src/main/java/com/njcn/gather/detection/util/DetectionUtil.java

@@ -1,6 +1,7 @@
 package com.njcn.gather.detection.util;
 
 import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.util.NumberUtil;
 import cn.hutool.core.util.ObjectUtil;
 import com.njcn.gather.detection.pojo.po.DevData;
 import lombok.extern.slf4j.Slf4j;
@@ -421,7 +422,7 @@ public class DetectionUtil {
             }
             return newList;
         }
-        return null;
+        return Collections.emptyList();
     }
 
     /**
@@ -437,4 +438,94 @@ public class DetectionUtil {
             System.out.println("  文件大小: " + file.length() + " bytes");
         }
     }
+
+    /**
+     * 获取皮尔逊系数
+     *
+     * <p>相关系数绝对值|r|所代表的相关强度</p>
+     * <ul>
+     *     <li>0.8 - 1.0：极强相关</li>
+     *     <li>0.6 - 0.8：强相关</li>
+     *     <li>0.4 - 0.6：中等程度相关</li>
+     *     <li>0.2 - 0.4：弱相关</li>
+     *     <li>0.0 - 0.2：极弱相关或无相关</li>
+     * </ul>
+     *
+     * @return
+     */
+    public static BigDecimal getPearsonCorrelationCoefficient(List<Double> x, List<Double> y) {
+        Double xAvg = x.parallelStream().mapToDouble(Double::doubleValue).average().orElse(0.0);
+        Double yAvg = y.parallelStream().mapToDouble(Double::doubleValue).average().orElse(0.0);
+
+        // 协方差求和
+        BigDecimal covarianceSum = BigDecimal.ZERO;
+        // x的方差
+        BigDecimal varianceX = BigDecimal.ZERO;
+        // y的方差
+        BigDecimal varianceY = BigDecimal.ZERO;
+        for (int i = 0; i < x.size(); i++) {
+            covarianceSum = covarianceSum.add(BigDecimal.valueOf((x.get(i) - xAvg) * (y.get(i) - yAvg)));
+            varianceX = varianceX.add(BigDecimal.valueOf(Math.pow(x.get(i) - xAvg, 2)));
+            varianceY = varianceY.add(BigDecimal.valueOf(Math.pow(y.get(i) - yAvg, 2)));
+        }
+        BigDecimal fm = BigDecimal.valueOf(Math.sqrt(varianceX.doubleValue()) * Math.sqrt(varianceY.doubleValue()));
+        if (NumberUtil.equals(fm.doubleValue(), BigDecimal.ZERO.doubleValue())) {
+            if (NumberUtil.equals(covarianceSum, BigDecimal.ZERO)) {
+                return BigDecimal.valueOf(1.0);
+            } else {
+                return BigDecimal.ZERO;
+            }
+        } else {
+            return BigDecimal.valueOf(Math.abs(covarianceSum.divide(fm, 8, BigDecimal.ROUND_HALF_UP).doubleValue())); //相关系数
+        }
+    }
+
+    /**
+     * 比值一致性，获取CV系数
+     *
+     * <p>一致性等级</p>
+     * <ul>
+     *     <li>CV<1%：非常优秀</li>
+     *     <li>1%≤CV＜5%：优良</li>
+     *     <li>5%≤CV＜10%：良好</li>
+     *     <li>10%≤CV＜20%：中等</li>
+     *     <li>20%≤CV：较差</li>
+     * </ul>
+     *
+     * @param x
+     * @param y
+     * @return
+     */
+    public static BigDecimal getCvCoefficient(List<Double> x, List<Double> y) {
+        List<BigDecimal> ratioList = new ArrayList<>();
+        for (int i = 0; i < x.size(); i++) {
+            ratioList.add(BigDecimal.valueOf(x.get(i) / y.get(i)));
+        }
+
+        BigDecimal avg = BigDecimal.valueOf(ratioList.parallelStream().mapToDouble(BigDecimal::doubleValue).average().orElse(0.0));
+        BigDecimal variance = BigDecimal.valueOf(
+                ratioList.parallelStream().mapToDouble(BigDecimal::doubleValue)
+                        .map(v -> Math.pow(v - avg.doubleValue(), 2)).average().orElse(0.0));
+
+        return BigDecimal.valueOf(Math.sqrt(variance.doubleValue()) / avg.doubleValue());
+    }
+
+    /**
+     * 计算新的系数
+     *
+     * @param devList
+     * @param stdDevList
+     * @return
+     */
+    public static Double getNewXi(List<Double> devList, List<Double> stdDevList) {
+        ArrayList<Double> xiList = new ArrayList<>();
+        for (int i = 0; i < stdDevList.size(); i++) {
+            if (!stdDevList.get(i).equals(0)) {
+                BigDecimal bigDecimalDev = BigDecimal.valueOf(devList.get(i));
+                BigDecimal bigDecimalStdDev = BigDecimal.valueOf(stdDevList.get(i));
+                xiList.add((bigDecimalDev.subtract(bigDecimalStdDev)).divide(BigDecimal.valueOf(2.0).multiply(bigDecimalDev), 8, BigDecimal.ROUND_HALF_UP).doubleValue() + 1.0);
+            }
+        }
+        return xiList.stream().mapToDouble(Double::doubleValue).average().orElse(1.0);
+    }
 }

detection/src/main/java/com/njcn/gather/detection/util/socket/CnSocketUtil.java

@@ -14,6 +14,8 @@ import com.njcn.gather.detection.util.socket.websocket.WebServiceManager;
  */
 public class CnSocketUtil {
 
+    public final static String FREQ_CONVERTER_TAG="_FreqConverter";
+
     public final static String DEV_TAG = "_Dev";
 
     public final static String CONTRAST_DEV_TAG = "_Contrast_Dev";

detection/src/main/java/com/njcn/gather/detection/util/socket/FormalTestManager.java

@@ -7,12 +7,15 @@ import com.njcn.gather.detection.pojo.po.DevData;
 import com.njcn.gather.detection.pojo.vo.DevLineTestResult;
 import com.njcn.gather.device.pojo.enums.PatternEnum;
 import com.njcn.gather.device.pojo.vo.PreDetection;
+import com.njcn.gather.dip.pojo.po.PqDipData;
 import com.njcn.gather.plan.pojo.enums.DataSourceEnum;
 import com.njcn.gather.plan.pojo.po.AdPlan;
 import com.njcn.gather.plan.pojo.po.AdPlanTestConfig;
 import com.njcn.gather.script.pojo.po.SourceIssue;
 import com.njcn.gather.system.dictionary.pojo.enums.DictDataEnum;
+import lombok.Data;
 
+import java.time.LocalDateTime;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
@@ -31,6 +34,20 @@ public class FormalTestManager {
     // 当前步骤
     public static SourceOperateCodeEnum currentStep;
 
+    public static SourceOperateCodeEnum freqConverterStep;
+    public static SourceOperateCodeEnum freqConverterDevStep;
+    /**
+     * 变频器存放数据的表后缀
+     */
+    public static Integer freqConverterTableSuffix;
+
+    public static String currentFreqConverterId;
+
+    /**
+     * 待采集后续变频器状态的Dip任务
+     */
+    public static Map<String, PendingDipTask> pendingDipTaskMap = new ConcurrentHashMap<>();
+
     /**
      * key:设备ip,value:当前设备下面的监测点ID(ip_通道号)
      */
@@ -208,4 +225,27 @@ public class FormalTestManager {
      * 是否进行相序校验
      */
     public static boolean isXu;
+
+    /**
+     * 清理变频器耐受实验运行态数据
+     */
+    public static void clearFreqConverterRuntimeState() {
+        currentFreqConverterId = null;
+        freqConverterTableSuffix = null;
+        pendingDipTaskMap.clear();
+    }
+
+    @Data
+    public static class PendingDipTask {
+        private PqDipData pqDipData;
+
+        private LocalDateTime targetEndTime;
+        private Integer originalTolerant;
+
+        public PendingDipTask(PqDipData pqDipData, LocalDateTime targetEndTime, Integer originalTolerant) {
+            this.pqDipData = pqDipData;
+            this.targetEndTime = targetEndTime;
+            this.originalTolerant = originalTolerant;
+        }
+    }
 }

detection/src/main/java/com/njcn/gather/detection/util/socket/SocketManager.java

@@ -315,4 +315,4 @@ public class SocketManager {
 
 
 }
-    
+

detection/src/main/java/com/njcn/gather/detection/util/socket/cilent/NettyClient.java

@@ -56,6 +56,109 @@ public class NettyClient {
      */
     private static NettyClient instance;
 
+    /**
+     * 静态方法：智能连接变频器设备（兼容性包装）
+     *
+     * @param ip        IP地址
+     * @param port      端口号
+     * @param ChannelId Channel唯一标识
+     * @param handler   变频器处理器
+     */
+    public static void commonConnect(String ip, Integer port, String ChannelId,
+                                     SimpleChannelInboundHandler handler) {
+        if (instance != null) {
+            instance.executeCommonConnect(ip, port, ChannelId, handler);
+        } else {
+            log.error("NettyClient未初始化，无法创建连接");
+        }
+    }
+
+    /**
+     * 执行变频器Socket连接建立流程
+     *
+     * @param ip        目标服务器IP地址
+     * @param port      目标服务器端口号
+     * @param ChannelId Channel唯一标识id
+     * @param handler   变频器业务处理器
+     */
+    private static void executeCommonConnect(String ip, Integer port,
+                                             String ChannelId,
+                                             SimpleChannelInboundHandler handler) {
+        NioEventLoopGroup group = createEventLoopGroup();
+
+        try {
+            Bootstrap bootstrap = configureBootstrap(group);
+            ChannelInitializer<NioSocketChannel> initializer = createCommonChannelInitializer(ChannelId, handler);
+            bootstrap.handler(initializer);
+            ChannelFuture channelFuture = bootstrap.connect(ip, port).sync();
+            handleCommonConnectionResult(channelFuture, ChannelId, handler, group);
+        } catch (Exception e) {
+            handleCommonConnectionException(e, ChannelId, handler, group);
+        }
+    }
+
+    /**
+     * 创建通用通道初始化器
+     *
+     * @param channelId Channel唯一标识id
+     * @param handler   通用业务处理器
+     * @return ChannelInitializer 通道初始化器
+     */
+    private static ChannelInitializer<NioSocketChannel> createCommonChannelInitializer(
+            String channelId, SimpleChannelInboundHandler handler) {
+        return new ChannelInitializer<NioSocketChannel>() {
+            @Override
+            protected void initChannel(NioSocketChannel ch) {
+                ch.pipeline()
+                        .addLast(new LineBasedFrameDecoder(10240 * 2))
+                        .addLast(new StringDecoder(CharsetUtil.UTF_8))
+                        .addLast(new StringEncoder(CharsetUtil.UTF_8))
+                        .addLast(new IdleStateHandler(60, 0, 0, TimeUnit.SECONDS))
+                        .addLast(handler);
+            }
+        };
+    }
+
+    /**
+     * 处理通用连接结果
+     *
+     * @param channelFuture 连接Future对象
+     * @param channelId     Channel唯一标识符
+     * @param handler       通用业务处理器
+     * @param group         事件循环组
+     */
+    private static void handleCommonConnectionResult(ChannelFuture channelFuture,
+                                                     String channelId,
+                                                     SimpleChannelInboundHandler handler,
+                                                     NioEventLoopGroup group) {
+        channelFuture.addListener((ChannelFutureListener) ch -> {
+            if (!ch.isSuccess()) {
+                log.error("连接Socket失败，channelId={}", channelId);
+                group.shutdownGracefully();
+            } else {
+                log.info("连接Socket成功，channel={}, channelId={}",
+                        channelId, channelFuture.channel().id());
+                SocketManager.addGroup(channelId, group);
+                SocketManager.addUser(channelId, channelFuture.channel());
+            }
+        });
+    }
+
+    /**
+     * 处理通用连接异常
+     *
+     * @param e         异常对象
+     * @param channelId Channel唯一标识id
+     * @param handler   通用业务处理器
+     * @param group     事件循环组
+     */
+    private static void handleCommonConnectionException(Exception e, String channelId,
+                                                        SimpleChannelInboundHandler handler,
+                                                        NioEventLoopGroup group) {
+        log.error("连接Socket服务端发生异常，channelId={}, error={}", channelId, e.getMessage(), e);
+        group.shutdownGracefully();
+    }
+
 
     @PostConstruct
     public void init() {

detection/src/main/java/com/njcn/gather/detection/util/socket/cilent/NettyFreqConverterClientHandler.java

@@ -0,0 +1,147 @@
+package com.njcn.gather.detection.util.socket.cilent;
+
+import cn.hutool.core.util.StrUtil;
+import com.njcn.gather.detection.handler.SocketFreqConverterService;
+import com.njcn.gather.detection.util.socket.FormalTestManager;
+import com.njcn.gather.detection.util.socket.SocketManager;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.SimpleChannelInboundHandler;
+import io.netty.handler.timeout.IdleState;
+import io.netty.handler.timeout.IdleStateEvent;
+import lombok.extern.slf4j.Slf4j;
+
+/**
+ * 变频器Netty客户端处理器
+ */
+@Slf4j
+public class NettyFreqConverterClientHandler extends SimpleChannelInboundHandler<String> {
+
+    /**
+     * 变频器Channel唯一标识符
+     */
+    private final String converterChannelTag;
+
+
+    /**
+     * 变频器Socket响应服务
+     */
+    private final SocketFreqConverterService socketFreqConverterService;
+
+    /**
+     * 重连次数
+     */
+    private int reconnectAttempts = 0;
+
+    /**
+     * 最大重连次数
+     */
+    private static final int MAX_RECONNECT_ATTEMPTS = 3;
+
+    /**
+     * 重连间隔（毫秒）
+     */
+    private static final long RECONNECT_INTERVAL_MS = 5000;
+
+    /**
+     * 是否正在重连
+     */
+    private volatile boolean isReconnecting = false;
+
+    /**
+     * 构造方法
+     *
+     * @param converterChannelTag        变频器Chanel唯一标识符
+     * @param socketFreqConverterService 变频器Socket响应服务
+     */
+    public NettyFreqConverterClientHandler(String converterChannelTag, SocketFreqConverterService socketFreqConverterService) {
+        this.converterChannelTag = converterChannelTag;
+        this.socketFreqConverterService = socketFreqConverterService;
+    }
+
+    @Override
+    public void channelActive(ChannelHandlerContext ctx) throws Exception {
+        log.info("变频器连接已建立，converterChannelTag={},  channelId={}", converterChannelTag, ctx.channel().id());
+
+        // 注册Channel到SocketManager
+        SocketManager.addUser(converterChannelTag, ctx.channel());
+
+        if (reconnectAttempts > 0) {
+            log.info("变频器重连成功，converterChannelTag={}, 重连次数={}", converterChannelTag, reconnectAttempts);
+            reconnectAttempts = 0;
+            isReconnecting = false;
+            socketFreqConverterService.onReconnectSuccess(converterChannelTag);
+        }
+
+        super.channelActive(ctx);
+    }
+
+    @Override
+    protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
+        if (StrUtil.isBlank(msg)) {
+            log.debug("收到空消息，忽略，converterChannelTag={}", converterChannelTag);
+            return;
+        }
+
+        log.info("收到变频器消息，converterChannelTag={}, msg={}", converterChannelTag, msg);
+
+        // 处理状态数据
+        socketFreqConverterService.handleRead(converterChannelTag, msg);
+    }
+
+    @Override
+    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
+        log.warn("变频器连接已断开，converterChannelTag={}", converterChannelTag);
+
+        socketFreqConverterService.cleanup(converterChannelTag);
+
+        if (!isReconnecting && reconnectAttempts < MAX_RECONNECT_ATTEMPTS && !FormalTestManager.isRemoveSocket) {
+            attemptReconnect(ctx);
+        } else if (reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
+            log.error("变频器重连失败，已达到最大重连次数{}次，converterChannelTag={}", MAX_RECONNECT_ATTEMPTS, converterChannelTag);
+        }
+
+        super.channelInactive(ctx);
+    }
+
+    @Override
+    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
+        log.error("变频器连接发生异常，converterChannelTag={}, error={}", converterChannelTag, cause.getMessage(), cause);
+        ctx.close();
+    }
+
+    @Override
+    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
+        if (evt instanceof IdleStateEvent) {
+            IdleStateEvent event = (IdleStateEvent) evt;
+            if (event.state() == IdleState.READER_IDLE) {
+                log.warn("变频器连接读空闲，converterChannelTag={}", converterChannelTag);
+                // 可以选择发送心跳或关闭连接
+            }
+        }
+        super.userEventTriggered(ctx, evt);
+    }
+
+    private void attemptReconnect(ChannelHandlerContext ctx) {
+        isReconnecting = true;
+        reconnectAttempts++;
+
+        log.info("准备重连变频器，converterChannelTag={}, 第{}/{}次重连，{}秒后开始",
+                converterChannelTag, reconnectAttempts, MAX_RECONNECT_ATTEMPTS, RECONNECT_INTERVAL_MS / 1000);
+
+        ctx.executor().schedule(() -> {
+            try {
+                log.info("开始执行变频器重连，converterChannelTag={}", converterChannelTag);
+                socketFreqConverterService.reconnect(converterChannelTag);
+            } catch (Exception e) {
+                log.error("变频器重连触发失败，converterChannelTag={}, error={}", converterChannelTag, e.getMessage(), e);
+                isReconnecting = false;
+
+                if (reconnectAttempts < MAX_RECONNECT_ATTEMPTS) {
+                    log.warn("将在{}秒后进行下一次重试", RECONNECT_INTERVAL_MS / 1000);
+                    ctx.executor().schedule(() -> attemptReconnect(ctx), RECONNECT_INTERVAL_MS, java.util.concurrent.TimeUnit.MILLISECONDS);
+                }
+            }
+        }, RECONNECT_INTERVAL_MS, java.util.concurrent.TimeUnit.MILLISECONDS);
+    }
+}
+

detection/src/main/java/com/njcn/gather/detection/util/socket/cilent/NettyFreqConverterDevClientHandler.java

@@ -0,0 +1,63 @@
+package com.njcn.gather.detection.util.socket.cilent;
+
+import com.njcn.gather.detection.handler.SocketFreqConverterDevService;
+import com.njcn.gather.detection.util.socket.FormalTestManager;
+import com.njcn.gather.detection.util.socket.SocketManager;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.SimpleChannelInboundHandler;
+import io.netty.handler.timeout.IdleState;
+import io.netty.handler.timeout.IdleStateEvent;
+import lombok.extern.slf4j.Slf4j;
+
+/**
+ * 设备 Netty 客户端处理器
+ */
+@Slf4j
+public class NettyFreqConverterDevClientHandler extends SimpleChannelInboundHandler<String> {
+
+    private final String devChannelTag;
+    private final SocketFreqConverterDevService socketFreqConverterDevService;
+
+    public NettyFreqConverterDevClientHandler(String devChannelTag, SocketFreqConverterDevService socketFreqConverterDevService) {
+        this.devChannelTag = devChannelTag;
+        this.socketFreqConverterDevService = socketFreqConverterDevService;
+    }
+
+    @Override
+    public void channelActive(ChannelHandlerContext ctx) throws Exception {
+        log.info("设备连接已建立，devChannelTag={}, channelId={}", devChannelTag, ctx.channel().id());
+        SocketManager.addUser(devChannelTag, ctx.channel());
+        super.channelActive(ctx);
+    }
+
+    @Override
+    protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
+        log.info("收到设备消息，devChannelTag={}, msg={}", devChannelTag, msg);
+
+        socketFreqConverterDevService.handleRead(devChannelTag, msg);
+    }
+
+    @Override
+    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
+        log.warn("设备连接已断开，devChannelTag={}", devChannelTag);
+        socketFreqConverterDevService.cleanup(devChannelTag);
+        super.channelInactive(ctx);
+    }
+
+    @Override
+    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
+        log.error("设备连接发生异常，devChannelTag={}, error={}", devChannelTag, cause.getMessage(), cause);
+        ctx.close();
+    }
+
+    @Override
+    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
+        if (evt instanceof IdleStateEvent) {
+            IdleStateEvent event = (IdleStateEvent) evt;
+            if (event.state() == IdleState.READER_IDLE) {
+                log.warn("设备连接读空闲，devChannelTag={}", devChannelTag);
+            }
+        }
+        super.userEventTriggered(ctx, evt);
+    }
+}

detection/src/main/java/com/njcn/gather/detection/util/socket/config/SocketConnectionConfig.java

@@ -18,29 +18,21 @@ import java.util.Set;
 @Component
 @ConfigurationProperties(prefix = "socket")
 public class SocketConnectionConfig {
+    /**
+     * 被检设备配置
+     */
+    private DeviceConfig device = new DeviceConfig();
 
     /**
      * 程控源设备配置
      */
     private SourceConfig source = new SourceConfig();
 
-    /**
-     * 被检设备配置
-     */
-    private DeviceConfig device = new DeviceConfig();
 
-    @Data
+    /**
-    public static class SourceConfig {
+     * 变频器配置
-        /**
+     */
-         * 程控源IP地址
+    private DeviceConfig freqConverter = new DeviceConfig();
-         */
-        private String ip;
-        
-        /**
-         * 程控源端口号
-         */
-        private Integer port;
-    }
 
     @Data
     public static class DeviceConfig {
@@ -48,13 +40,33 @@ public class SocketConnectionConfig {
          * 被检设备IP地址
          */
         private String ip;
-        
+
         /**
          * 被检设备端口号
          */
         private Integer port;
     }
 
+    @Data
+    public static class SourceConfig {
+        /**
+         * 程控源IP地址
+         */
+        private String ip;
+
+        /**
+         * 程控源端口号
+         */
+        private Integer port;
+    }
+
+    /**
+     * 获取被检设备配置
+     */
+    public DeviceConfig getDevice() {
+        return device;
+    }
+
     /**
      * 获取程控源配置
      */
@@ -63,10 +75,10 @@ public class SocketConnectionConfig {
     }
 
     /**
-     * 获取被检设备配置
+     * 获取变频器配置
      */
-    public DeviceConfig getDevice() {
+    public DeviceConfig getFreqConverter() {
-        return device;
+        return freqConverter;
     }
 
     /**

detection/src/main/java/com/njcn/gather/device/controller/PqDevController.java

@@ -189,4 +189,14 @@ public class PqDevController extends BaseController {
         }
         return pqDevService.importDev(file, patternId, planId, response, cover);
     }
+
+    @OperateInfo
+    @GetMapping("/listAll")
+    @ApiOperation("查询所有未删除设备数据")
+    public HttpResult<List<PqDevVO>> listAll() {
+        String methodDescribe = getMethodDescribe("listAll");
+        LogUtil.njcnDebug(log, "{}，查询所有设备", methodDescribe);
+        List<PqDevVO> result = pqDevService.listAll();
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, result, methodDescribe);
+    }
 }

detection/src/main/java/com/njcn/gather/device/controller/PqStandardDevController.java

@@ -12,6 +12,7 @@ import com.njcn.common.pojo.response.HttpResult;
 import com.njcn.common.utils.LogUtil;
 import com.njcn.gather.device.pojo.param.PqStandardDevParam;
 import com.njcn.gather.device.pojo.po.PqStandardDev;
+import com.njcn.gather.device.pojo.vo.PqStandardDevVO;
 import com.njcn.gather.device.service.IPqStandardDevService;
 import com.njcn.web.controller.BaseController;
 import com.njcn.web.utils.FileUtil;
@@ -55,10 +56,10 @@ public class PqStandardDevController extends BaseController {
     @GetMapping("/getById")
     @ApiOperation("根据id查询标准设备")
     @ApiImplicitParam(name = "id", value = "标准设备id", required = true)
-    public HttpResult<PqStandardDev> getById(@RequestParam("id") String id) {
+    public HttpResult<PqStandardDevVO> getById(@RequestParam("id") String id) {
         String methodDescribe = getMethodDescribe("getById");
         LogUtil.njcnDebug(log, "{}，查询ID为：{}", methodDescribe, id);
-        PqStandardDev result = pqStandardDevService.getPqStandardDevById(id);
+        PqStandardDevVO result = pqStandardDevService.getPqStandardDevById(id);
         return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, result, methodDescribe);
     }
 

detection/src/main/java/com/njcn/gather/device/mapper/PqStandardDevGainMapper.java

@@ -0,0 +1,13 @@
+package com.njcn.gather.device.mapper;
+
+import com.github.yulichang.base.MPJBaseMapper;
+import com.njcn.gather.device.pojo.po.PqStandardDevGain;
+
+/**
+ * @author caozehui
+ * @date 2026-01-12
+ */
+public interface PqStandardDevGainMapper extends MPJBaseMapper<PqStandardDevGain> {
+
+}
+

detection/src/main/java/com/njcn/gather/device/mapper/PqStandardDevGainRecordMapper.java

@@ -0,0 +1,13 @@
+package com.njcn.gather.device.mapper;
+
+import com.github.yulichang.base.MPJBaseMapper;
+import com.njcn.gather.device.pojo.po.PqStandardDevGainRecord;
+
+/**
+ * @author caozehui
+ * @date 2026-01-15
+ */
+public interface PqStandardDevGainRecordMapper extends MPJBaseMapper<PqStandardDevGainRecord> {
+
+}
+

detection/src/main/java/com/njcn/gather/device/mapper/mapping/PqStandardDevGainMapper.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.njcn.gather.device.mapper.PqStandardDevGainMapper">
+
+
+</mapper>
+

detection/src/main/java/com/njcn/gather/device/mapper/mapping/PqStandardDevGainRecordMapper.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.njcn.gather.device.mapper.PqStandardDevGainRecordMapper">
+
+
+</mapper>
+

detection/src/main/java/com/njcn/gather/device/pojo/po/PqStandardDevGain.java

@@ -0,0 +1,61 @@
+package com.njcn.gather.device.pojo.po;
+
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.njcn.db.mybatisplus.bo.BaseEntity;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+import java.io.Serializable;
+
+/**
+ * @author caozehui
+ * @date 2026-01-12
+ */
+@Data
+@EqualsAndHashCode(callSuper = true)
+@TableName("pq_standard_dev_gain")
+public class PqStandardDevGain extends BaseEntity implements Serializable {
+    private static final long serialVersionUID = -46280767885558804L;
+
+
+    /**
+     * 标准设备Id_通道号
+     */
+    @TableId
+    private String stdDevMonitorId;
+
+    private Integer uaGain;
+
+    private Integer ubGain;
+
+
+    private Integer ucGain;
+
+
+    private Integer u0Gain;
+
+
+    private Integer iaGain;
+
+
+    private Integer ibGain;
+
+
+    private Integer icGain;
+
+
+    private Integer i0Gain;
+
+
+    private Integer uabGain;
+
+
+    private Integer ubcGain;
+
+
+    private Integer ucaGain;
+
+    private Integer state;
+}
+

detection/src/main/java/com/njcn/gather/device/pojo/po/PqStandardDevGainRecord.java

@@ -0,0 +1,35 @@
+package com.njcn.gather.device.pojo.po;
+
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.njcn.db.mybatisplus.bo.BaseEntity;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+import java.io.Serializable;
+
+/**
+ * @author caozehui
+ * @date 2026-01-15
+ */
+@Data
+@TableName("pq_standard_dev_gain_record")
+public class PqStandardDevGainRecord implements Serializable {
+    private static final long serialVersionUID = 477276215572686991L;
+
+    /**
+     * 标准设备监测点id,由设备id_通道号组成
+     */
+    private String stdDevMonitorId;
+
+    /**
+     * 被检设备监测点id,由设备id_通道号组成
+     */
+    private String devMonitorId;
+
+    /**
+     * 系数下发次数
+     */
+    private Integer num;
+
+}
+

detection/src/main/java/com/njcn/gather/device/pojo/vo/PqStandardDevVO.java

@@ -0,0 +1,20 @@
+package com.njcn.gather.device.pojo.vo;
+
+import com.njcn.gather.device.pojo.po.PqStandardDev;
+import com.njcn.gather.device.pojo.po.PqStandardDevGain;
+import lombok.Data;
+
+import java.util.List;
+
+/**
+ * @author caozehui
+ * @data 2026-01-19
+ */
+@Data
+public class PqStandardDevVO extends PqStandardDev {
+
+    /**
+     * 通道系数
+     */
+    List<PqStandardDevGain> gainList;
+}

detection/src/main/java/com/njcn/gather/device/service/IPqDevService.java

@@ -288,4 +288,6 @@ public interface IPqDevService extends IService<PqDev> {
      * @return
      */
     List<ContrastDevExcel> getExportContrastDevData(List<PqDevVO> pqDevVOList);
+
+    List<PqDevVO> listAll();
 }

detection/src/main/java/com/njcn/gather/device/service/IPqStandardDevGainRecordService.java

@@ -0,0 +1,29 @@
+package com.njcn.gather.device.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.njcn.gather.device.pojo.po.PqStandardDevGainRecord;
+
+import java.util.List;
+
+/**
+ * @author caozehui
+ * @date 2026-01-15
+ */
+public interface IPqStandardDevGainRecordService extends IService<PqStandardDevGainRecord> {
+
+    /**
+     * 获取最大下发系数的次数
+     *
+     * @param stdDevMonitorId
+     * @param devMonitorId
+     * @return
+     */
+    int getMaxNum(String stdDevMonitorId, String devMonitorId);
+
+    /**
+     * 批量新增或更新记录
+     * @param recordList
+     * @return
+     */
+    boolean addOrUpdate(List<PqStandardDevGainRecord> recordList);
+}

detection/src/main/java/com/njcn/gather/device/service/IPqStandardDevGainService.java

@@ -0,0 +1,19 @@
+package com.njcn.gather.device.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.njcn.gather.device.pojo.po.PqStandardDevGain;
+
+import java.util.List;
+
+/**
+ * @author caozehui
+ * @date 2026-01-12
+ */
+public interface IPqStandardDevGainService extends IService<PqStandardDevGain> {
+
+    boolean add(List<PqStandardDevGain> pqStandardDevGainList);
+
+    PqStandardDevGain get(String stdDevMonitorId);
+
+    List<PqStandardDevGain> list(String stdDevId);
+}

detection/src/main/java/com/njcn/gather/device/service/IPqStandardDevService.java

@@ -4,6 +4,7 @@ import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.baomidou.mybatisplus.extension.service.IService;
 import com.njcn.gather.device.pojo.param.PqStandardDevParam;
 import com.njcn.gather.device.pojo.po.PqStandardDev;
+import com.njcn.gather.device.pojo.vo.PqStandardDevVO;
 import com.njcn.gather.device.pojo.vo.PreDetection;
 import org.springframework.web.multipart.MultipartFile;
 
@@ -30,7 +31,7 @@ public interface IPqStandardDevService extends IService<PqStandardDev> {
      * @param id 设备id
      * @return 设备对象
      */
-    PqStandardDev getPqStandardDevById(String id);
+    PqStandardDevVO getPqStandardDevById(String id);
 
     /**
      * 新增标准设备

detection/src/main/java/com/njcn/gather/device/service/impl/PqDevServiceImpl.java

@@ -1625,4 +1625,31 @@ public class PqDevServiceImpl extends ServiceImpl<PqDevMapper, PqDev> implements
         }
         return result;
     }
+
+    @Override
+    public List<PqDevVO> listAll() {
+        return this.lambdaQuery()
+                .eq(PqDev::getState, DataStateEnum.ENABLE.getCode())
+                .orderByDesc(PqDev::getCreateTime)
+                .list().stream().map(pqDev -> {
+                    PqDevVO pqDevVO = new PqDevVO();
+                    BeanUtil.copyProperties(pqDev, pqDevVO);
+                    // 解密序列号和密钥
+                    if (StrUtil.isNotBlank(pqDevVO.getSeries())) {
+                        pqDevVO.setSeries(EncryptionUtil.decoderString(1, pqDevVO.getSeries()));
+                    }
+                    if (StrUtil.isNotBlank(pqDevVO.getDevKey())) {
+                        pqDevVO.setDevKey(EncryptionUtil.decoderString(1, pqDevVO.getDevKey()));
+                    }
+                    // 填充设备类型信息
+                    DevType devType = devTypeService.getById(pqDevVO.getDevType());
+                    if (ObjectUtil.isNotNull(devType)) {
+                        pqDevVO.setDevType(devType.getName());
+                        pqDevVO.setDevChns(devType.getDevChns());
+                        pqDevVO.setDevVolt(devType.getDevVolt());
+                        pqDevVO.setDevCurr(devType.getDevCurr());
+                    }
+                    return pqDevVO;
+                }).collect(Collectors.toList());
+    }
 }

detection/src/main/java/com/njcn/gather/device/service/impl/PqStandardDevGainRecordServiceImpl.java

@@ -0,0 +1,45 @@
+package com.njcn.gather.device.service.impl;
+
+import cn.hutool.core.collection.CollectionUtil;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.njcn.gather.device.mapper.PqStandardDevGainRecordMapper;
+import com.njcn.gather.device.pojo.po.PqStandardDevGainRecord;
+import com.njcn.gather.device.service.IPqStandardDevGainRecordService;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+/**
+ * @author caozehui
+ * @date 2026-01-15
+ */
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class PqStandardDevGainRecordServiceImpl extends ServiceImpl<PqStandardDevGainRecordMapper, PqStandardDevGainRecord> implements IPqStandardDevGainRecordService {
+
+    @Override
+    public int getMaxNum(String stdDevMonitorId, String devMonitorId) {
+        return this.lambdaQuery().eq(PqStandardDevGainRecord::getStdDevMonitorId, stdDevMonitorId)
+                .eq(PqStandardDevGainRecord::getDevMonitorId, devMonitorId)
+                .list().stream().mapToInt(PqStandardDevGainRecord::getNum).max().orElse(0);
+    }
+
+    @Override
+    public boolean addOrUpdate(List<PqStandardDevGainRecord> recordList) {
+        recordList.forEach(record -> {
+            List<PqStandardDevGainRecord> list = this.lambdaQuery().eq(PqStandardDevGainRecord::getStdDevMonitorId, record.getStdDevMonitorId())
+                    .eq(PqStandardDevGainRecord::getDevMonitorId, record.getDevMonitorId()).list();
+            if (CollectionUtil.isNotEmpty(list)) {
+                this.lambdaUpdate().eq(PqStandardDevGainRecord::getStdDevMonitorId, record.getStdDevMonitorId())
+                        .eq(PqStandardDevGainRecord::getDevMonitorId, record.getDevMonitorId())
+                        .set(PqStandardDevGainRecord::getNum, record.getNum()).update();
+            } else {
+                this.save(record);
+            }
+        });
+        return true;
+    }
+}

detection/src/main/java/com/njcn/gather/device/service/impl/PqStandardDevGainServiceImpl.java

@@ -0,0 +1,42 @@
+package com.njcn.gather.device.service.impl;
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.njcn.gather.device.mapper.PqStandardDevGainMapper;
+import com.njcn.gather.device.pojo.po.PqStandardDevGain;
+import com.njcn.gather.device.service.IPqStandardDevGainService;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * @author caozehui
+ * @date 2026-01-12
+ */
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class PqStandardDevGainServiceImpl extends ServiceImpl<PqStandardDevGainMapper, PqStandardDevGain> implements IPqStandardDevGainService {
+
+    @Override
+    public boolean add(List<PqStandardDevGain> pqStandardDevGainList) {
+        log.info("add PqStandardDevGainList: {}", pqStandardDevGainList.size());
+        List<String> stdMonitorIdList = pqStandardDevGainList.stream().map(PqStandardDevGain::getStdDevMonitorId).distinct().collect(Collectors.toList());
+        List<String> existingStdMonitorIdList = this.listByIds(stdMonitorIdList).stream().map(PqStandardDevGain::getStdDevMonitorId).collect(Collectors.toList());
+
+        pqStandardDevGainList = pqStandardDevGainList.stream().filter(pqStandardDevGain -> !existingStdMonitorIdList.contains(pqStandardDevGain.getStdDevMonitorId())).collect(Collectors.toList());
+        return this.saveBatch(pqStandardDevGainList);
+    }
+
+    @Override
+    public PqStandardDevGain get(String stdDevMonitorId) {
+        return this.lambdaQuery().eq(PqStandardDevGain::getStdDevMonitorId, stdDevMonitorId).one();
+    }
+
+    @Override
+    public List<PqStandardDevGain> list(String stdDevId) {
+        return this.lambdaQuery().likeRight(PqStandardDevGain::getStdDevMonitorId, stdDevId).orderByAsc(PqStandardDevGain::getStdDevMonitorId).list();
+    }
+}

detection/src/main/java/com/njcn/gather/device/service/impl/PqStandardDevServiceImpl.java

@@ -19,8 +19,11 @@ import com.njcn.common.utils.EncryptionUtil;
 import com.njcn.gather.device.mapper.PqStandardDevMapper;
 import com.njcn.gather.device.pojo.param.PqStandardDevParam;
 import com.njcn.gather.device.pojo.po.PqStandardDev;
+import com.njcn.gather.device.pojo.po.PqStandardDevGain;
 import com.njcn.gather.device.pojo.vo.PqStandardDevExcel;
+import com.njcn.gather.device.pojo.vo.PqStandardDevVO;
 import com.njcn.gather.device.pojo.vo.PreDetection;
+import com.njcn.gather.device.service.IPqStandardDevGainService;
 import com.njcn.gather.device.service.IPqStandardDevService;
 import com.njcn.gather.plan.mapper.AdPlanStandardDevMapper;
 import com.njcn.gather.plan.service.IAdPlanStandardDevService;
@@ -58,8 +61,7 @@ public class PqStandardDevServiceImpl extends ServiceImpl<PqStandardDevMapper, P
     private final IDevTypeService devTypeService;
     private final IDictDataService dictDataService;
     private final IDictTypeService dictTypeService;
-    private final AdPlanStandardDevMapper adPlanStandardDevMapper;
+    private final IPqStandardDevGainService pqStandardDevGainService;
-    private final IAdPlanStandardDevService adPlanStandardDevService;
 
     @Override
     public Page<PqStandardDev> listPqStandardDevs(PqStandardDevParam.QueryParam queryParam) {
@@ -73,13 +75,17 @@ public class PqStandardDevServiceImpl extends ServiceImpl<PqStandardDevMapper, P
     }
 
     @Override
-    public PqStandardDev getPqStandardDevById(String id) {
+    public PqStandardDevVO getPqStandardDevById(String id) {
         PqStandardDev standardDev = this.getById(id);
+        PqStandardDevVO pqStandardDevVO = BeanUtil.copyProperties(standardDev, PqStandardDevVO.class);
         if (standardDev.getEncryptionFlag() == 1) {
-            standardDev.setSeries(EncryptionUtil.decoderString(1, standardDev.getSeries()));
+            pqStandardDevVO.setSeries(EncryptionUtil.decoderString(1, standardDev.getSeries()));
-            standardDev.setDevKey(EncryptionUtil.decoderString(1, standardDev.getDevKey()));
+            pqStandardDevVO.setDevKey(EncryptionUtil.decoderString(1, standardDev.getDevKey()));
         }
-        return standardDev;
+
+        List<PqStandardDevGain> gainList = pqStandardDevGainService.list(id);
+        pqStandardDevVO.setGainList(gainList);
+        return pqStandardDevVO;
     }
 
     @Override

detection/src/main/java/com/njcn/gather/dip/mapper/PqDipDataMapper.java

@@ -0,0 +1,11 @@
+package com.njcn.gather.dip.mapper;
+
+import com.github.yulichang.base.MPJBaseMapper;
+import com.njcn.gather.dip.pojo.po.PqDipData;
+
+/**
+ * @author caozehui
+ * @date 2026-04-09
+ */
+public interface PqDipDataMapper extends MPJBaseMapper<PqDipData> {
+}

detection/src/main/java/com/njcn/gather/dip/pojo/po/PqDipData.java

@@ -0,0 +1,37 @@
+package com.njcn.gather.dip.pojo.po;
+
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+/**
+ * 电压暂降数据
+ *
+ * @author caozehui
+ * @date 2026-04-09
+ */
+@Data
+@TableName(value = "ad_harmonic_xx")
+public class PqDipData {
+
+    /**
+     * 主键ID
+     */
+    private String id;
+
+    /**
+     * 起始时间戳
+     */
+    private LocalDateTime startTime;
+
+    /**
+     * 残余电压，单位：%Ur
+     */
+    private Double residualVoltage;
+
+    /**
+     * 持续时间，单位：ms
+     */
+    private Integer durationMs;
+}

detection/src/main/java/com/njcn/gather/dip/pojo/po/vo/DipPoint.java

@@ -0,0 +1,26 @@
+package com.njcn.gather.dip.pojo.po.vo;
+
+import lombok.Data;
+
+/**
+ * @author caozehui
+ * @data 2026-04-16
+ */
+@Data
+public class DipPoint {
+
+    /**
+     * 残余电压，单位：%Ur
+     */
+    private Double residualVoltage;
+
+    /**
+     * 持续时间，单位：ms
+     */
+    private Integer durationMs;
+
+    /**
+     * 0为不耐受，1为耐受
+     */
+    private Boolean tolerant;
+}

detection/src/main/java/com/njcn/gather/dip/service/IPqDipDataService.java

@@ -0,0 +1,23 @@
+package com.njcn.gather.dip.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.njcn.gather.dip.pojo.po.PqDipData;
+
+import java.util.List;
+
+/**
+ * @author caozehui
+ * @date 2026-04-09
+ */
+public interface IPqDipDataService extends IService<PqDipData> {
+
+    /**
+     * 查询指定变频器所对应的电压暂降数据
+     *
+     * @param suffix 表后缀
+     * @return
+     */
+    List<PqDipData> listDipData(Integer suffix);
+
+    void clearAllData(Integer suffix);
+}

detection/src/main/java/com/njcn/gather/dip/service/impl/PqDipDataServiceImpl.java

@@ -0,0 +1,34 @@
+package com.njcn.gather.dip.service.impl;
+
+import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.njcn.db.mybatisplus.handler.DynamicTableNameHandler;
+import com.njcn.gather.dip.mapper.PqDipDataMapper;
+import com.njcn.gather.dip.pojo.po.PqDipData;
+import com.njcn.gather.dip.service.IPqDipDataService;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+/**
+ * @author caozehui
+ * @date 2026-04-09
+ */
+@Service
+public class PqDipDataServiceImpl extends ServiceImpl<PqDipDataMapper, PqDipData> implements IPqDipDataService {
+    @Override
+    public List<PqDipData> listDipData(Integer suffix) {
+        DynamicTableNameHandler.setTableName("pq_dip_data_" + suffix);
+        LambdaQueryChainWrapper<PqDipData> wrapper = this.lambdaQuery().orderByAsc(PqDipData::getStartTime);
+        List<PqDipData> result = wrapper.list();
+        DynamicTableNameHandler.remove();
+        return result;
+    }
+
+    @Override
+    public void clearAllData(Integer suffix) {
+        DynamicTableNameHandler.setTableName("pq_dip_data_" + suffix);
+        this.remove(null);
+        DynamicTableNameHandler.remove();
+    }
+}

detection/src/main/java/com/njcn/gather/freqConverter/config/FreqConverterConfig.java

@@ -0,0 +1,21 @@
+package com.njcn.gather.freqConverter.config;
+
+import lombok.Data;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.stereotype.Component;
+
+/**
+ * @author caozehui
+ * @data 2026-04-15
+ */
+@Data
+@Component
+@ConfigurationProperties(prefix = "freq-converter")
+public class FreqConverterConfig {
+    private Long schedulePeriod;
+    private Integer tolerant;
+    private Integer dt;
+    private Integer direction;
+    private Integer allowErrorDuration;
+    private Double allowErrorResidualVoltage;
+}

detection/src/main/java/com/njcn/gather/freqConverter/controller/FreqConverterController.java

@@ -0,0 +1,116 @@
+package com.njcn.gather.freqConverter.controller;
+
+import cn.hutool.core.util.StrUtil;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.njcn.common.pojo.annotation.OperateInfo;
+import com.njcn.common.pojo.constant.OperateType;
+import com.njcn.common.pojo.enums.response.CommonResponseEnum;
+import com.njcn.common.pojo.response.HttpResult;
+import com.njcn.common.utils.LogUtil;
+import com.njcn.gather.freqConverter.pojo.param.PqFreqConverterParam;
+import com.njcn.gather.freqConverter.pojo.po.PqFreqConverterConfig;
+import com.njcn.gather.freqConverter.pojo.vo.TolerantPointVO;
+import com.njcn.gather.freqConverter.service.IFreqConverterService;
+import com.njcn.gather.freqConverter.service.IPqFreqConverterConfigService;
+import com.njcn.web.controller.BaseController;
+import com.njcn.web.utils.HttpResultUtil;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiImplicitParam;
+import io.swagger.annotations.ApiOperation;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+/**
+ * @author caozehui
+ * @data 2026-04-13
+ */
+@Slf4j
+@Api(tags = "变频器")
+@RestController
+@RequestMapping("/freqConverter")
+@RequiredArgsConstructor
+public class FreqConverterController extends BaseController {
+    private final IFreqConverterService freqConverterService;
+    private final IPqFreqConverterConfigService pqFreqConverterConfigService;
+
+
+    @OperateInfo
+    @PostMapping("/list")
+    @ApiOperation("分页查询变频器列表")
+    @ApiImplicitParam(name = "queryParam", value = "查询参数", required = true)
+    public HttpResult<Page<PqFreqConverterConfig>> list(@RequestBody @Validated PqFreqConverterParam.QueryParam queryParam) {
+        String methodDescribe = getMethodDescribe("list");
+        LogUtil.njcnDebug(log, "{}，查询数据为：{}", methodDescribe, queryParam);
+        Page<PqFreqConverterConfig> result = pqFreqConverterConfigService.listPqFreqConverterConfigs(queryParam);
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, result, methodDescribe);
+    }
+
+    @OperateInfo(operateType = OperateType.ADD)
+    @PostMapping("/add")
+    @ApiOperation("新增变频器")
+    @ApiImplicitParam(name = "pqDevParam", value = "被检设备", required = true)
+    public HttpResult<Boolean> add(@RequestBody @Validated PqFreqConverterParam param) {
+        String methodDescribe = getMethodDescribe("add");
+        LogUtil.njcnDebug(log, "{}，新增数据为：{}", methodDescribe, param);
+        boolean result = pqFreqConverterConfigService.addPqFreqConverterConfig(param);
+        if (result) {
+            return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, true, methodDescribe);
+        } else {
+            return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.FAIL, false, methodDescribe);
+        }
+    }
+
+    @OperateInfo(operateType = OperateType.UPDATE)
+    @PostMapping("/update")
+    @ApiOperation("修改变频器")
+    @ApiImplicitParam(name = "updateParam", value = "被检设备", required = true)
+    public HttpResult<Boolean> update(@RequestBody @Validated PqFreqConverterParam.UpdateParam param) {
+        String methodDescribe = getMethodDescribe("update");
+        LogUtil.njcnDebug(log, "{}，修改数据为：{}", methodDescribe, param);
+        boolean result = pqFreqConverterConfigService.updatePqFreqConverterConfig(param);
+        if (result) {
+            return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, true, methodDescribe);
+        } else {
+            return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.FAIL, false, methodDescribe);
+        }
+    }
+
+    @OperateInfo(operateType = OperateType.DELETE)
+    @PostMapping("/delete")
+    @ApiOperation("删除变频器")
+    @ApiImplicitParam(name = "param", value = "删除参数", required = true)
+    public HttpResult<Boolean> delete(@RequestBody @Validated List<String> ids) {
+        String methodDescribe = getMethodDescribe("delete");
+        LogUtil.njcnDebug(log, "{}，删除ID数据为：{}", methodDescribe, String.join(StrUtil.COMMA, ids));
+        boolean result = pqFreqConverterConfigService.deletePqFreqConverterConfig(ids);
+        if (result) {
+            return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, true, methodDescribe);
+        } else {
+            return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.FAIL, false, methodDescribe);
+        }
+    }
+
+    @GetMapping("/result")
+    @ApiOperation("查询变频器测试结果")
+    @ApiImplicitParam(name = "param", value = "查询参数", required = true)
+    public HttpResult<List<TolerantPointVO>> result(@RequestParam("converterId") String converterId) {
+        String methodDescribe = getMethodDescribe("result");
+        LogUtil.njcnDebug(log, "{}，查询ID数据为：{}", methodDescribe, converterId);
+        List<TolerantPointVO> tolerantPoints = freqConverterService.getDipPoints(converterId);
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, tolerantPoints, methodDescribe);
+    }
+
+//    @GetMapping("/scurve")
+//    @ApiOperation("获取绘制特性曲线的point点")
+//    @ApiImplicitParam(name = "converterId", value = "变频器ID", required = true)
+//    public HttpResult<List<TolerantPointVO>> getScurvePoints(@RequestParam("converterId") String converterId) {
+//        String methodDescribe = getMethodDescribe("getScurvePoints");
+//        LogUtil.njcnDebug(log, "{}，查询ID数据为：{}", methodDescribe, converterId);
+//        List<TolerantPointVO> tolerantPoints = freqConverterService.getFeaturesScurvePoints(converterId);
+//        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, tolerantPoints, methodDescribe);
+//    }
+}

detection/src/main/java/com/njcn/gather/freqConverter/mapper/FreqConverterStatusMapper.java

@@ -0,0 +1,11 @@
+package com.njcn.gather.freqConverter.mapper;
+
+import com.github.yulichang.base.MPJBaseMapper;
+import com.njcn.gather.freqConverter.pojo.po.FreqConverterStatus;
+
+/**
+ * @author caozehui
+ * @data 2026-04-07
+ */
+public interface FreqConverterStatusMapper extends MPJBaseMapper<FreqConverterStatus> {
+}

detection/src/main/java/com/njcn/gather/freqConverter/mapper/PqFreqConverterConfigMapper.java

@@ -0,0 +1,11 @@
+package com.njcn.gather.freqConverter.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.njcn.gather.freqConverter.pojo.po.PqFreqConverterConfig;
+
+/**
+ * @author caozehui
+ * @data 2026-04-08
+ */
+public interface PqFreqConverterConfigMapper  extends BaseMapper<PqFreqConverterConfig> {
+}

detection/src/main/java/com/njcn/gather/freqConverter/mapper/PqFreqConverterTestResMapper.java

@@ -0,0 +1,11 @@
+package com.njcn.gather.freqConverter.mapper;
+
+import com.github.yulichang.base.MPJBaseMapper;
+import com.njcn.gather.freqConverter.pojo.po.PqFreqConverterTestRes;
+
+/**
+ * @author caozehui
+ * @data 2026-04-14
+ */
+public interface PqFreqConverterTestResMapper extends MPJBaseMapper<PqFreqConverterTestRes> {
+}

detection/src/main/java/com/njcn/gather/freqConverter/pojo/param/PqFreqConverterParam.java

@@ -0,0 +1,66 @@
+package com.njcn.gather.freqConverter.pojo.param;
+
+import com.njcn.common.pojo.constant.PatternRegex;
+import com.njcn.gather.pojo.constant.DetectionValidMessage;
+import com.njcn.web.pojo.param.BaseParam;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+import javax.validation.constraints.NotBlank;
+import javax.validation.constraints.Pattern;
+
+/**
+ * @author caozehui
+ * @data 2026-04-13
+ */
+@Data
+public class PqFreqConverterParam {
+    @ApiModelProperty(value = "名称", required = true)
+    private String name;
+
+    @ApiModelProperty(value = "电脑串口名", required = true)
+    private String portName;
+
+    @ApiModelProperty(value = "变频器设置从机地址", required = true)
+    private Integer slaveAddress;
+
+    @ApiModelProperty(value = "变频器设置波特率", required = true)
+    private Integer baudRate;
+
+    @ApiModelProperty(value = "奇偶校验类型: None, Even, Odd", required = true)
+    private String parity;
+
+    @ApiModelProperty(value = "变频器数据位", required = true)
+    private Integer dataBits;
+
+    @ApiModelProperty(value = "变频器停止位，当前只支持 1 或 2", required = true)
+    private Integer stopBits;
+
+    @ApiModelProperty(value = "串口读写超时，单位毫秒", required = true)
+    private Integer timeoutMs;
+    private Integer testStatus;
+
+    /**
+     * 分页查询实体
+     */
+    @Data
+    @EqualsAndHashCode(callSuper = true)
+    public static class QueryParam extends BaseParam {
+        @ApiModelProperty(value = "名称", required = true)
+        private String name;
+    }
+
+    /**
+     * 更新操作实体
+     */
+    @Data
+    @EqualsAndHashCode(callSuper = true)
+    public static class UpdateParam extends PqFreqConverterParam {
+
+        @ApiModelProperty(value = "id", required = true)
+        @NotBlank(message = DetectionValidMessage.ID_NOT_BLANK)
+        @Pattern(regexp = PatternRegex.SYSTEM_ID, message = DetectionValidMessage.ID_FORMAT_ERROR)
+        private String id;
+    }
+}

detection/src/main/java/com/njcn/gather/freqConverter/pojo/po/FreqConverterStatus.java

@@ -0,0 +1,31 @@
+package com.njcn.gather.freqConverter.pojo.po;
+
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+/**
+ * @author caozehui
+ * @data 2026-04-07
+ */
+@Data
+@TableName(value = "ad_harmonic_xx")
+public class FreqConverterStatus {
+
+    /**
+     * 主键ID
+     */
+    private String id;
+
+    private Integer slaveAddress;
+
+    private Integer statusWord1;
+
+    private String statusWord1Hex;
+
+    /**
+     * 状态记录时刻（时间戳）
+     */
+    private LocalDateTime timestamp;
+}

detection/src/main/java/com/njcn/gather/freqConverter/pojo/po/PqFreqConverterConfig.java

@@ -0,0 +1,73 @@
+package com.njcn.gather.freqConverter.pojo.po;
+
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.njcn.db.mybatisplus.bo.BaseEntity;
+import lombok.Data;
+
+/**
+ * 变频器配置实体类
+ */
+@Data
+@TableName("pq_freq_converter_config")
+public class PqFreqConverterConfig extends BaseEntity {
+
+    /**
+     * 主键ID
+     */
+    private String id;
+
+    /**
+     * 变频器名称
+     */
+    private String name;
+
+    /**
+     * 电脑串口名，如COM1
+     */
+    private String portName;
+
+    /**
+     * 变频器设置从机地址，范围1~127
+     */
+    private Integer slaveAddress;
+
+    /**
+     * 变频器设置波特率，如19200
+     */
+    private Integer baudRate;
+
+    /**
+     * 奇偶校验类型: None, Even, Odd
+     */
+    private String parity;
+
+    /**
+     * 变频器数据位
+     */
+    private Integer dataBits;
+
+    /**
+     * 变频器停止位，当前只支持 1 或 2
+     */
+    private Integer stopBits;
+
+    /**
+     * 串口读写超时，单位毫秒
+     */
+    private Integer timeoutMs;
+
+    /**
+     * 数据表后缀
+     */
+    private Integer suffix;
+
+    /**
+     * 检测状态，0未检测，1检测完成
+     */
+    private Integer testStatus;
+
+    /**
+     * 状态：0-删除 1-正常
+     */
+    private Integer state;
+}

detection/src/main/java/com/njcn/gather/freqConverter/pojo/po/PqFreqConverterTestRes.java

@@ -0,0 +1,41 @@
+package com.njcn.gather.freqConverter.pojo.po;
+
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+/**
+ * @author caozehui
+ * @data 2026-04-14
+ */
+@Data
+@TableName(value = "ad_harmonic_xx")
+public class PqFreqConverterTestRes {
+    /**
+     * 主键ID
+     */
+    private String id;
+
+    /**
+     * 残余电压，单位：%Ur
+     */
+    private Double residualVoltage;
+
+    /**
+     * 持续时间，单位：ms
+     */
+    private Integer durationMs;
+
+    /**
+     * 0为不耐受，1为耐受，2为特性曲线点
+     */
+    private Integer tolerant;
+
+    /**
+     *  时间
+     */
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss.SSS", timezone = "GMT+8")
+    private LocalDateTime time;
+}

detection/src/main/java/com/njcn/gather/freqConverter/pojo/vo/TolerantPointVO.java

@@ -0,0 +1,34 @@
+package com.njcn.gather.freqConverter.pojo.vo;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+/**
+ * @author caozehui
+ * @data 2026-04-13
+ */
+@Data
+public class TolerantPointVO {
+    /**
+     * 持续时间，单位ms
+     */
+    private Integer durationMs;
+
+    /**
+     * 残余电压，单位：%Ur
+     */
+    private Double residualVoltage;
+
+    /**
+     * 是否耐受。0-否，1-是，2-表示特性曲线点
+     */
+    private Integer tolerant;
+
+    /**
+     * 时间
+     */
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss.SSS", timezone = "GMT+8")
+    private LocalDateTime time;
+}

detection/src/main/java/com/njcn/gather/freqConverter/service/IFreqConverterService.java

@@ -0,0 +1,62 @@
+package com.njcn.gather.freqConverter.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.njcn.gather.freqConverter.pojo.po.FreqConverterStatus;
+import com.njcn.gather.freqConverter.pojo.vo.TolerantPointVO;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+/**
+ * @author caozehui
+ * @data 2026-04-07
+ */
+public interface IFreqConverterService extends IService<FreqConverterStatus> {
+
+
+    /**
+     * 保存变频器状态数据
+     *
+     * @param suffix 表后缀
+     * @param status 变频器状态数据
+     * @return 是否保存成功
+     */
+    boolean saveFreqConverterStatus(Integer suffix, FreqConverterStatus status);
+
+
+    /**
+     * 查询指定变频器的状态历史
+     *
+     * @param converterId 变频器ID
+     * @return 状态数据列表
+     */
+    List<FreqConverterStatus> listStatusData(String converterId);
+
+    /**
+     * 清空所有数据
+     *
+     * @param converterId 变频器ID
+     * @return
+     */
+    void clearAllData(Integer converterId);
+
+    /**
+     * 根据设备暂降数据判断变频器是否耐受
+     *
+     * @param converterId 变频器Id
+     * @return 是否耐受
+     */
+    List<TolerantPointVO> getDipPoints(String converterId);
+
+    List<FreqConverterStatus> getDipDurationStatusData(Integer suffix, LocalDateTime startTime, LocalDateTime endTime);
+
+    FreqConverterStatus getLastStatusData(Integer suffix, LocalDateTime startTime);
+
+    /**
+     * 获取变频器特性曲线点
+     *
+     * @param converterId 变频器ID
+     * @return
+     */
+    List<TolerantPointVO> getFeaturesScurvePoints(String converterId);
+}

detection/src/main/java/com/njcn/gather/freqConverter/service/IPqFreqConverterConfigService.java

@@ -0,0 +1,27 @@
+package com.njcn.gather.freqConverter.service;
+
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.njcn.gather.freqConverter.pojo.param.PqFreqConverterParam;
+import com.njcn.gather.freqConverter.pojo.po.PqFreqConverterConfig;
+
+import java.util.List;
+
+/**
+ * @author caozehui
+ * @data 2026-04-08
+ */
+public interface IPqFreqConverterConfigService extends IService<PqFreqConverterConfig> {
+    Page<PqFreqConverterConfig> listPqFreqConverterConfigs(PqFreqConverterParam.QueryParam queryParam);
+
+    Integer getSuffix(String converterId);
+
+    boolean addPqFreqConverterConfig(PqFreqConverterParam param);
+
+    boolean updatePqFreqConverterConfig(PqFreqConverterParam.UpdateParam param);
+
+    boolean deletePqFreqConverterConfig(List<String> ids);
+
+    boolean updateTestStatus(String converterId, Integer testStatus);
+
+}

detection/src/main/java/com/njcn/gather/freqConverter/service/IPqFreqConverterTestResService.java

@@ -0,0 +1,50 @@
+package com.njcn.gather.freqConverter.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.njcn.gather.freqConverter.pojo.po.PqFreqConverterTestRes;
+
+import java.util.List;
+
+/**
+ * @author caozehui
+ * @data 2026-04-14
+ */
+public interface IPqFreqConverterTestResService extends IService<PqFreqConverterTestRes> {
+    /**
+     * 清空所有数据
+     *
+     * @param suffix 表后缀
+     * @return
+     */
+    void clearAllData(Integer suffix);
+
+    /**
+     * 新增结果记录
+     *
+     * @param suffix      表后缀
+     * @param testResList 结果数据
+     * @return 是否成功
+     */
+    boolean saveTestRes(Integer suffix, List<PqFreqConverterTestRes> testResList);
+
+    /**
+     * 更新结果记录
+     *
+     * @param suffix      表后缀
+     * @param testResList 结果数据
+     * @return 是否成功
+     */
+    boolean updateTestRes(Integer suffix, List<PqFreqConverterTestRes> testResList);
+
+    /**
+     * 查询结果记录
+     *
+     * @param suffix 表后缀
+     * @return 结果列表
+     */
+    List<PqFreqConverterTestRes> listTestRes(Integer suffix);
+
+    PqFreqConverterTestRes getLastByDuration(Integer suffix, String id, Integer durationMs);
+
+    PqFreqConverterTestRes getLastByResidualVoltage(Integer suffix, String id, Double residualVoltage);
+}

detection/src/main/java/com/njcn/gather/freqConverter/service/impl/FreqConverterServiceImpl.java

@@ -0,0 +1,172 @@
+package com.njcn.gather.freqConverter.service.impl;
+
+import cn.hutool.core.util.IdUtil;
+import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.njcn.db.mybatisplus.handler.DynamicTableNameHandler;
+import com.njcn.gather.dip.service.IPqDipDataService;
+import com.njcn.gather.freqConverter.mapper.FreqConverterStatusMapper;
+import com.njcn.gather.freqConverter.pojo.po.FreqConverterStatus;
+import com.njcn.gather.freqConverter.pojo.po.PqFreqConverterTestRes;
+import com.njcn.gather.freqConverter.pojo.vo.TolerantPointVO;
+import com.njcn.gather.freqConverter.service.IFreqConverterService;
+import com.njcn.gather.freqConverter.service.IPqFreqConverterConfigService;
+import com.njcn.gather.freqConverter.service.IPqFreqConverterTestResService;
+import lombok.AllArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.LocalDateTime;
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * 变频器状态数据Service实现类
+ * <p>
+ * 实现变频器状态数据的存储、查询和清理功能。
+ * 当数据量超过阈值时，自动清理无效或过期数据，避免内存和数据库资源浪费。
+ * </p>
+ *
+ * @author CN_Gather Detection Team
+ * @version 1.0
+ * @since 2026
+ */
+@Service
+@AllArgsConstructor
+public class FreqConverterServiceImpl extends ServiceImpl<FreqConverterStatusMapper, FreqConverterStatus> implements IFreqConverterService {
+    private final IPqFreqConverterConfigService pqFreqConverterConfigService;
+    private final IPqDipDataService dipDataService;
+    private final IPqFreqConverterTestResService pqFreqConverterTestResService;
+
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public boolean saveFreqConverterStatus(Integer suffix, FreqConverterStatus status) {
+        if (status.getId() == null) {
+            status.setId(IdUtil.fastSimpleUUID());
+        }
+        DynamicTableNameHandler.setTableName(PqFreqConverterConfigServiceImpl.PQ_FREQ_CONVERTER_STATUS_TB_PREFIX + suffix);
+        boolean result = this.save(status);
+        DynamicTableNameHandler.remove();
+        return result;
+    }
+
+    @Override
+    public List<FreqConverterStatus> listStatusData(String converterId) {
+        Integer suffix = pqFreqConverterConfigService.getSuffix(converterId);
+
+        DynamicTableNameHandler.setTableName(PqFreqConverterConfigServiceImpl.PQ_FREQ_CONVERTER_STATUS_TB_PREFIX + suffix);
+        LambdaQueryChainWrapper<FreqConverterStatus> wrapper = this.lambdaQuery().orderByAsc(FreqConverterStatus::getTimestamp);
+        List<FreqConverterStatus> result = wrapper.list();
+        DynamicTableNameHandler.remove();
+
+        return result;
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void clearAllData(Integer suffix) {
+        DynamicTableNameHandler.setTableName(PqFreqConverterConfigServiceImpl.PQ_FREQ_CONVERTER_STATUS_TB_PREFIX + suffix);
+        this.remove(null);
+        DynamicTableNameHandler.remove();
+    }
+
+    @Override
+    public List<TolerantPointVO> getDipPoints(String converterId) {
+        Integer suffix = pqFreqConverterConfigService.getSuffix(converterId);
+
+        DynamicTableNameHandler.setTableName(PqFreqConverterConfigServiceImpl.PQ_FREQ_CONVERTER_TEST_RES_TB_PREFIX + suffix);
+        List<PqFreqConverterTestRes> pqFreqConverterTestResList = pqFreqConverterTestResService.list();
+        DynamicTableNameHandler.remove();
+        List<TolerantPointVO> result = pqFreqConverterTestResList.stream().map(item -> {
+                    TolerantPointVO tolerantPointVO = new TolerantPointVO();
+                    tolerantPointVO.setDurationMs(item.getDurationMs());
+                    tolerantPointVO.setResidualVoltage(item.getResidualVoltage());
+                    tolerantPointVO.setTolerant(item.getTolerant());
+                    tolerantPointVO.setTime(item.getTime());
+                    return tolerantPointVO;
+                })
+                .sorted(Comparator.comparingInt(TolerantPointVO::getDurationMs))
+                .sorted(Comparator.comparingDouble(TolerantPointVO::getResidualVoltage)).collect(Collectors.toList());
+
+        return result;
+    }
+
+    @Override
+    public List<FreqConverterStatus> getDipDurationStatusData(Integer suffix, LocalDateTime startTime, LocalDateTime endTime) {
+        DynamicTableNameHandler.setTableName(PqFreqConverterConfigServiceImpl.PQ_FREQ_CONVERTER_STATUS_TB_PREFIX + suffix);
+        List<FreqConverterStatus> result = this.lambdaQuery()
+                .between(FreqConverterStatus::getTimestamp, startTime, endTime)
+                .orderByAsc(FreqConverterStatus::getTimestamp)
+                .list();
+        DynamicTableNameHandler.remove();
+        return result;
+    }
+
+    @Override
+    public FreqConverterStatus getLastStatusData(Integer suffix, LocalDateTime startTime) {
+        DynamicTableNameHandler.setTableName(PqFreqConverterConfigServiceImpl.PQ_FREQ_CONVERTER_STATUS_TB_PREFIX + suffix);
+        FreqConverterStatus one = this.lambdaQuery().le(FreqConverterStatus::getTimestamp, startTime)
+                .orderByDesc(FreqConverterStatus::getTimestamp)
+                .last("limit 1")
+                .one();
+        DynamicTableNameHandler.remove();
+        return one;
+    }
+
+    @Override
+    public List<TolerantPointVO> getFeaturesScurvePoints(String converterId) {
+        List<TolerantPointVO> dipPoints = this.getDipPoints(converterId);
+        if (dipPoints == null || dipPoints.isEmpty()) {
+            return new ArrayList<>();
+        }
+
+        Map<Integer, List<TolerantPointVO>> durationPointMap = dipPoints.stream()
+                .collect(Collectors.groupingBy(TolerantPointVO::getDurationMs, TreeMap::new, Collectors.toList()));
+        if (durationPointMap.size() < 2) {
+            return new ArrayList<>();
+        }
+
+        List<TolerantPointVO> result = new ArrayList<>();
+
+        TolerantPointVO firstPoint = new TolerantPointVO();
+
+        List<Integer> keyList = durationPointMap.keySet().stream().collect(Collectors.toList());
+        Integer i1 = keyList.get(0);
+        List<TolerantPointVO> tolerantPointVOS1 = durationPointMap.get(i1);
+        Collections.sort(tolerantPointVOS1, Comparator.comparing(TolerantPointVO::getResidualVoltage));
+        TolerantPointVO tolerantPointVO1 = tolerantPointVOS1.get(0);
+
+        Integer i2 = keyList.get(1);
+        List<TolerantPointVO> tolerantPointVOS2 = durationPointMap.get(i2);
+        Collections.sort(tolerantPointVOS2, Comparator.comparing(TolerantPointVO::getResidualVoltage));
+        TolerantPointVO tolerantPointVO2 = tolerantPointVOS2.get(0);
+
+        firstPoint.setDurationMs((i1 + i2) / 2);
+        firstPoint.setResidualVoltage((tolerantPointVO1.getResidualVoltage() + tolerantPointVO2.getResidualVoltage()) / 2D);
+        firstPoint.setTolerant(2);
+        result.add(firstPoint);
+
+        durationPointMap.entrySet().stream()
+                .forEach(entry -> {
+                    List<TolerantPointVO> sameDurationPoints = entry.getValue().stream()
+                            .sorted(Comparator.comparing(TolerantPointVO::getResidualVoltage, Comparator.reverseOrder()))
+                            .collect(Collectors.toList());
+
+                    for (int index = 0; index < sameDurationPoints.size() - 1; index++) {
+                        TolerantPointVO currentPoint = sameDurationPoints.get(index);
+                        TolerantPointVO nextPoint = sameDurationPoints.get(index + 1);
+                        if (!Objects.equals(currentPoint.getTolerant(), nextPoint.getTolerant())) {
+                            TolerantPointVO featurePoint = new TolerantPointVO();
+                            featurePoint.setDurationMs(entry.getKey());
+                            featurePoint.setResidualVoltage((currentPoint.getResidualVoltage() + nextPoint.getResidualVoltage()) / 2D);
+                            featurePoint.setTolerant(2);
+                            result.add(featurePoint);
+                            break;
+                        }
+                    }
+                });
+
+        return result;
+    }
+}

detection/src/main/java/com/njcn/gather/freqConverter/service/impl/PqFreqConverterConfigServiceImpl.java

@@ -0,0 +1,136 @@
+package com.njcn.gather.freqConverter.service.impl;
+
+import cn.hutool.core.bean.BeanUtil;
+import cn.hutool.core.collection.CollectionUtil;
+import cn.hutool.core.util.ObjectUtil;
+import cn.hutool.core.util.StrUtil;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.njcn.common.pojo.enums.common.DataStateEnum;
+import com.njcn.gather.freqConverter.mapper.PqFreqConverterConfigMapper;
+import com.njcn.gather.freqConverter.pojo.param.PqFreqConverterParam;
+import com.njcn.gather.freqConverter.pojo.po.PqFreqConverterConfig;
+import com.njcn.gather.freqConverter.service.IPqFreqConverterConfigService;
+import com.njcn.gather.storage.mapper.TableGenMapper;
+import lombok.AllArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+
+/**
+ * @author caozehui
+ * @data 2026-04-08
+ */
+@Service
+@AllArgsConstructor
+public class PqFreqConverterConfigServiceImpl extends ServiceImpl<PqFreqConverterConfigMapper, PqFreqConverterConfig> implements IPqFreqConverterConfigService {
+    private final TableGenMapper tableGenMapper;
+
+    /**
+     * 表名前缀
+     */
+    public static final String PQ_FREQ_CONVERTER_STATUS_TB_PREFIX = "pq_freq_converter_status_";
+    public static final String PQ_DIP_DATA_TB_PREFIX = "pq_dip_data_";
+    public static final String PQ_FREQ_CONVERTER_TEST_RES_TB_PREFIX = "pq_freq_converter_test_res_";
+
+    @Override
+    public Page<PqFreqConverterConfig> listPqFreqConverterConfigs(PqFreqConverterParam.QueryParam queryParam) {
+        QueryWrapper wrapper = new QueryWrapper<>();
+        wrapper.like(StrUtil.isNotBlank(queryParam.getName()), "name", queryParam.getName());
+        wrapper.eq("state", 1);
+        return this.page(new Page<>(queryParam.getPageNum(), queryParam.getPageSize()), wrapper);
+    }
+
+    @Override
+    public Integer getSuffix(String converterId) {
+        PqFreqConverterConfig freqConverterConfig = this.lambdaQuery().eq(PqFreqConverterConfig::getId, converterId).one();
+        return freqConverterConfig.getSuffix();
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public boolean addPqFreqConverterConfig(PqFreqConverterParam param) {
+        // 建表
+        PqFreqConverterConfig freqConverterConfig = this.lambdaQuery().orderByDesc(PqFreqConverterConfig::getSuffix)
+                .last("limit 1").one();
+        Integer maxSuffix = 1;
+        if (ObjectUtil.isNotNull(freqConverterConfig)) {
+            maxSuffix = freqConverterConfig.getSuffix() + 1;
+        }
+
+        String tableSql = "CREATE TABLE `" + PQ_FREQ_CONVERTER_STATUS_TB_PREFIX + maxSuffix + "`(" +
+                "  `id` char(32) NOT NULL COMMENT '主键ID'," +
+                "  `slave_address` int(11) DEFAULT NULL COMMENT '从机地址'," +
+                "  `status_word1` int(11) DEFAULT NULL COMMENT '状态字1'," +
+                "  `status_word1_hex` varchar(20) DEFAULT NULL COMMENT '状态字1十六进制'," +
+                "  `timestamp` datetime(3) NOT NULL COMMENT '状态记录时刻（时间戳）'," +
+                "   PRIMARY KEY (`id`) USING BTREE" +
+                ") ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='变频器状态表';";
+        tableGenMapper.genTable(tableSql);
+
+        tableSql = "CREATE TABLE `" + PQ_DIP_DATA_TB_PREFIX + maxSuffix + "` (" +
+                "   `id` char(32) NOT NULL COMMENT '主键ID'," +
+                "   `start_time` datetime(3) NOT NULL COMMENT '起始时间戳'," +
+                "   `residual_voltage` decimal(6,2) NOT NULL COMMENT '残余电压(%Ur)'," +
+                "   `duration_ms` int(11) NOT NULL COMMENT '持续时间(ms)'," +
+                "    PRIMARY KEY (`id`)" +
+                ") ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='电压暂降数据表';";
+        tableGenMapper.genTable(tableSql);
+
+        tableSql = "CREATE TABLE `" + PQ_FREQ_CONVERTER_TEST_RES_TB_PREFIX + maxSuffix + "` (" +
+                "   `id` char(32) NOT NULL COMMENT '主键ID'," +
+                "   `residual_voltage` decimal(6,2) NOT NULL COMMENT '残余电压(%Ur)'," +
+                "   `duration_ms` int(11) NOT NULL COMMENT '持续时间(ms)'," +
+                "   `tolerant` tinyInt(1) NOT NULL COMMENT '0为不耐受，1为耐受，2为特征点'," +
+                "    `time` datetime(3) DEFAULT NULL COMMENT '时间',"+
+                "    PRIMARY KEY (`id`)" +
+                ") ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='变频器耐受实验结果';";
+        tableGenMapper.genTable(tableSql);
+
+        PqFreqConverterConfig pqFreqConverterConfig = BeanUtil.copyProperties(param, PqFreqConverterConfig.class);
+        pqFreqConverterConfig.setSuffix(maxSuffix);
+        pqFreqConverterConfig.setTestStatus(0);
+        pqFreqConverterConfig.setState(DataStateEnum.ENABLE.getCode());
+        return this.save(pqFreqConverterConfig);
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public boolean updatePqFreqConverterConfig(PqFreqConverterParam.UpdateParam param) {
+        PqFreqConverterConfig pqFreqConverterConfig = BeanUtil.copyProperties(param, PqFreqConverterConfig.class);
+        return this.updateById(pqFreqConverterConfig);
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public boolean deletePqFreqConverterConfig(List<String> ids) {
+        StringBuffer sql = new StringBuffer();
+        sql.append("drop table if exists ");
+
+        List<PqFreqConverterConfig> pqFreqConverterConfigs = this.listByIds(ids);
+        for (PqFreqConverterConfig pqFreqConverterConfig : pqFreqConverterConfigs) {
+            Integer suffix = pqFreqConverterConfig.getSuffix();
+            sql.append(PQ_FREQ_CONVERTER_STATUS_TB_PREFIX + suffix + ",")
+                    .append(PQ_DIP_DATA_TB_PREFIX + suffix + ",")
+                    .append(PQ_FREQ_CONVERTER_TEST_RES_TB_PREFIX + suffix + ",");
+        }
+
+        sql.deleteCharAt(sql.length() - 1);
+        // 删除表
+        tableGenMapper.genTable(sql.toString());
+        return this.lambdaUpdate()
+                .in(CollectionUtil.isNotEmpty(ids), PqFreqConverterConfig::getId, ids)
+                .set(PqFreqConverterConfig::getState, 0).update();
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public boolean updateTestStatus(String converterId, Integer testStatus) {
+        return this.lambdaUpdate()
+                .eq(PqFreqConverterConfig::getId, converterId)
+                .set(PqFreqConverterConfig::getTestStatus, testStatus)
+                .update();
+    }
+}

detection/src/main/java/com/njcn/gather/freqConverter/service/impl/PqFreqConverterTestResServiceImpl.java

@@ -0,0 +1,81 @@
+package com.njcn.gather.freqConverter.service.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.njcn.db.mybatisplus.handler.DynamicTableNameHandler;
+import com.njcn.gather.freqConverter.config.FreqConverterConfig;
+import com.njcn.gather.freqConverter.mapper.PqFreqConverterTestResMapper;
+import com.njcn.gather.freqConverter.pojo.po.PqFreqConverterTestRes;
+import com.njcn.gather.freqConverter.service.IPqFreqConverterTestResService;
+import lombok.AllArgsConstructor;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+/**
+ * @author caozehui
+ * @data 2026-04-14
+ */
+@Service
+@AllArgsConstructor
+public class PqFreqConverterTestResServiceImpl extends ServiceImpl<PqFreqConverterTestResMapper, PqFreqConverterTestRes> implements IPqFreqConverterTestResService {
+    private final FreqConverterConfig freqConverterConfig;
+
+    @Override
+    public void clearAllData(Integer suffix) {
+        DynamicTableNameHandler.setTableName(PqFreqConverterConfigServiceImpl.PQ_FREQ_CONVERTER_TEST_RES_TB_PREFIX + suffix);
+        this.remove(null);
+        DynamicTableNameHandler.remove();
+    }
+
+
+    @Override
+    public boolean saveTestRes(Integer suffix, List<PqFreqConverterTestRes> testResList) {
+        DynamicTableNameHandler.setTableName(PqFreqConverterConfigServiceImpl.PQ_FREQ_CONVERTER_TEST_RES_TB_PREFIX + suffix);
+        this.saveBatch(testResList);
+        DynamicTableNameHandler.remove();
+        return true;
+    }
+
+    @Override
+    public boolean updateTestRes(Integer suffix, List<PqFreqConverterTestRes> testResList) {
+        DynamicTableNameHandler.setTableName(PqFreqConverterConfigServiceImpl.PQ_FREQ_CONVERTER_TEST_RES_TB_PREFIX + suffix);
+        this.updateBatchById(testResList);
+        DynamicTableNameHandler.remove();
+        return true;
+    }
+
+    @Override
+    public List<PqFreqConverterTestRes> listTestRes(Integer suffix) {
+        DynamicTableNameHandler.setTableName(PqFreqConverterConfigServiceImpl.PQ_FREQ_CONVERTER_TEST_RES_TB_PREFIX + suffix);
+        List<PqFreqConverterTestRes> result = this.list();
+        DynamicTableNameHandler.remove();
+        return result;
+    }
+
+    @Override
+    public PqFreqConverterTestRes getLastByDuration(Integer suffix, String id, Integer durationMs) {
+        DynamicTableNameHandler.setTableName(PqFreqConverterConfigServiceImpl.PQ_FREQ_CONVERTER_TEST_RES_TB_PREFIX + suffix);
+        LambdaQueryWrapper<PqFreqConverterTestRes> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.between(PqFreqConverterTestRes::getDurationMs, durationMs - freqConverterConfig.getAllowErrorDuration(), durationMs + freqConverterConfig.getAllowErrorDuration())
+                .ne(PqFreqConverterTestRes::getId, id)
+                .orderByAsc(PqFreqConverterTestRes::getResidualVoltage)
+                .last("limit 1");
+        PqFreqConverterTestRes result = this.getOne(queryWrapper);
+        DynamicTableNameHandler.remove();
+        return result;
+    }
+
+    @Override
+    public PqFreqConverterTestRes getLastByResidualVoltage(Integer suffix, String id, Double residualVoltage) {
+        DynamicTableNameHandler.setTableName(PqFreqConverterConfigServiceImpl.PQ_FREQ_CONVERTER_TEST_RES_TB_PREFIX + suffix);
+        LambdaQueryWrapper<PqFreqConverterTestRes> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.between(PqFreqConverterTestRes::getResidualVoltage, residualVoltage - freqConverterConfig.getAllowErrorResidualVoltage(), residualVoltage + freqConverterConfig.getAllowErrorResidualVoltage())
+                .ne(PqFreqConverterTestRes::getId, id)
+                .orderByDesc(PqFreqConverterTestRes::getDurationMs)
+                .last("limit 1");
+        PqFreqConverterTestRes result = this.getOne(queryWrapper);
+        DynamicTableNameHandler.remove();
+        return result;
+    }
+}

detection/src/main/java/com/njcn/gather/monitor/service/IPqMonitorService.java

@@ -121,8 +121,8 @@ public interface IPqMonitorService extends IService<PqMonitor> {
 
     /**
      * 根据被检设备id和监测点编号获取监测点信息
-     * @param id 被检设备id
+     * @param devId 设备id
      * @param monitorNum 监测点编号
      */
-    PqMonitor getByDevAndNum(String id, int monitorNum);
+    PqMonitor getByDevIdAndNum(String devId, int monitorNum);
 }

detection/src/main/java/com/njcn/gather/monitor/service/impl/PqMonitorServiceImpl.java

@@ -84,6 +84,7 @@ public class PqMonitorServiceImpl extends ServiceImpl<PqMonitorMapper, PqMonitor
             if (ObjectUtil.isNotNull(pqMonitor)) {
                 BeanUtil.copyProperties(monitorList.get(0), pqMonitor, "id", "realtimeResult", "statisticsResult", "recordedResult", "realtimeNum", "statisticsNum", "recordedNum", "resultType", "qualifiedNum");
                 newMonitorList.add(pqMonitor);
+                existedMonitorList.remove(pqMonitor);
             } else {
                 newMonitorList.addAll(monitorList);
             }
@@ -168,6 +169,7 @@ public class PqMonitorServiceImpl extends ServiceImpl<PqMonitorMapper, PqMonitor
                 this.baseMapper.updatePlanReportRState(plan.getId(), PlanReportStateEnum.REPORT_STATE_NOT_GENERATED.getValue());
             }
         }
+        this.removeByIds(existedMonitorList.stream().map(PqMonitor::getId).collect(Collectors.toList()));
         return this.saveOrUpdateBatch(newMonitorList);
     }
 
@@ -438,7 +440,7 @@ public class PqMonitorServiceImpl extends ServiceImpl<PqMonitorMapper, PqMonitor
     }
 
     @Override
-    public PqMonitor getByDevAndNum(String devId, int monitorNum) {
+    public PqMonitor getByDevIdAndNum(String devId, int monitorNum) {
         QueryWrapper<PqMonitor> wrapper = new QueryWrapper<>();
         wrapper.eq("pq_monitor.Dev_Id", devId)
                 .eq("pq_monitor.Num", monitorNum);

detection/src/main/java/com/njcn/gather/plan/service/impl/AdPlanServiceImpl.java

@@ -1265,7 +1265,7 @@ public class AdPlanServiceImpl extends ServiceImpl<AdPlanMapper, AdPlan> impleme
         for (int i = 1; i <= maxTime; i++) {
             row2[i] = i + "次检测";
             int tempI = i;
-            List<PqDevVO> tempDevList = devList.stream().filter(dev -> dev.getRecheckNum() <= tempI).collect(Collectors.toList());
+            List<PqDevVO> tempDevList = devList.stream().filter(dev -> dev.getRecheckNum() == tempI).collect(Collectors.toList());
             long passCount = tempDevList.stream().filter(dev -> dev.getCheckResult() == CheckResultEnum.ACCORD.getValue()).count();
             row3[i] = passCount + "";
             row4[i] = total + "";

detection/src/main/java/com/njcn/gather/report/service/impl/PqReportServiceImpl.java

@@ -1173,7 +1173,7 @@ public class PqReportServiceImpl extends ServiceImpl<PqReportMapper, PqReport> i
             Integer monitorNum = next.getKey();
             // 线路下的指标数据
             List<ContrastTestResult> contrastTestResults = next.getValue();
-            PqMonitor pqMonitor = pqMonitorService.getByDevAndNum(pqDevVO.getId(), monitorNum);
+            PqMonitor pqMonitor = pqMonitorService.getByDevIdAndNum(pqDevVO.getId(), monitorNum);
             // 插入回路号前，先换个页
             todoInsertList.add(Docx4jUtil.createPageBreakParagraph());
             // 回路标题
@@ -2503,7 +2503,7 @@ public class PqReportServiceImpl extends ServiceImpl<PqReportMapper, PqReport> i
      * 创建回路标题到报告中
      */
     private P getContrastLineTitle(Map<String, List<Docx4jUtil.HeadingContent>> contentMap, int monitorNum, int index, ObjectFactory factory, PqDevVO pqDevVO) {
-        PqMonitor pqMonitor = pqMonitorService.getByDevAndNum(pqDevVO.getId(), monitorNum);
+        PqMonitor pqMonitor = pqMonitorService.getByDevIdAndNum(pqDevVO.getId(), monitorNum);
         String monitorInfoName = "";
         if (StrUtil.isNotBlank(pqDevVO.getSubName()) && Objects.nonNull(pqMonitor)) {
             monitorInfoName = "(" + pqDevVO.getSubName() + "-" + pqMonitor.getName() + ")";

detection/src/main/java/com/njcn/gather/result/controller/ResultController.java

@@ -198,7 +198,7 @@ public class ResultController extends BaseController {
         String methodDescribe = getMethodDescribe("getCheckItem");
 
         LogUtil.njcnDebug(log, "{}，查询数据为：{}", methodDescribe, monitorQueryParam);
-        List<ContrastTestItemVO> result = resultService.getCheckItem(monitorQueryParam.getPlanId(), monitorQueryParam.getDevId(), monitorQueryParam.getChnNum(), monitorQueryParam.getNum());
+        List<ContrastTestItemVO> result = resultService.getCheckItem(monitorQueryParam.getPlanId(), monitorQueryParam.getDevId(), monitorQueryParam.getChnNum(), monitorQueryParam.getNum(), monitorQueryParam.getCode());
         return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, result, methodDescribe);
     }
 }

detection/src/main/java/com/njcn/gather/result/pojo/param/MonitorQueryParam.java

@@ -17,4 +17,6 @@ public class MonitorQueryParam {
     private Integer waveNum;
 
     private String planId;
+
+    private String code;
 }

detection/src/main/java/com/njcn/gather/result/service/IResultService.java

@@ -123,9 +123,10 @@ public interface IResultService {
      * @param devId
      * @param chnNum
      * @param num
+     * @param code
      * @return
      */
-    List<ContrastTestItemVO> getCheckItem(String planId, String devId, String chnNum, Integer num);
+    List<ContrastTestItemVO> getCheckItem(String planId, String devId, String chnNum, Integer num,String code);
 
     /**
      * 获取设备比对式结果，用于出比对检测的报告

detection/src/main/java/com/njcn/gather/result/service/impl/ResultServiceImpl.java

@@ -341,10 +341,19 @@ public class ResultServiceImpl implements IResultService {
     private void dipScriptTypeName(List<PqScriptDtls> subValue, List<TreeDataVO> subTypeList, Map<Integer, Set<Integer>> finalResultMap, Boolean isValueType, String name, Integer start, Integer end) {
         List<TreeDataVO> info = new ArrayList<>();
         List<PqScriptDtls> dip = subValue.stream()
-                .filter(x -> "Dip".equals(x.getValueType()) && "A".equals(x.getPhase()))
+//                .filter(x -> "Dip".equals(x.getValueType()) && "A".equals(x.getPhase()))
+                .filter(x -> "Dip".equals(x.getValueType()))
                 .filter(x -> x.getTransValue() >= start && x.getTransValue() <= end)
                 .sorted(Comparator.comparing(PqScriptDtls::getScriptIndex))
                 .collect(Collectors.toList());
+        LinkedHashMap<Integer, List<PqScriptDtls>> idxDipMap = dip.stream().collect(Collectors.groupingBy(d -> d.getScriptIndex(), LinkedHashMap::new, Collectors.toList()));
+
+        dip.clear();
+        idxDipMap.forEach((idx, scriptDtlList) -> {
+            scriptDtlList.sort(Comparator.comparing(PqScriptDtls::getPhase));
+            dip.add(scriptDtlList.get(0));
+        });
+
         TreeDataVO vo = new TreeDataVO();
         vo.setScriptTypeName(name);
         vo.setScriptTypeCode("Base_" + start + "_" + end);
@@ -1883,10 +1892,10 @@ public class ResultServiceImpl implements IResultService {
     }
 
     @Override
-    public List<ContrastTestItemVO> getCheckItem(String planId, String devId, String chnNum, Integer num) {
+    public List<ContrastTestItemVO> getCheckItem(String planId, String devId, String chnNum, Integer num, String code) {
 //        PqDev dev = pqDevService.getById(devId);
         AdPlan plan = adPlanService.getById(planId);
-        String code = String.valueOf(plan.getCode());
+//        String code = String.valueOf(plan.getCode());
 
         String monitorId = devId + CnSocketUtil.SPLIT_TAG + chnNum;
 

entrance/src/main/resources/application.yml

@@ -6,10 +6,10 @@ spring:
   datasource:
     druid:
       driver-class-name: com.mysql.cj.jdbc.Driver
-#      url: jdbc:mysql://192.168.1.24:13306/pqs91002?useUnicode=true&characterEncoding=utf-8&useSSL=true&serverTimezone=Asia/Shanghai&rewriteBatchedStatements=true
+      #      url: jdbc:mysql://192.168.1.24:13306/pqs91002?useUnicode=true&characterEncoding=utf-8&useSSL=true&serverTimezone=Asia/Shanghai&rewriteBatchedStatements=true
-#      username: root
+      #      username: root
-#      password: njcnpqs
+      #      password: njcnpqs
-      url: jdbc:mysql://192.168.1.24:13306/pqs9100_nx?useUnicode=true&characterEncoding=utf-8&useSSL=true&serverTimezone=Asia/Shanghai&rewriteBatchedStatements=true
+      url: jdbc:mysql://192.168.1.24:13306/pqs9100_hn?useUnicode=true&characterEncoding=utf-8&useSSL=true&serverTimezone=Asia/Shanghai&rewriteBatchedStatements=true
       username: root
       password: njcnpqs
       #初始化建立物理连接的个数、最小、最大连接数
@@ -36,9 +36,9 @@ mybatis-plus:
     #驼峰命名
     map-underscore-to-camel-case: true
     #配置sql日志输出
-    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
+    # log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
     #关闭日志输出
-  #    log-impl: org.apache.ibatis.logging.nologging.NoLoggingImpl
+    log-impl: org.apache.ibatis.logging.nologging.NoLoggingImpl
   global-config:
     db-config:
       #指定主键生成策略
@@ -46,12 +46,15 @@ mybatis-plus:
 
 
 socket:
-  source:
-    ip: 127.0.0.1
-    port: 62000
   device:
     ip: 127.0.0.1
     port: 61000
+  source:
+    ip: 127.0.0.1
+    port: 63000
+  freqConverter:
+    ip: 127.0.0.1
+    port: 63000
 #  source:
 #    ip: 192.168.1.121
 #    port: 10086
@@ -60,7 +63,7 @@ socket:
 #    port: 61000
 
 webSocket:
-  port: 7777
+  port: 7778
 
 #源参数下发，暂态数据默认值
 Dip:
@@ -122,4 +125,12 @@ power-quality:
 # 激活配置
 activate:
   private-key: "MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCcUyYhVqczGxblL+o/xZzF/8nf+LjrfUE/dS1aRHM7uMDD0cgCArhjtfneFePrMxt+Z7W8yNBzSarub8qsfhaVNikV7Es7oaeTygfjQXTi2n4AFkir3fM07J08RpWhl5M8f8uWTCuvFUYAw00gq55typqmnbkmJa2VIUy/iQf+cMCP7abz4/jNhUzUR3qA7TV4oMRgTdIEDUp63YF8dOC+JH8XxYrCVeHXV6fLCwmesdMzl0lB2VTEKMfLbXhOmF5g7P9y/16VCcN8UBuZlbyYfn+GAxJOSbeHi5HshOKfoSuD7Jz+3WQZpNavOWjIFExKIU38/CvnJCOP7XBCqpSTAgMBAAECggEAYeWokWRE3TpvwiOZnUpR/aVMdVi75a3ROL5XIpqPV61B+t/bU3cEpl0GF9C5pUeiRi0IoStZb3mI9D1KPW/REKyUWkhabQO1gFYbTnRlkNOn6MILzKX4cwJjDaZeeo4EBPU7N+qHyOOXrU6hdH5FfxhMdV983ajm5eeuupxER1C2kAcIklTeVpTX6EKOgZb5LBp5ssOVm2P42pOauvcRozRcvZmqnErXmukv0H4l3EVNt4rHpTn9riHUC63e8JfiYzVaF6zuNUxv6nHEft0/SRMw11XSTnNfDzcKqgjz6ksFBS/6eQQYKESk+ONC53HUuYHFAknkwsPupDCT2W8FIQKBgQDLHT/xCU3nxGr4vFKBDNaO2D5oK20ECbBO4oDvLWWmQG7f+6TsMy8PgVdMnoL4RfqGlwFAKEpS6KVFHnBVqnNEhcdy9uCI7x7Xx8UnyUtxj1EDTm76uta9Ki9OrlqB6tImDM9+Ya3vGktW37ht4WOx2OsJRhG1dbf6RLwFlH7DWwKBgQDFBxvi5I1BR6hg6Tj7xd2SqOT2Y+BED3xuSYENhWbmMhLJDResaB7mjztbxlYaY2mOE0holWm2uDmVFFhMh4jYXik4hYH8nmDzq9mDpZCZ9pyjYqnAP8THoAa8EbgrUWB8A6BPH4iL3KbMnBfBKY0pIr2xrvnjQjNBAgta7KDRKQKBgCe6oe4wxrdF2TKsC2tIqpMoQxS3Icy/ZGgZr+SYuaBKTCWtoDW/UT40K3JGMxIDBhzbXphBCUCsVt9tM8Xd4EwP6tJW7dZ7B0pnve2pVwNwaAVAiz6p2yUHIle+jN+Koe5lZRSwYIg7WW81tWpwwsJfzqFyvjYDP6hJV4mz4ROvAoGAaRcdnKvjXApomShMqJ4lTPChD3q+SA8qg3jZSOj6tZXHx00gb2kp8jg7pPvpOTIFPy6x1Ha9aCRjMk0ju84fA6lVuzwa1S907wOehUVuF3Eeo1cgy9Y3k3KbpPyeixxgpkUY4JslLdSHc2NemD0dee951qhJyRmqVOZOQDUuoeECgYEAqBw2cAFk3vM97WY06TSldGA8ajVHx3BYRjj+zl62NTQthy8fw3tqxb3c5e8toOmZWKjZvDhg2TRLhsDDQWEYg3LZG87REqVIjgEPcpjNLidjygGX8n3JF2o0O5I/EMvl0s/+LVQONfduOBvhwDqr8QNisbLsyneiAq7umewMolo="
-  public-key: "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAnFMmIVanMxsW5S/qP8Wcxf/J3/i4631BP3UtWkRzO7jAw9HIAgK4Y7X53hXj6zMbfme1vMjQc0mq7m/KrH4WlTYpFexLO6Gnk8oH40F04tp+ABZIq93zNOydPEaVoZeTPH/LlkwrrxVGAMNNIKuebcqapp25JiWtlSFMv4kH/nDAj+2m8+P4zYVM1Ed6gO01eKDEYE3SBA1Ket2BfHTgviR/F8WKwlXh11enywsJnrHTM5dJQdlUxCjHy214TpheYOz/cv9elQnDfFAbmZW8mH5/hgMSTkm3h4uR7ITin6Erg+yc/t1kGaTWrzloyBRMSiFN/Pwr5yQjj+1wQqqUkwIDAQAB"
+  public-key: "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAnFMmIVanMxsW5S/qP8Wcxf/J3/i4631BP3UtWkRzO7jAw9HIAgK4Y7X53hXj6zMbfme1vMjQc0mq7m/KrH4WlTYpFexLO6Gnk8oH40F04tp+ABZIq93zNOydPEaVoZeTPH/LlkwrrxVGAMNNIKuebcqapp25JiWtlSFMv4kH/nDAj+2m8+P4zYVM1Ed6gO01eKDEYE3SBA1Ket2BfHTgviR/F8WKwlXh11enywsJnrHTM5dJQdlUxCjHy214TpheYOz/cv9elQnDfFAbmZW8mH5/hgMSTkm3h4uR7ITin6Erg+yc/t1kGaTWrzloyBRMSiFN/Pwr5yQjj+1wQqqUkwIDAQAB"
+
+freq-converter:
+  schedule-period: 200 #定时器运行间隔
+  tolerant: 1 #耐受状态
+  dt: 200 #延迟时间ms
+  direction: 0 #0为横向1为纵向
+  allow-error-duration: 6 #暂态持续时间允许最大误差ms
+  allow-error-residual-voltage: 2.0 #暂态幅值允许最多误差%

storage/src/main/java/com/njcn/gather/storage/mapper/TableGenMapper.java

@@ -12,4 +12,6 @@ public interface TableGenMapper {
 
 
     void genNonHarmonicResultTable(@Param("code") String code, @Param("isContrast") boolean isContrast);
+
+    void genTable(@Param("tableSql") String tableSql);
 }

storage/src/main/java/com/njcn/gather/storage/mapper/mapping/TableGenMapper.xml

@@ -72,6 +72,10 @@
         ) COMMENT='非谐波类检测结果表';
     </update>
 
+    <update id="genTable" parameterType="string">
+        ${tableSql}
+    </update>
+
 
 </mapper>
 

system/src/main/java/com/njcn/gather/system/cfg/pojo/param/SysTestConfigParam.java

@@ -28,6 +28,9 @@ public class SysTestConfigParam {
     @ApiModelProperty(value = "场景")
     private String scene;
 
+    @ApiModelProperty(value = "比对监测后，当电压、电流不符合时，是否对标准设备进行系数校准")
+    private Integer coefficient;
+
     @Data
     public static class UpdateParam extends SysTestConfigParam {
         @ApiModelProperty("id")

system/src/main/java/com/njcn/gather/system/cfg/pojo/po/SysTestConfig.java

@@ -51,6 +51,11 @@ public class SysTestConfig extends BaseEntity implements Serializable {
      */
     private Integer scale;
 
+    /**
+     * 比对监测后，当电压、电流不符合时，是否对标准设备进行系数校准
+     */
+    private Integer coefficient;
+
 
     /**
      * 状态：0-删除 1-正常

system/src/main/java/com/njcn/gather/system/cfg/service/impl/SysTestConfigServiceImpl.java

@@ -49,6 +49,7 @@ public class SysTestConfigServiceImpl extends ServiceImpl<SysTestConfigMapper, S
         oneConfig.setScale(ObjectUtil.isNotNull(param.getScale()) ? param.getScale() : oneConfig.getScale());
         oneConfig.setMaxTime(ObjectUtil.isNotNull(param.getMaxTime()) ? param.getMaxTime() : oneConfig.getMaxTime());
         oneConfig.setScene(StringUtils.isNotBlank(param.getScene()) ? param.getScene() : oneConfig.getScene());
+        oneConfig.setCoefficient(param.getCoefficient());
         return this.updateById(oneConfig);
     }