@jiabaida/tools 1.0.0 → 1.0.2

package/src/core/BleCmdAnalysis/BaseParamProtocol.js

@@ -0,0 +1,651 @@
+
+import { getSysParamCmd } from './readAndSetParam'
+import { decimalToHex, hexToDecimal } from '../BleDataProcess';
+import { batteryInfoJson, capInfoJson, voltageInfoJson, currentInfoJson, tempInfoJson, equalizerFunJson, capVolInfoJson, funcJson, tempFuncJson, systemJson, funcAndTempFuncJson } from '../dataJson/baseParamsJson.js'
+import { readExistFactory, getProtectCountCmd, enterFactory } from './BleCmdDD.js'
+/**
+ * 
+ * @param {*} value 原始十进制值字数组
+ * @param {*} n 缩放因子
+ * @param {*} offset 偏移量
+ * @param {*} scope 保留小数位数
+ * @returns 
+ */
+function format(value, n = 1, offset = 0, scope = 0) {
+  if (!value) return null;
+  // 将十进制值的数组合并为一个十六进制值
+  value = value.map((el) => {
+    const hexValue = decimalToHex(el)
+    console.log('el: ------------', hexValue);
+    return hexValue;
+  })
+  const v = parseInt(value.join(''), 16) * n + offset;
+  if (scope == undefined) return v;
+  const formatted = v.toFixed(scope);
+
+  // 格式化数字
+  return Number(formatted);
+}
+/**
+ * 温度解析
+ * @param {*} arr  十进制数组
+ * @returns 温度摄氏度值
+ */
+function formatTemp(arr) {
+  if (!arr) return null;
+  let string = '0x' + toHexString(arr)
+  let value = parseInt(string, 16); // 转换为十进制数 
+  // 写入 2731+（实际温度*10）
+  // 读 (绝对温度 - 2731) / 10
+  value = ((value - 2731) / 10)
+  return Number(value)
+}
+/**
+ * 
+ * @param {*} arr 十进制数组
+ * @returns 8位二进制数组
+ */
+function formatBinary(arr) {
+  if (!arr) return null;
+  // 处理读出来的数据
+  // 将数组元素转换为二进制字符串
+  let binaryString = arr.map(num => num.toString(2).padStart(8, '0')).join('');
+  // 将二进制字符串转换为数组并翻转
+  let resultArray = binaryString.split('').map(Number).reverse();
+  return resultArray
+}
+/**
+ * 发送命令序列
+ * @param {Object} datasInfo 存储数据的对象
+ * @param {string} chipType 芯片类型
+ * @param {string} deviceId 设备ID
+ * @param {Array<any>} params 参数数组
+ */
+const sendCmdSeq = async (datasInfo, chipType, deviceId, params) => {
+  let index = 0;
+  // 读多个参数时统一进出工厂
+  if(!chipType) await enterFactory(deviceId);
+  while (index < params.length) {
+    const item = params[index];
+    try {
+      const basedata = await getSysParamCmd(chipType, deviceId, item, false);
+      datasInfo[item.key] = basedata;
+      index++; // 只有当前操作成功完成后才增加索引
+    } catch (error) {
+      console.error(`获取参数 ${item.key} 失败:`, error);
+      // 可以选择继续执行下一个，或者中断执行
+      // break; // 如果要在失败时中断
+      index++; // 如果希望失败时也继续下一个
+    }
+  }
+  if(!chipType) await readExistFactory(deviceId);
+}
+let crsDivisor = 0.1;
+/**
+ * 解析FA基础参数
+ * @param {string} chipType 芯片类型
+ * @param {string} deviceId 设备ID
+ * @param {number} index 菜单索引 
+ * index-1 基本信息
+ * index-2 初始设置
+ * index-3 电压保护参数
+ * index-4 电流设置
+ * index-5 温度设置
+ * index-6 均衡设置
+ * index-7 电容电压
+ * index-8 连接内阻
+ * index-9 温控及功能配置
+ * index-10 系统设置
+ * index-11 保护次数
+ */
+export const getBaseParams = async (chipType, deviceData, index, paramObj) => {
+  console.log('chipType: ', chipType);
+  const deviceId = deviceData?.deviceId;
+  const protocolVersion = deviceData?.protocolVersion || "00";
+  console.warn('protocolVersion: ', protocolVersion);
+  const  v = hexToDecimal(protocolVersion)
+  if(v == 2 || (v >= 20 && v < 80)) crsDivisor = 0.01;
+  console.log('v: ', v);
+  try {
+    let dataInfo = {}
+    switch (index) {
+      case 1:
+        let datasInfo1 = {};
+        await sendCmdSeq(datasInfo1, chipType, deviceId, batteryInfoJson)
+        dataInfo = getBaseInfo(datasInfo1)
+        return dataInfo
+      case 2:
+        let datasInfo2 = {}
+        if (chipType) {
+          /**连续读两个参数 */
+          const capData = await getSysParamCmd(chipType, deviceId, { ...capInfoJson[0], paramLength: 4 })
+          console.warn('capData: ', capData);
+          datasInfo2['normCap'] = capData?.slice(0, 2)
+          datasInfo2['cycleCap'] = capData?.slice(2, 4)
+          const capData2 = await getSysParamCmd(chipType, deviceId, capInfoJson[2])
+          datasInfo2['fullCap'] = capData2?.slice(0, 2)
+        } else {
+          await sendCmdSeq(datasInfo2, chipType, deviceId, capInfoJson)
+        }
+        dataInfo = getCapInfo(datasInfo2)
+        return dataInfo
+      case 3:
+        let datasInfo3 = {}
+        if (chipType) {
+          let vindex = voltageInfoJson.findIndex((el) => el.paramNo == 16)
+          console.log('vindex: ------------', vindex);
+          let vindex1 = voltageInfoJson.findIndex((el) => el.paramNo == 48)
+          let vindex2 = voltageInfoJson.findIndex((el) => el.paramNo == 38)
+          const voltageData = await getSysParamCmd(chipType, deviceId, { ...voltageInfoJson[vindex], paramLength: 16 })
+          const voltageData1 = await getSysParamCmd(chipType, deviceId, { ...voltageInfoJson[vindex1], paramLength: 8 })
+          const voltageData2 = await getSysParamCmd(chipType, deviceId, { ...voltageInfoJson[vindex2], paramLength: 4 })
+          console.log('voltageData: ', voltageData);
+          datasInfo3['allOvervoltageProtect'] = voltageData?.slice(0, 2)
+          datasInfo3['allOverpressureRecovery'] = voltageData?.slice(2, 4)
+          datasInfo3['allLowvoltageProtect'] = voltageData?.slice(4, 6)
+          datasInfo3['allLowvoltageRecover'] = voltageData?.slice(6, 8)
+          datasInfo3['singleOvervoltageProtect'] = voltageData?.slice(8, 10)
+          datasInfo3['singleOverpressureRecovery'] = voltageData?.slice(10, 12)
+          datasInfo3['singleLowvoltageProtect'] = voltageData?.slice(12, 14)
+          datasInfo3['singleLowvoltageRecover'] = voltageData?.slice(14, 16)
+          datasInfo3['allLowvoltageDelay'] = voltageData1?.slice(0, 2)
+          datasInfo3['allOverpressureDelay'] = voltageData1?.slice(2, 4)
+          datasInfo3['singleLowvoltageDelayed'] = voltageData1?.slice(4, 6)
+          datasInfo3['singleOverpressureDelay'] = voltageData1?.slice(6, 8)
+          datasInfo3['hardwareOV'] = voltageData2?.slice(0, 2)
+          datasInfo3['hardwareUV'] = voltageData2?.slice(2, 4)
+        } else {
+          await sendCmdSeq(datasInfo3, chipType, deviceId, voltageInfoJson)
+        }
+        dataInfo = getVoltageInfo(datasInfo3, chipType)
+        return dataInfo
+      case 4:
+        let datasInfo4 = {}
+        if (chipType) {
+          let cindex = currentInfoJson.findIndex((el) => el.paramNo == 24)
+          let cindex1 = currentInfoJson.findIndex((el) => el.paramNo == 52)
+          let cindex2 = currentInfoJson.findIndex((el) => el.paramNo == 40)
+          const currentData = await getSysParamCmd(chipType, deviceId, { ...currentInfoJson[cindex], paramLength: 4 })
+          const currentData1 = await getSysParamCmd(chipType, deviceId, { ...currentInfoJson[cindex1], paramLength: 8 })
+          const currentData2 = await getSysParamCmd(chipType, deviceId, { ...currentInfoJson[cindex2], paramLength: 8 })
+          console.log('currentData: ', currentData);
+          datasInfo4['occhg'] = currentData?.slice(0, 2)
+          datasInfo4['dischargeOvercurrentProtect'] = currentData?.slice(2, 4)
+          datasInfo4['chargeOvercurrentDelay'] = currentData1?.slice(0, 2)
+          datasInfo4['chargeOvercurrentRecoverDelay'] = currentData1?.slice(2, 4)
+          datasInfo4['dischargeOvercurrentDelay'] = currentData1?.slice(4, 6)
+          datasInfo4['dischargeOvercurrentRecoverDelay'] = currentData1?.slice(6, 8)
+          datasInfo4['level2OvercurrentProtect'] = currentData2?.slice(0, 2)
+          datasInfo4['level2OvercurrentProtectV'] = currentData2?.slice(2, 4)
+          datasInfo4['shortcircuiProtectRecoverDelay'] = currentData2?.slice(6, 8)
+        } else {
+          await sendCmdSeq(datasInfo4, chipType, deviceId, currentInfoJson)
+        }
+        dataInfo = getCurrentInfo(datasInfo4, chipType)
+        return dataInfo
+      case 5:
+        let datasInfo5 = {}
+        if (chipType) {
+          let tindex = tempInfoJson.findIndex((el) => el.paramNo == 8)
+          let tindex1 = tempInfoJson.findIndex((el) => el.paramNo == 44)
+          const tempData = await getSysParamCmd(chipType, deviceId, { ...tempInfoJson[tindex], paramLength: 16 })
+          const tempData1 = await getSysParamCmd(chipType, deviceId, { ...tempInfoJson[tindex1], paramLength: 8 })
+          console.log('tempData: ', tempData);
+          datasInfo5['chargeHightempProtect'] = tempData?.slice(0, 2)
+          datasInfo5['chargeHightempRecover'] = tempData?.slice(2, 4)
+          datasInfo5['chargeLowtempProtect'] = tempData?.slice(4, 6)
+          datasInfo5['chargeLowtempRecover'] = tempData?.slice(6, 8)
+          datasInfo5['dischargingHightempProtect'] = tempData?.slice(8, 10)
+          datasInfo5['dischargingHightempRecover'] = tempData?.slice(10, 12)
+          datasInfo5['dischargingLowtempProtect'] = tempData?.slice(12, 14)
+          datasInfo5['dischargingLowtempRecover'] = tempData?.slice(14, 16)
+          datasInfo5['chargeLowtempDelay'] = tempData1?.slice(0, 2)
+          datasInfo5['chargeHightempDelay'] = tempData1?.slice(2, 4)
+          datasInfo5['dischargingLowtempDelay'] = tempData1?.slice(4, 6)
+          datasInfo5['dischargingHightempDelay'] = tempData1?.slice(6, 8)
+        } else {
+          await sendCmdSeq(datasInfo5, chipType, deviceId, tempInfoJson)
+        }
+        dataInfo = getTempInfo(datasInfo5, chipType)
+        return dataInfo
+      case 6:
+        let datasInfo6 = {}
+        if (chipType) {
+          const equalizerFunData = await getSysParamCmd(chipType, deviceId, { ...equalizerFunJson[0], paramLength: 4 })
+          console.log('equalizerFunData: ', equalizerFunData);
+          datasInfo6['equalizingVoltage'] = equalizerFunData?.slice(0, 2)
+          datasInfo6['accuracyEqualization'] = equalizerFunData?.slice(2, 4)
+        } else {
+          await sendCmdSeq(datasInfo6, chipType, deviceId, equalizerFunJson)
+        }
+        dataInfo = getEqualizerFunInfo(datasInfo6)
+        return dataInfo
+      case 7:
+        let datasInfo7 = {}
+        if (chipType) {
+          let capVolIndex = capVolInfoJson.findIndex((el) => el.paramNo == 34)
+          let capVolIndex1 = capVolInfoJson.findIndex((el) => el.paramNo == 106)
+          const capVolInfoData = await getSysParamCmd(chipType, deviceId, { ...capVolInfoJson[0], paramLength: 4 })
+          const capVolInfoData1 = await getSysParamCmd(chipType, deviceId, { ...capVolInfoJson[capVolIndex], paramLength: 8 })
+          const capVolInfoData2 = await getSysParamCmd(chipType, deviceId, { ...capVolInfoJson[capVolIndex1], paramLength: 12 })
+          console.log('capVolInfoData: ', capVolInfoData);
+          datasInfo7['fullVolt'] = capVolInfoData?.slice(0, 2)
+          datasInfo7['emptyVolt'] = capVolInfoData?.slice(2, 4)
+          datasInfo7['voltage80p'] = capVolInfoData1?.slice(0, 2)
+          datasInfo7['voltage60p'] = capVolInfoData1?.slice(2, 4)
+          datasInfo7['voltage40p'] = capVolInfoData1?.slice(4, 6)
+          datasInfo7['voltage20p'] = capVolInfoData1?.slice(6, 8)
+          datasInfo7['voltage90p'] = capVolInfoData2?.slice(0, 2)
+          datasInfo7['voltage70p'] = capVolInfoData2?.slice(2, 4)
+          datasInfo7['voltage50p'] = capVolInfoData2?.slice(4, 6)
+          datasInfo7['voltage30p'] = capVolInfoData2?.slice(6, 8)
+          datasInfo7['voltage10p'] = capVolInfoData2?.slice(8, 10)
+          datasInfo7['voltage100p'] = capVolInfoData2?.slice(10, 12)
+
+        } else {
+          await sendCmdSeq(datasInfo7, chipType, deviceId, capVolInfoJson)
+        }
+        dataInfo = getcapVolInfoInfo(datasInfo7, chipType)
+        return dataInfo
+      case 9:
+        let datasInfo9 = {}
+        if (chipType) {
+          const funcAndTempFuncData = await getSysParamCmd(chipType, deviceId, { ...funcAndTempFuncJson[0], paramLength: 4 })
+          console.log('funcAndTempFuncData: ', funcAndTempFuncData);
+          datasInfo9['func'] = funcAndTempFuncData?.slice(0, 2)
+          datasInfo9['tempFunc'] = funcAndTempFuncData?.slice(2, 4)
+        } else {
+          await sendCmdSeq(datasInfo9, chipType, deviceId, funcAndTempFuncJson)
+        }
+        dataInfo = getFuncAndTempFuncInfo(datasInfo9)
+        return dataInfo
+      case 10:
+        let datasInfo10 = {}
+        await sendCmdSeq(datasInfo10, chipType, deviceId, systemJson)
+        dataInfo = getSystemInfo(datasInfo10)
+        return dataInfo
+      case 11: 
+        const counts = await getProtectCountCmd(deviceId)
+        console.log('counts: ', counts);
+        return counts
+      default:
+        if(!paramObj) return null
+        let defaultDataInfo = {}
+        const onedata = await getSysParamCmd(chipType, deviceId, paramObj)
+        defaultDataInfo[paramObj.key] = onedata?.slice(0, 2)
+        return defaultDataInfo
+    }
+  } catch (error) {
+    console.error('error: 读系统参数报错 getBaseParams', error);
+    throw error
+  }
+
+};
+
+/**读取检流阻值 */
+/**
+ * 读取检流阻值
+ * @param {*} chipType 芯片类型
+ * @param {*} deviceId 设备id
+ * @returns 检流阻值
+ */
+export const getResistance = async (chipType, deviceId) => {
+  try {
+    const rsnsValue = await getSysParamCmd(chipType, deviceId, systemJson[2])
+    const CSR = format(rsnsValue, crsDivisor, 0, 2)
+    return CSR
+  } catch (error) {
+    console.error('error: 读检流阻值报错 getResistance', error);
+    throw error
+  }
+}
+
+/**
+ * 
+ * @param {*} datas 读取到的参数对象，对应属性名为所取字段名，值为读取到的原始十六进制值数组
+ * @returns 
+ */
+export const getBaseInfo = async (datas) => {
+  try {
+    console.log('datas: ', datas);
+    const barCode = getCharCodeConnect(datas?.barCode)
+    const manufacturer = getCharCodeConnect(datas?.manufacturer)
+    const model = getCharCodeConnect(datas?.model)
+    const bmsModel = getCharCodeConnect(datas?.bmsModel, true)
+    const producedDate = getProductDate(datas?.producedDate)
+    const bmsAddr = getBmsAddress(datas?.bmsAddr)
+    return {
+      barCode,
+      manufacturer,
+      model,
+      bmsModel,
+      producedDate,
+      bmsAddr,
+    }
+  } catch (error) {
+    console.error('error: ', error);
+  }
+}
+const getCharCodeConnect = (content, clearZero = false) => {
+  console.log('content: ---------------', content);
+  if (!content) return null;
+  const length = content[0]
+  let arr = content.splice(1, length)
+  if (clearZero) {
+    // 去掉数组末尾的0，防止转码后存在空格
+    while (arr[arr.length - 1] === 0) {
+      arr.pop();
+    }
+  }
+  console.log('arr: -------------------', arr);
+  return String.fromCharCode(...arr)
+}
+function getProductDate(content) {
+  if (!content) return null;
+  let arr = content.splice(0, 2)
+  let string = '0x'
+  arr.forEach((el) => {
+    string += decimalToHex(el)
+  })
+  console.log(string, 'string日期');
+  let day = string & 0x1f
+  let month = (string >> 5) & 0x0f
+  let year = 2000 + (string >> 9)
+  return `${year}-${month}-${day}`
+}
+function getBmsAddress(content) { //12个16进制数
+  if (!content) return null;
+  console.log(content, 'content======');
+  let arr = content.splice(0, 12)
+  let string = toHexString(arr)
+  return string
+}
+/**
+ * 数组转换为16进制字符串
+ * @param {*} arr 数组
+ * @returns 16进制字符串
+ */
+function toHexString(arr) {
+  let string = ''
+  arr.forEach((el) => {
+    string += decimalToHex(el)
+  })
+  return string
+}
+const getCapInfo = async (datas) => {
+  console.log('datas: ', datas);
+  const normCap = format(datas.normCap, 0.01, 0, 2)
+  const cycleCap = format(datas.cycleCap, 0.01, 0, 2)
+  const fullCap = format(datas.fullCap, 0.01, 0, 2)
+  return {
+    normCap,
+    cycleCap,
+    fullCap
+  }
+}
+
+const getVoltageInfo = async (datas, chipType) => {
+  console.log('datas: ', datas);
+  const allOvervoltageProtect = format(datas.allOvervoltageProtect, 0.01, 0, 3)
+  const allOverpressureRecovery = format(datas.allOverpressureRecovery, 0.01, 0, 3)
+  const allLowvoltageProtect = format(datas.allLowvoltageProtect, 0.01, 0, 3)
+  const allLowvoltageRecover = format(datas.allLowvoltageRecover, 0.01, 0, 3)
+  const singleOvervoltageProtect = format(datas.singleOvervoltageProtect, 0.001, 0, 3)
+  const singleOverpressureRecovery = format(datas.singleOverpressureRecovery, 0.001, 0, 3)
+  const singleLowvoltageProtect = format(datas.singleLowvoltageProtect, 0.001, 0, 3)
+  const singleLowvoltageRecover = format(datas.singleLowvoltageRecover, 0.001, 0, 3)
+  const hardwareOV = format(datas.hardwareOV, 0.001, 0, 3)
+  const hardwareUV = format(datas.hardwareUV, 0.001, 0, 3)
+  let singleOverpressureDelay = null
+  let singleLowvoltageDelayed = null
+  let allLowvoltageDelay = null
+  let allOverpressureDelay = null
+  if (chipType) {
+    singleOverpressureDelay = format(datas.singleOverpressureDelay, 1)
+    singleLowvoltageDelayed = format(datas.singleLowvoltageDelayed, 1)
+    allLowvoltageDelay = format(datas.allLowvoltageDelay, 1)
+    allOverpressureDelay = format(datas.allOverpressureDelay, 1)
+  } else {
+    // 高字节欠压延时，低字节过压延时，单位是S
+    singleLowvoltageDelayed = datas.singleLowvoltageDelayed[0]
+    singleOverpressureDelay = datas.singleLowvoltageDelayed[1]
+    allLowvoltageDelay = datas.allLowvoltageDelay[0]
+    allOverpressureDelay = datas.allLowvoltageDelay[1]
+  }
+  return {
+    allOvervoltageProtect,
+    allOverpressureRecovery,
+    allLowvoltageProtect,
+    allLowvoltageRecover,
+    singleOvervoltageProtect,
+    singleOverpressureRecovery,
+    singleLowvoltageProtect,
+    singleLowvoltageRecover,
+    singleOverpressureDelay,
+    singleLowvoltageDelayed,
+    hardwareOV,
+    hardwareUV,
+    allLowvoltageDelay,
+    allOverpressureDelay,
+  }
+}
+const getCurrentInfo = async (datas, chipType) => {
+  console.log('datas: ', datas);
+  const occhg = format(datas.occhg, 0.01, 0, 3)
+  // 采用补码形式传送
+  const dischargeOvercurrentProtect = (datas.dischargeOvercurrentProtect || datas.dischargeOvercurrentProtect == 0) && (format(datas.dischargeOvercurrentProtect, 1, 0, 3) - 0x10000) * 0.01
+
+  let chargeOvercurrentDelay = null
+  let chargeOvercurrentRecoverDelay = null
+  let dischargeOvercurrentDelay = null
+  let dischargeOvercurrentRecoverDelay = null
+  let shortcircuiProtectRecoverDelay = null
+  let leve2OvercurrentDelay = 0
+  let level2OvercurrentProtect = 0
+  let shortcircuiProtect = 0
+  let shortcircuiProtectDelay = 0
+  let level2OvercurrentProtectV = null
+  let overAndUnderDelay = 0
+  if (chipType) {
+    chargeOvercurrentDelay = format(datas.chargeOvercurrentDelay, 1)
+    chargeOvercurrentRecoverDelay = format(datas.chargeOvercurrentRecoverDelay, 1)
+    dischargeOvercurrentDelay = format(datas.dischargeOvercurrentDelay, 1)
+    dischargeOvercurrentRecoverDelay = format(datas.dischargeOvercurrentRecoverDelay, 1)
+    shortcircuiProtectRecoverDelay = format(datas.shortcircuiProtectRecoverDelay, 1)
+    level2OvercurrentProtect = getNewProtectAndDelay(datas.level2OvercurrentProtect).value1
+    leve2OvercurrentDelay = getNewProtectAndDelay(datas.level2OvercurrentProtect).value2
+    shortcircuiProtect = getNewProtectAndDelay(datas.level2OvercurrentProtectV).value1
+    shortcircuiProtectDelay = getNewProtectAndDelay(datas.level2OvercurrentProtectV).value2
+  } else {
+    chargeOvercurrentDelay = datas.chargeOvercurrentDelay[0]
+    chargeOvercurrentRecoverDelay = datas.chargeOvercurrentDelay[1]
+    dischargeOvercurrentDelay = datas.dischargeOvercurrentDelay[0]
+    dischargeOvercurrentRecoverDelay = datas.dischargeOvercurrentDelay[1]
+    overAndUnderDelay = datas.shortcircuiProtectRecoverDelay[0] //存储硬件过欠压延时信息 写入短路释放延时时需传
+    shortcircuiProtectRecoverDelay = datas.shortcircuiProtectRecoverDelay[1]
+    level2OvercurrentProtectV = getOldProtectAndDelay(datas.level2OvercurrentProtect).double
+    shortcircuiProtect = getOldProtectAndDelay(datas.level2OvercurrentProtect).value1
+    shortcircuiProtectDelay = getOldProtectAndDelay(datas.level2OvercurrentProtect).value2
+    level2OvercurrentProtect = getOldProtectAndDelay(datas.level2OvercurrentProtect).value3
+    leve2OvercurrentDelay = getOldProtectAndDelay(datas.level2OvercurrentProtect).value4
+  }
+  return {
+    occhg,
+    dischargeOvercurrentProtect,
+    chargeOvercurrentDelay,
+    chargeOvercurrentRecoverDelay,
+    dischargeOvercurrentDelay,
+    dischargeOvercurrentRecoverDelay,
+    leve2OvercurrentDelay,
+    level2OvercurrentProtectV,
+    shortcircuiProtectRecoverDelay,
+    shortcircuiProtect,
+    shortcircuiProtectDelay,
+    level2OvercurrentProtect,
+    overAndUnderDelay
+  }
+}
+function getNewProtectAndDelay(arr) {
+  if(arr?.length !== 2) return {
+    value1: 0,
+    value2: 0
+  }
+  // 根据协议文档说明计算 
+  // 读取出来的是两个字节的十进制,分别转为8位二进制,再拼接
+  // 将数组元素转换为二进制字符串
+  let binaryString = arr.map(num => num.toString(2).padStart(8, '0')).join('');
+  // 将二进制字符串转换为数组
+  let resultArray = binaryString.split('').map(Number)
+  let arr1 = resultArray.slice(8, 12)
+  let arr2 = resultArray.slice(12)
+  const value1 = parseInt(arr1.join(''), 2);
+  const value2 = parseInt(arr2.join(''), 2);
+  return {
+    value1,
+    value2
+  }
+}
+// 获取旧协议的过流和短路数据
+function getOldProtectAndDelay(arr) {
+  if(arr?.length !== 2) return {
+    double: false,
+    value1: 0,
+    value2: 0,
+    value3: 0,
+    value4: 0
+  }
+  // 根据协议文档说明计算 
+  const binaryString = arr.map(num => num.toString(2).padStart(8, '0')).join('');
+  console.log('【解析硬件过流及短路】', binaryString);
+  const resultArray = binaryString.split('').map(Number);
+  const arr1 = [0, ...resultArray.slice(5, 8)]
+  const arr2 = resultArray.slice(1, 5)
+  const arr3 = resultArray.slice(12)
+  const arr4 = resultArray.slice(8, 12)
+  const value1 = parseInt(arr1.join(''), 2);
+  const value2 = parseInt(arr2.join(''), 2);
+  const value3 = parseInt(arr3.join(''), 2);
+  const value4 = parseInt(arr4.join(''), 2);
+
+  return {
+    double: resultArray[0] === 1, // 双倍值判断
+    value1,
+    value2,
+    value3,
+    value4
+  };
+}
+
+const getTempInfo = (datas, chipType) => {
+  console.log('datas: ', datas);
+  const chargeHightempProtect = formatTemp(datas.chargeHightempProtect)
+  const chargeHightempRecover = formatTemp(datas.chargeHightempRecover)
+  const chargeLowtempProtect = formatTemp(datas.chargeLowtempProtect)
+  const chargeLowtempRecover = formatTemp(datas.chargeLowtempRecover)
+  const dischargingHightempProtect = formatTemp(datas.dischargingHightempProtect)
+  const dischargingHightempRecover = formatTemp(datas.dischargingHightempRecover)
+  const dischargingLowtempProtect = formatTemp(datas.dischargingLowtempProtect)
+  const dischargingLowtempRecover = formatTemp(datas.dischargingLowtempRecover)
+  let chargeHightempDelay = null
+  let chargeLowtempDelay = null
+  let dischargingHightempDelay = null
+  let dischargingLowtempDelay = null
+  if (chipType) {
+    chargeHightempDelay = format(datas.chargeHightempDelay, 1)
+    chargeLowtempDelay = format(datas.chargeLowtempDelay, 1)
+    dischargingHightempDelay = format(datas.dischargingHightempDelay, 1)
+    dischargingLowtempDelay = format(datas.dischargingLowtempDelay, 1)
+  } else {
+    chargeHightempDelay = datas.chargeLowtempDelay[1]
+    chargeLowtempDelay = datas.chargeLowtempDelay[0]
+    dischargingHightempDelay = datas.dischargingLowtempDelay[1]
+    dischargingLowtempDelay = datas.dischargingLowtempDelay[0]
+  }
+  return {
+    chargeHightempProtect,
+    chargeHightempRecover,
+    chargeLowtempProtect,
+    chargeLowtempRecover,
+    dischargingHightempProtect,
+    dischargingHightempRecover,
+    dischargingLowtempProtect,
+    dischargingLowtempRecover,
+    chargeHightempDelay,
+    chargeLowtempDelay,
+    dischargingHightempDelay,
+    dischargingLowtempDelay
+  }
+}
+
+const getEqualizerFunInfo = (datas) => {
+  const equalizingVoltage = format(datas.equalizingVoltage, 0.001, 0, 3)
+  const accuracyEqualization = format(datas.accuracyEqualization, 1, 0, 2)
+  return {
+    equalizingVoltage,
+    accuracyEqualization
+  }
+}
+const getcapVolInfoInfo = (datas) => {
+  const fullVolt = format(datas.fullVolt, 0.001, 0, 3)
+  const emptyVolt = format(datas.emptyVolt, 0.001, 0, 3)
+  const voltage10p = format(datas.voltage10p, 0.001, 0, 3)
+  const voltage20p = format(datas.voltage20p, 0.001, 0, 3)
+  const voltage30p = format(datas.voltage30p, 0.001, 0, 3)
+  const voltage40p = format(datas.voltage40p, 0.001, 0, 3)
+  const voltage50p = format(datas.voltage50p, 0.001, 0, 3)
+  const voltage60p = format(datas.voltage60p, 0.001, 0, 3)
+  const voltage70p = format(datas.voltage70p, 0.001, 0, 3)
+  const voltage80p = format(datas.voltage80p, 0.001, 0, 3)
+  const voltage90p = format(datas.voltage90p, 0.001, 0, 3)
+  const voltage100p = format(datas.voltage100p, 0.001, 0, 3)
+  return {
+    fullVolt,
+    emptyVolt,
+    voltage10p,
+    voltage20p,
+    voltage30p,
+    voltage40p,
+    voltage50p,
+    voltage60p,
+    voltage70p,
+    voltage80p,
+    voltage90p,
+    voltage100p,
+  }
+}
+const getFuncAndTempFuncInfo = (datas) => {
+  const binaryFuncArr = formatBinary(datas.func)
+  const binaryTempArr = formatBinary(datas.tempFunc)
+  const func = {}
+  // 遍历funcJson数组，将每个对象的key属性作为funcObj的属性名，值设为binaryFuncArr对应值
+  funcJson.forEach((item, index) => {
+    if (item.key) {
+      func[item.key] = binaryFuncArr[index]
+    }
+  })
+  const tempFunc = {}
+  tempFuncJson.forEach((item, index) => {
+    if (item.key) {
+      tempFunc[item.key] = binaryTempArr[index]
+    }
+  })
+  return { func, tempFunc }
+}
+const getSystemInfo = (datas) => {
+  const serialNumber = format(datas.serialNumber, 1)
+  const cycleCount = format(datas.cycleCount, 1)
+  const strCount = format(datas.strCount, 1)
+  const rsnsValue = format(datas.rsnsValue, crsDivisor, 0, 2)
+  // const identifyCurrent = format(datas.identifyCurrent, 1)
+  // const sleepTime = format(datas.sleepTime, 1)
+  // const capacityInterval = format(datas.capacityInterval, 1)
+  return {
+    serialNumber,
+    cycleCount,
+    strCount,
+    rsnsValue,
+    // identifyCurrent,
+    // sleepTime,
+    // capacityInterval
+  }
+}