diff --git a/src/views/base/warning/components/form-warning.vue b/src/views/base/warning/components/form-warning.vue
index 01cd48f..d428d56 100644
--- a/src/views/base/warning/components/form-warning.vue
+++ b/src/views/base/warning/components/form-warning.vue
@@ -396,7 +396,8 @@ export default {
                     }
                     const valueTemp = parseFloat(value);
                     // 检查前导零（例如 '0000' 或 '000.000000'）
-                    if (value !== valueTemp.toString() || valueTemp.toString() === "0") {
+                    // if(valueTemp.toString()==="0")
+                    if (value !== valueTemp.toString() && value !== "0") {
                       return callback(new Error('请输入0~100内的数据且小数点后最多保留六位'));
                     }
                     if(valueTemp.toString().includes('.')==true){
@@ -432,6 +433,11 @@ export default {
                       return callback(new Error('请勿输入非数字'));
                     }
                     const valueTemp = parseFloat(value);
+                    // 检查前导零（例如 '0000' 或 '000.000000'）
+                    // if(valueTemp.toString()==="0")
+                    if (value !== valueTemp.toString() && value !== "0") {
+                      return callback(new Error('请输入0~100内的数据且小数点后最多保留六位'));
+                    }
                     if(valueTemp.toString().includes('.')==true){
                       if (valueTemp < 0 || valueTemp > 100 ||valueTemp.toString().split(".")[1].length>6) {
                       callback(new Error('请输入0~100内的数据且小数点后最多保留六位'));
@@ -458,25 +464,34 @@ export default {
                 {
                   validator: (rule, value, callback) => {
                     if (value === '' || value === null) {
-                      return callback(new Error('请正确输入噪声阈值(小数点后最多保留六位)'));
+                      return callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
                     }
                     const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
                     if(!regexTwo.test(value)){
                       return callback(new Error('请勿输入非数字'));
                     }
                     const valueTemp = parseFloat(value);
+                    // 检查前导零（例如 '0000' 或 '000.000000'）
+                    // if(valueTemp.toString()==="0")
+                    if (value !== valueTemp.toString() && value !== "0") {
+                      return callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
+                    }
                     if(valueTemp.toString().includes('.')==true){
-                      if (valueTemp.toString().split(".")[1].length>6) {
-                      callback(new Error('请正确输入噪声阈值(小数点后最多保留六位)'));
+                      if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>6) {
+                      callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
                     } else {
                       callback();
                     }
                     }else{
+                      if (valueTemp < 0 ) {
+                      callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
+                    } else {
                       callback();
+                    }
                   }
-                },
                   trigger: 'blur'
                 }
+              }
               ],
               configVal3Max: [
                 {
@@ -487,25 +502,34 @@ export default {
                 {
                   validator: (rule, value, callback) => {
                     if (value === '' || value === null) {
-                      return callback(new Error('请正确输入噪声阈值(小数点后最多保留六位)'));
+                      return callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
                     }
                     const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
                     if(!regexTwo.test(value)){
                       return callback(new Error('请勿输入非数字'));
                     }
                     const valueTemp = parseFloat(value);
+                    // 检查前导零（例如 '0000' 或 '000.000000'）
+                    // if(valueTemp.toString()==="0")
+                    if (value !== valueTemp.toString() && value !== "0") {
+                      return callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
+                    }
                     if(valueTemp.toString().includes('.')==true){
-                      if (valueTemp.toString().split(".")[1].length>6) {
-                      callback(new Error('请正确输入噪声阈值(小数点后最多保留六位)'));
+                      if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>6) {
+                      callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
                     } else {
                       callback();
                     }
                     }else{
+                      if (valueTemp < 0 ) {
+                      callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
+                    } else {
                       callback();
+                    }
                   }
-                },
                   trigger: 'blur'
                 }
+              }
               ],
               configVal4Min: [
                 {
@@ -516,25 +540,34 @@ export default {
                 {
                   validator: (rule, value, callback) => {
                     if (value === '' || value === null) {
-                      return callback(new Error('请正确输入PM2.5阈值(小数点后最多保留六位)'));
+                      return callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
                     }
                     const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
                     if(!regexTwo.test(value)){
                       return callback(new Error('请勿输入非数字'));
                     }
                     const valueTemp = parseFloat(value);
+                    // 检查前导零（例如 '0000' 或 '000.000000'）
+                    // if(valueTemp.toString()==="0")
+                    if (value !== valueTemp.toString() && value !== "0") {
+                      return callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
+                    }
                     if(valueTemp.toString().includes('.')==true){
-                      if (valueTemp.toString().split(".")[1].length>6) {
-                      callback(new Error('请正确输入PM2.5阈值(小数点后最多保留六位)'));
+                      if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>6) {
+                      callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
                     } else {
                       callback();
                     }
                     }else{
+                      if (valueTemp < 0 ) {
+                      callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
+                    } else {
                       callback();
+                    }
                   }
-                },
                   trigger: 'blur'
                 }
+              }
               ],
               configVal4Max: [
                 {
@@ -545,25 +578,34 @@ export default {
                 {
                   validator: (rule, value, callback) => {
                     if (value === '' || value === null) {
-                      return callback(new Error('请正确输入PM2.5阈值(小数点后最多保留六位)'));
+                      return callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
                     }
                     const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
                     if(!regexTwo.test(value)){
                       return callback(new Error('请勿输入非数字'));
                     }
                     const valueTemp = parseFloat(value);
+                    // 检查前导零（例如 '0000' 或 '000.000000'）
+                    // if(valueTemp.toString()==="0")
+                    if (value !== valueTemp.toString() && value !== "0") {
+                      return callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
+                    }
                     if(valueTemp.toString().includes('.')==true){
-                      if (valueTemp.toString().split(".")[1].length>6) {
-                      callback(new Error('请正确输入PM2.5阈值(小数点后最多保留六位)'));
+                      if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>6) {
+                      callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
                     } else {
                       callback();
                     }
                     }else{
+                      if (valueTemp < 0 ) {
+                      callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
+                    } else {
                       callback();
+                    }
                   }
-                },
                   trigger: 'blur'
                 }
+              }
               ],
               configVal5Min: [
                 {
@@ -574,25 +616,34 @@ export default {
                 {
                   validator: (rule, value, callback) => {
                     if (value === '' || value === null) {
-                      return callback(new Error('请正确输入PM10阈值(小数点后最多保留六位)'));
+                      return callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
                     }
                     const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
                     if(!regexTwo.test(value)){
                       return callback(new Error('请勿输入非数字'));
                     }
                     const valueTemp = parseFloat(value);
+                    // 检查前导零（例如 '0000' 或 '000.000000'）
+                    // if(valueTemp.toString()==="0")
+                    if (value !== valueTemp.toString() && value !== "0") {
+                      return callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
+                    }
                     if(valueTemp.toString().includes('.')==true){
-                      if (valueTemp.toString().split(".")[1].length>6) {
-                      callback(new Error('请正确输入PM10阈值(小数点后最多保留六位)'));
+                      if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>6) {
+                      callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
                     } else {
                       callback();
                     }
                     }else{
+                      if (valueTemp < 0 ) {
+                      callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
+                    } else {
                       callback();
+                    }
                   }
-                },
                   trigger: 'blur'
                 }
+              }
               ],
               configVal5Max: [
                 {
@@ -603,25 +654,34 @@ export default {
                 {
                   validator: (rule, value, callback) => {
                     if (value === '' || value === null) {
-                      return callback(new Error('请正确输入PM10阈值(小数点后最多保留六位)'));
+                      return callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
                     }
                     const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
                     if(!regexTwo.test(value)){
                       return callback(new Error('请勿输入非数字'));
                     }
                     const valueTemp = parseFloat(value);
+                    // 检查前导零（例如 '0000' 或 '000.000000'）
+                    // if(valueTemp.toString()==="0")
+                    if (value !== valueTemp.toString() && value !== "0") {
+                      return callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
+                    }
                     if(valueTemp.toString().includes('.')==true){
-                      if (valueTemp.toString().split(".")[1].length>6) {
-                      callback(new Error('请正确输入PM10阈值(小数点后最多保留六位)'));
+                      if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>6) {
+                      callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
                     } else {
                       callback();
                     }
                     }else{
+                      if (valueTemp < 0 ) {
+                      callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
+                    } else {
                       callback();
+                    }
                   }
-                },
                   trigger: 'blur'
                 }
+              }
               ],
             },
             projectParams2Rules: {
@@ -641,19 +701,34 @@ export default {
                 {
                   validator: (rule, value, callback) => {
                     if (value === '' || value === null) {
-                      return callback(new Error('请必须输入0~90的数'));
+                      return callback(new Error('请输入0~90内的数据且小数点后最多保留六位'));
                     }
-                    // const numValue = value.trim();
-                    // 正则表达式：负数、零和正整数
-                    const integerPattern = /^(0|[1-9]\d*(\.\d+)?|0\.\d+)$/;
-                    if (!integerPattern.test(value) && value <= 90) {
-                         callback(new Error('请必须输入0~90的数'));
+                    const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
+                    if(!regexTwo.test(value)){
+                      return callback(new Error('请勿输入非数字'));
+                    }
+                    const valueTemp = parseFloat(value);
+                    // 检查前导零（例如 '0000' 或 '000.000000'）
+                    // if(valueTemp.toString()==="0")
+                    if (value !== valueTemp.toString() && value !== "0") {
+                      return callback(new Error('请输入0~90内的数据且小数点后最多保留六位'));
+                    }
+                    if(valueTemp.toString().includes('.')==true){
+                      if (valueTemp < 0 || valueTemp > 90 ||valueTemp.toString().split(".")[1].length>6) {
+                      callback(new Error('请输入0~90内的数据且小数点后最多保留六位'));
                     } else {
                       callback();
                     }
-                  },
+                    }else{
+                      if (valueTemp < 0 || valueTemp > 90) {
+                      callback(new Error('请输入0~90内的数据且小数点后最多保留六位'));
+                    } else {
+                      callback();
+                    }
+                  }
                   trigger: 'blur'
                 }
+              }
               ],
               configVal1Max: [
                 {
@@ -664,19 +739,34 @@ export default {
                 {
                   validator: (rule, value, callback) => {
                     if (value === '' || value === null) {
-                      return callback(new Error('请必须输入0~90的数'));
+                      return callback(new Error('请输入0~90内的数据且小数点后最多保留六位'));
                     }
-                    // const numValue = value.trim();
-                    // 正则表达式：负数、零和正整数
-                    const integerPattern = /^(0|[1-9]\d*(\.\d+)?|0\.\d+)$/;
-                    if (!integerPattern.test(value) && value <= 90) {
-                         callback(new Error('请必须输入0~90的数'));
+                    const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
+                    if(!regexTwo.test(value)){
+                      return callback(new Error('请勿输入非数字'));
+                    }
+                    const valueTemp = parseFloat(value);
+                    // 检查前导零（例如 '0000' 或 '000.000000'）
+                    // if(valueTemp.toString()==="0")
+                    if (value !== valueTemp.toString() && value !== "0") {
+                      return callback(new Error('请输入0~90内的数据且小数点后最多保留六位'));
+                    }
+                    if(valueTemp.toString().includes('.')==true){
+                      if (valueTemp < 0 || valueTemp > 90 ||valueTemp.toString().split(".")[1].length>6) {
+                      callback(new Error('请输入0~90内的数据且小数点后最多保留六位'));
                     } else {
                       callback();
                     }
-                  },
+                    }else{
+                      if (valueTemp < 0 || valueTemp > 90) {
+                      callback(new Error('请输入0~90内的数据且小数点后最多保留六位'));
+                    } else {
+                      callback();
+                    }
+                  }
                   trigger: 'blur'
                 }
+              }
               ],
             },
             projectParams3Rules: {
@@ -696,19 +786,34 @@ export default {
                 {
                   validator: (rule, value, callback) => {
                     if (value === '' || value === null) {
-                      return callback(new Error('请必须输入非负数'));
+                      return callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
                     }
-                    // const numValue = value.trim();
-                    // 正则表达式：负数、零和正整数
-                    const integerPattern = /^(0|[1-9]\d*(\.\d+)?|0\.\d+)$/;
-                    if (!integerPattern.test(value)) {
-                         callback(new Error('请必须输入非负数'));
+                    const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
+                    if(!regexTwo.test(value)){
+                      return callback(new Error('请勿输入非数字'));
+                    }
+                    const valueTemp = parseFloat(value);
+                    // 检查前导零（例如 '0000' 或 '000.000000'）
+                    // if(valueTemp.toString()==="0")
+                    if (value !== valueTemp.toString() && value !== "0") {
+                      return callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
+                    }
+                    if(valueTemp.toString().includes('.')==true){
+                      if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>6) {
+                      callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
                     } else {
                       callback();
                     }
-                  },
+                    }else{
+                      if (valueTemp < 0 ) {
+                      callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
+                    } else {
+                      callback();
+                    }
+                  }
                   trigger: 'blur'
                 }
+              }
               ],
               configVal1Max: [
                 {
@@ -719,19 +824,34 @@ export default {
                 {
                   validator: (rule, value, callback) => {
                     if (value === '' || value === null) {
-                      return callback(new Error('请必须输入非负数'));
+                      return callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
                     }
-                    // const numValue = value.trim();
-                    // 正则表达式：负数、零和正整数
-                    const integerPattern = /^(0|[1-9]\d*(\.\d+)?|0\.\d+)$/;
-                    if (!integerPattern.test(value)) {
-                         callback(new Error('请必须输入非负数'));
+                    const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
+                    if(!regexTwo.test(value)){
+                      return callback(new Error('请勿输入非数字'));
+                    }
+                    const valueTemp = parseFloat(value);
+                    // 检查前导零（例如 '0000' 或 '000.000000'）
+                    // if(valueTemp.toString()==="0")
+                    if (value !== valueTemp.toString() && value !== "0") {
+                      return callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
+                    }
+                    if(valueTemp.toString().includes('.')==true){
+                      if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>6) {
+                      callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
                     } else {
                       callback();
                     }
-                  },
+                    }else{
+                      if (valueTemp < 0 ) {
+                      callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
+                    } else {
+                      callback();
+                    }
+                  }
                   trigger: 'blur'
                 }
+              }
               ],
             },
             projectParams4Rules: {
@@ -758,6 +878,11 @@ export default {
                       return callback(new Error('请勿输入非数字'));
                     }
                     const valueTemp = parseFloat(value);
+                    // 检查前导零（例如 '0000' 或 '000.000000'）
+                    // if(valueTemp.toString()==="0")
+                    if (value !== valueTemp.toString() && value !== "0") {
+                      return callback(new Error('请输入0~100内的数据且小数点后最多保留六位'));
+                    }
                     if(valueTemp.toString().includes('.')==true){
                       if (valueTemp < 0 || valueTemp > 100 ||valueTemp.toString().split(".")[1].length>6) {
                       callback(new Error('请输入0~100内的数据且小数点后最多保留六位'));
@@ -791,6 +916,11 @@ export default {
                       return callback(new Error('请勿输入非数字'));
                     }
                     const valueTemp = parseFloat(value);
+                    // 检查前导零（例如 '0000' 或 '000.000000'）
+                    // if(valueTemp.toString()==="0")
+                    if (value !== valueTemp.toString() && value !== "0") {
+                      return callback(new Error('请输入0~100内的数据且小数点后最多保留六位'));
+                    }
                     if(valueTemp.toString().includes('.')==true){
                       if (valueTemp < 0 || valueTemp > 100 ||valueTemp.toString().split(".")[1].length>6) {
                       callback(new Error('请输入0~100内的数据且小数点后最多保留六位'));
@@ -817,19 +947,34 @@ export default {
                 {
                   validator: (rule, value, callback) => {
                     if (value === '' || value === null) {
-                      return callback(new Error('请必须输入非负数'));
+                      return callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
                     }
-                    // const numValue = value.trim();
-                    // 正则表达式：负数、零和正整数
-                    const integerPattern = /^(0|[1-9]\d*(\.\d+)?|0\.\d+)$/;
-                    if (!integerPattern.test(value)) {
-                         callback(new Error('请必须输入非负数'));
+                    const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
+                    if(!regexTwo.test(value)){
+                      return callback(new Error('请勿输入非数字'));
+                    }
+                    const valueTemp = parseFloat(value);
+                    // 检查前导零（例如 '0000' 或 '000.000000'）
+                    // if(valueTemp.toString()==="0")
+                    if (value !== valueTemp.toString() && value !== "0") {
+                      return callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
+                    }
+                    if(valueTemp.toString().includes('.')==true){
+                      if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>6) {
+                      callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
                     } else {
                       callback();
                     }
-                  },
+                    }else{
+                      if (valueTemp < 0 ) {
+                      callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
+                    } else {
+                      callback();
+                    }
+                  }
                   trigger: 'blur'
                 }
+              }
               ],
               configVal2Max: [
                 {
@@ -840,19 +985,34 @@ export default {
                 {
                   validator: (rule, value, callback) => {
                     if (value === '' || value === null) {
-                      return callback(new Error('请必须输入非负数'));
+                      return callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
                     }
-                    // const numValue = value.trim();
-                    // 正则表达式：负数、零和正整数
-                    const integerPattern = /^(0|[1-9]\d*(\.\d+)?|0\.\d+)$/;
-                    if (!integerPattern.test(value)) {
-                         callback(new Error('请必须输入非负数'));
+                    const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
+                    if(!regexTwo.test(value)){
+                      return callback(new Error('请勿输入非数字'));
+                    }
+                    const valueTemp = parseFloat(value);
+                    // 检查前导零（例如 '0000' 或 '000.000000'）
+                    // if(valueTemp.toString()==="0")
+                    if (value !== valueTemp.toString() && value !== "0") {
+                      return callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
+                    }
+                    if(valueTemp.toString().includes('.')==true){
+                      if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>6) {
+                      callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
                     } else {
                       callback();
                     }
-                  },
+                    }else{
+                      if (valueTemp < 0 ) {
+                      callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
+                    } else {
+                      callback();
+                    }
+                  }
                   trigger: 'blur'
                 }
+              }
               ],
               configVal3Min: [
                 {
@@ -870,6 +1030,11 @@ export default {
                       return callback(new Error('请勿输入非数字'));
                     }
                     const valueTemp = parseFloat(value);
+                    // 检查前导零（例如 '0000' 或 '000.000000'）
+                    // if(valueTemp.toString()==="0")
+                    if (value !== valueTemp.toString() && value !== "0") {
+                      return callback(new Error('请输入0~100内的数据且小数点后最多保留六位'));
+                    }
                     if(valueTemp.toString().includes('.')==true){
                       if (valueTemp < 0 || valueTemp > 100 ||valueTemp.toString().split(".")[1].length>6) {
                       callback(new Error('请输入0~100内的数据且小数点后最多保留六位'));
@@ -883,9 +1048,9 @@ export default {
                       callback();
                     }
                   }
-                },
                   trigger: 'blur'
                 }
+              }
               ],
               configVal3Max: [
                 {
@@ -903,6 +1068,11 @@ export default {
                       return callback(new Error('请勿输入非数字'));
                     }
                     const valueTemp = parseFloat(value);
+                    // 检查前导零（例如 '0000' 或 '000.000000'）
+                    // if(valueTemp.toString()==="0")
+                    if (value !== valueTemp.toString() && value !== "0") {
+                      return callback(new Error('请输入0~100内的数据且小数点后最多保留六位'));
+                    }
                     if(valueTemp.toString().includes('.')==true){
                       if (valueTemp < 0 || valueTemp > 100 ||valueTemp.toString().split(".")[1].length>6) {
                       callback(new Error('请输入0~100内的数据且小数点后最多保留六位'));
@@ -916,9 +1086,9 @@ export default {
                       callback();
                     }
                   }
-                },
                   trigger: 'blur'
                 }
+              }
               ],
               configVal4Min: [
                 {
@@ -929,19 +1099,34 @@ export default {
                 {
                   validator: (rule, value, callback) => {
                     if (value === '' || value === null) {
-                      return callback(new Error('请必须输入非负数'));
+                      return callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
                     }
-                    // const numValue = value.trim();
-                    // 正则表达式：负数、零和正整数
-                    const integerPattern = /^(0|[1-9]\d*(\.\d+)?|0\.\d+)$/;
-                    if (!integerPattern.test(value)) {
-                         callback(new Error('请必须输入非负数'));
+                    const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
+                    if(!regexTwo.test(value)){
+                      return callback(new Error('请勿输入非数字'));
+                    }
+                    const valueTemp = parseFloat(value);
+                    // 检查前导零（例如 '0000' 或 '000.000000'）
+                    // if(valueTemp.toString()==="0")
+                    if (value !== valueTemp.toString() && value !== "0") {
+                      return callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
+                    }
+                    if(valueTemp.toString().includes('.')==true){
+                      if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>6) {
+                      callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
                     } else {
                       callback();
                     }
-                  },
+                    }else{
+                      if (valueTemp < 0 ) {
+                      callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
+                    } else {
+                      callback();
+                    }
+                  }
                   trigger: 'blur'
                 }
+              }
               ],
               configVal4Max: [
                 {
@@ -952,19 +1137,34 @@ export default {
                 {
                   validator: (rule, value, callback) => {
                     if (value === '' || value === null) {
-                      return callback(new Error('请必须输入非负数'));
+                      return callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
                     }
-                    // const numValue = value.trim();
-                    // 正则表达式：负数、零和正整数
-                    const integerPattern = /^(0|[1-9]\d*(\.\d+)?|0\.\d+)$/;
-                    if (!integerPattern.test(value)) {
-                         callback(new Error('请必须输入非负数'));
+                    const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
+                    if(!regexTwo.test(value)){
+                      return callback(new Error('请勿输入非数字'));
+                    }
+                    const valueTemp = parseFloat(value);
+                    // 检查前导零（例如 '0000' 或 '000.000000'）
+                    // if(valueTemp.toString()==="0")
+                    if (value !== valueTemp.toString() && value !== "0") {
+                      return callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
+                    }
+                    if(valueTemp.toString().includes('.')==true){
+                      if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>6) {
+                      callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
                     } else {
                       callback();
                     }
-                  },
+                    }else{
+                      if (valueTemp < 0 ) {
+                      callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
+                    } else {
+                      callback();
+                    }
+                  }
                   trigger: 'blur'
                 }
+              }
               ],
             },
             // 各类下拉