diff --git a/frontend/src/api/check/interface/index.ts b/frontend/src/api/check/interface/index.ts
index 4c7c1d1..d75db35 100644
--- a/frontend/src/api/check/interface/index.ts
+++ b/frontend/src/api/check/interface/index.ts
@@ -51,8 +51,11 @@ export namespace CheckData {
     // 用来描述 通道检测结果
     export enum ChnCheckResultEnum {
         UNKNOWN = -1,
-        FAIL = 0,
+        LOADING = 0,
         SUCCESS = 1,
+        FAIL = 2,
+        UNCONNECTED = 3,
+        ERRORDATA = 4
     }
 
     //用来描述 某个脚本测试项对所有通道的检测结果
@@ -68,12 +71,20 @@ export namespace CheckData {
         }>
     }
 
+    export enum ButtonColorEnum {
+        INFO = '#909399',
+        LOADING = '#607eab',
+        SUCCESS = '#67c23a',
+        WARNING ='#e6a23c',
+        DANGER = '#f56c6c',
+    }
+
     /**
      * 用于描述 （设备）通道检测结果展示的按钮类型
      */
     export interface ButtonResult {
-        resultType: 'info' | 'success' | 'danger',
-        resultValue: '-' | '√' | '×'
+        color: ButtonColorEnum
+        icon: 'Minus' | 'Loading' | 'Close' | 'CircleCheckFilled' | 'Link' | 'WarnTriangleFilled'
     }
 
     /**
@@ -96,7 +107,7 @@ export namespace CheckData {
      * 定义检测日志类型
      */
     export interface LogItem {
-        type: 'info' | 'error'
+        type: 'info' | 'warning' | 'error'
         log: string
     }
 }
diff --git a/frontend/src/api/check/test/index.ts b/frontend/src/api/check/test/index.ts
index 23ece4c..c8b4c9f 100644
--- a/frontend/src/api/check/test/index.ts
+++ b/frontend/src/api/check/test/index.ts
@@ -1,5 +1,13 @@
 import http from "@/api";
 
-export const getCheckItemDetail = (params: { deviceId: string, chnNum: number, checkItemId?: string }) => {
-    return http.post<any>("/check/test/detail/", params, {loading: false});
+export const getFormData = (params: { deviceId: string, chnNum: number}) => {
+    return http.post<any>("/check/detail/", params, {loading: false});
+}
+
+export const getTreeData = (params: { deviceId: string, chnNum: number, checkItemId: string }) => {
+    return http.post<any>("/check/treeData/", params, {loading: false});
+}
+
+export const getCheckData = (params: { deviceId: string, chnNum: number, checkItemId: string }) => {
+    return http.post<any>("/check/data/", params, {loading: false});
 }
\ No newline at end of file
diff --git a/frontend/src/views/home/components/dataCheckSingleChannelSingleTestPopup.vue b/frontend/src/views/home/components/dataCheckSingleChannelSingleTestPopup.vue
index 235f7cd..c683141 100644
--- a/frontend/src/views/home/components/dataCheckSingleChannelSingleTestPopup.vue
+++ b/frontend/src/views/home/components/dataCheckSingleChannelSingleTestPopup.vue
@@ -17,8 +17,8 @@
             <el-input v-model='formContent.deviceName' :disabled="true"/>
           </el-form-item>
           <el-form-item label='通道号'>
-            <el-select v-model="formContent.monitorIdx" @change="handleChnNumChange">
-              <el-option v-for="item in chnList" :key="item.value" :label="item.value"
+            <el-select v-model="formContent.monitorIdx" @change="handleChnChange">
+              <el-option v-for="item in chnList" :key="item.value" :label="item.label"
                          :value="item.value"/>
             </el-select>
           </el-form-item>
@@ -34,8 +34,10 @@
             </el-radio-group>
           </div>
           <div class="content-tree">
-            <el-tree :default-expanded-keys="defaultExpandedKeys" node-key="id" :data="treeData"
-                     :props="defaultProps" @node-click="handleNodeClick"/>
+            <el-tree v-if="switchItem === 0" :default-expanded-keys="defaultExpandedKeys" node-key="id"
+                     :data="treeDataUnQualified" :props="defaultProps" @node-click="handleNodeClick"/>
+            <el-tree v-if="switchItem === 1" :default-expanded-keys="defaultExpandedKeys" node-key="id"
+                     :data="treeDataAll" :props="defaultProps" @node-click="handleNodeClick"/>
           </div>
         </div>
 
@@ -66,6 +68,8 @@ import {reactive, ref} from 'vue'
 import DataCheckResultTable from './dataCheckResultTable.vue'
 import DataCheckRawDataTable from './dataCheckRawDataTable.vue'
 import {CheckData} from "@/api/check/interface";
+import {getFormData, getTreeData, getCheckData} from "@/api/check/test";
+import {useDictStore} from "@/stores/modules/dict";
 
 const {appendToBody} = withDefaults(defineProps<{
   appendToBody: boolean
@@ -76,6 +80,10 @@ const defaultProps = {
   children: "children",
 };
 
+const dictStore = useDictStore()
+
+const visible = ref(false)
+
 // 表单数据
 const formContent = reactive<CheckData.DataCheck>({
   scriptName: '',
@@ -84,13 +92,14 @@ const formContent = reactive<CheckData.DataCheck>({
   deviceName: '',
   monitorIdx: '',
 })
+let deviceId: string = ''
+let scriptType: string = ''
+
 // 通道下拉列表
-let chnList: number[] = []
+let chnList: any[] = []
 
 // 不符合测试项、全部测试项切换
 const switchItem = ref<number>(-1)
-// 左侧树数据（仅用于展示）
-const treeData=reactive<CheckData.ScriptItem[]>([])
 // 左侧树数据-不符合测试项
 let treeDataUnQualified: CheckData.ScriptItem[] = []
 // 左侧树数据-全部测试项
@@ -99,314 +108,241 @@ let treeDataAll: CheckData.ScriptItem[] = []
 const checkedScriptId = ref<string>('')
 
 
-const currentScriptDsc = ref('电压准确度检测：频率：42.5Hz Ua=46.192V 0° Ub=46.192V -120° Uc=46.192V 120° Ia=1A 0° Ib=1A -120° Ic=1A 120°');
+const currentScriptDsc = ref('');
 // 右侧Tab选中项
 const activeTab = ref<string>('resultTab')
 // 检测结果表格数据
-const checkResultTableData = reactive<CheckData.CheckResult[]>([
-  {
-    chnNum: '1',
-    standardValue: 57.74,
-    L1: 57.73,
-    L1_errValue: 0.01,
-    L2: 57.73,
-    L2_errValue: 0.01,
-    L3: 57.73,
-    L3_errValue: 0.01,
-    maxErrVaule: 0.05774,
-    result: '合格',
-  }
-])
+const checkResultTableData = reactive<CheckData.CheckResult[]>([])
 // 原始数据表格数据
-const rawTableData = reactive<CheckData.RawDataItem[]>([
-  {
-    updateTime: "2024-10-10 09:30:00",
-    L1: 57.73,
-    L2: 57.73,
-    L3: 57.73,
-  },
-  {
-    updateTime: "2024-10-10 09:30:03",
-    L1: 57.73,
-    L2: 57.73,
-    L3: 57.73,
-  },
-  {
-    updateTime: "2024-10-10 09:30:06",
-    L1: 57.73,
-    L2: 57.73,
-    L3: 57.73,
-  },
-  {
-    updateTime: "2024-10-10 09:30:09",
-    L1: 57.73,
-    L2: 57.73,
-    L3: 57.73,
-  },
-  {
-    updateTime: "2024-10-10 09:30:12",
-    L1: 57.73,
-    L2: 57.73,
-    L3: 57.73,
-  },
-  {
-    updateTime: "2024-10-10 09:30:15",
-    L1: 57.73,
-    L2: 57.73,
-    L3: 57.73,
-  },
-  {
-    updateTime: "2024-10-10 09:30:18",
-    L1: 57.73,
-    L2: 57.73,
-    L3: 57.73,
-  },
-  {
-    updateTime: "2024-10-10 09:30:21",
-    L1: 57.73,
-    L2: 57.73,
-    L3: 57.73,
-  },
-  {
-    updateTime: "2024-10-10 09:30:24",
-    L1: 57.73,
-    L2: 57.73,
-    L3: 57.73,
-  },
-  {
-    updateTime: "2024-10-10 09:30:27",
-    L1: 57.73,
-    L2: 57.73,
-    L3: 57.73,
-  },
-  {
-    updateTime: "2024-10-10 09:30:30",
-    L1: 57.73,
-    L2: 57.73,
-    L3: 57.73,
-  },
-  {
-    updateTime: "2024-10-10 09:30:33",
-    L1: 57.73,
-    L2: 57.73,
-    L3: 57.73,
-  },
-  {
-    updateTime: "2024-10-10 09:30:36",
-    L1: 57.73,
-    L2: 57.73,
-    L3: 57.73,
-  },
-  {
-    updateTime: "2024-10-10 09:30:39",
-    L1: 57.73,
-    L2: 57.73,
-    L3: 57.73,
-  },
-  {
-    updateTime: "2024-10-10 09:30:42",
-    L1: 57.73,
-    L2: 57.73,
-    L3: 57.73,
-  },
-  {
-    updateTime: "2024-10-10 09:30:45",
-    L1: 57.73,
-    L2: 57.73,
-    L3: 57.73,
-  },
-  {
-    updateTime: "2024-10-10 09:30:48",
-    L1: 57.73,
-    L2: 57.73,
-    L3: 57.73,
-  },
-  {
-    updateTime: "2024-10-10 09:30:51",
-    L1: 57.73,
-    L2: 57.73,
-    L3: 57.73,
-  },
-  {
-    updateTime: "2024-10-10 09:30:54",
-    L1: 57.73,
-    L2: 57.73,
-    L3: 57.73,
-  },
-  {
-    updateTime: "2024-10-10 09:30:57",
-    L1: 57.73,
-    L2: 57.73,
-    L3: 57.73,
-  }
-])
+const rawTableData = reactive<CheckData.RawDataItem[]>([])
 
 const resultTableRef = ref()
 const rawDataTableRef = ref()
 
 // 左侧树默认展开节点id
-const defaultExpandedKeys = computed(() => {
-  return [getDefaultId(treeData)]
-})
+let defaultExpandedKeys: string[] = []
+
+// 监控通道号下拉框
+const handleChnChange = (data: any) => {
+
+  console.log("通道号下拉框", data);
+
+  // 后端请求，查询该通道号下的测试项（可以只查询不合格测试项，也可以全部测试项、不合格测试项都查询）
+  // const result = await getTreeData({deviceId, formContent.monitorIdx, scriptType})
+  //  treeDataUnQualified=[]
+  //  treeDataAll=[]
+
 
-// 改变通道号下拉框触发事件
-const handleChnNumChange = (data: any) => {
-  formContent.monitorIdx = data.value
 }
-watch(() => formContent.monitorIdx, (newVal, oldVal) => {
-  if (newVal) {
-    console.log("通道号下拉框", newVal, oldVal);
-
-    // 后端请求，查询该通道号下的测试项（可以只查询不合格测试项，也可以全部测试项、不合格测试项都查询）
-    //  treeDataUnQualified=[]
-    //  treeDataAll=[]
-
-  }
-})
+// watch(() => formContent.monitorIdx, (newVal, oldVal) => {
+//   if (newVal) {
+//     console.log("通道号下拉框", newVal, oldVal);
+//
+//     // 后端请求，查询该通道号下的测试项（可以只查询不合格测试项，也可以全部测试项、不合格测试项都查询）
+//     // const result = await getTreeData({deviceId, formContent.monitorIdx, scriptType})
+//     //  treeDataUnQualified=[]
+//     //  treeDataAll=[]
+//
+//   }
+// })
 
 // 点击左侧树节点触发事件
 const handleNodeClick = (data: any) => {
   if (!data.children) {
     checkedScriptId.value = data.id
+    currentScriptDsc.value = data.scriptName
   }
 };
 
 watch(checkedScriptId, (newVal, oldVal) => {
   if (newVal) {
-    console.log("左侧树被选中的叶子节点id", newVal, oldVal);
-    // checkResultTableData
+    console.log("左侧树被选中的叶子节点id", newVal);
+    // 发起请求，查询该测试项的检测结果
+    // const result = await getCheckData({deviceId, formContent.monitorIdx, scriptType})
+    Object.assign(checkResultTableData, [{
+      chnNum: '1',
+      standardValue: 57.74,
+      L1: 57.73,
+      L1_errValue: 0.01,
+      L2: 57.73,
+      L2_errValue: 0.01,
+      L3: 57.73,
+      L3_errValue: 0.01,
+      maxErrVaule: 0.05774,
+      result: '合格',
+    }])
+    Object.assign(rawTableData, [
+      {
+        updateTime: "2024-10-10 09:30:00",
+        L1: 57.73,
+        L2: 57.73,
+        L3: 57.73,
+      },
+      {
+        updateTime: "2024-10-10 09:30:03",
+        L1: 57.73,
+        L2: 57.73,
+        L3: 57.73,
+      },
+      {
+        updateTime: "2024-10-10 09:30:06",
+        L1: 57.73,
+        L2: 57.73,
+        L3: 57.73,
+      },
+      {
+        updateTime: "2024-10-10 09:30:09",
+        L1: 57.73,
+        L2: 57.73,
+        L3: 57.73,
+      },
+      {
+        updateTime: "2024-10-10 09:30:12",
+        L1: 57.73,
+        L2: 57.73,
+        L3: 57.73,
+      },
+      {
+        updateTime: "2024-10-10 09:30:15",
+        L1: 57.73,
+        L2: 57.73,
+        L3: 57.73,
+      },
+      {
+        updateTime: "2024-10-10 09:30:18",
+        L1: 57.73,
+        L2: 57.73,
+        L3: 57.73,
+      },
+      {
+        updateTime: "2024-10-10 09:30:21",
+        L1: 57.73,
+        L2: 57.73,
+        L3: 57.73,
+      },
+      {
+        updateTime: "2024-10-10 09:30:24",
+        L1: 57.73,
+        L2: 57.73,
+        L3: 57.73,
+      },
+      {
+        updateTime: "2024-10-10 09:30:27",
+        L1: 57.73,
+        L2: 57.73,
+        L3: 57.73,
+      },
+      {
+        updateTime: "2024-10-10 09:30:30",
+        L1: 57.73,
+        L2: 57.73,
+        L3: 57.73,
+      },
+      {
+        updateTime: "2024-10-10 09:30:33",
+        L1: 57.73,
+        L2: 57.73,
+        L3: 57.73,
+      },
+      {
+        updateTime: "2024-10-10 09:30:36",
+        L1: 57.73,
+        L2: 57.73,
+        L3: 57.73,
+      },
+      {
+        updateTime: "2024-10-10 09:30:39",
+        L1: 57.73,
+        L2: 57.73,
+        L3: 57.73,
+      },
+      {
+        updateTime: "2024-10-10 09:30:42",
+        L1: 57.73,
+        L2: 57.73,
+        L3: 57.73,
+      },
+      {
+        updateTime: "2024-10-10 09:30:45",
+        L1: 57.73,
+        L2: 57.73,
+        L3: 57.73,
+      },
+      {
+        updateTime: "2024-10-10 09:30:48",
+        L1: 57.73,
+        L2: 57.73,
+        L3: 57.73,
+      },
+      {
+        updateTime: "2024-10-10 09:30:51",
+        L1: 57.73,
+        L2: 57.73,
+        L3: 57.73,
+      },
+      {
+        updateTime: "2024-10-10 09:30:54",
+        L1: 57.73,
+        L2: 57.73,
+        L3: 57.73,
+      },
+      {
+        updateTime: "2024-10-10 09:30:57",
+        L1: 57.73,
+        L2: 57.73,
+        L3: 57.73,
+      }
+    ])
   }
 })
 
 // 切换不合格测试项、全部测试项 触发事件
-// const handleSwitch = (data: any) => {
-//   if (data === 0) {
-//     //Object.assign(treeData, treeDataUnQualified)
-//   } else {
-//     //Object.assign(treeData, treeDataAll)
-//   }
-// }
 watch(switchItem, (newVal, oldVal) => {
-  if (switchItem.value === 0) {
-    Object.assign(treeData, treeDataUnQualified)
+  let node = null
+  if (newVal === 0) {
+    node = getDefaultNode(treeDataUnQualified)
   }
-  if (switchItem.value === 1) {
-    Object.assign(treeData, treeDataAll)
+  if (newVal === 1) {
+    node = getDefaultNode(treeDataAll)
   }
-},{immediate:true})
 
+  currentScriptDsc.value = node?.scriptName
+  checkedScriptId.value = node?.id
+  defaultExpandedKeys = [node?.id]
+})
 
-const visible = ref(false)
-
-const close = () => {
-  //数据清空
-  Object.assign(formContent, {
-    scriptName: '',
-    errorSysName: '',
-    dataRule: '',
-    deviceName: '',
-    monitorIdx: '',
-  })
-  checkedScriptId.value = ''
-  activeTab.value = 'rawDataTab'
-
-  visible.value = false;
-};
-
-const open = async (deviceId: string, chnNum: number, checkItemId?: string) => {
+const open = async (_deviceId: string, chnNum: number, _scriptType?: string) => {
+  console.log(_deviceId, chnNum, _scriptType);
+  deviceId = _deviceId
+  scriptType = _scriptType ?? ''
   switchItem.value = 0
-  // 发起后端请求，查询详细信息
-  // 当checkItemId为空时，默认显示全部测试项、全部不合格测试项
-  // 当checkItemId不为空时，默认显示当前checkItemId的测试项、属于当前checkItemId的不合格测试项
-  checkItemId = checkItemId ?? ''
-  console.log(deviceId, chnNum, checkItemId);
-  //const result = await getCheckItemDetail({deviceId, chnNum, checkItemId})
-
+  // 发起后端请求，查询详细信息 当chnNum为-1时，查询所有通道号
+  //const result1 = await getFormData({deviceId, chnNum})
 
   // 数据处理
-  chnList = [
-    {value: '1',},
-    {
-      value: '2 （不合格）',
-    },
-    {
-      value: '3',
-    },
-    {
-      value: '4 （不合格）',
-    },]
-  Object.assign(formContent, {
+  let resFormContent = {
     scriptName: 'Q/GDW 10650.4-2021 模拟式',
     errorSysName: 'Q/GDW 10650.2-2021',
-    dataRule: '所有值',
+    dataRule: '505f063f9f91ab108d895a9fe96b5dce',
     deviceName: '被检设备1',
-    monitorIdx: chnList[0].value,
-  })
+    chnList:[
+      {value: '1', label: '1'},
+      {value: '2', label: '0'},
+      {value: '3', label: '1'},
+      {value: '4', label: '0'}],
+  }
+  chnList = resFormContent.chnList.map(item => ({
+    value: item.value,
+    label: item.label == '1' ? `${item.value}` : `${item.value}（不符合）`
+  }))
 
-  treeDataAll=[{
-      "id": "1",
-      "pid": "0",
-      "scriptName": "频率准确度检测",
-      "children": [
-        {
-          "id": "1-1",
-          "pid": "1",
-          "scriptName": "额定工作条件下的检测",
-          "children": [
-            {
-              "id": "1-1-1",
-              "pid": "1-1",
-              "scriptName": "输入：频率 42.5Hz..."
-            },
-            {
-              "id": "1-1-2",
-              "pid": "1-1",
-              "scriptName": "输入：频率 50.0Hz..."
-            },
-            {
-              "id": "1-1-3",
-              "pid": "1-1",
-              "scriptName": "输入：频率 50.05Hz...."
-            }
-          ]
-        },
-        {
-          "id": "1-2",
-          "pid": "1",
-          "scriptName": "电压对频率测量的影响",
-          "children": [
-            {
-              "id": "1-2-1",
-              "pid": "1-2",
-              "scriptName": "输入：频率 50.05Hz Ua =10%Un..."
-            },
-            {
-              "id": "1-2-1",
-              "pid": "1-2",
-              "scriptName": "输入：频率 51.05Hz Ua =10%Un..."
-            },
-            {
-              "id": "1-2-2",
-              "pid": "1-2",
-              "scriptName": "输入：频率 52.05Hz Ua =10%Un..."
-            }
-          ]
-        },
-        {
-          "id": "1-3",
-          "pid": "1",
-          "scriptName": "谐波对频率测量的影响",
-          "children": [
-            {
-              "id": "1-3-1",
-              "pid": "1-3",
-              "scriptName": "输入：频率 50.05Hz Ua =100%Un..."
-            }
-          ]
-        }
-      ]
-    }]
-  treeDataUnQualified=[{
+  let dataRuleName = dictStore.getDictData('Data_Rule').find(item=>item.id==resFormContent.dataRule)?.name
+
+  Object.assign(formContent, {...resFormContent,dataRule:dataRuleName,monitorIdx: chnList[0].value})
+
+
+  // const result2 = await getTreeData({deviceId, formContent.monitorIdx, checkItemId})
+  treeDataAll = [{
     "id": "1",
     "pid": "0",
     "scriptName": "频率准确度检测",
@@ -433,6 +369,47 @@ const open = async (deviceId: string, chnNum: number, checkItemId?: string) => {
           }
         ]
       },
+      {
+        "id": "1-2",
+        "pid": "1",
+        "scriptName": "电压对频率测量的影响",
+        "children": [
+          {
+            "id": "1-2-1",
+            "pid": "1-2",
+            "scriptName": "输入：频率 50.05Hz Ua =10%Un..."
+          },
+          {
+            "id": "1-2-1",
+            "pid": "1-2",
+            "scriptName": "输入：频率 51.05Hz Ua =10%Un..."
+          },
+          {
+            "id": "1-2-2",
+            "pid": "1-2",
+            "scriptName": "输入：频率 52.05Hz Ua =10%Un..."
+          }
+        ]
+      },
+      {
+        "id": "1-3",
+        "pid": "1",
+        "scriptName": "谐波对频率测量的影响",
+        "children": [
+          {
+            "id": "1-3-1",
+            "pid": "1-3",
+            "scriptName": "输入：频率 50.05Hz Ua =100%Un..."
+          }
+        ]
+      }
+    ]
+  }]
+  treeDataUnQualified = [{
+    "id": "1",
+    "pid": "0",
+    "scriptName": "频率准确度检测",
+    "children": [
       {
         "id": "1-2",
         "pid": "1",
@@ -458,211 +435,36 @@ const open = async (deviceId: string, chnNum: number, checkItemId?: string) => {
     ]
   }]
 
-  // Object.assign(treeData, [
-  //   {
-  //     "id": "1",
-  //     "pid": "0",
-  //     "scriptName": "频率准确度检测",
-  //     "children": [
-  //       {
-  //         "id": "1-1",
-  //         "pid": "1",
-  //         "scriptName": "额定工作条件下的检测",
-  //         "children": [
-  //           {
-  //             "id": "1-1-1",
-  //             "pid": "1-1",
-  //             "scriptName": "输入：频率 42.5Hz..."
-  //           },
-  //           {
-  //             "id": "1-1-2",
-  //             "pid": "1-1",
-  //             "scriptName": "输入：频率 50.0Hz..."
-  //           },
-  //           {
-  //             "id": "1-1-3",
-  //             "pid": "1-1",
-  //             "scriptName": "输入：频率 50.05Hz...."
-  //           }
-  //         ]
-  //       },
-  //       {
-  //         "id": "1-2",
-  //         "pid": "1",
-  //         "scriptName": "电压对频率测量的影响",
-  //         "children": [
-  //           {
-  //             "id": "1-2-1",
-  //             "pid": "1-2",
-  //             "scriptName": "输入：频率 50.05Hz Ua =10%Un..."
-  //           },
-  //           {
-  //             "id": "1-2-1",
-  //             "pid": "1-2",
-  //             "scriptName": "输入：频率 51.05Hz Ua =10%Un..."
-  //           },
-  //           {
-  //             "id": "1-2-2",
-  //             "pid": "1-2",
-  //             "scriptName": "输入：频率 52.05Hz Ua =10%Un..."
-  //           }
-  //         ]
-  //       },
-  //       {
-  //         "id": "1-3",
-  //         "pid": "1",
-  //         "scriptName": "谐波对频率测量的影响",
-  //         "children": [
-  //           {
-  //             "id": "1-3-1",
-  //             "pid": "1-3",
-  //             "scriptName": "输入：频率 50.05Hz Ua =100%Un..."
-  //           }
-  //         ]
-  //       }
-  //     ]
-  //   },
-  //   {
-  //     "id": "2",
-  //     "pid": "0",
-  //     "scriptName": "电压准确度检测",
-  //     "children": [
-  //       {
-  //         "pid": "2",
-  //         "id": "2-1",
-  //         "scriptName": "额定工作条件下的检测",
-  //         "children": [
-  //           {
-  //             "id": "2-1-1",
-  //             "pid": "2-1",
-  //             "scriptName": "输入：频率 42.5Hz..."
-  //           },
-  //           {
-  //             "id": "2-1-2",
-  //             "pid": "2-1",
-  //             "scriptName": "输入：频率 50.0Hz..."
-  //           },
-  //           {
-  //             "id": "2-1-3",
-  //             "pid": "2-1",
-  //             "scriptName": "输入：频率 50.05Hz..."
-  //           }
-  //         ]
-  //       },
-  //       {
-  //         "pid": "2",
-  //         "id": "2-2",
-  //         "scriptName": "电压对频率测量的影响",
-  //         "children": [
-  //           {
-  //             "id": "2-2-1",
-  //             "pid": "2-2",
-  //             "scriptName": "输入：频率 50.05Hz Ua =10%Un..."
-  //           },
-  //           {
-  //             "id": "2-2-1",
-  //             "pid": "2-2",
-  //             "scriptName": "输入：频率 51.05Hz Ua =10%Un..."
-  //           },
-  //           {
-  //             "id": "2-2-2",
-  //             "pid": "2-2",
-  //             "scriptName": "输入：频率 52.05Hz Ua =10%Un..."
-  //           }
-  //         ]
-  //       },
-  //       {
-  //         "pid": "2",
-  //         "id": "2-3",
-  //         "scriptName": "谐波对频率测量的影响",
-  //         "children": [
-  //           {
-  //             "id": "2-3-1",
-  //             "pid": "2-3",
-  //             "scriptName": "输入：频率 50.05Hz Ua =100%Un..."
-  //           }
-  //         ]
-  //       }
-  //     ]
-  //   },
-  //   {
-  //     "id": "3",
-  //     "pid": "0",
-  //     "scriptName": "谐波准确度检测",
-  //     "children": [
-  //       {
-  //         "id": "3-1",
-  //         "pid": "3",
-  //         "scriptName": "额定工作条件下的检测",
-  //         "children": [
-  //           {
-  //             "id": "3-1-1",
-  //             "pid": "3-1",
-  //             "scriptName": "输入：频率 42.5Hz..."
-  //           },
-  //           {
-  //             "id": "3-1-2",
-  //             "pid": "3-1",
-  //             "scriptName": "输入：频率 50.0Hz..."
-  //           },
-  //           {
-  //             "id": "3-1-3",
-  //             "pid": "3-1",
-  //             "scriptName": "输入：频率 50.05Hz..."
-  //           }
-  //         ]
-  //       },
-  //       {
-  //         "id": "3-2",
-  //         "pid": "3",
-  //         "scriptName": "电压对频率测量的影响",
-  //         "children": [
-  //           {
-  //             "id": "3-2-1",
-  //             "pid": "3-2",
-  //             "scriptName": "输入：频率 50.05Hz Ua =10%Un..."
-  //           },
-  //           {
-  //             "id": "3-2-1",
-  //             "pid": "3-2",
-  //             "scriptName": "输入：频率 51.05Hz Ua =10%Un..."
-  //           },
-  //           {
-  //             "id": "3-2-2",
-  //             "pid": "3-2",
-  //             "scriptName": "输入：频率 52.05Hz Ua =10%Un..."
-  //           }
-  //         ]
-  //       },
-  //       {
-  //         "id": "3-3",
-  //         "pid": "3",
-  //         "scriptName": "谐波对频率测量的影响",
-  //         "children": [
-  //           {
-  //             "id": "3-3-1",
-  //             "pid": "3-3",
-  //             "name": "输入：频率 50.05Hz Ua =100%Un..."
-  //           }
-  //         ]
-  //       }
-  //     ]
-  //   }
-  // ])
-
-  checkedScriptId.value = defaultExpandedKeys.value[0] ?? ''
-
   visible.value = true;
 }
 
-const findFirstLeafNode = (node: any): string => {
+const close = () => {
+  //数据清空
+  Object.assign(formContent, {
+    scriptName: '',
+    errorSysName: '',
+    dataRule: '',
+    deviceName: '',
+    monitorIdx: '',
+  })
+  treeDataAll = []
+  treeDataUnQualified = []
+  checkedScriptId.value = ''
+  activeTab.value = 'rawDataTab'
+  currentScriptDsc.value = ''
+  switchItem.value = -1
+
+  visible.value = false;
+};
+
+const findFirstLeafNode = (node: any): any => {
   if (!node.children || node.children.length === 0) {
-    return node.id;
+    return node;
   }
 
   return findFirstLeafNode(node.children[0]);
 }
-const getDefaultId = (data: any[]): string | null => {
+const getDefaultNode = (data: any[]) => {
   if (!data || data.length === 0) {
     return null;
   }
diff --git a/frontend/src/views/home/components/test.vue b/frontend/src/views/home/components/test.vue
index 707aaa8..1fa518d 100644
--- a/frontend/src/views/home/components/test.vue
+++ b/frontend/src/views/home/components/test.vue
@@ -11,7 +11,7 @@
           v-if="testStatus=='process' && activeIndex < checkTotal"
           :disabled="activeIndex===0"
           :icon="VideoPause"
-          @click="emit('update:testStatus','paused')">停止检测
+          @click="handlePauseTest">停止检测
       </el-button>
 
       <el-button type="success" v-if="activeIndex >= checkTotal" :icon="Check" disabled>检测完成</el-button>
@@ -20,7 +20,7 @@
           type="warning"
           v-if="testStatus=='paused' && activeIndex < checkTotal"
           :icon="Refresh"
-          @click="emit('update:testStatus','process')"
+          @click="handleResumeTest"
       >继续检测
       </el-button>
       <el-button type="text" :icon="InfoFilled" @click="showTestLog">检测项进度</el-button>
@@ -38,7 +38,7 @@
     </div>
 
     <div class="dialog-content">
-      <el-table :data="checkResultView" :cell-class-name="tableCell" row-key="scriptId" height="450px"
+      <el-table :data="checkResultView" row-key="scriptId" height="450px"
                 :header-cell-style="{ background: '#003078', color: '#eee', textAlign: 'center' } " style="width: 100%"
                 border>
         <el-table-column fixed prop="scriptName" label="检测项目" width="140px" align="center">
@@ -51,16 +51,24 @@
                              :label="'通道'+chnItem" align="center">
               <template #default="{row}">
                 <el-tooltip
-                    :content="row.devices[index1].chnResult[index2].resultType==='info' ? '暂无数据' : '点击查看详情'"
+                    :content="row.devices[index1].chnResult[index2].color===CheckData.ButtonColorEnum.INFO ? '暂无数据' : '点击查看详情'"
                     placement="top">
                   <el-button
-                      :disabled="row.devices[index1].chnResult[index2].resultType=='info'"
-                      :type="row.devices[index1].chnResult[index2].resultType"
+                      :disabled="row.devices[index1].chnResult[index2].color==CheckData.ButtonColorEnum.INFO"
+                      :color="row.devices[index1].chnResult[index2].color"
                       size="small"
                       @click="handleClick(row.scriptId,item.deviceId,chnItem)"
+                      style="align-self: center;"
                   >
-                    {{ row.devices[index1].chnResult[index2].resultValue }}
+                    <el-icon v-if="row.devices[index1].chnResult[index2].icon==='Loading'" class="loading-box"
+                             style="color: #fff">
+                      <component :is="Loading"/>
+                    </el-icon>
+                    <el-icon v-else style="color: #fff">
+                      <component :is="row.devices[index1].chnResult[index2].icon"/>
+                    </el-icon>
                   </el-button>
+
                 </el-tooltip>
               </template>
             </el-table-column>
@@ -68,18 +76,25 @@
         </template>
 
         <template v-else>
-          <el-table-column v-for="(item,index) in deviceList" :key="item.deviceId" :label="item.deviceName"
+          <el-table-column v-for="(item,index1) in deviceList" :key="item.deviceId" :label="item.deviceName"
                            :min-width="110" align="center">
             <template #default="{row}">
-              <el-tooltip :content="row.devices[index].chnResult[0].resultType==='info' ? '暂无数据' : '点击查看详情'"
-                          placement="top">
+              <el-tooltip
+                  :content="row.devices[index1].chnResult[0].color===CheckData.ButtonColorEnum.INFO ? '暂无数据' : '点击查看详情'"
+                  placement="top">
                 <el-button
-                    :disabled="row.devices[index].chnResult[0].resultType=='info'"
-                    :type="row.devices[index].chnResult[0].resultType"
+                    :disabled="row.devices[index1].chnResult[0].color===CheckData.ButtonColorEnum.INFO"
+                    :color="row.devices[index1].chnResult[0].color"
                     size="small"
                     @click="handleClick(row.scriptId,item.deviceId,-1)"
                 >
-                  {{ row.devices[index].chnResult[0].resultValue }}
+                  <el-icon v-if="row.devices[index1].chnResult[0].icon==='Loading'" class="loading-box"
+                           style="color: #fff">
+                    <component :is="Loading"/>
+                  </el-icon>
+                  <el-icon v-else style="color: #fff">
+                    <component :is="row.devices[index1].chnResult[0].icon"/>
+                  </el-icon>
                 </el-button>
               </el-tooltip>
             </template>
@@ -95,10 +110,10 @@
       <!--    <template #header>-->
       <!--      <div style="background: #003078 !important; color: #fff !important; font-size: 18px;">检测项进度</div>-->
       <!--    </template>-->
-      <div ref="scrollContainer">
+      <div ref="scrollContainerRef" style="height: 100%; overflow-y: auto;">
         <p v-for="(item, index) in testLogList"
            :key="index"
-           :style="{color:item.type==='error'?'#F56C6C':'var(--el-text-color-regular)'}">
+           :style="{color:item.type==='error'?'#F56C6C': item.type==='warning'?'#e6a23c':'var(--el-text-color-regular)'}">
           {{ item.log }}<br/>
         </p>
       </div>
@@ -112,21 +127,33 @@
   <dataCheckSingleChannelSingleTestPopup ref="dataCheckSingleChannelSingleTestPopupRef"/>
 </template>
 <script lang="tsx" setup name="test">
-import {Check, InfoFilled, Refresh, VideoPause} from '@element-plus/icons-vue'
+import {
+  Check,
+  InfoFilled,
+  Refresh,
+  VideoPause,
+  Minus,
+  Close,
+  CircleCheckFilled,
+  WarnTriangleFilled,
+  Loading,
+  Link
+} from '@element-plus/icons-vue'
 import resultPopup from './resultPopup.vue'
 import dataCheckSingleChannelSingleTestPopup from './dataCheckSingleChannelSingleTestPopup.vue'
 import {reactive, ref, watch} from "vue";
 import {dialogBig} from "@/utils/elementBind";
 import {CheckData} from "@/api/check/interface"
 import {useCheckStore} from "@/stores/modules/check";
+import {ElMessage, ElMessageBox} from "element-plus";
 
 const checkStore = useCheckStore()
 
 // 最大通道数
-const MAX_CHN_SUM = 10
+const MAX_CHN_SUM = 8
 
 // 总测试项数
-const checkTotal = ref(0)
+let checkTotal = 0
 
 const props = defineProps({
   testStatus: {
@@ -139,7 +166,7 @@ const props = defineProps({
   }
 })
 
-const emit = defineEmits(['update:testStatus', 'update:webMsgSend']);
+const emit = defineEmits(['update:testStatus', 'update:webMsgSend','sendPause','sendResume']);
 
 // 用来保存测试项进度抽屉是否打开
 const drawer = ref(false)
@@ -149,10 +176,8 @@ const customColors = [{color: "#5cb87a", percentage: 100}]
 const scriptData = reactive<CheckData.ScriptItem[]>([])
 // 用来保存被检设备
 const deviceList = reactive<CheckData.Device[]>([])
-// 用来保存定时器
-const timer: any = ref("");
 // 当前进行的测试项索引
-const activeIndex = ref(0)
+let activeIndex = 1
 // 百分比
 const percentage = ref(0);
 //测试项开始检测时间（或继续检测时间）
@@ -163,15 +188,15 @@ const timeDifference = ref(0)
 // 真正的检测结果（详细到通道）
 const checkResult = reactive<CheckData.ScriptChnItem[]>([])
 // 用来存放检测出现失败的测试项id。只要有一个通道检测不合格，则该检测项的id会被加入该数组。
-const errorCheckItem = reactive<string[]>([]);
+let errorCheckItem: Array<{ scriptId: string, type: 'info' | 'warning' | 'error' }> = []
 // 用来存放检测日志
-const testLogList = ref<CheckData.LogItem[]>([{type: 'info', log: '暂无数据，等待检测开始'}])
+const testLogList = reactive<CheckData.LogItem[]>([{type: 'info', log: '暂无数据，等待检测开始'}])
 
 const testStatus = toRef(props, 'testStatus')
 const webMsgSend = toRef(props, 'webMsgSend')
 
 const resultDialogVisible = ref(false)
-const scrollContainer = ref<HTMLElement | null>(null);
+const scrollContainerRef = ref();
 const dataCheckSingleChannelSingleTestPopupRef = ref<InstanceType<typeof dataCheckSingleChannelSingleTestPopup>>()
 
 
@@ -199,12 +224,27 @@ const checkResultView = computed(() => {
 
       if (chnSum.value <= MAX_CHN_SUM) {
         for (let j = 0; j < device.chnResult.length; j++) {
-          if (device.chnResult[j] == CheckData.ChnCheckResultEnum.UNKNOWN) {
-            tempChnBtnResult.push({resultType: 'info', resultValue: '-'})
-          } else if (device.chnResult[j] == CheckData.ChnCheckResultEnum.FAIL) {
-            tempChnBtnResult.push({resultType: 'danger', resultValue: '×'})
-          } else {
-            tempChnBtnResult.push({resultType: 'success', resultValue: '√'})
+          switch (device.chnResult[j]) {
+            case CheckData.ChnCheckResultEnum.UNKNOWN:
+              tempChnBtnResult.push({color: CheckData.ButtonColorEnum.INFO, icon: 'Minus'})
+              break;
+            case CheckData.ChnCheckResultEnum.LOADING:
+              tempChnBtnResult.push({color: CheckData.ButtonColorEnum.LOADING, icon: 'Loading'})
+              break;
+            case CheckData.ChnCheckResultEnum.SUCCESS:
+              tempChnBtnResult.push({color: CheckData.ButtonColorEnum.SUCCESS, icon: 'CircleCheckFilled'})
+              break;
+            case CheckData.ChnCheckResultEnum.FAIL:
+              tempChnBtnResult.push({color: CheckData.ButtonColorEnum.DANGER, icon: 'Close'})
+              break;
+            case CheckData.ChnCheckResultEnum.UNCONNECTED:
+              tempChnBtnResult.push({color: CheckData.ButtonColorEnum.WARNING, icon: 'Link'})
+              break;
+            case CheckData.ChnCheckResultEnum.ERRORDATA:
+              tempChnBtnResult.push({color: CheckData.ButtonColorEnum.WARNING, icon: 'WarnTriangleFilled'})
+              break;
+            default:
+              break;
           }
         }
       } else {
@@ -212,12 +252,27 @@ const checkResultView = computed(() => {
         if (device.chnResult.some(item => item == CheckData.ChnCheckResultEnum.FAIL)) {
           tempChnResult = CheckData.ChnCheckResultEnum.FAIL
         }
-        if (tempChnResult == CheckData.ChnCheckResultEnum.UNKNOWN) {
-          tempChnBtnResult.push({resultType: 'info', resultValue: '-'})
-        } else if (tempChnResult == CheckData.ChnCheckResultEnum.FAIL) {
-          tempChnBtnResult.push({resultType: 'danger', resultValue: '×'})
-        } else {
-          tempChnBtnResult.push({resultType: 'success', resultValue: '√'})
+        switch (tempChnResult) {
+          case CheckData.ChnCheckResultEnum.UNKNOWN:
+            tempChnBtnResult.push({color: CheckData.ButtonColorEnum.INFO, icon: 'Minus'})
+            break;
+          case CheckData.ChnCheckResultEnum.LOADING:
+            tempChnBtnResult.push({color: CheckData.ButtonColorEnum.LOADING, icon: 'Loading'})
+            break;
+          case CheckData.ChnCheckResultEnum.SUCCESS:
+            tempChnBtnResult.push({color: CheckData.ButtonColorEnum.SUCCESS, icon: 'CircleCheckFilled'})
+            break;
+          case CheckData.ChnCheckResultEnum.FAIL:
+            tempChnBtnResult.push({color: CheckData.ButtonColorEnum.DANGER, icon: 'Close'})
+            break;
+          case CheckData.ChnCheckResultEnum.UNCONNECTED:
+            tempChnBtnResult.push({color: CheckData.ButtonColorEnum.WARNING, icon: 'Link'})
+            break;
+          case CheckData.ChnCheckResultEnum.ERRORDATA:
+            tempChnBtnResult.push({color: CheckData.ButtonColorEnum.WARNING, icon: 'WarnTriangleFilled'})
+            break;
+          default:
+            break;
         }
       }
 
@@ -229,100 +284,253 @@ const checkResultView = computed(() => {
     })
     return temp
   })
-
   return result
 })
 
 watch(testStatus, function (newValue, oldValue) {
   if (newValue == 'start') {
+    startTimer() // todo 可移除
     emit('update:testStatus', 'process')
-    startTimer()
   }
   if (newValue == 'paused' && oldValue == 'process') {
     handlePauseOrContinue()
   }
   if (newValue === 'process' && oldValue == 'paused') {
+    activeIndex++
     handlePauseOrContinue()
   }
 })
 
 watch(webMsgSend, function (newValue, oldValue) {
-  if (activeIndex.value <= checkTotal.value) {
+  if (activeIndex <= checkTotal) {
     switch (newValue.requestId) {
-      case 'Test_Freq':
-        console.log('检测开始')
-        updateCheckResultView("Freq")
+      case 'Test_PreTest_Fail':
+        ElMessageBox.alert('预检测失败，请检查设备连接情况', '预检测失败', {
+          confirmButtonText: '确定',
+          type: 'error',
+        }).then(() => {
+          emit('update:testStatus', 'success')
+        })
         break;
-      case 'Test_VOL':
-        updateCheckResultView("VOL")
+      case 'Test_Pause_Success':
+        ElMessage.success('暂停成功')
+        emit('update:testStatus','paused')
         break;
-      case 'Test_Harm_V':
-        updateCheckResultView("Harm_V")
+      case 'Test_Pause_Fail':
+        ElMessage.error('暂停失败')
         break;
-      case 'Test_Harm_I':
-        updateCheckResultView("Harm_I")
+      case 'Test_Resume_Success':
+        ElMessage.success('开始继续检测')
+        emit('update:testStatus','process')
         break;
-      case 'Test_Harm_P':
-        updateCheckResultView("Harm_P")
+      case 'Test_Resume_Fail':
+        ElMessage.error('无法继续检测')
         break;
-      case 'Test_InHarm_V':
-        updateCheckResultView("InHarm_V")
+      case 'Test_VOL_Start':
+        updateCheckResultView("VOL", true)
+        updateLog(true)
         break;
-      case 'Test_InHarm_I':
-        updateCheckResultView("InHarm_I")
+      case 'Test_VOL_End':
+        updateCheckResultView("VOL", false)
+        updateLog(false)
+        updatePercentage()
+        if (testStatus.value != 'paused') {
+          activeIndex++
+          startTimer()
+        }
         break;
-      case 'Test_Dip':
-        updateCheckResultView("Dip")
+      case 'Test_Freq_Start':
+        updateCheckResultView("Freq", true)
+        updateLog(true)
         break;
-      case 'Test_CUR':
-        updateCheckResultView("CUR")
+      case 'Test_Freq_End':
+        updateCheckResultView("Freq", false)
+        updateLog(false)
+        updatePercentage()
+        if (testStatus.value != 'paused') {
+          activeIndex++;
+          startTimer()
+        }
         break;
-      case 'Test_MSQI_U':
-        updateCheckResultView("MSQI_U")
+      case 'Test_Harm_V_Start':
+        updateCheckResultView("Harm_V", true)
+        updateLog(true)
         break;
-      case 'Test_MSQI_I':
-        updateCheckResultView("MSQI_I")
+      case 'Test_Harm_V_End':
+        updateCheckResultView("Harm_V", false)
+        updateLog(false)
+        updatePercentage()
+        if (testStatus.value != 'paused') {
+          activeIndex++;
+          startTimer()
+        }
         break;
-      case 'Test_Flicker':
-        updateCheckResultView("Flicker")
+      case 'Test_Harm_I_Start':
+        updateCheckResultView("Harm_I", true)
+        updateLog(true)
+        break;
+      case 'Test_Harm_I_End':
+        updateCheckResultView("Harm_I", false)
+        updateLog(false)
+        updatePercentage()
+        if (testStatus.value != 'paused') {
+          activeIndex++;
+          startTimer()
+        }
+        break;
+      case 'Test_Harm_P_Start':
+        updateCheckResultView("Harm_P", true)
+        updateLog(true)
+        break;
+      case 'Test_Harm_P_End':
+        updateCheckResultView("Harm_P", false)
+        updateLog(false)
+        updatePercentage()
+        if (testStatus.value != 'paused') {
+          activeIndex++;
+          startTimer()
+        }
+        break;
+      case 'Test_InHarm_V_Start':
+        updateCheckResultView("InHarm_V", true)
+        updateLog(true)
+        break;
+      case 'Test_InHarm_V_End':
+        updateCheckResultView("InHarm_V", false)
+        updateLog(false)
+        updatePercentage()
+        if (testStatus.value != 'paused') {
+          activeIndex++;
+          startTimer()
+        }
+        break;
+      case 'Test_InHarm_I_Start':
+        updateCheckResultView("InHarm_I", true)
+        updateLog(true)
+        break;
+      case 'Test_InHarm_I_End':
+        updateCheckResultView("InHarm_I", false)
+        updateLog(false)
+        updatePercentage()
+        if (testStatus.value != 'paused') {
+          activeIndex++;
+          startTimer()
+        }
+        break;
+      case 'Test_Dip_Start':
+        updateCheckResultView("Dip", true)
+        updateLog(true)
+        break;
+      case 'Test_Dip_End':
+        updateCheckResultView("Dip", false)
+        updateLog(false)
+        updatePercentage()
+        if (testStatus.value != 'paused') {
+          activeIndex++;
+          startTimer()
+        }
+        break;
+      case 'Test_CUR_Start':
+        updateCheckResultView("CUR", true)
+        updateLog(true)
+        break;
+      case 'Test_CUR_End':
+        updateCheckResultView("CUR", false)
+        updateLog(false)
+        updatePercentage()
+        if (testStatus.value != 'paused') {
+          activeIndex++;
+          startTimer()
+        }
+        break;
+      case 'Test_MSQI_U_Start':
+        updateCheckResultView("MSQI_U", true)
+        updateLog(true)
+        break;
+      case 'Test_MSQI_U_End':
+        updateCheckResultView("MSQI_U", false)
+        updateLog(false)
+        updatePercentage()
+        if (testStatus.value != 'paused') {
+          activeIndex++;
+          startTimer()
+        }
+        break;
+      case 'Test_MSQI_I_Start':
+        updateCheckResultView("MSQI_I", true)
+        updateLog(true)
+        break;
+      case 'Test_MSQI_I_End':
+        updateCheckResultView("MSQI_I", false)
+        updateLog(false)
+        updatePercentage()
+        if (testStatus.value != 'paused') {
+          activeIndex++;
+          startTimer()
+        }
+        break;
+      case 'Test_Flicker_Start':
+        updateCheckResultView("Flicker", true)
+        updateLog(true)
+        break;
+      case 'Test_Flicker_End':
+        updateCheckResultView("Flicker", false)
+        updateLog(false)
+        updatePercentage()
+        if (testStatus.value != 'paused') {
+          activeIndex++;
+          startTimer()
+        }
         break;
       case 'Test_Quit':
+        updateLog(false)
+        updatePercentage()
         console.log('检测结束')
         break;
     }
-
-    updateLog()
-    activeIndex.value++;
-
-    if (percentage.value < 100) {
-      percentage.value = Math.trunc(activeIndex.value / checkTotal.value * 100);
-    } else {
-      percentage.value = 100;
-      clearInterval(timer.value)
-      timer.value = null;
-      emit('update:testStatus', 'success')
-
-      ElMessageBox.alert('检测全部结束,你可以停留在此页面查看检测结果，或返回首页进行复检、报告生成和归档等操作', '检测完成', {
-        // if you want to disable its autofocus
-        // autofocus: false,
-        confirmButtonText: '确定',
-      })
-      clear();
-    }
-  } else {
-    clearInterval(timer.value)
-    timer.value = null;
-    emit('update:testStatus', 'success')
-    scrollToBottom();
   }
 }, {deep: true})
 
+// 更新进度条
+const updatePercentage = () => {
+  if (activeIndex < checkTotal) {
+    percentage.value = Math.trunc(activeIndex / checkTotal * 100);
+  } else {
+    percentage.value = 100;
+    emit('update:testStatus', 'success')
+
+    ElMessageBox.alert('检测全部结束,你可以停留在此页面查看检测结果，或返回首页进行复检、报告生成和归档等操作', '检测完成', {
+      // if you want to disable its autofocus
+      // autofocus: false,
+      confirmButtonText: '确定',
+    })
+    clear();
+  }
+}
+
+// todo 可移除start
+let randomUnConnectedRaw = -1
+let randomUnConnectedDeviceId = -1
+let randomErrorDataRaw = -1
+// todo 可移除end
+
 onBeforeMount(() => {
   initScriptData()
   initDeviceList()
   initCheckResult()
+
+  // todo 可移除start
+  let a = getRandomInt(scriptData.length) + 4
+  randomUnConnectedRaw = a < scriptData.length ? a : scriptData.length
+  randomUnConnectedDeviceId = deviceList[getRandomInt(deviceList.length)].deviceId
+  randomErrorDataRaw = getRandomInt(scriptData.length) + 1
+  while (randomErrorDataRaw === randomUnConnectedRaw) {
+    randomErrorDataRaw = getRandomInt(scriptData.length) + 1
+  }
+  // todo 可移除end
 })
 
+
 const showTestLog = () => {
   drawer.value = true
 }
@@ -330,8 +538,8 @@ const showTestLog = () => {
 // 初始化检测脚本数据
 const initScriptData = () => {
   let map = new Map<string, string>()
-  map.set('Freq', '频率')
-      .set('VOL', '电压')
+  map.set('VOL', '电压')
+      .set('Freq', '频率')
       .set('Harm_V', '谐波电压')
       .set('Harm_I', '谐波电流')
       .set('Harm_P', '谐波有功功率')
@@ -344,8 +552,8 @@ const initScriptData = () => {
       .set('Flicker', '短时闪变')
 
   let response: CheckData.ScriptItem[] = [
-    {id: '1', code: 'Freq', scriptName: '频率准确度检测'},
-    {id: '2', code: 'VOL', scriptName: '电压准确度检测'},
+    {id: '1', code: 'VOL', scriptName: '电压准确度检测'},
+    {id: '2', code: 'Freq', scriptName: '频率准确度检测'},
     {id: '3', code: 'Harm_V', scriptName: '谐波电压准确度检测'},
     {id: '4', code: 'Harm_I', scriptName: '谐波电流准确度检测'},
     {id: '5', code: 'Harm_P', scriptName: '谐波有功功率准确度检测'},
@@ -366,7 +574,7 @@ const initScriptData = () => {
   })
 
   scriptData.push(...temp)
-  checkTotal.value = scriptData.length + 1
+  checkTotal = scriptData.length + 1
 }
 // 初始化设备列表
 const initDeviceList = () => {
@@ -416,8 +624,8 @@ const updateCheckResult = (data: CheckData.ScriptChnItem) => {
 }
 
 const scrollToBottom = () => {
-  if (scrollContainer.value) {
-    scrollContainer.value.scrollTop = scrollContainer.value.scrollHeight;
+  if (scrollContainerRef.value) {
+    scrollContainerRef.value.scrollTop = scrollContainerRef.value.scrollHeight;
   }
 };
 
@@ -427,11 +635,11 @@ function getRandomInt(max: number): number {
 
 //判断该检测项（例如 频率准确度检测）是否全部合格（所有设备所有通道所有子检测项目全部合格为合格，否则为不合格）
 function getItemCheckResult(scriptId: string): boolean {
-  let items = errorCheckItem.filter((item) => item === scriptId)
+  let items = errorCheckItem.filter((item) => item.scriptId === scriptId)
   if (items.length > 0) {
-    return false
-  } else {
     return true
+  } else {
+    return false
   }
 }
 
@@ -456,268 +664,82 @@ function getTimeDifference(timeDifference: number): string {
 }
 
 // 更新日志
-const updateLog = () => {
+const updateLog = (isStart: boolean) => {
   const currentTime = ref(new Date().toLocaleString());
   let timeDifferenceItem = 0
 
-  switch (activeIndex.value) {
-    case 1:
-      timeDifference.value = 0;
-      testLogList.value.length = 0; // 清空数组
-      testLogList.value.push({
-        type: 'info',
-        log: currentTime.value + '：检测开始',
-      })
-      startData.value = new Date();
-      break;
-    case 2:
-      endData.value = new Date();
-      timeDifferenceItem = endData.value.getTime() - startData.value.getTime();
-      timeDifference.value += timeDifferenceItem
-      if (getItemCheckResult(scriptData[activeIndex.value - 2].id)) {
-        testLogList.value.push({
-          type: 'info',
-          log: currentTime.value + '：频率准确度检测合格，用时' + getTimeDifference(timeDifferenceItem),
-        })
-      } else {
-        testLogList.value.push({
-          type: 'error',
-          log: currentTime.value + '：频率准确度检测不合格，用时' + getTimeDifference(timeDifferenceItem),
-        })
-      }
-      startData.value = new Date();
-      break;
-    case 3:
-      endData.value = new Date();
-      timeDifferenceItem = endData.value.getTime() - startData.value.getTime();
-      timeDifference.value += timeDifferenceItem
-      if (getItemCheckResult(scriptData[activeIndex.value - 2].id)) {
-        testLogList.value.push({
-          type: 'info',
-          log: currentTime.value + '：电压准确度检测合格，用时' + getTimeDifference(timeDifferenceItem),
-        })
-      } else {
-        testLogList.value.push({
-          type: 'error',
-          log: currentTime.value + '：电压准确度检测不合格，用时' + getTimeDifference(timeDifferenceItem),
-        })
-      }
-      startData.value = new Date();
-      break;
-    case 4:
-      endData.value = new Date();
-      timeDifferenceItem = endData.value.getTime() - startData.value.getTime();
-      timeDifference.value += timeDifferenceItem
-      if (getItemCheckResult(scriptData[activeIndex.value - 2].id)) {
-        testLogList.value.push({
-          type: 'info',
-          log: currentTime.value + '：谐波电压准确度检测合格，用时' + getTimeDifference(timeDifferenceItem),
-        })
-      } else {
-        testLogList.value.push({
-          type: 'error',
-          log: currentTime.value + '：谐波电压准确度检测不合格，用时' + getTimeDifference(timeDifferenceItem),
-        })
-      }
-      startData.value = new Date();
-      break;
-    case 5:
-      endData.value = new Date();
-      timeDifferenceItem = endData.value.getTime() - startData.value.getTime();
-      timeDifference.value += timeDifferenceItem
-      if (getItemCheckResult(scriptData[activeIndex.value - 2].id)) {
-        testLogList.value.push({
-          type: 'info',
-          log: currentTime.value + '：谐波电流准确度检测合格，用时' + getTimeDifference(timeDifferenceItem),
-        })
-      } else {
-        testLogList.value.push({
-          type: 'error',
-          log: currentTime.value + '：谐波电流准确度检测不合格，用时' + getTimeDifference(timeDifferenceItem),
-        })
-      }
-      startData.value = new Date();
-      break;
-    case 6:
-      endData.value = new Date();
-      timeDifferenceItem = endData.value.getTime() - startData.value.getTime();
-      timeDifference.value += timeDifferenceItem
-      if (getItemCheckResult(scriptData[activeIndex.value - 2].id)) {
-        testLogList.value.push({
-          type: 'info',
-          log: currentTime.value + '：谐波有功功率准确度检测合格，用时' + getTimeDifference(timeDifferenceItem),
-        })
-      } else {
-        testLogList.value.push({
-          type: 'error',
-          log: currentTime.value + '：谐波有功功率准确度检测不合格，用时' + getTimeDifference(timeDifferenceItem),
-        })
-      }
-      startData.value = new Date();
-      break;
-    case 7:
-      endData.value = new Date();
-      timeDifferenceItem = endData.value.getTime() - startData.value.getTime();
-      timeDifference.value += timeDifferenceItem
-      if (getItemCheckResult(scriptData[activeIndex.value - 2].id)) {
-        testLogList.value.push({
-          type: 'info',
-          log: currentTime.value + '：间谐波电压准确度检测合格，用时' + getTimeDifference(timeDifferenceItem),
-        })
-      } else {
-        testLogList.value.push({
-          type: 'error',
-          log: currentTime.value + '：间谐波电压准确度检测不合格，用时' + getTimeDifference(timeDifferenceItem),
-        })
-      }
-      startData.value = new Date();
-      break;
-    case 8:
-      endData.value = new Date();
-      timeDifferenceItem = endData.value.getTime() - startData.value.getTime();
-      timeDifference.value += timeDifferenceItem
-      if (getItemCheckResult(scriptData[activeIndex.value - 2].id)) {
-        testLogList.value.push({
-          type: 'info',
-          log: currentTime.value + '：间谐波电流准确度检测合格，用时' + getTimeDifference(timeDifferenceItem),
-        })
-      } else {
-        testLogList.value.push({
-          type: 'error',
-          log: currentTime.value + '：间谐波电流准确度检测不合格，用时' + getTimeDifference(timeDifferenceItem),
-        })
-      }
-      startData.value = new Date();
-      break;
-    case 9:
-      endData.value = new Date();
-      timeDifferenceItem = endData.value.getTime() - startData.value.getTime();
-      timeDifference.value += timeDifferenceItem
-      if (getItemCheckResult(scriptData[activeIndex.value - 2].id)) {
-        testLogList.value.push({
-          type: 'info',
-          log: currentTime.value + '：暂态准确度检测合格，用时' + getTimeDifference(timeDifferenceItem),
-        })
-      } else {
-        testLogList.value.push({
-          type: 'error',
-          log: currentTime.value + '：暂态准确度检测不合格，用时' + getTimeDifference(timeDifferenceItem),
-        })
-      }
-      startData.value = new Date();
-      break;
-    case 10:
-      endData.value = new Date();
-      timeDifferenceItem = endData.value.getTime() - startData.value.getTime();
-      timeDifference.value += timeDifferenceItem
-      if (getItemCheckResult(scriptData[activeIndex.value - 2].id)) {
-        testLogList.value.push({
-          type: 'info',
-          log: currentTime.value + '：电流准确度检测合格，用时' + getTimeDifference(timeDifferenceItem),
-        })
-      } else {
-        testLogList.value.push({
-          type: 'error',
-          log: currentTime.value + '：电流准确度检测不合格，用时' + getTimeDifference(timeDifferenceItem),
-        })
-      }
-      startData.value = new Date();
-      break;
-    case 11:
-      endData.value = new Date();
-      timeDifferenceItem = endData.value.getTime() - startData.value.getTime();
-      timeDifference.value += timeDifferenceItem
-      if (getItemCheckResult(scriptData[activeIndex.value - 2].id)) {
-        testLogList.value.push({
-          type: 'info',
-          log: currentTime.value + '：电压不平衡度检测合格，用时' + getTimeDifference(timeDifferenceItem),
-        })
-      } else {
-        testLogList.value.push({
-          type: 'error',
-          log: currentTime.value + '：电压不平衡度检测不合格，用时' + getTimeDifference(timeDifferenceItem),
-        })
-      }
-      startData.value = new Date();
-      break;
-    case 12:
-      endData.value = new Date();
-      timeDifferenceItem = endData.value.getTime() - startData.value.getTime();
-      timeDifference.value += timeDifferenceItem
-      if (getItemCheckResult(scriptData[activeIndex.value - 2].id)) {
-        testLogList.value.push({
-          type: 'info',
-          log: currentTime.value + '：电流不平衡度检测合格，用时' + getTimeDifference(timeDifferenceItem),
-        })
-      } else {
-        testLogList.value.push({
-          type: 'error',
-          log: currentTime.value + '：电流不平衡度检测不合格，用时' + getTimeDifference(timeDifferenceItem),
-        })
-      }
-      startData.value = new Date();
-      break;
-    case 13:
-      endData.value = new Date();
-      timeDifferenceItem = endData.value.getTime() - startData.value.getTime();
-      timeDifference.value += timeDifferenceItem
-      if (getItemCheckResult(scriptData[activeIndex.value - 2].id)) {
-        testLogList.value.push({
-          type: 'info',
-          log: currentTime.value + '：闪变准确度检测合格，用时' + getTimeDifference(timeDifferenceItem),
-        })
-      } else {
-        testLogList.value.push({
-          type: 'error',
-          log: currentTime.value + '：闪变准确度检测不合格，用时' + getTimeDifference(timeDifferenceItem),
-        })
-      }
-
-      testLogList.value.push({
-        type: 'info',
-        log: currentTime.value + '：检测结束，总用时' + getTimeDifference(timeDifference.value),
-      })
-      break;
+  if (activeIndex === 1 && isStart) {
+    timeDifference.value = 0;
+    testLogList.length = 0; // 清空数组
   }
+  // debugger
+  if (activeIndex < checkTotal) {
+    if (isStart) {
+      startData.value = new Date();
+      testLogList.push({
+        type: 'info',
+        log: currentTime.value + ` ：${scriptData[activeIndex - 1].scriptName}准确度检测：开始`,
+      })
+    } else {
+      endData.value = new Date();
+      timeDifferenceItem = endData.value.getTime() - startData.value.getTime();
+      timeDifference.value += timeDifferenceItem
+
+      if (getItemCheckResult(scriptData[activeIndex - 1].id)) {
+        testLogList.push({
+          type: 'error',
+          log: currentTime.value + ` ：${scriptData[activeIndex - 1].scriptName}准确度检测结束：不符合，用时` + getTimeDifference(timeDifferenceItem),
+        })
+      } else {
+        testLogList.push({
+          type: 'info',
+          log: currentTime.value + ` ：${scriptData[activeIndex - 1].scriptName}准确度检测结束：符合，用时` + getTimeDifference(timeDifferenceItem),
+        })
+      }
+    }
+  } else {
+    testLogList.push({
+      type: 'info',
+      log: currentTime.value + ' ：检测结束，总用时' + getTimeDifference(timeDifference.value),
+    })
+  }
+
   scrollToBottom();
 }
 
 // 动态获取表格单元格样式
-function tableCell({row, columnIndex}) {
-  let items = errorCheckItem.filter((item) => item === row.scriptId)
+// function tableCell({row, columnIndex}) {
+//   let items = errorCheckItem.filter((item) => item === row.scriptId)
+//
+//   if (columnIndex === 0 && items.length > 0) {
+//     return 'warning-row'
+//   }
+//   if (columnIndex === 0) {
+//     return 'header-row'
+//   }
+// }
 
-  if (columnIndex === 0 && items.length > 0) {
-    return 'warning-row'
-  }
-  if (columnIndex === 0) {
-    return 'header-row'
-  }
-}
-
-const updateCheckResultView = (scriptCode: string) => {
+const updateCheckResultView = (scriptCode: string, isStart: boolean) => {
+  // debugger
   let scriptId = scriptData.filter(item => item.code === scriptCode)[0]?.id
-  let temp = simulateCheck(scriptId)
+  let temp = null
+  if (isStart) {
+    temp = getLoadingResult(scriptId)
+  } else {
+    temp = getCheckResult(scriptId)
+  }
   updateCheckResult(temp)
 };
 
-// 模拟检测 todo 可移除
-const simulateCheck = (scriptId: string) => {
+// 获取loading状态的结果
+const getLoadingResult = (scriptId: string) => {
   let devices = []
 
   devices = deviceList.map(item => {
 
     let tempChnResult: CheckData.ChnCheckResultEnum[] = []
     for (let i = 0; i < item.chnNum; i++) {
-      tempChnResult.push(CheckData.ChnCheckResultEnum.SUCCESS)
-    }
-
-    let randomNum = getRandomInt(item.chnNum * 2)
-    if (activeIndex.value >= 4 && activeIndex.value <= 6) {
-      if (randomNum < item.chnNum) {
-        tempChnResult[randomNum] = CheckData.ChnCheckResultEnum.FAIL
-
-        errorCheckItem.push(scriptId)
-      }
+      tempChnResult.push(CheckData.ChnCheckResultEnum.LOADING)
     }
 
     return {
@@ -735,6 +757,97 @@ const simulateCheck = (scriptId: string) => {
   return tempScriptChnItem
 }
 
+
+// 模拟检测 todo 可移除
+const getCheckResult = (scriptId: string) => {
+  // debugger
+  let devices = []
+
+  if (activeIndex === randomErrorDataRaw) {
+    devices = deviceList.map(item => {
+      let tempChnResult: CheckData.ChnCheckResultEnum[] = []
+      if (item.deviceId === randomUnConnectedDeviceId && activeIndex >= randomUnConnectedRaw) {
+        for (let i = 0; i < item.chnNum; i++) {
+          tempChnResult.push(CheckData.ChnCheckResultEnum.UNCONNECTED)
+          //errorCheckItem.push({scriptId,type:'warning'})
+        }
+      } else {
+        for (let i = 0; i < item.chnNum; i++) {
+          tempChnResult.push(CheckData.ChnCheckResultEnum.ERRORDATA)
+          //errorCheckItem.push({scriptId,type:'warning'})
+        }
+      }
+
+      return {
+        deviceId: item.deviceId,
+        deviceName: item.deviceName,
+        chnResult: tempChnResult,
+      }
+    })
+  } else {
+    devices = deviceList.map(item => {
+      let tempChnResult: CheckData.ChnCheckResultEnum[] = []
+      if (item.deviceId === randomUnConnectedDeviceId && activeIndex >= randomUnConnectedRaw) {
+        for (let i = 0; i < item.chnNum; i++) {
+          tempChnResult.push(CheckData.ChnCheckResultEnum.UNCONNECTED)
+          //errorCheckItem.push({scriptId,type:'warning'})
+        }
+      } else {
+        for (let i = 0; i < item.chnNum; i++) {
+          tempChnResult.push(CheckData.ChnCheckResultEnum.SUCCESS)
+        }
+        let randomNum = getRandomInt(item.chnNum * 2)
+        if (randomNum < item.chnNum && activeIndex >= 4 && activeIndex <= 8) {
+          tempChnResult[randomNum] = CheckData.ChnCheckResultEnum.FAIL
+          errorCheckItem.push({scriptId, type: 'error'})
+        }
+      }
+
+      return {
+        deviceId: item.deviceId,
+        deviceName: item.deviceName,
+        chnResult: tempChnResult,
+      }
+    })
+  }
+
+
+  // devices = deviceList.map(item => {
+  //
+  //   let tempChnResult: CheckData.ChnCheckResultEnum[] = []
+  //   for (let i = 0; i < item.chnNum; i++) {
+  //     tempChnResult.push(CheckData.ChnCheckResultEnum.SUCCESS)
+  //   }
+  //
+  //   let randomNum = getRandomInt(item.chnNum * 2)
+  //   if (activeIndex >= 2 && activeIndex <= 8) {
+  //     if (randomNum % 3 === 0) {
+  //       let a = getRandomInt(2) === 1 ? CheckData.ChnCheckResultEnum.ERRORDATA : CheckData.ChnCheckResultEnum.UNCONNECTED
+  //       tempChnResult.splice(tempChnResult.length - 1 - item.chnNum, item.chnNum, CheckData.ChnCheckResultEnum.ERRORDATA)
+  //     }else{
+  //       if (randomNum < item.chnNum) {
+  //         tempChnResult[randomNum] = (randomNum % 2) + 1
+  //
+  //         errorCheckItem.push(scriptId)
+  //       }
+  //     }
+  //   }
+  //
+  //   return {
+  //     deviceId: item.deviceId,
+  //     deviceName: item.deviceName,
+  //     chnResult: tempChnResult,
+  //   }
+  // })
+
+  let tempScriptChnItem: CheckData.ScriptChnItem = {
+    scriptId,
+    devices,
+  }
+
+  return tempScriptChnItem
+}
+
 // 处理暂停、继续按钮点击事件
 const handlePauseOrContinue = () => {
   const currentTime = ref(new Date().toLocaleString());
@@ -744,19 +857,20 @@ const handlePauseOrContinue = () => {
     const Pausetime = endData.value.getTime() - startData.value.getTime();
     timeDifference.value += Pausetime
 
-    testLogList.value.push({
+    testLogList.push({
       type: 'info',
       log: currentTime.value + '：暂停检测',
     })
-    pauseTimer()
+    console.log('暂停中')
   }
   if (testStatus.value == "process") {
     startData.value = new Date();
-    testLogList.value.push({
+    testLogList.push({
       type: 'info',
       log: currentTime.value + '：继续检测',
     })
-    resumeTimer()
+    startTimer()
+    console.log('开始继续检测')
   }
 };
 
@@ -765,110 +879,172 @@ const handleClick = (scriptId: string, deviceId: any, chnNum: number) => {
   dataCheckSingleChannelSingleTestPopupRef.value?.open(deviceId, chnNum, scriptId);
 };
 
+// todo 可移除
 const startTimer = () => {
-  if (activeIndex.value === 0) {
-    activeIndex.value++;
+  console.log('开始检测第' + activeIndex + '项')
+  switch (activeIndex) {
+    case 1:
+      emit('update:webMsgSend', {
+        requestId: 'Test_VOL_Start',
+        params: {}
+      })
+      setTimeout(() => {
+        emit('update:webMsgSend', {
+          requestId: 'Test_VOL_End',
+          params: {}
+        })
+      }, 2000);
+      break;
+    case 2:
+      emit('update:webMsgSend', {
+        requestId: 'Test_Freq_Start',
+        params: {}
+      })
+      setTimeout(() => {
+        emit('update:webMsgSend', {
+          requestId: 'Test_Freq_End',
+          params: {}
+        })
+      }, 2000);
+      break;
+
+    case 3:
+      emit('update:webMsgSend', {
+        requestId: 'Test_Harm_V_Start',
+        params: {}
+      })
+      setTimeout(() => {
+        emit('update:webMsgSend', {
+          requestId: 'Test_Harm_V_End',
+          params: {}
+        })
+      }, 2000)
+      break;
+    case 4:
+      emit('update:webMsgSend', {
+        requestId: 'Test_Harm_I_Start',
+        params: {}
+      })
+      setTimeout(() => {
+        emit('update:webMsgSend', {
+          requestId: 'Test_Harm_I_End',
+          params: {}
+        })
+      }, 2000)
+      break;
+    case 5:
+      emit('update:webMsgSend', {
+        requestId: 'Test_Harm_P_Start',
+        params: {}
+      })
+      setTimeout(() => {
+        emit('update:webMsgSend', {
+          requestId: 'Test_Harm_P_End',
+          params: {}
+        })
+      }, 2000)
+      break;
+    case 6:
+      emit('update:webMsgSend', {
+        requestId: 'Test_InHarm_V_Start',
+        params: {}
+      })
+      setTimeout(() => {
+        emit('update:webMsgSend', {
+          requestId: 'Test_InHarm_V_End',
+          params: {}
+        })
+      }, 2000)
+      break;
+    case 7:
+      emit('update:webMsgSend', {
+        requestId: 'Test_InHarm_I_Start',
+        params: {}
+      })
+      setTimeout(() => {
+        emit('update:webMsgSend', {
+          requestId: 'Test_InHarm_I_End',
+          params: {}
+        })
+      }, 2000)
+      break;
+    case 8:
+      emit('update:webMsgSend', {
+        requestId: 'Test_Dip_Start',
+        params: {}
+      })
+      setTimeout(() => {
+        emit('update:webMsgSend', {
+          requestId: 'Test_Dip_End',
+          params: {}
+        })
+      }, 2000)
+      break;
+    case 9:
+      emit('update:webMsgSend', {
+        requestId: 'Test_CUR_Start',
+        params: {}
+      })
+      setTimeout(() => {
+        emit('update:webMsgSend', {
+          requestId: 'Test_CUR_End',
+          params: {}
+        })
+      }, 2000)
+      break;
+    case 10:
+      emit('update:webMsgSend', {
+        requestId: 'Test_MSQI_U_Start',
+        params: {}
+      })
+      setTimeout(() => {
+        emit('update:webMsgSend', {
+          requestId: 'Test_MSQI_U_End',
+          params: {}
+        })
+      }, 2000)
+      break;
+    case 11:
+      emit('update:webMsgSend', {
+        requestId: 'Test_MSQI_I_Start',
+        params: {}
+      })
+      setTimeout(() => {
+        emit('update:webMsgSend', {
+          requestId: 'Test_MSQI_I_End',
+          params: {}
+        }, 2000)
+      })
+      break;
+    case 12:
+      emit('update:webMsgSend', {
+        requestId: 'Test_Flicker_Start',
+        params: {}
+      })
+      setTimeout(() => {
+        emit('update:webMsgSend', {
+          requestId: 'Test_Flicker_End',
+          params: {}
+        })
+      }, 2000)
+      break;
+    case 13:
+      emit('update:webMsgSend', {
+        requestId: 'Test_Quit',
+        params: {}
+      })
+      break;
   }
-  //if (timer.value !== null) return; // 如果定时器已经启动，则不再重复启动
-  timer.value = setInterval(() => {
-    if (activeIndex.value <= checkTotal.value) {
-      switch (activeIndex.value) {
-        case 1:
-          emit('update:webMsgSend', {
-            requestId: 'Test_Freq',
-            params: {}
-          })
-          break;
-        case 2:
-          emit('update:webMsgSend', {
-            requestId: 'Test_VOL',
-            params: {}
-          })
-          break;
-        case 3:
-          emit('update:webMsgSend', {
-            requestId: 'Test_Harm_V',
-            params: {}
-          })
-          break;
-        case 4:
-          emit('update:webMsgSend', {
-            requestId: 'Test_Harm_I',
-            params: {}
-          })
-          break;
-        case 5:
-          emit('update:webMsgSend', {
-            requestId: 'Test_Harm_P',
-            params: {}
-          })
-          break;
-        case 6:
-          emit('update:webMsgSend', {
-            requestId: 'Test_InHarm_V',
-            params: {}
-          })
-          break;
-        case 7:
-          emit('update:webMsgSend', {
-            requestId: 'Test_InHarm_I',
-            params: {}
-          })
-          break;
-        case 8:
-          emit('update:webMsgSend', {
-            requestId: 'Test_Dip',
-            params: {}
-          })
-          break;
-        case 9:
-          emit('update:webMsgSend', {
-            requestId: 'Test_CUR',
-            params: {}
-          })
-          break;
-        case 10:
-          emit('update:webMsgSend', {
-            requestId: 'Test_MSQI_U',
-            params: {}
-          })
-          break;
-        case 11:
-          emit('update:webMsgSend', {
-            requestId: 'Test_MSQI_I',
-            params: {}
-          })
-          break;
-        case 12:
-          emit('update:webMsgSend', {
-            requestId: 'Test_Flicker',
-            params: {}
-          })
-          break;
-        case 13:
-          emit('update:webMsgSend', {
-            requestId: 'Test_Quit',
-            params: {}
-          })
-          break;
-      }
-    }
-  }, 2000);
 };
 
-const pauseTimer = () => {
-  if (timer.value) {
-    clearInterval(timer.value);
-    timer.value = null;
-  }
-  console.log('暂停中')
+const handlePauseTest = () => {
+  // 发送暂停指令
+  emit('sendPause')
 };
 
-const resumeTimer = () => {
-  if (!timer.value) {
-    startTimer();
-  }
-  console.log('开始继续检测')
+const handleResumeTest = () => {
+  // 发送继续检测指令
+  emit('sendResume')
 };
 
 //完成检测
@@ -878,17 +1054,20 @@ const handleFinishTest = () => {
 };
 
 const handleReCheck = () => {
-  activeIndex.value = 0;
+  activeIndex = 1;
   percentage.value = 0;
-  // tableData.value.length = 0;
-  testLogList.value.length = 0;
+  testLogList.length = 0;
   errorCheckItem.length = 0;
-  //tableData.value = JSON.parse(JSON.stringify(operatorTableData.value));
-  resumeTimer()
+  // resumeTimer()
 };
 
 function clear() {
+  errorCheckItem.length = 0;
 }
+
+defineExpose({
+  clear,
+})
 </script>
 
 <style scoped lang="scss">
@@ -958,8 +1137,9 @@ function clear() {
     font-size: 14px;
   }
 }
-.drawer-container{
-  :deep(header.el-drawer__header){
+
+.drawer-container {
+  :deep(header.el-drawer__header) {
     color: #fff !important;
     background-color: #003078 !important;
 
@@ -967,12 +1147,26 @@ function clear() {
       color: #ccc !important;
     }
 
-    .el-drawer__title{
+    .el-drawer__title {
       color: #fff !important;
     }
   }
 }
 
+.loading-box {
+  animation: loading 1.5s linear infinite;
+}
+
+@keyframes loading {
+  from {
+    transform: rotate(0deg);
+  }
+  to {
+    transform: rotate(360deg);
+  }
+}
+
+
 //:deep(.el-drawer .el-drawer__title){
 //  background-color: #003078 !important;
 //}
diff --git a/frontend/src/views/home/components/testPopup.vue b/frontend/src/views/home/components/testPopup.vue
index 35ab4df..90d9f7e 100644
--- a/frontend/src/views/home/components/testPopup.vue
+++ b/frontend/src/views/home/components/testPopup.vue
@@ -17,7 +17,7 @@
         <preTest ref="preTestRef" v-if="stepsActiveIndex === 0" v-model:testStatus="preTestStatus" :webMsgSend="webMsgSend"></preTest>
         <timeTest v-if="stepsActiveIndex === 1 && isTimeCheck" v-model:testStatus="timeTestStatus"></timeTest>
         <!-- <channelsTest v-if="stepsActiveIndex === 2" v-model:testStatus="channelsTestStatus"></channelsTest> -->
-        <test v-if="stepsActiveIndex >= 2" v-model:testStatus="TestStatus" :webMsgSend="webMsgSend" @update:webMsgSend="webMsgSend=$event"></test>
+        <test ref="testRef" v-if="stepsActiveIndex >= 2" v-model:testStatus="TestStatus" :webMsgSend="webMsgSend" @update:webMsgSend="webMsgSend=$event" @sendPause="sendPause" @sendResume="sendResume"></test>
 
         <template #footer>
             <div>
@@ -146,18 +146,20 @@ const detectionOptions = ref([
   const dialogTitle = ref('');
   const isTimeCheck = ref(false)
   const preTestRef = ref(null);
+  const testRef = ref(null);
+
+  // const devIdArr = ref([])
+  // const planId = ref('')
 
-  const devIdArr = ref([])
-  const planId = ref('')
 
   // 打开弹窗，可能是新增，也可能是编辑
   const open = (selection: Device.ResPqDev[],title: string,time:boolean) => {
 
 
     const checkStates = selection.map(item => item.checkState);
-    devIdArr.value = selection.map(item => item.id);
-    planId.value =selection[0].planId
-    console.log('wwwwwwwwwwwwwwwww',selection)
+    // devIdArr.value = selection.map(item => item.id);
+    // planId.value =selection[0].planId
+    // console.log('wwwwwwwwwwwwwwwww',selection)
 
     const allCheckStatesEqual = new Set(checkStates).size <= 1;
 
@@ -206,13 +208,18 @@ const detectionOptions = ref([
     });
 
 
+
+
   }
 
   let loading;
   const handleSubmit = () => {
     skipDisabled.value = true
     console.log('=============',stepsActiveIndex.value)
+
     let deviceIds = checkStore.devices.map((item) => item.deviceId)
+    let planId = checkStore.planId
+
     switch (stepsActiveIndex.value) {
       case 0:
         preTestStatus.value = 'start'
@@ -225,8 +232,9 @@ const detectionOptions = ref([
          })*/
         startPreTest({
           userPageId: "cdf",
-          devIds:devIdArr.value,
-          planId:planId.value
+          devIds:deviceIds,
+          planId:planId,
+          operateType:'0' // '0'为预检测、‘1‘为正式检测
         }).then(res=>{
 
 
@@ -243,27 +251,32 @@ const detectionOptions = ref([
           // startTest({deviceIds}).then(res => {
           //   console.log(res)
           //   if (res.code === 20000) {
-          //     TestStatus.value = 'process'
+          //     TestStatus.value = 'start'
+          //     webMsgSend.value = ''
           //   } else {
           //     ElMessage.error(res.message)
           //   }
           // })
           TestStatus.value = 'start'
         } else if (TestStatus.value == 'process') {
+          // 发送暂停指令
           // pauseTest({deviceIds}).then(res => {
           //   console.log(res)
           //   if (res.code === 20000) {
           //     TestStatus.value = 'paused'
+          // webMsgSend.value = ''
           //   } else {
           //     ElMessage.error(res.message)
           //   }
           // })
           TestStatus.value = 'paused'
         } else if (TestStatus.value == 'paused') {
+          // 发送继续指令
           // resumeTest({deviceIds}).then(res => {
           //   console.log(res)
           //   if (res.code === 20000) {
           //     TestStatus.value = 'process'
+          // webMsgSend.value = ''
           //   } else {
           //     ElMessage.error(res.message)
           //   }
@@ -316,6 +329,14 @@ const detectionOptions = ref([
     }
   })
 
+  const sendPause = () => {
+    console.log('发送暂停指令')
+
+  }
+  const sendResume = () => {
+    console.log('发送继续检测指令')
+  }
+
 const getIcon = (index: number) => {
   if (stepsActiveIndex.value > index) return SuccessFilled;
   switch (index) {
@@ -393,7 +414,7 @@ const getIcon = (index: number) => {
   const handleCancel = () => {
     // clearData()
     // emit('update:visible', false); // 关闭对话框
-    
+    testRef.value?.clear()
   };