@jiabaida/tools 1.0.0 → 1.0.2

package/src/core/BleCmdAnalysis/BleCmdDD.js

@@ -0,0 +1,1214 @@
+import { getData } from './BleCmdAnalysis.js'
+import { generateCrcCheckSum, decimalToHex, hex2string, hexArr2string, hexToDecimal, stringToTwoHexArray, hexArr2Assic, generateCrc16modbusCheck } from '../BleDataProcess';
+import { getFFAA80Async, resolveFFAA80 } from './BleCmdFFAA.js';
+// #region 进出工厂
+/**进工厂 */
+export const enterFactory = async (deviceId) => {
+  return set_PlanCMD_DD(deviceId, 'DD5A00025678FF3077');
+}
+/**写参数退工厂 */
+export const existFactory = async (deviceId) => {
+  return set_PlanCMD_DD(deviceId, 'DD5A01022828ffad77');
+}
+/**读参数退工厂 */
+export const readExistFactory = async (deviceId) => {
+  return set_PlanCMD_DD(deviceId, 'DD5A01020000FFFD77');
+}
+// #region DD通用指令
+/**DD通用指令
+ * @param {*} deviceId
+ * @param {*} command eg: 'DD5A01020000FFFD77'
+ * @returns
+ */
+export const set_PlanCMD_DD = async (deviceId, command) => {
+  if (typeof command == 'string') {
+    command = command.match(/(.{2})/g).map((o) => `0x${o}`);
+  }
+  let result = null;
+  try {
+    const data = await getData(
+      deviceId,
+      {
+        command,
+        commandVerifyHandler: (hexArr) => ({ verified: hexArr[0] == 0xdd, pkgLen: hexArr[3] + 7 }),
+        pkgVerifyHandler: (pkg) => ({ verified: true }),
+      },
+      'PlanCMD_DD'
+    );
+    if (data) {
+      const dataStr = hexArr2string(data);
+      const content = data.slice(4, data.length - 3);
+      result = {
+        data,
+        dataStr,
+        status: hex2string(data[2]),
+        len: data[3],
+        content,
+      };
+    } else {
+      result = {
+        status: 0,
+        content: [],
+      };
+    }
+  } catch (error) {
+    console.error(error);
+  }
+  return result;
+}
+
+// #region 3B3C指令
+export const set_PlanCMD_3B3C = async (deviceId, command) => {
+  if (typeof command == 'string') {
+    command = command.match(/(.{2})/g).map((o) => `0x${o}`);
+  }
+  let result = null;
+  try {
+    const data = await getData(
+      deviceId,
+      {
+        command,
+        commandVerifyHandler: (hexArr) => ({ verified: hexArr[0] == 0x3b && hexArr[1] == 0x3c, pkgLen: hexArr[11] + 15 }),
+        pkgVerifyHandler: (pkg) => ({ verified: true }),
+      },
+      'PlanCMD_3B3C'
+    );
+    if (data) {
+      const dataStr = hexArr2string(data);
+      const content = data.slice(12, data.length - 3);
+      result = {
+        dataStr,
+        status: data[10] == 0x80 ? 1 : 0, // 0x80表示失败
+        addr: hexArr2string(data.slice(2, 10)),
+        content,
+      };
+    }
+  } catch (error) {
+    console.error(error);
+  }
+  return result;
+}
+
+// #region 获取设备3B3C信息包
+/** 获取设备3B3C信息包
+ *
+ * @param {*} deviceId
+ * @returns
+ */
+export const get3B3CAsync = async (deviceId) => {
+  const /*帧头*/ header = ['0x3b', '0x3c'];
+  const /*地址码*/ addressCode = ['0x00', '0x00', '0x00', '0x00', '0x00', '0x00', '0x00', '0x00'];
+  const /*命令码*/ commandCode = ['0x01'];
+  const /*数据内容*/ data = [];
+  const /*数据内容长度*/ dataLength = [`0x${decimalToHex(data.length, 2)}`];
+  const /*校验位(地址码~数据内容)*/ check = generateCrc16modbusCheck([...addressCode, ...commandCode, ...dataLength, ...data], false);
+  const /*帧尾*/ footer = ['0x0d'];
+
+  // 帧头-地址码-命令码-数据内容长度-数据内容(没有时为空)-校验位-帧尾 3B3C-0000000000000000-01-00-NULL-9771-0D
+
+  const command = [...header, ...addressCode, ...commandCode, ...dataLength, ...data, ...check, ...footer];
+  const response = '3B3C010000000000000001470104070235000208555031365330313503154A42442D4C313653323030412E31302E30322E3031041E4A4244343831303030303100000000000000000000000000000000000000327A0D';
+  return getData(
+    deviceId,
+    {
+      command,
+      commandVerifyHandler: (hexArr) => ({ verified: hexArr[0] == 0x3b && hexArr[1] == 0x3c, pkgLen: hexArr[11] + 15 }),
+      pkgVerifyHandler: (pkg) => {
+        const len = pkg.length;
+        const [c1, c2] = generateCrc16modbusCheck(pkg.slice(2, len - 3));
+        const [_c1, _c2] = [pkg[len - 3], pkg[len - 2]];
+        return { verified: c1 == _c1 && c2 == _c2 };
+      },
+    },
+    '3B3C'
+  );
+}
+
+// #region 解析3B3C信息包
+/** 解析3B3C信息包
+ *
+ * @param {number[]} data 3b3c十六进制数据数组
+ * @returns
+ */
+export const resolve3B3C = (data) => {
+  if (!data) return null;
+  // [59, 60, 1, 0, 0, 0, 0, 0, 0, 0, 1, 71, 1, 4, 7, 2, 53, 0, 2, 8, 85, 80, 49, 54, 83, 48, 49, 53, 3, 21, 74, 66, 68, 45, 76, 49, 54, 83, 50, 48, 48, 65, 46, 49, 48, 46, 48, 50, 46, 48, 49, 4, 30, 74, 66, 68, 52, 56, 49, 48, 48, 48, 48, 49, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 50, 122, 13]
+  // 3B3C010000000000000001470104070235000208555031365330313503154A42442D4C313653323030412E31302E30322E3031041E4A4244343831303030303100000000000000000000000000000000000000327A0D
+
+  // [59, 60, 0, 0, 0, 0, 0, 0, 0, 0, 1, 22, 1, 4, 0, 2, 1, 0, 2, 0, 3, 10, 68, 72, 48, 52, 46, 49, 46, 52, 46, 55, 4, 0, 119, 90, 13];
+  // 3B3C000000000000000001160104000201000200030A444830342E312E342E370400775A0D
+  const dataStr = hexArr2string(data);
+  let result = {
+    dataStr,
+    status: hex2string(data[10]),
+    addr: hexArr2string(data.slice(2, 10)),
+  };
+  const content = data.slice(12, data.length - 3);
+  const CONTENT = [/*产品类型-TYPE*/ '01', /*产品类型标识长度*/ '04', /*产品类型表示*/ '00', /*前端类型标识*/ '02', /*协议版本标识*/ '01', /*层级关系架构*/ '00', /*硬件版本号-TYPE*/ '02', /*硬件版本号长度*/ '00', /*软件版本号-TYPE*/ '03', /*软件版本号长度*/ '0a', /*软件版本号内容ASCII*/ '44', /*软件版本号内容ASCII*/ '48', /*软件版本号内容ASCII*/ '30', /*软件版本号内容ASCII*/ '34', /*软件版本号内容ASCII*/ '2e', /*软件版本号内容ASCII*/ '31', /*软件版本号内容ASCII*/ '2e', /*软件版本号内容ASCII*/ '34', /*软件版本号内容ASCII*/ '2e', /*软件版本号内容ASCII*/ '37', /*PCB-TYPE*/ '04', /*PCB内容长度*/ '00'];
+  while (content.length > 0) {
+    const [v1, v2, ...v] = content.splice(0, content[1] + 2);
+    if (v1 == 0x01) {
+      result['productFlag'] = hex2string(v1);
+      result['productLen'] = v2;
+      if (v) {
+        const [productType, frontType, protocolV, level] = v.map((o) => hex2string(o));
+        Object.assign(result, { productType, frontType, protocolV, level });
+      }
+    }
+    if (v1 == 0x02) {
+      result['hardwareFlag'] = hex2string(v1);
+      result['hardwareLen'] = v2;
+      result['hardwareV'] = hexArr2Assic(v);
+    }
+    if (v1 == 0x03) {
+      result['sofewareFlag'] = hex2string(v1);
+      result['sofewareLen'] = v2;
+      result['sofewareV'] = hexArr2Assic(v);
+    }
+    if (v1 == 0x04) {
+      result['pcbFlag'] = hex2string(v1);
+      result['pcbLen'] = v2;
+      result['pcbContent'] = hexArr2Assic(v);
+    }
+  }
+  return result;
+}
+
+// #region 获取设备基本信息03指令
+/** 获取设备基本信息03指令
+ *
+ * @param {*} deviceId
+ * @returns
+ */
+export const getDDA503Async = async (deviceId) => {
+  const command = ['0xdd', '0xa5', '0x03', '0x00', '0xff', '0xfd', '0x77'];
+  const response = 'DD03002313E10000199D27100000310F00000000000014410310060BB60BC60BC10BBA0BBD0BC1F89777';
+
+  const hex = await getData(
+    deviceId,
+    {
+      command,
+      commandVerifyHandler: (hexArr) => ({ verified: hexArr[0] == 0xdd && hexArr[1] == 0x03, pkgLen: hexArr[3] + 7 }),
+      pkgVerifyHandler: (pkg) => {
+        const len = pkg.length;
+        const [c1, c2] = generateCrcCheckSum(pkg.slice(2, len - 3));
+        const [_c1, _c2] = [pkg[len - 3], pkg[len - 2]];
+        return { verified: c1 == _c1 && c2 == _c2 };
+      },
+    },
+    'DDA5_03'
+  );
+  if (!hex) return null;
+  return resolveDDA503(hex);
+}
+
+// #region 解析基本信息03指令
+/** 解析基本信息03指令
+ *
+ * @param {number[]} data DDA503十六进制数据数组
+ * @returns {Object} 解析后的设备信息对象
+ * @returns {string} dataStr 十六进制数据数组转换后的字符串
+ * @returns {string} status 状态信息的字符串表示
+ * @returns {number} len 数据长度
+ * @returns {string} softwareV 软件版本信息的字符串表示
+ * @returns {boolean} chargeSwitch 充电开关状态，true 表示打开，false 表示关闭
+ * @returns {boolean} dischargeSwitch 放电开关状态，true 表示打开，false 表示关闭
+ * @returns {string} BMSVersion BMS 软件版本号
+ * @returns {string} totalVoltage 总电压，单位伏特，保留两位小数
+ * @returns {number} electricity 总电流，单位安培，保留两位小数
+ * @returns {string} power 功率，单位瓦特，保留两位小数
+ * @returns {number} soc 电池剩余电量百分比
+ * @returns {number} surplusCapacity 剩余容量，单位 Ah，保留两位小数
+ * @returns {number} normCap 标称容量，单位 Ah，保留两位小数
+ * @returns {number} humidity 湿度值
+ * @returns {number} cycleIndex 循环次数
+ * @returns {number} fullChargeCapacity 满充容量，单位 Ah
+ * @returns {number} SOH 电池健康状态百分比
+ * @returns {boolean} heatingState 是否正在加热，true 表示正在加热，false 表示未加热
+ * @returns {number} heatingCurrent 加热电流，单位 mA
+ * @returns {boolean} isFactoryMode 是否处于工厂模式，true 表示是，false 表示否
+ * @returns {boolean} equilibriumStatus 均衡状态，true 表示正在均衡，false 表示未均衡
+ * @returns {boolean} protectStatus 保护状态，true 表示存在保护状态，false 表示正常
+ * @returns {string} protectStatusIndex 发生保护的状态索引，以逗号分隔的字符串
+ * @returns {number} ntcNums NTC 传感器数量
+ * @returns {string[]} temperaturesList 温度列表，单位摄氏度，保留一位小数
+ * @returns {string[]} fahTempList 华氏度温度列表，保留一位小数
+ * @returns {number} fet FET 状态值
+ * balances 单串均衡数组
+ */
+export const resolveDDA503 = (data) => {
+  if (!data) return null;
+  const cmdResp03 = hexArr2string(data);
+  const content = data.slice(4, data.length - 3);
+
+  const binArr = data[24].toString(2).padStart(8, '0').split('').reverse();
+
+  const balances = data.slice(16, 20).flatMap((byte) =>
+    byte.toString(2).padStart(8, "0").split("").reverse()
+  );
+  console.warn("BC: ---------------", balances);
+  const fet = data[24];
+  /**充电开关 */
+  const chargeSwitch = !!Number(binArr[0]);
+  const dischargeSwitch = !!Number(binArr[1]);
+
+  /** 软件版本 */
+  const BMSVersion = decimalToHex(data[22]);
+
+  const humidityIndex = data[26] * 2 + 27;
+  /**湿度 */
+  const humidity = data[humidityIndex];
+  // 判断电流及容量单位，默认10mAh, 当fet控制状态bit7=1或者湿度值为88(十六进制，对应十进制136)时，单位为100mAh
+  const n = !!Number(binArr[7]) || humidity == 136 ? 10 : 100;
+  /**总电压 */
+  const totalVoltage = Number((((data[4] << 8) + (data[5] & 0x0ff)) / 100).toFixed(2))
+  let current = (data[6] << 8) + (data[7] & 0x0ff);
+  current = current > 32768 ? (current - 65536) / n : current / n;
+  /**总电流 */
+  const electricity = Number(current.toFixed(2));
+  /**功率 */
+  const power = Number((totalVoltage * electricity).toFixed(2));
+  /** soc % */
+  const soc = data[23] ?? 0;
+  /** 串数 */
+  const seriesNum = data[25] ?? 0;
+
+  const volumeHex = decimalToHex(data[8]) + decimalToHex(data[9]); // 10mAh
+
+  /** 剩余容量 */
+  const surplusCapacity = Number((hexToDecimal(volumeHex) / n).toFixed(2));
+
+  const normCapHex = decimalToHex(data[10]) + decimalToHex(data[11]);
+  /** 标称容量 */
+  const normCap = Number((hexToDecimal(normCapHex) / n).toFixed(2));
+
+  const cycleHex = decimalToHex(data[12]) + decimalToHex(data[13]);
+  /** 循环次数 */
+  const cycleIndex = hexToDecimal(cycleHex);
+
+  const fccHex = decimalToHex(data[humidityIndex + 3]) + decimalToHex(data[humidityIndex + 4]);
+  /** 满充容量 */
+  const fullChargeCapacity = Number((hexToDecimal(fccHex) / n).toFixed(2));
+  const SOH = cycleIndex <= 100 ? 100 : Math.min(100, (fullChargeCapacity / normCap) * 100);
+  /**是否正在加热 当FET bit3=1 OR bit4=1（任意一个为1），则加热状态=开*/
+  const heatingState = !!Number(binArr[4]) || !!Number(binArr[3])
+  /**加热电流 */
+  let heatingCurrent = null;
+  // 判断模组回复长度（内容长度加起止位命令码等）是否大于计算出的加热电流的索引加上校验码停止位（由于是索引，长度需加1）
+  const hasHeatingCurrent = data[3] + 7 >= humidityIndex + 9 + 4 + 1;
+  const hasEquilCurrent = data[3] + 7 >= humidityIndex + 7 + 4 + 1;
+  // 如果处于加热状态且存在加热电流数据
+  if (heatingState && hasHeatingCurrent) {
+    const i = humidityIndex + 9;
+    heatingCurrent = heatingCurrent = (
+      ((data[i] << 8) | data[i + 1]) /
+      100
+    ).toFixed(2);
+  }
+  let equilibriumCurrent = null;
+  // 均衡电流
+  if (hasEquilCurrent) {
+    const i = humidityIndex + 7;
+    let equilCurrent = (data[i] << 8) + (data[i + 1] & 0x0ff);
+    equilCurrent = equilCurrent > 32768 ? (equilCurrent - 65536) / 1000 : equilCurrent / 1000;
+    equilibriumCurrent = Number(equilCurrent.toFixed(2));
+  }
+  /**是否是工厂模式 */
+  const isFactoryMode = !!Number(binArr[6]);
+  /**均衡状态 */
+  const equilibriumStatus = !(data[16] === 0 && data[17] === 0);
+  /**保护状态 */
+  const protectStatus = !(data[20] === 0 && data[21] === 0);
+  // 解析保护状态
+  const protectStateHex = decimalToHex(data[20]) + decimalToHex(data[21]);
+  const protVal = hexToDecimal(protectStateHex);
+
+  // 告警状态下标
+  let alarmIndex = data[26] * 2 + 28;
+  let alarmStateHex = decimalToHex(data[alarmIndex]) + decimalToHex(data[alarmIndex + 1]);
+  let alarmsState = hexToDecimal(alarmStateHex);
+
+  const ntcNums = data[26] & 0xff;
+  /**温度 */
+  const temperaturesList = Array.from({ length: ntcNums }, (_, i) => {
+    const tempH = data[26 + i * 2 + 1] & 0xff;
+    const tempL = data[26 + i * 2 + 2] & 0xff;
+    return ((tempH * 256 + tempL - 2731) / 10).toFixed(1);
+  });
+  /** 华氏度 */
+  const fahTempList = []
+  temperaturesList.forEach((el) => {
+    const value = Number(el) * (9 / 5) + 32;
+    fahTempList.push(value.toFixed(1))
+  })
+  const temperatures = temperaturesList.map((item, index) => ({
+    name: index + 1,
+    value: item,
+  }));
+  return {
+    cmdResp03,
+    status: hex2string(data[2]),
+    len: data[3],
+    softwareV: hex2string(content[18]),
+    balances,
+    BMSVersion,
+    soc,
+    normCap,
+    surplusCapacity,
+    totalVoltage,
+    electricity,
+    power,
+    cycleIndex,
+    equilibriumStatus,
+    chargeSwitch,
+    dischargeSwitch,
+    temperatures,
+    humidity,
+    protectStatus,
+    fullChargeCapacity,
+    SOH,
+    heatingState,
+    heatingCurrent,
+    equilibriumCurrent,
+    isFactoryMode,
+    protVal,
+    alarmsState,
+    ntcNums,
+    temperaturesList,
+    fahTempList,
+    fet,
+    seriesNum,
+  };
+}
+
+// #region 获取DDA504数据
+/** 获取DDA504数据
+ * 电压数据
+ * @param {*} deviceId
+ * @returns
+ */
+export const getDDA504Async = async (deviceId, dataScope) => {
+  const command = ['0xdd', '0xa5', '0x04', '0x00', '0xff', '0xfc', '0x77'];
+  const response = '';
+
+  const hex = await getData(
+    deviceId,
+    {
+      command,
+      commandVerifyHandler: (hexArr) => ({ verified: hexArr[0] == 0xdd && hexArr[1] == 0x04, pkgLen: hexArr[3] + 7 }),
+      pkgVerifyHandler: (pkg) => {
+        const len = pkg.length;
+        const [c1, c2] = generateCrcCheckSum(pkg.slice(2, len - 3));
+        const [_c1, _c2] = [pkg[len - 3], pkg[len - 2]];
+        return { verified: c1 == _c1 && c2 == _c2 };
+      },
+    },
+    'DDA5_04'
+  );
+  if (!hex) return null;
+  return resolveDDA504(hex, dataScope);
+}
+
+// #region 解析DDA504数据
+/**
+ * 解析硬件电压数据 04 指令
+ *
+ * @param {number[]} data DDA504十六进制数据数组
+ * @param {boolean} [dataScope=false] 是否启用高精度数据解析，默认值为 false
+ * @returns {Object} 解析后的电压数据对象
+ * @returns {string} dataStr 十六进制数据数组转换后的字符串
+ * @returns {number[]} voltageList 电压列表，根据 dataScope 保留不同精度
+ * @returns {number|null} highestVoltage 最高电压，根据 dataScope 保留不同精度，若电压列表为空则为 null
+ * @returns {number|null} lowestVoltage 最低电压，根据 dataScope 保留不同精度，若电压列表为空则为 null
+ * @returns {number|null} averageVoltage 平均电压，根据 dataScope 保留不同精度，若电压列表为空则为 null
+ * @returns {number|null} dropoutVoltage 电压差，根据 dataScope 保留不同精度，若电压列表为空则为 null
+ */
+export const resolveDDA504 = (data, dataScope) => {
+  console.log('data: ', data);
+  if (!data) return null;
+  const cmdResp04 = hexArr2string(data);
+  const voltageList = [];
+  for (let index = 4; index < parseInt(data[3]) + 4; index += 2) {
+
+    let voltageHex = decimalToHex(data[index]) + decimalToHex(data[index + 1]);
+    let voltage = hexToDecimal(voltageHex);
+    voltageList.push(Number(voltage));
+  }
+  let highestVoltage = null
+  let lowestVoltage = null
+  let averageVoltage = null
+  let dropoutVoltage = null
+  if (voltageList.length > 0) {
+    // 最高、最低电压
+    highestVoltage = Math.max(...voltageList);
+    lowestVoltage = Math.min(...voltageList);
+    // 计算平均电压
+    const sum = voltageList.reduce((acc, cur) => acc + cur, 0);
+    averageVoltage = sum / voltageList.length;
+    // 压差
+    const dropout = highestVoltage - lowestVoltage;
+
+    // 精度处理
+    const precision = dataScope ? 3 : 2;
+    highestVoltage = Number((highestVoltage / 1000).toFixed(precision));
+    lowestVoltage = Number((lowestVoltage / 1000).toFixed(precision));
+    averageVoltage = Number((averageVoltage / 1000).toFixed(precision));
+    dropoutVoltage = Number((dropout / 1000).toFixed(precision));
+  }
+  voltageList.forEach((v, i) => {
+    let newV = v / 1000
+    voltageList[i] = Number(newV.toFixed(dataScope ? 3 : 2));
+  });
+  const voltageSeries = voltageList.map((item, index) => ({
+    name: index + 1,
+    value: item,
+  }));
+  return {
+    cmdResp04,
+    voltageList,
+    voltageSeries,
+    highestVoltage,
+    lowestVoltage,
+    averageVoltage,
+    dropoutVoltage
+  };
+}
+
+// #region 获取芯片类型
+/** 获取芯片类型
+ *
+ * @param {*} deviceId
+ * @returns
+ */
+export const getChipTypeAsync = async (deviceId) => {
+  const command = ['0xdd', '0xa5', '0x00', '0x00', '0x00', '0x00', '0x77'];
+  const hex = await getData(
+    deviceId,
+    {
+      command,
+      commandVerifyHandler: (hexArr) => ({ verified: hexArr[0] == 0xdd && hexArr[1] == 0x00, pkgLen: hexArr[3] + 7 }),
+      pkgVerifyHandler: (pkg) => {
+        const len = pkg.length;
+        const [c1, c2] = generateCrcCheckSum(pkg.slice(2, len - 3));
+        const [_c1, _c2] = [pkg[len - 3], pkg[len - 2]];
+        return { verified: c1 == _c1 && c2 == _c2 };
+      },
+    },
+    'DDA5_00'
+  );
+  if (!hex) return null;
+  return resolveDDA500(hex);
+}
+
+// #region 解析芯片类型
+/** 解析芯片类型
+ *
+ * @param {number[]} data DDA500十六进制数据数组
+ * @returns {Object} 解析后的芯片类型对象
+ * @returns {string} dataStr 十六进制数据数组转换后的字符串
+ * @returns {string} status 状态码
+ * @returns {number} len 数据长度
+ * @returns {string} type 芯片类型
+ */
+export const resolveDDA500 = (data) => {
+  // 'dd00 0002 0005 fff9 77';
+  // 当XX = 0或者发送该指令不回复时，默认BMS方案为TI方案，
+  // 当XX = 1时 为凹凸方案
+  // 当XX = 2时 为新塘松下方案
+  // 当XX = 3时 为中颖309方案
+  // 当XX = 4时 为中颖303方案，
+  // 当XX = 5时 为集澈芯片
+  if (!data) return null;
+  const dataStr = hexArr2string(data);
+  return {
+    dataStr,
+    status: hex2string(data[2]),
+    len: data[3],
+    type: data[5],
+  };
+}
+
+// #region 设置MOS开关 E1指令
+/**设置MOS开关
+ * value:
+ * 0x00 - 充电MOS打开 放电MOS打开
+ * 0x01 - 充电MOS关闭 放电MOS打开
+ * 0x02 - 充电MOS打开 放电MOS关闭
+ * 0x03 - 充电MOS关闭 放电MOS关闭
+ */
+export const getDD5AE1Async = async (deviceId, value) => {
+  const _command = ['0xE1', '0x02', '0x00' /*0x00用户级别控制  0xaa运营级别控制*/, value];
+  const checks = generateCrcCheckSum(_command);
+  const command = ['0xDD', '0x5A', ..._command, ...checks, '0x77'];
+
+  // T： DD 5A E1 02 00 02 FF 1B 77
+  // R： DD E1 00000000 77
+  return getData(
+    deviceId,
+    {
+      command,
+      commandVerifyHandler: (hexArr) => ({ verified: hexArr[0] == 0xdd && hexArr[1] == 0xe1, pkgLen: hexArr[3] + 7 }),
+      pkgVerifyHandler: (pkg) => {
+        return { verified: true };
+      },
+    },
+    'DD5A_E1'
+  );
+}
+
+// #region 设置MOS开关 FB指令
+/**设置MOS开关 FB
+   * type:
+   * 0x00 - 放电MOS 
+   * 0x01 - 充电MOS
+   * 0x03 - 预放电MOS
+   * 0x05 - 电池激活
+   * 0x06 - 加热控制
+   * 
+   * value:
+   * 0x00 - 打开
+   * 0x01 - 关闭
+   * 
+   * 电池激活 value:   
+   * 0x00 - 解除激活
+   * 0x01 - 激活
+   * 0x02 - 试用30分钟激活
+   * 0x03 - 试用一小时激活
+   * 0x04 - 试用两小时激活
+   * 0x05 - 试用三小时激活
+   * * 加热控制 value:
+   * 0x00 - 关闭加热
+   * 0x01 - 开启加热
+   */
+export const getDD5AFBAsync = async (deviceId, type, value) => {
+  const _command = ['0xFB', '0x02', type, value];
+  const checks = generateCrcCheckSum(_command);
+  const command = ['0xDD', '0x5A', ..._command, ...checks, '0x77'];
+  console.log('command: ', command);
+  return getData(
+    deviceId,
+    {
+      command,
+      commandVerifyHandler: (hexArr) => ({ verified: hexArr[0] == 0xdd && hexArr[1] == 0xfb, pkgLen: hexArr[3] + 7 }),
+      pkgVerifyHandler: (pkg) => {
+        return { verified: true };
+      },
+    },
+    'DD5A_FB'
+  );
+}
+/** 解析DD指令响应
+ *
+ * @param {*} data
+ * @returns
+ */
+export const resolveBaseDD = (data) => {
+  if (!data) return null;
+  const dataStr = hexArr2string(data);
+  const content = data.slice(4, data.length - 3);
+  return {
+    dataStr,
+    status: hex2string(data[2]),
+    len: data[3],
+    content,
+  };
+}
+
+// #region 0A 控制指令
+/**
+   * 0A 控制指令
+   * @param {*} deviceId  设备id
+   * @param {*} values  指令内容 十六进制字符串 eg: '0100'
+   * 
+   * @param 0100	- 重置容量 重置容量按照电压参数重新估算容量
+   * @param 0200	- 清除历史保护次数
+   * @param 0300	- 复位一次单片机
+   * @param 0400	- 清除保护状态和告警状态
+   * @param 0500	- 保护板进入到休眠状态
+   * @param 0600	- 进入超低功耗，需要充电唤醒。
+   * @param 0700	- 自动均衡模式,发送该指令自动开启均衡
+   * @param 0800	- 进入储运模式
+   * @param 0900	- 设置SOC-20%开关功能 双聚版本，设置为1之后则低于20%会关闭放电
+   * @param 0A00	- 低于20%强制打开指令 当SOC_20%功能有效，并且SOC<20%,可发送此指令强制打开
+   * @param 0B00	- 强制启动-启动模式 启动电池模式时强启启动输出，强制输出1小时
+   * @param 0C00	- 强制加热 加热到15℃自动停止
+   * @param 0D00	- 低电量蜂鸣器报警功能 蜂鸣器  放电时  每30S响一次    放电结束延时5分钟
+   * @param 0E00	- 打开低电量闪断功能 闪断功能为当从10%或者5%时触发，触发后控制MOS打嗝，开1S断1S，循环3次
+   * @param 0F00	- 关闭低电量闪断功能
+   * @param 1881	- 恢复出厂设置参数
+   * @param FFFF	- 心跳包
+   * @returns hex 数组
+   */
+export const getDD5A0AAsync = async (deviceId, value) => {
+  const values = stringToTwoHexArray(value);
+  const _command = ['0x0A', '0x02', ...values];
+  const checks = generateCrcCheckSum(_command);
+  const command = ['0xDD', '0x5A', ..._command, ...checks, '0x77'];
+  console.log('command: ', command);
+  return getData(
+    deviceId,
+    {
+      command,
+      commandVerifyHandler: (hexArr) => ({ verified: hexArr[0] == 0xdd && hexArr[1] == 0x0A, pkgLen: hexArr[3] + 7 }),
+      pkgVerifyHandler: (pkg) => {
+        return { verified: true };
+      },
+    },
+    `DD5A_0A_${value}`
+  );
+}
+
+// #region 设置满充容量
+/**设置满充容量
+   *
+   * @param {*} deviceId
+   * @param {*} value AH
+   * @returns
+   */
+export const getDD5AFAAsync = async (deviceId, value) => {
+  const hex = value * 100; /*AH => 10mAh*/
+  const hexStr = decimalToHex(hex, 4);
+  const _values = [`0x${hexStr.slice(0, 2)}`, `0x${hexStr.slice(2, 4)}`];
+  const _command = ['0xFA', '0x05', '0x00', '0x70', '0x01', ..._values];
+  const checks = generateCrcCheckSum(_command);
+  const command = ['0xDD', '0x5A', ..._command, ...checks, '0x77'];
+  return getData(
+    deviceId,
+    {
+      command,
+      commandVerifyHandler: (hexArr) => ({ verified: hexArr[0] == 0xdd && hexArr[1] == 0xfa, pkgLen: hexArr[3] + 7 }),
+      pkgVerifyHandler: (pkg) => {
+        return { verified: true };
+      },
+    },
+    'DD5A_FA'
+  );
+}
+
+// #region 获取设备硬件版本号05指令
+/** 获取设备硬件版本号05指令
+   *
+   * @param {*} deviceId
+   * @returns
+   */
+export const getDDA505Async = async (deviceId) => {
+  const command = ['0xdd', '0xa5', '0x05', '0x00', '0xff', '0xfb', '0x77'];
+  const response = 'DD 05 00 0A 30 31 32 33 34 35 36 37 38 39 FD E9 77';
+
+  return getData(
+    deviceId,
+    {
+      command,
+      commandVerifyHandler: (hexArr) => ({ verified: hexArr[0] == 0xdd && hexArr[1] == 0x05, pkgLen: hexArr[3] + 7 }),
+      pkgVerifyHandler: (pkg) => {
+        const len = pkg.length;
+        const [c1, c2] = generateCrcCheckSum(pkg.slice(2, len - 3));
+        const [_c1, _c2] = [pkg[len - 3], pkg[len - 2]];
+        return { verified: c1 == _c1 && c2 == _c2 };
+      },
+    },
+    'DDA5_05'
+  );
+}
+/** 解析硬件版本号05指令
+ *
+ * @param {number[]} data DDA505十六进制数据数组
+ * @returns
+ */
+export const resolveDDA505 = (data) => {
+  if (!data) return null;
+  const dataStr = hexArr2string(data);
+  return {
+    dataStr,
+    status: hex2string(data[2]),
+    len: data[3],
+    hardwareV: hexArr2Assic(data.slice(4, data.length - 3)),
+  };
+}
+
+// #region 新协议读参数
+/**DDA5FA 读参数FA指令 新协议
+   * @param {string[]} paramNo 参数号 十六进制字符串数组
+   * @param {string} length 长度 十六进制字符串数组
+   * @returns 
+  */
+export const getDDA5FAAsync = async (deviceId, paramNo, length) => {
+  const header = ['0xDD', '0xA5']
+  const _values = [...paramNo, length];
+  const lengthHex = decimalToHex(_values.length)
+  const _command = ['0xFA', lengthHex, ..._values];
+  const checks = generateCrcCheckSum(_command);
+  const command = [...header, ..._command, ...checks, '0x77'];
+  return getData(
+    deviceId,
+    {
+      command,
+      commandVerifyHandler: (hexArr) => ({ verified: hexArr[0] == 0xdd && hexArr[1] == 0xFA, pkgLen: hexArr[3] + 7 }),
+      pkgVerifyHandler: (pkg) => {
+        return { verified: true };
+      },
+    },
+    'READ_DDA5_FA'
+  );
+}
+
+// #region 写参数FA指令 新协议
+/**DDA5FA 写参数FA指令 新协议
+ * @param {string[]} paramNo 参数号 十六进制字符串数组
+ * @param {string} valueLength 写入值的长度(写入几个值) 十六进制字符串数组
+ * @param {string[]} content 写入值内容（按对应序号的长度字节） 十六进制字符串数组
+ * @returns 
+*/
+export const setDDA5FAAsync = async (deviceId, paramNo, valueLength, content) => {
+  const header = ['0xDD', '0x5A']
+  const _values = [...paramNo, valueLength, ...content];
+  const lengthHex = decimalToHex(_values.length)
+  const _command = ['0xFA', lengthHex, ..._values];
+  const checks = generateCrcCheckSum(_command);
+  const command = [...header, ..._command, ...checks, '0x77'];
+  return getData(
+    deviceId,
+    {
+      command,
+      commandVerifyHandler: (hexArr) => ({ verified: hexArr[0] == 0xdd && hexArr[1] == 0xFA, pkgLen: hexArr[3] + 7 }),
+      pkgVerifyHandler: (pkg) => {
+        return { verified: true };
+      },
+    },
+    'SET_DDA5_FA'
+  );
+}
+/**
+ * 解析DDA5FA数据
+ * @param {*} data 
+ * @returns 
+ */
+export const resolveDDA5FA = (data) => {
+  if (!data) return null;
+  const dataStr = hexArr2string(data);
+  return {
+    dataStr,
+    status: hex2string(data[2]),
+    len: data[3],
+    type: data[5],
+    value: data.slice(7, -3),
+  };
+}
+
+// #region 读参数旧协议
+/** 获取读参数FA指令 旧协议
+ *
+ * @param {*} deviceId
+ * @returns
+ */
+export const getDDA5OldAsync = async (deviceId, path) => {
+  const values = [path, '0x00']
+  const checks = generateCrcCheckSum(values);
+  const command = ['0xDD', '0xa5', ...values, ...checks, '0x77'];
+
+  return getData(
+    deviceId,
+    {
+      command,
+      commandVerifyHandler: (hexArr) => ({ verified: hexArr[0] == 0xdd && hexArr[1] == path, pkgLen: hexArr[3] + 7 }),
+      pkgVerifyHandler: (pkg) => {
+        const len = pkg.length;
+        const [c1, c2] = generateCrcCheckSum(pkg.slice(2, len - 3));
+        const [_c1, _c2] = [pkg[len - 3], pkg[len - 2]];
+        return { verified: c1 == _c1 && c2 == _c2 };
+      },
+    },
+    'DDA5_读旧协议读参'
+  );
+}
+
+// #region 写参数旧协议
+/**写入参数 旧协议
+ *
+ * @param {*} deviceId
+ * @param {*} path "0x17"
+ * @param {string[]} value 写入值内容 十六进制字符串数组  ["0x00,0x00"]
+ * @returns
+ */
+export const setDDA5OldAsync = async (deviceId, path, value, type = '') => {
+
+  const values = [path, '0x02', ...value]
+  const checks = generateCrcCheckSum(values);
+  const command = ['0xDD', '0x5A', ...values, ...checks, '0x77'];
+
+  return getData(
+    deviceId,
+    {
+      command,
+      commandVerifyHandler: (hexArr) => ({ verified: hexArr[0] == 0xdd && hexArr[1] == path, pkgLen: hexArr[3] + 7 }),
+      pkgVerifyHandler: (pkg) => ({ verified: true }),
+    },
+    'DDA5_写旧协议读参' + type
+  );
+}
+
+// #region 设置剩余容量
+/**设置剩余容量 */
+export const getDD5AE0Async = async (deviceId, value) => {
+  const hex = value * 100; /*AH => 10mAh*/
+  const hexStr = decimalToHex(hex, 4);
+  const _values = [`0x${hexStr.slice(0, 2)}`, `0x${hexStr.slice(2, 4)}`];
+  const _command = ['0xE0', '0x02', ..._values];
+  const checks = generateCrcCheckSum(_command);
+  // DD5AE0 02 XXXXCCCC77
+  const command = ['0xDD', '0x5A', ..._command, ...checks, '0x77'];
+  console.warn('=======CCCCCCC=SET===', { value, hex, hexStr, _values, _command, checks, command });
+  const response = 'DDE0 0000 0000 77';
+  return getData(
+    deviceId,
+    {
+      command,
+      commandVerifyHandler: (hexArr) => ({ verified: hexArr[0] == 0xdd && hexArr[1] == 0xe0, pkgLen: hexArr[3] + 7 }),
+      pkgVerifyHandler: (pkg) => {
+        return { verified: true };
+      },
+    },
+    'DD5A_E0'
+  );
+}
+
+// #region BMS复位
+/** BMS复位 */
+export const getDD5A0EAsync = async (deviceId) => {
+  const command = ['0xDD', '0x5A', '0x0E', '0x02', '0x81', '0x18', '0xFF', '0x57', '0x77'];
+  return getData(
+    deviceId,
+    {
+      command,
+      commandVerifyHandler: (hexArr) => ({ verified: hexArr[0] == 0xdd && hexArr[1] == 0x0e, pkgLen: hexArr[3] + 7 }),
+      pkgVerifyHandler: (pkg) => {
+        return { verified: true };
+      },
+    },
+    'DD5A_0E_复位'
+  );
+}
+
+// #region 加热测试
+/** 加热测试 */
+export const getDD5AE4Async = async (deviceId) => {
+  const command = ['0xdd', '0x5a', '0xe4', '0x02', '0x18', '0x81', '0xfe', '0x81', '0x77'];
+  return getData(
+    deviceId,
+    {
+      command,
+      commandVerifyHandler: (hexArr) => ({ verified: hexArr[0] == 0xdd && hexArr[1] == 0xe4, pkgLen: hexArr[3] + 7 }),
+      pkgVerifyHandler: (pkg) => {
+        return { verified: true };
+      },
+    },
+    'DD5A_E4'
+  );
+}
+
+
+// #region 5A通用写入指令
+/**发送5A写入指令
+   * 
+   * @param {*} deviceId 
+   * @param {*} path 指令路径
+   * @param path 0xB0 电压校准
+   * @param path 0x0B 清除保护次数
+   * @param {*} lengthHex 内容长度
+   * @param {*} values 指令值
+   * @returns 
+   */
+export const getDD5AAllAsync = async (deviceId, path, lengthHex, values, type) => {
+  const _command = [path, lengthHex, ...values];
+  const checks = generateCrcCheckSum(_command);
+  const command = ['0xDD', '0x5A', ..._command, ...checks, '0x77'];
+  return getData(
+    deviceId,
+    {
+      command,
+      commandVerifyHandler: (hexArr) => ({ verified: hexArr[0] == 0xdd && hexArr[1] == path, pkgLen: hexArr[3] + 7 }),
+      pkgVerifyHandler: (pkg) => {
+        return { verified: true };
+      },
+    },
+    `DD5A_${path}_${type}`
+  );
+}
+
+// #region 发送BMS指令 原始指令
+/**发送BMS指令 原始指令
+   * 
+   * @param {*} deviceId 
+   * @param {*} values 原始指令值字符串
+   * @returns 
+   */
+export const sendBMSAsync = async (deviceId, values) => {
+  // 将 values 字符串按两两字符分隔，并在每一项前添加 '0x'
+  const command = values.match(/[0-9a-fA-F]{2}/g)?.map(item => `0x${item}`) || [];
+  return getData(
+    deviceId,
+    {
+      command,
+      commandVerifyHandler: (hexArr) => ({ verified: hexArr[0] == 0xdd && hexArr[1] == command[2], pkgLen: hexArr[3] + 7 }),
+      pkgVerifyHandler: (pkg) => {
+        return { verified: true };
+      },
+    },
+    `DD5A_${command[2]}`
+  );
+}
+// #region 解析BMS指令 原始指令
+/** 解析BMS指令 原始指令
+ *
+ * @param {number[]} data DD 十六进制数据数组
+ * @returns {object} 解析后的数据 十六进制数据字符串
+ */
+export const resolveBMSCmd = (data) => {
+  if (!data) return null;
+  const dataStr = hexArr2string(data);
+  return {
+    dataStr,
+    status: hex2string(data[2]),
+    len: data[3],
+  };
+}
+// #region 保护次数
+/**
+ * 保护次数
+ * @param {*} deviceId 
+ * @returns 保护次数数组
+ */
+export const getProtectCountCmd = async (deviceId) => {
+  const command = ['0xdd', '0xa5', '0xaa', '0x00', '0xff', '0x56', '0x77'];
+  const data = await getData(
+    deviceId,
+    {
+      command,
+      commandVerifyHandler: (hexArr) => ({ verified: hexArr[0] == 0xdd && hexArr[1] == 0xaa, pkgLen: hexArr[3] + 7 }),
+      pkgVerifyHandler: (pkg) => {
+        return { verified: true };
+      },
+    },
+    'DDA5_AA保护次数'
+  );
+  const arr = [];
+  // 使用循环来简化索引操作
+  for (let i = 4; i < data.length - 4; i += 2) {
+    const offset = i;
+    console.log('offset', offset);
+    // 优化位运算，确保位移和加法的优先级正确
+    let value = ((data[offset] & 0xff) << 8) + (data[offset + 1] & 0xff)
+    arr.push(value);
+  }
+  return arr;
+}
+// #region 清除电池循环次数
+/**清除电池循环次数
+   * - 需要进/退工厂
+   */
+export const getDD5A17Async = async (deviceId) => {
+  // DD5A17020001FFE677
+  const command = ['0xDD', '0x5A', '0x17', '0x02', '0x00', '0x01', '0xFF', '0xE6', '0x77'];
+  return getData(
+    deviceId,
+    {
+      command,
+      commandVerifyHandler: (hexArr) => ({ verified: hexArr[0] == 0xdd && hexArr[1] == 0x17, pkgLen: hexArr[3] + 7 }),
+      pkgVerifyHandler: (pkg) => {
+        return { verified: true };
+      },
+    },
+    'DD5A_17-清除电池循环次数'
+  );
+}
+
+// #region 历史运行履历
+/** 获取历史运行履历总数 */
+export const getDDA507Async = async (deviceId) => {
+  // DD A5 07 00 FF F9 77
+  // DD 07 00 04 00 02 00 02 FF F8 77
+  // DD07000400020002FFF877
+  const command = ['0xDD', '0xA5', '0x07', '0x00', '0xFF', '0xF9', '0x77'];
+  return getData(
+    deviceId,
+    {
+      command,
+      commandVerifyHandler: (hexArr) => ({ verified: hexArr[0] == 0xdd && hexArr[1] == 0x07, pkgLen: hexArr[3] + 7 }),
+      pkgVerifyHandler: (pkg) => {
+        const len = pkg.length;
+        const [c1, c2] = generateCrcCheckSum(pkg.slice(2, len - 3));
+        const [_c1, _c2] = [pkg[len - 3], pkg[len - 2]];
+        return { verified: c1 == _c1 && c2 == _c2 };
+      },
+    },
+    'DDA5_07历史运行履历总数'
+  );
+}
+/**读取履历详情
+ *
+ * @param {*} deviceId
+ * @param {*} i 当前条数
+ * @returns
+ */
+export const getDDA508Async = async (deviceId, i = 0) => {
+  // DD A5 08 00 FF F8 77
+
+  // DD08004400020000042F215B0009400500000000
+  // 983A0A000000990B980B0000000037022802020F
+  // 0100350237023602350233023502330233023402
+  // 32023202320233022F022802F90E77
+
+  const _command = ['0x08', `0x${i.toString(16).padStart(2, 0)}`];
+  const checks = generateCrcCheckSum(_command);
+
+  const command = ['0xDD', '0xA5', ..._command, ...checks, '0x77'];
+  return getData(
+    deviceId,
+    {
+      command,
+      commandVerifyHandler: (hexArr) => ({ verified: hexArr[0] == 0xdd && hexArr[1] == 0x08, pkgLen: hexArr[3] + 7 }),
+      pkgVerifyHandler: (pkg) => {
+        const len = pkg.length;
+        const [c1, c2] = generateCrcCheckSum(pkg.slice(2, len - 3));
+        const [_c1, _c2] = [pkg[len - 3], pkg[len - 2]];
+        return { verified: c1 == _c1 && c2 == _c2 };
+      },
+    },
+    'DDA5_08读取履历详情'
+  );
+}
+
+// #region 解析保护状态
+/** 解析保护状态 */
+export const resolveProtections = (binary) => {
+  const arr = binary.split('').reverse();
+  // "device.0041": "单体过压保护",
+  // "device.0042": "单体欠压保护",
+  // "device.0043": "整组过压保护",
+  // "device.0044": "整组欠压保护",
+  // "device.0045": "充电过温保护",
+  // "device.0046": "充电低温保护",
+  // "device.0047": "放电过温保护",
+  // "device.0048": "放电低温保护",
+  // "device.0049": "充电过流保护",
+  // "device.0050": "放电过流保护",
+  // "device.0051": "短路保护",
+  // "device.0052": "前端检测IC错误",
+  // "device.0053": "软件锁定MOS",
+  // "device.0054": "充电MOS击穿",
+  // "device.0055": "放电MOS击穿",
+  // "device.00551": "PCB高温",
+  const map = ['device.0041', 'device.0042', 'device.0043', 'device.0044', 'device.0045', 'device.0046', 'device.0047', 'device.0048', 'device.0049', 'device.0050', 'device.0051', 'device.0052', 'device.0053', 'device.0054', 'device.0055', 'device.00551'];
+  let _arr = [];
+  let _indexs = [];
+  for (let i = 0; i < arr.length; i++) {
+    if (arr[i] == 1) {
+      _arr.push(map[i])
+      _indexs.push(i)
+    };
+  }
+  return { _arr, _indexs };
+}
+
+// #region 解析履历详情
+/** 解析履历详情 */
+export const resolveDDA508 = (data) => {
+  if (!data) return null;
+  // DD 08 00 44 0002 0000 04 2F21 5B0009 4005 0000 0000
+  // 983A0A000000990B980B0000000037022802020F
+  // 0100350237023602350233023502330233023402
+  // 32023202320233022F022802F90E77
+  if (!data) return null;
+  const hexArr = data.map((o) => o.toString(16).padStart(2, '0').toUpperCase());
+  const f = (s) => parseInt(s, 16);
+  const fet = data[40].toString(2).padStart(8, '0').split('').reverse();
+  const protection = f(hexArr[23] + hexArr[22])
+    .toString(2)
+    .padStart(16, '0');
+  const n = !!Number(fet[7]) ? 10 : 100; // bit7(1: 100mAh 0:10mAh)
+  let current = (hexArr[16] << 8) + (hexArr[17] & 0x0ff);
+  current = current > 32768 ? (current - 65536) / n : current / n;
+  const electricity = Number(current.toFixed(2));
+  const sysTime = (data[30] * 65536) + (data[31] * 256) + data[32]; // 系统时间 分钟数
+  console.log('hexArr[30], hexArr[31], hexArr[32]', hexArr[30], hexArr[31], hexArr[32]);
+
+  console.warn('sysTime: ', sysTime);
+  const reportTime = (data[11] * 65536) + (data[12] * 256) + data[13]; // 上报时间 分钟数
+  console.log('data[11], data[12], data[13]', data[11], data[12], data[13]);
+
+  console.warn('reportTime: ', reportTime);
+  const time = Math.abs(sysTime - reportTime) * 60 * 1000; // 时间差 毫秒数 相差的时间戳
+  console.warn('time: ', time);
+  const timestamp = new Date().getTime() - time; // 当前系统时间减去时间差，得到历史时间戳
+  console.warn('new Date().getTime(): ', new Date().getTime());
+  return {
+    dataStr: hexArr.join(''),
+    status: hex2string(data[2]),
+    len: data[3],
+    total: f(hexArr[4] + hexArr[5]), // 总页数
+    page: f(hexArr[6] + hexArr[7]), // 当前页(从0开始)
+    type: data[8], // 1放电开始 2充电开始 3电流停止 4保护 5告警 6定时
+    sysTime: sysTime,
+    timestamp, // 历史时间戳
+    sumV: (f(hexArr[15] + hexArr[14]) / 100).toFixed(2), // 总电压,单位10mV=>V
+    sumE: electricity, // 总电流,单位A
+    restC: (f(hexArr[19] + hexArr[18]) / n).toFixed(2), // 剩余容量,单位Ah
+    designC: (f(hexArr[21] + hexArr[20]) / n).toFixed(2), // 剩余容量,单位Ah
+    protections: resolveProtections(protection)._arr, // 保护标志
+    protectionIndex: resolveProtections(protection)._indexs, // 保护标志
+    tH: ((f(hexArr[27] + hexArr[26]) - 2731) / 10).toFixed(2), // 最高温度
+    tL: ((f(hexArr[29] + hexArr[28]) - 2731) / 10).toFixed(2), // 最低温度
+    vH: (f(hexArr[35] + hexArr[34]) / 1000).toFixed(3), // 最高单体电压 mv=>V
+    vL: (f(hexArr[37] + hexArr[36]) / 1000).toFixed(3), // 最低单体电压 mv=>V
+    nH: f(hexArr[38]), // 最高单体编号
+    nL: f(hexArr[39]), // 最低单体编号
+    fet: fet.join(''),
+  };
+}
+// #region 3B3C指令
+export const get3B3CInfo = ({ deviceId, macAddr, moduleType, productType }) => {
+  return new Promise(async (resolve, reject) => {
+    let reportData = { macAddr, moduleTypeKey: moduleType, productKey: productType };
+    let _3b3c = null;
+    let _dda5_03 = null;
+    let _dda5_05 = null;
+    let _ffaa_80 = null;
+    try {
+      if (!deviceId) throw new Error('deviceId required');
+      // 发送FFAA_80
+      const _ffaa_80_hex = await getFFAA80Async(deviceId, 'AT^VERSION?');
+      _ffaa_80 = resolveFFAA80(_ffaa_80_hex);
+      console.warn('Report-3B3C    _ffaa_80    ', { _ffaa_80_hex, _ffaa_80 });
+      if (_ffaa_80) reportData['moduleVersion'] = _ffaa_80?.moduleVersion;
+
+      // 发送3B3C
+      const _3b3c_hex = await get3B3CAsync(deviceId);
+      _3b3c = resolve3B3C(_3b3c_hex);
+      console.warn('Report-3B3C    _3b3c    ', { _3b3c_hex, _3b3c });
+      if (_3b3c) {
+        reportData['cmdContent'] = _3b3c?.dataStr;
+      } /*3B3C超时 or 不支持3B3C*/ else {
+        // 发送DDA5_03
+        const _dda5_03_hex = await getDDA503Async(deviceId);
+        _dda5_03 = resolveDDA503(_dda5_03_hex);
+        console.warn('Report-3B3C    _dda5_03    ', { _dda5_03_hex, _dda5_03 });
+        if (_dda5_03) reportData['bmsVersion'] = _dda5_03?.softwareV;
+
+        // 发送DDA5_05
+        const _dda5_05_hex = await getDDA505Async(deviceId);
+        _dda5_05 = resolveDDA505(_dda5_05_hex);
+        console.warn('Report-3B3C    _dda5_05    ', { _dda5_05_hex, _dda5_05 });
+        if (_dda5_05) reportData['bmsSn'] = _dda5_05?.hardwareV;
+      }
+
+      // try {
+      //   // 直接上报
+      //   const res = await serverApi.request({ url: serverApi.urls['report3B3C'], method: 'post', data: reportData }, 'json');
+      //   console.warn('Report-3B3C    Report: ', { reportData, res });
+      // } catch (error) {}
+      resolve({ reportData, _3b3c, _dda5_03, _dda5_05, _ffaa_80 });
+    } catch (error) {
+      reject(error);
+    }
+  });
+}