U ld9实时修改

he wei

2021-11-24 657b5bbd77103c76a94a3cfec52e538ed7d844f4

U ld9实时修改

 src/assets/js/apis/dischargeTest/ld9.js

@@ -6,7 +6,9 @@
   * @param data  查询条件
   * {
   *   num: 0,
   *   BattGroupId: 0,
   *   ,StationName: batt.StationName
       ,StationName1: batt.StationName1
       ,BattGroupId: batt.BattGroupId
   * }
   * @returns {AxiosPromise}
   */
@@ -14,7 +16,30 @@
    return axios({
      method: 'post',
      url: 'LD9_setparamAction_ld9action_serchByCondition',
      data: 'json='+JSON.stringify(data),
      data: 'json=' + JSON.stringify(data),
    });
  },

  /**
   * 设定参数
   */
  setParams(data) {
    return axios({
      method: 'post',
      url: 'LD9_setparamAction_ld9action_update',
      data: 'json=' + JSON.stringify(data),
    });
  },

  /**
   * 发送指令
   * LD9_setparamAction_ld9action_serchbyDev_id
   */
   start (data) {
    return axios({
      method: 'post',
      url: 'LD9_setparamAction_ld9action_serchbyDev_id',
      data: 'json=' + JSON.stringify(data),
    });
  },
}

 src/assets/js/const/const_ld_nine.js

@@ -65,7 +65,7 @@
      max: 270,
      msg: '取值范围60.0~270.0（保留一位小数）'
    },
    param_res_args: {
    param_res_high: {
      pattern: /^[0-9]+(\.[0-9]{0,1})?$/,
      regVal: true,
      min: 0,

 src/assets/js/const/index.js

@@ -16,7 +16,7 @@
import const_power from "@/assets/js/const/const_power";
import const_powerCabinet from "@/assets/js/const/const_powerCabinet";
import const_alarm_level from "@/assets/js/const/const_alarm_level";
// import const_storage from "./const_storage";
import const_ld_nine from "./const_ld_nine";
export {
    const_9100,
    const_61850,
@@ -36,5 +36,5 @@
    const_power,
    const_powerCabinet,
    const_alarm_level,
    // const_storage,
    const_ld_nine,
};

 src/components/params/LdNineParams.vue

@@ -5,7 +5,8 @@
    label-position="top"
    :model="params"
    :rules="rules"
    class="params-dialog">
    class="params-dialog"
  >
    <el-form-item label="电池组名称">
      <el-input v-model="otherParams.groupName" readonly></el-input>
    </el-form-item>
@@ -40,8 +41,11 @@
        <el-form-item label="测试起始电池序号">
          <el-select v-model="params.param_teststart_batt_num">
            <el-option
              v-for="(item, key) in monNums" :key="'key'+key"
              :value="item.value" :label="item.label"></el-option>
              v-for="(item, key) in monNums"
              :key="'key' + key"
              :value="item.value"
              :label="item.label"
            ></el-option>
          </el-select>
        </el-form-item>
      </el-col>
@@ -61,12 +65,18 @@
        </el-form-item>
      </el-col>
      <el-col :span="layout.span">
        <el-form-item label="单体电压下限阀值（0~14.0V）" prop="param_mon_curr_low">
        <el-form-item
          label="单体电压下限阀值（0~14.0V）"
          prop="param_mon_curr_low"
        >
          <el-input v-model="params.param_mon_curr_low"></el-input>
        </el-form-item>
      </el-col>
      <el-col :span="layout.span">
        <el-form-item label="单体电压上限阀值（0~14.0V）" prop="param_mon_curr_high">
        <el-form-item
          label="单体电压上限阀值（0~14.0V）"
          prop="param_mon_curr_high"
        >
          <el-input v-model="params.param_mon_curr_high"></el-input>
        </el-form-item>
      </el-col>
@@ -76,27 +86,39 @@
        </el-form-item>
      </el-col>
      <el-col :span="layout.span">
        <el-form-item label="在线电压阀值（60.0~270.0℃）" prop="param_online_vol">
        <el-form-item
          label="在线电压阀值（60.0~270.0℃）"
          prop="param_online_vol"
        >
          <el-input v-model="params.param_online_vol"></el-input>
        </el-form-item>
      </el-col>
      <el-col :span="layout.span">
        <el-form-item label="在线电压恢复阀值（60.0~270.0℃）" prop="param_online_vol_recover">
        <el-form-item
          label="在线电压恢复阀值（60.0~270.0℃）"
          prop="param_online_vol_recover"
        >
          <el-input v-model="params.param_online_vol_recover"></el-input>
        </el-form-item>
      </el-col>
      <el-col :span="layout.span">
        <el-form-item label="内阻告警上限（0~65.0mΩ）" prop="param_res_args">
          <el-input v-model="params.param_res_args"></el-input>
        <el-form-item label="内阻告警上限（0~65.0mΩ）" prop="param_res_high">
          <el-input v-model="params.param_res_high"></el-input>
        </el-form-item>
      </el-col>
      <el-col :span="layout.span">
        <el-form-item label="充电电流下限阀值（0.30~4.00A）" prop="param_charge_curr_low">
        <el-form-item
          label="充电电流下限阀值（0.30~4.00A）"
          prop="param_charge_curr_low"
        >
          <el-input v-model="params.param_charge_curr_low"></el-input>
        </el-form-item>
      </el-col>
      <el-col :span="layout.span">
        <el-form-item label="充电容量下限阀值（60~100%）" prop="param_charge_cap_low">
        <el-form-item
          label="充电容量下限阀值（60~100%）"
          prop="param_charge_cap_low"
        >
          <el-input v-model="params.param_charge_cap_low"></el-input>
        </el-form-item>
      </el-col>
@@ -107,25 +129,25 @@
      </el-col>
    </el-row>
    <div class="form-footer">
      <three-btn :disabled="!startTestFlag">启动测试</three-btn>
      <three-btn :disabled="!startTestFlag" @click="confirmStartTest">启动测试</three-btn>
      <three-btn @click="getParams(true)">读取</three-btn>
      <three-btn :disabled="!setTestFlag">设定</three-btn>
      <three-btn :disabled="!setTestFlag" @click="submitFrom">设定</three-btn>
    </div>
  </el-form>
</template>

<script>
import const_ld_nine from "@/assets/js/const/const_ld_nine";
import {testVal} from "@/assets/js/tools";
import { testVal } from "@/assets/js/tools";
export default {
  name: "LdNineParams",
  props: {
    batt: {
      type: Object,
      default() {
        return {}
      }
    }
        return {};
      },
    },
  },
  data() {
    let cmd = const_ld_nine.cmd;
@@ -133,8 +155,8 @@
    let rules = const_ld_nine.rules;

    return {
      startTestFlag: false,       // 启动测试的状态
      setTestFlag: false,         // 设置参数的状态
      startTestFlag: false, // 启动测试的状态
      setTestFlag: false, // 设置参数的状态
      layout: {
        gutter: 16,
        span: 8,
@@ -143,97 +165,121 @@
      params: {
        num: 0,
        dev_id: 0,
        param_teststart_batt_num: 0,                //测试起始电池序号
        param_cap: 0,                                //标称容量
        param_teststart_batt_num: 0, //测试起始电池序号
        param_cap: 0, //标称容量
        op_cmd: 0,
        param_discharge_curr: 0,                  //放电电流0.001
        param_mon_curr_high: 0,                  //单体上限0.001
        param_charge_curr: 0,                        //充电电流0.001
        param_mon_curr_low: 0,                    //单体下限0.001
        param_online_vol: 0,                      //在线电压阀值0.01
        param_charge_curr_low: 0,          //充电电流下限阀值0.001
        param_charge_cap_low: 0,            //充电容量下限阀值%
        param_online_vol_recover: 0,    //在线电压恢复阀值0.01
        param_junheng_model: 0,                        //均衡功能     0->禁用   1->启用
        param_datasource: 0,                        // 数据来源
        param_res_args: 0,                            // 内阻测试系数
        param_cap_low: 0,                        // 容量告警下限
        param_tmp_high: 0,                        // 温度告警上限
        param_res_high: 0                        // 内阻告警上限
        param_discharge_curr: 0, //放电电流0.001
        param_mon_curr_high: 0, //单体上限0.001
        param_charge_curr: 0, //充电电流0.001
        param_mon_curr_low: 0, //单体下限0.001
        param_online_vol: 0, //在线电压阀值0.01
        param_charge_curr_low: 0, //充电电流下限阀值0.001
        param_charge_cap_low: 0, //充电容量下限阀值%
        param_online_vol_recover: 0, //在线电压恢复阀值0.01
        param_junheng_model: 0, //均衡功能     0->禁用   1->启用
        param_datasource: 0, // 数据来源
        param_res_args: 0, // 内阻测试系数
        param_cap_low: 0, // 容量告警下限
        param_tmp_high: 0, // 温度告警上限
        param_res_high: 0, // 内阻告警上限
      },
      rules: {
        param_cap: [{
          validator(rule, value, callback) {
            testVal(rule, value, callback, rules.param_cap)
        param_cap: [
          {
            validator(rule, value, callback) {
              testVal(rule, value, callback, rules.param_cap);
            },
            trigger: "change",
          },
          trigger: 'change'
        }],
        param_discharge_curr: [{
          validator(rule, value, callback) {
            testVal(rule, value, callback, rules.param_discharge_curr)
        ],
        param_discharge_curr: [
          {
            validator(rule, value, callback) {
              testVal(rule, value, callback, rules.param_discharge_curr);
            },
            trigger: "change",
          },
          trigger: 'change'
        }],
        param_charge_curr: [{
          validator(rule, value, callback) {
            testVal(rule, value, callback, rules.param_charge_curr)
        ],
        param_charge_curr: [
          {
            validator(rule, value, callback) {
              testVal(rule, value, callback, rules.param_charge_curr);
            },
            trigger: "change",
          },
          trigger: 'change'
        }],
        param_mon_curr_low: [{
          validator(rule, value, callback) {
            testVal(rule, value, callback, rules.param_mon_curr_low)
        ],
        param_mon_curr_low: [
          {
            validator(rule, value, callback) {
              testVal(rule, value, callback, rules.param_mon_curr_low);
            },
            trigger: "change",
          },
          trigger: 'change'
        }],
        param_mon_curr_high: [{
          validator(rule, value, callback) {
            testVal(rule, value, callback, rules.param_mon_curr_high)
        ],
        param_mon_curr_high: [
          {
            validator(rule, value, callback) {
              testVal(rule, value, callback, rules.param_mon_curr_high);
            },
            trigger: "change",
          },
          trigger: 'change'
        }],
        param_tmp_high: [{
          validator(rule, value, callback) {
            testVal(rule, value, callback, rules.param_tmp_high)
        ],
        param_tmp_high: [
          {
            validator(rule, value, callback) {
              testVal(rule, value, callback, rules.param_tmp_high);
            },
            trigger: "change",
          },
          trigger: 'change'
        }],
        param_online_vol: [{
          validator(rule, value, callback) {
            testVal(rule, value, callback, rules.param_online_vol)
        ],
        param_online_vol: [
          {
            validator(rule, value, callback) {
              testVal(rule, value, callback, rules.param_online_vol);
            },
            trigger: "change",
          },
          trigger: 'change'
        }],
        param_online_vol_recover: [{
          validator(rule, value, callback) {
            testVal(rule, value, callback, rules.param_online_vol_recover)
        ],
        param_online_vol_recover: [
          {
            validator(rule, value, callback) {
              testVal(rule, value, callback, rules.param_online_vol_recover);
            },
            trigger: "change",
          },
          trigger: 'change'
        }],
        param_res_args: [{
          validator(rule, value, callback) {
            testVal(rule, value, callback, rules.param_res_args)
        ],
        param_res_high: [
          {
            validator(rule, value, callback) {
              testVal(rule, value, callback, rules.param_res_high);
            },
            trigger: "change",
          },
          trigger: 'change'
        }],
        param_charge_curr_low: [{
          validator(rule, value, callback) {
            testVal(rule, value, callback, rules.param_charge_curr_low)
        ],
        param_charge_curr_low: [
          {
            validator(rule, value, callback) {
              testVal(rule, value, callback, rules.param_charge_curr_low);
            },
            trigger: "change",
          },
          trigger: 'change'
        }],
        param_charge_cap_low: [{
          validator(rule, value, callback) {
            testVal(rule, value, callback, rules.param_charge_cap_low)
        ],
        param_charge_cap_low: [
          {
            validator(rule, value, callback) {
              testVal(rule, value, callback, rules.param_charge_cap_low);
            },
            trigger: "change",
          },
          trigger: 'change'
        }],
        param_cap_low: [{
          validator(rule, value, callback) {
            testVal(rule, value, callback, rules.param_cap_low)
        ],
        param_cap_low: [
          {
            validator(rule, value, callback) {
              testVal(rule, value, callback, rules.param_cap_low);
            },
            trigger: "change",
          },
          trigger: 'change'
        }],
        ],
      },
      testType: 81,
    };
@@ -247,66 +293,205 @@
      }
      // 启动按钮不可点击
      this.startTestFlag = false;
      this.$apis.dischargeTest.ld9.getParams({
        num: this.cmd.get,
        BattGroupId: this.batt.BattGroupId,
      }).then(res=>{
        // 关闭等待框
        this.$layer.close(loading);
        let rs = JSON.parse(res.data.result);
        if(rs.code == 1) {
          this.$layer.msg('读取成功！');
        }else {
      let batt = this.batt;
      this.$apis.dischargeTest.ld9
        .getParams({
          num: this.cmd.get,
          StationName: batt.StationName,
          StationName1: batt.StationName1,
          BattGroupId: batt.BattGroupId,
        })
        .then((res) => {
          // 关闭等待框
          this.$layer.close(loading);
          let rs = JSON.parse(res.data.result);
          console.log(rs, "====rs");
          if (rs.code == 1) {
            this.$layer.msg("读取成功！");
            this.params = rs.data[0].ld9_param;
            // 设置按钮可点击
            this.setTestFlag = true;
          } else {
            // 设置按钮不可点击
            this.setTestFlag = false;
            this.$layer.msg("读取失败！");
          }
        })
        .catch((error) => {
          // 关闭等待框
          this.$layer.close(loading);
          // 设置按钮不可点击
          this.setTestFlag = false;
          this.$layer.msg('读取失败！');
          this.$layer.msg("读取失败，请检查网络。");
        });
    },
    submitFrom() {
      this.$refs.ruleForm.validate((valid) => {
        // 校验通过
        if (valid) {
          // 设置参数
          this.setParams(true);
        } else {
          this.$layer.msg("存在校验未通过的数据！");
          return false;
        }
      }).catch(error => {
        // 关闭等待框
        this.$layer.close(loading);
        // 设置按钮不可点击
        this.setTestFlag = false;
        this.$layer.msg('读取失败，请检查网络。');
      });
    },
    // 设定参数
    setParams(showLoad) {
      // 定义等待框
      let loading;
      if (showLoad) {
        loading = this.$layer.loading(1);
      }
      // 启动按钮不可点击
      this.startTestFlag = false;
      let batt = this.batt;
      let param = this.params;
      this.$apis.dischargeTest.ld9
        .setParams({
          num: this.cmd.set,
          dev_id: batt.FBSDeviceId,
          param_teststart_batt_num: param.param_teststart_batt_num,
          param_cap: param.param_cap,
          param_discharge_curr: param.param_discharge_curr,
          param_mon_curr_high: param.param_mon_curr_high,
          param_charge_curr: param.param_charge_curr,
          param_mon_curr_low: param.param_mon_curr_low,
          param_online_vol: param.param_online_vol,
          param_charge_curr_low: param.param_charge_curr_low,
          param_charge_cap_low: param.param_charge_cap_low,
          param_online_vol_recover: param.param_online_vol_recover,
          param_junheng_model: param.param_junheng_model,
          param_cap_low: param.param_cap_low,
          param_tmp_high: param.param_tmp_high,
          param_res_high: param.param_res_high,
        })
        .then((res) => {
          // 关闭等待框
          this.$layer.close(loading);
          let rs = JSON.parse(res.data.result);
          console.log(rs, "====rs1");
          if (rs.code == 1) {
            this.$layer.msg("设定成功！");
            this.startTestFlag = true;
          } else {
            // 设置按钮不可点击
            this.startTestFlag = false;
            this.$layer.msg("设定失败！");
          }
        })
        .catch((error) => {
          // 关闭等待框
          this.$layer.close(loading);
          // 设置按钮不可点击
          this.startTestFlag = false;
          this.$layer.msg("设定失败，请检查网络。");
        });
    },
    // 确认框
    confirmStartTest() {
      this.$layer.prompt(
        {
          title: "输入启动口令，并确认",
          formType: 2,
          area: ["300px", "180px"],
        },
        (pass, index) => {
          // 请求后台校验密码
          this.$apis.login
            .checkUserPwd(pass)
            .then((res) => {
              let rs = JSON.parse(res.data.result);
              if (rs.code == 1) {
                // 关闭弹出框
                this.$layer.close(index);
                this.$layer.msg("密码检测通过，启动测试");
                // 启动测试
                this.startTest();
              } else {
                this.$layer.msg("启动口令错误！");
              }
            })
            .catch((error) => {
              console.log(error);
              this.$layer.msg("网络请求异常");
            });
        }
      );
    },
    // 启动
    startTest() {
      // 等待框
      let loading = this.$layer.loading(1);
      // 请求后台
      this.$apis.dischargeTest.ld9
        .start({
          num: this.cmd.start,
          dev_id: this.batt.FBSDeviceId
        })
        .then((res) => {
          let rs = JSON.parse(res.data.result);
          if (rs.code == 1) {
            // 提示信息
            this.$layer.msg("启动测试成功");
          } else {
            // 提示信息
            this.$layer.msg("启动测试失败！");
          }
          // 关闭等待框
          this.$layer.close(loading);
        })
        .catch((error) => {
          console.log(error);
          // 关闭等待框
          this.$layer.close(loading);
          // 提示信息
          this.$layer.msg("启动测试失败，启动测试请求异常！");
        });
    }
  },
  computed: {
    otherParams() {
      let batt = this.batt;
      let groupInfo = '单体数量:' + this.batt.MonCount + ";电压(V):"
          + this.batt.MonVolStd + ";容量(AH):" + this.batt.MonCapStd;
      let groupInfo =
        "单体数量:" +
        this.batt.MonCount +
        ";电压(V):" +
        this.batt.MonVolStd +
        ";容量(AH):" +
        this.batt.MonCapStd;
      return {
        groupName: batt.StationName + "-" + batt.BattGroupName,
        FBSDeviceId: batt.FBSDeviceId,
        groupInfo: groupInfo,
        GroupIndexInFBSDevice: this.batt.GroupIndexInFBSDevice + 1,
      }
      };
    },
    monNums() {
      let monCount = this.batt.MonCount;
      let list = [];
      for(let i=0; i<=monCount; i++) {
        if(monCount>9 && i==0) {
      for (let i = 0; i <= monCount; i++) {
        if (monCount > 9 && i == 0) {
          list.push({
            value: 0,
            label: "默认"
            label: "默认",
          });
        }else {
        } else {
          list.push({
            value: i,
            label: "单体"+i
          })
            label: "单体" + i,
          });
        }
      }
      return list;
    }
    },
  },
  mounted() {

  }
}
    this.getParams(true);
  },
};
</script>

<style scoped>

</style>

 src/pages/dataTest/realTime.vue

@@ -903,7 +903,7 @@
  getConduct,
} from "../../assets/js/tools";

import { const_61850, const_9100 } from "../../assets/js/const";
import { const_61850, const_9100, const_ld_nine } from "../../assets/js/const";
import getMarkLineData from "@/components/chart/js/getMarkLineData";
import BarChartThreeD from "@/components/chart/BarChartThreeD";
import JggdInfoTab from "./components/jggdInfoTab.vue";
@@ -2520,6 +2520,8 @@
          ) {
            // 停止设备
            this.stopBtsTest();
          } else if (regEquipType(this.batt.FBSDeviceId, "LD9")) {
            this.stopLD9();
          } else {
            // 提示信息
            this.$layer.msg("未知设备类型，暂无法停止测试！");
@@ -2527,6 +2529,36 @@
        }
      );
    },
    // 停止LD9测试
    stopLD9() {
      // 开启等待框
      let loading = this.$layer.loading(1);
      // 请求后台
      this.$apis.dischargeTest.ld9
        .stop({
          num: const_ld_nine.cmd.stop,
          dev_id: this.batt.FBSDeviceId,
        })
        .then((res) => {
          let rs = JSON.parse(res.data.result);
          if (rs.code == 1) {
            // 提示信息
            this.$layer.msg("停止测试成功");
          } else {
            // 提示信息
            this.$layer.msg("停止测试失败！");
          }
          // 关闭等待框
          this.$layer.close(loading);
        })
        .catch((error) => {
          console.log(error);
          // 关闭等待框
          this.$layer.close(loading);
          // 提示信息
          this.$layer.msg("停止测试失败，停止测试请求异常！");
        });
    },
    // 停止bts测试
    stopBtsTest() {
      // 开启等待框