@jiabaida/tools 1.0.0 → 1.0.2

package/src/core/BleCmdAnalysis/ESHostProtocol.js

@@ -0,0 +1,829 @@
+import {hexStringToBinary, decimalToHex} from '../BleDataProcess';
+function format(value, n, offset, scope) {
+  const v = parseInt(value.join(''), 16) * n + offset;
+  if (scope == undefined) return v;
+  return v.toFixed(scope);
+}
+
+function socFormat(value, n, offset, scope) {
+  const v = parseInt(value.join(''), 16) * n + offset;
+  return Math.floor(v);
+}
+function kelvinToCelsius(value) {
+  return (value - 273.1).toFixed(2);
+}
+
+function formatBools(value, n, offset, scope, len) {
+  const hexs = value.join('');
+  const binary = hexStringToBinary(hexs).split('');
+  // 倒叙取值
+  binary.reverse();
+  const arr = new Array(Math.max(len, binary.length));
+  for (let i = 0; i < arr.length; i++) {
+    arr[i] = binary[i] == '1' || binary[i] == 1;
+  }
+  return arr;
+}
+
+function hexToAscii(hexString) {
+  let asciiString = '';
+  for (let i = 0; i < hexString.length; i += 2) {
+    const hexPair = hexString.substr(i, 2);
+    const decimalValue = parseInt(hexPair, 16);
+    asciiString += String.fromCharCode(decimalValue);
+  }
+  const result = asciiString.replace(/\u0000/g, '');
+
+  return result;
+}
+function formatP_N(value, n, offset, scope = 2) {
+  const el = ['0x', ...value].join('') * 1;
+  let negative = (el & 0x8000) !== 0;
+  const v = negative ? el - 0x10000 : el;
+  return (v * n + offset).toFixed(scope);
+}
+export class HostProtocol {
+  readValue;
+  receiveLength;
+
+  constructor() {
+    this.readValue = [];
+    this.receiveLength = null;
+  }
+  /**01 50 00 00 00 FF 00 00  => 01 50 00 00 00 FF 00 00 E1 F2
+   *
+   * @param {*} values
+   * @returns
+   */
+  // console.log(HostProtocol.generateCheck([0x01, 0x50, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00]), 'E1 F2');
+  getBuffer(values) {
+    const checks = this.generateCheck(values); // ['0xE1','0xF2']
+    const arr = [...values, ...checks];
+    if (arr[1] == '0x79') {
+      console.log('======下发指令======', arr.join('').replace(/0x/g, ''), arr);
+    }
+    const buffer = new ArrayBuffer(arr.length);
+    const dataView = new DataView(buffer);
+    arr.forEach((v, i) => dataView.setUint8(i, v.toString()));
+    return buffer;
+  }
+  /**e.g [0x01, 0x78, 0x10, 0x00, 0x10, 0xA0, 0x00, 0x00] => [0x7F, 0xB2]
+   *
+   * @param data 地址码 + 功能码 + 起始地址 + 结束地址 + 数据长度
+   * @returns 低/高位校验码
+   *
+   */
+  generateCheck(data) {
+    const hex = this.crc16modbus(data);
+    const hexStr = decimalToHex(hex, 4);
+    return [`0x${hexStr.slice(0, 2)}`, `0x${hexStr.slice(2, 4)}`];
+  }
+  generateCheck2(dataHexString) {
+    const dataBytes = [];
+    for (let i = 0; i < dataHexString.length; i += 2) {
+      dataBytes.push(parseInt(dataHexString.substr(i, 2), 16));
+    }
+    let crc = 0xffff;
+    const polynomial = 0xa001;
+    for (const byte of dataBytes) {
+      crc ^= byte;
+      for (let i = 0; i < 8; i++) {
+        if (crc & 0x0001) {
+          crc = ((crc >> 1) ^ polynomial) & 0xffff;
+        } else {
+          crc >>= 1;
+        }
+      }
+    }
+    const res = crc.toString(16).toUpperCase();
+    return [res.slice(-2), res.slice(-4, -2)];
+  }
+  crc16modbus(data) {
+    let crc = 0xffff;
+    for (let i = 0; i < data.length; i++) {
+      crc ^= data[i];
+      for (let j = 0; j < 8; j++) {
+        if (crc & 0x0001) {
+          crc = (crc >> 1) ^ 0xa001;
+        } else {
+          crc = crc >> 1;
+        }
+      }
+    }
+    // The result needs to be swapped
+    crc = ((crc & 0xff) << 8) | ((crc >> 8) & 0xff);
+    return crc & 0xffff;
+  }
+
+  resolveResponse(value, callback) {
+    const intArr = Array.prototype.map.call(new Uint8Array(value), (x) => ('00' + x.toString(16)).slice(-2));
+
+    if (intArr.length > 0) {
+      if (this.receiveLength == null) {
+        const intArr = Array.prototype.map.call(new Uint8Array(value), (x) => x);
+        this.receiveLength = intArr[7] + 10;
+      }
+      this.readValue = this.readValue.concat(intArr);
+      if (this.readValue.length == this.receiveLength) {
+        callback([...this.readValue]);
+        this.readValue = [];
+        this.receiveLength = null;
+      }
+    } else {
+      this.readValue = [];
+      this.receiveLength = null;
+    }
+  }
+  // #region 解析pack综合数据
+  /**
+   * 解析pack综合数据
+   * @param {Array} values 回复的指令数组
+   * @returns 
+   */
+  // 综合数据(0x01 0x50)
+  getHostData(values) {
+    if (values[0] != 0x01 || values[1] != 0x50) return null;
+    const d_0x01_0x50 = ['01', '50', '00', '00', '00', 'FF', /**数据长度*/ '00', '2E', /*数据内容 46+10=56*/ '14', '64', '00', '00', '00', '30', '00', '64', '0B', 'E7', '0C', 'DB', '0B', 'E0', '0B', 'DB', '0B', 'D9', '00', '03', '02', 'D9', '05', 'DC', '00', '01', '00', '02', '00', '00', '00', '00', '00', '00', '02', '09', '02', '04', '02', '01', '02', '02', '00', '00', '00', '00', /*check*/ 'DD', '32'];
+    const data = values.slice(8, values.length - 2).map((x) => ('00' + x.toString(16)).toUpperCase().slice(-2));
+
+    // 汇总电压-V
+    const summarizedVoltage = format([data[0], data[1]], 0.01, 0, 2);
+    // 汇总电流-A
+    const summarizedElectricity = formatP_N([data[2], data[3]], 0.1, 0, 2);
+    // SOC-%
+    const soc = socFormat([data[4], data[5]], 1, 0, 0);
+    // SOH
+    const soh = format([data[6], data[7]], 1, 0, 0);
+    // 环境温度 ℃
+    const envTemperature = kelvinToCelsius(format([data[8], data[9]], 0.1, 0, 2));
+    // 最高单体电压-mV-V
+    const maxVoltage = format([data[10], data[11]], 0.001, 0, 3);
+    // 最低单体电压-mV-V
+    const minVoltage = format([data[12], data[13]], 0.001, 0, 3);
+    // 最高温度
+    const maxTemperature = kelvinToCelsius(format([data[14], data[15]], 0.1, 0, 2));
+    // 最低温度
+    const minTemperature = kelvinToCelsius(format([data[16], data[17]], 0.1, 0, 2));
+    // MOS状态
+    const [dischangeMos, changeMos, dischangeState, changeState] = formatBools([data[18], data[19]], 1, 0, undefined, 4);
+    // 剩余容量-AH
+    const restCapacity = format([data[20], data[21]], 0.1, 0, 2);
+    // 满充容量-AH
+    const fullCapacity = format([data[22], data[23]], 0.1, 0, 2);
+    // 并机个数
+    const PACK_DATA_paralleNum = [data[24], data[25]].join('');
+    const PACK_DATA_paralleState = [data[26], data[27]].join('');
+    const paralleNum = format([data[24], data[25]], 1, 0, 0);
+    // 并机状态
+    const paralleState = formatBools([data[26], data[27]], 1, 0, undefined, paralleNum);
+
+    // console.warn('===并机个数====', PACK_DATA_paralleNum, paralleNum);
+    // console.warn('===并机状态====', PACK_DATA_paralleState, paralleState);
+
+    // 循环次数
+    const cycleNum = format([data[28], data[29]], 1, 0, 0);
+    // 保护状态
+    const protectionInfo = formatBools([data[30], data[31], data[32], data[33]], 1, 0, undefined, 28);
+    // 最高单体序号
+    const maxMonomerNum = format([data[35]], 1, 0);
+    // 最低单体序号
+    const minMonomerNum = format([data[37]], 1, 0);
+    // 最高温度序号
+    const maxTemperatureNum = format([data[39]], 1, 0);
+    // 最低温度序号
+    const minTemperatureNum = format([data[41]], 1, 0);
+    // CAN协议
+    const can = format([data[42], data[43]], 1, 0);
+    // RS485协议
+    const rs485 = format([data[44], data[45]], 1, 0);
+
+    return { summarizedVoltage, summarizedElectricity, soc, soh, envTemperature, maxVoltage, minVoltage, maxTemperature, minTemperature, dischangeMos, changeMos, dischangeState, changeState, restCapacity, fullCapacity, paralleNum, paralleState, cycleNum, protectionInfo, maxMonomerNum, minMonomerNum, maxTemperatureNum, minTemperatureNum, can, rs485, PACK_DATA_paralleNum, PACK_DATA_paralleState };
+  }
+  // #region 解析pack基本信息
+  /**
+   * 解析pack基本信息
+   * @param {Array} values 回复的指令数组
+   * @returns {Object} 参数
+   */
+  // 基本信息(0xXX 0x78 10 00 10 A0 00 00 ...)
+  getBaseInfo(values) {
+    if (values[1] != 0x78 || values[2] != 0x10) return null;
+    const d_0x02_0x78 = ['02', '78', '10', '00', '10', 'A0', /**/ '00', '96', /**/ '14', '57', '14', '57', '00', '04', '93', 'E0', '12', 'C0', '1C', '20', '3A', '98', '3A', '98', '03', '29', '03', '34', '00', '00', '00', '64', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '09', '0C', 'DA', '00', '04', '0B', '9C', '0C', 'B6', '00', '01', '03', '25', '00', '02', '03', '23', '03', '24', '02', '40', '02', 'EE', '01', 'A4', '05', 'DC', '00', '10', '0C', 'D9', '0C', 'D6', '0C', 'D8', '0B', '9C', '0C', 'D8', '0C', 'D8', '0C', 'D8', '0C', 'D8', '0C', 'DA', '0C', 'D9', '0C', 'D8', '0C', 'DA', '0C', 'DA', '0B', 'FB', '0C', 'D9', '0C', 'D4', '00', '04', '03', '25', '03', '23', '03', '24', '03', '24', '00', '00', '00', '00', '00', '01', '4A', '42', '44', '34', '38', '31', '35', '30', '30', '30', '31', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '01', '00', '02', /**/ '87', 'CC'];
+    const data = values.slice(8, values.length - 2).map((x) => ('00' + x.toString(16)).toUpperCase().slice(-2));
+
+    // 总电压-V
+    const summarizedVoltage = format([data[0], data[1]], 0.01, 0, 2);
+    // 总电流-A
+    const summarizedElectricity = format([data[4], data[5], data[6], data[7]], 0.01, -3000, 2);
+    // SOC-%
+    const soc = socFormat([data[8], data[9]], 0.01, 0, 0);
+    // 剩余容量-Ah
+    const restCapacity = format([data[10], data[11]], 0.01, 0, 2);
+    // 满充容量-Ah
+    const fullCapacity = format([data[12], data[13]], 0.01, 0, 2);
+    // 标称容量-Ah
+    const nominalCapacity = format([data[14], data[15]], 0.01, 0, 2);
+    // MOS温度
+    const mosTemperature = format([data[16], data[17]], 0.1, -50, 2);
+    // 环境温度
+    const envTemperature = format([data[18], data[19]], 0.1, -50, 2);
+    // 充放电状态
+    const state = format([data[20], data[21]], 1, 0);
+    // SOH
+    const soh = format([data[22], data[23]], 1, 0);
+    // 保护信息
+    const protectionInfo = formatBools([data[24], data[25], data[26], data[27]], 1, 0, undefined, 28);
+    // 告警信息
+    const warningInfo = formatBools([data[28], data[29], data[30], data[31]], 1, 0, undefined, 19);
+    // MOS状态
+    const [dischangeMos, changeMos, preChangeState, hotState, fanState, dryContact1, dryContact2, limitedModule] = formatBools([data[32], data[33]], 1, 0, undefined, 8);
+    // 循环次数
+    const cycleNum = format([data[36], data[37]], 1, 0, 0);
+    // 最高单体序号
+    const maxMonomerNum = format([data[38], data[39]], 1, 0);
+    // 最高单体电压-mV-V
+    const maxVoltage = format([data[40], data[41]], 0.001, 0, 3);
+    // 最低单体序号
+    const minMonomerNum = format([data[42], data[43]], 1, 0);
+    // 最低单体电压-mV-V
+    const minVoltage = format([data[44], data[45]], 0.001, 0, 3);
+    // 最高温度序号
+    const maxTemperatureNum = format([data[48], data[49]], 1, 0);
+    // 最高温度
+    const maxTemperature = format([data[50], data[51]], 0.1, -50, 2);
+    // 最低温度序号
+    const minTemperatureNum = format([data[52], data[53]], 1, 0);
+    // 最低温度
+    const minTemperature = format([data[54], data[55]], 0.1, -50, 2);
+    // 单体个数
+    const cellNum = format([data[66], data[67]], 1, 0);
+    // 电池单体电压-mV-V
+    const cellVoltages = [...Array(cellNum)].map((_, i) => format([data[68 + i * 2], data[69 + i * 2]], 0.001, 0, 3));
+    // 温度个数
+    const n = 68 + 2 * cellNum;
+    const temperatureNum = format([data[n], data[n + 1]], 1, 0);
+    // 电池单体温度
+    const m = n + 2;
+    const temperatures = [...Array(temperatureNum)].map((_, i) => format([data[m + i * 2], data[m + 1 + i * 2]], 0.1, -50, 2));
+    // 均衡状态
+    const q = m + 2 * temperatureNum;
+    const cellEquilibriumInfo = formatBools([data[q], data[q + 1], data[q + 2], data[q + 3]], 1, 0, undefined, cellNum);
+
+    return { summarizedVoltage, summarizedElectricity, soc, restCapacity, fullCapacity, nominalCapacity, mosTemperature, envTemperature, state, soh, protectionInfo, warningInfo, dischangeMos, changeMos, preChangeState, hotState, fanState, dryContact1, dryContact2, limitedModule, cycleNum, maxMonomerNum, maxVoltage, minMonomerNum, minVoltage, maxTemperatureNum, maxTemperature, minTemperatureNum, minTemperature, cellNum, cellVoltages, temperatureNum, temperatures, cellEquilibriumInfo };
+  }
+  // #region 解析pack告警与保护参数
+  /**
+   * 解析pack告警与保护参数
+   * @param {Array}values 回复的指令数组
+   * @returns 
+   */
+  // 告警与保护参数(0xXX 0x78 18 00 19 00 00 00 ...)
+  getProtectionParams(values) {
+    if (values[1] != 0x78 || values[2] != 0x18) return null;
+    const d_0x02_0x78_0x1800 = `['01','78','18','00','19','A0',/**/'00','D0',/**/'0E','10','0D','48','0B','B8','0E','42','0D','48','0B','B8','0A','8C','0B','54','0B','B8','09','C4','0B','B8','0B','B8','16','80','15','40','0B','B8','16','D0','15','40','0B','B8','10','68','12','C0','03','E8','0F','A0','12','C0','0B','B8','06','40','05','78','07','D0','06','A4','07','D0','02','58','FF','FF','07','08','01','F4','02','58','06','40','05','78','07','D0','06','A4','07','D0','00','3C','00','03','07','08','00','C8','00','3C','04','1A','03','E8','0B','B8','04','7E','03','E8','0B','B8','02','26','02','58','0B','B8','01','F4','02','26','0B','B8','04','1A','03','E8','0B','B8','04','7E','03','E8','0B','B8','01','5E','01','90','0B','B8','01','2C','01','5E','0B','B8','05','AA','05','14','0B','B8','06','0E','05','46','0B','B8','04','4C','03','E8','0B','B8','04','7E','04','4C','0B','B8','04','7E','01','90','0B','B8','01','2C','01','5E','0B','B8','00','50','00','50','0B','B8','00','50','00','50','0B','B8','02','58','01','F4','07','D0','03','20','01','F4','07','D0','00','0A','00','0F','07','D0','00','03','00','05','07','D0',/**/ '31','9D']`;
+    const data = values.slice(8, values.length - 2).map((x) => ('00' + x.toString(16)).toUpperCase().slice(-2));
+
+    /* ********** 单体过压 ********** */
+    // 单体过压告警值-mV
+    const monomerOverVoltageWarning = format([data[0], data[1]], 1, 0, 0);
+    // 单体过压告警恢复值-mV
+    const monomerOverVoltageRecovery = format([data[2], data[3]], 1, 0, 0);
+    // 单体过压告警延迟-mS
+    const monomerOverVoltageDelay = format([data[4], data[5]], 1, 0, 0);
+    // 单体过压保护值-mV
+    const monomerOverVoltageProtection = format([data[6], data[7]], 1, 0, 0);
+    // 单体过压保护恢复值-mV
+    const monomerOverVoltageProtectionRecovery = format([data[8], data[9]], 1, 0, 0);
+    // 单体过压保护延时-mS
+    const monomerOverVoltageProtectionDelay = format([data[10], data[11]], 1, 0, 0);
+
+    /* ********** 单体欠压 ********** */
+    // 单体欠压告警值-mV
+    const monomerUnderVoltageWarning = format([data[12], data[13]], 1, 0, 0);
+    // 单体欠压告警恢复值-mV
+    const monomerUnderVoltageRecovery = format([data[14], data[15]], 1, 0, 0);
+    // 单体欠压告警延迟-mS
+    const monomerUnderVoltageDelay = format([data[16], data[17]], 1, 0, 0);
+    // 单体欠压保护值-mV
+    const monomerUnderVoltageProtection = format([data[18], data[19]], 1, 0, 0);
+    // 单体欠压保护恢复值-mV
+    const monomerUnderVoltageProtectionRecovery = format([data[20], data[21]], 1, 0, 0);
+    // 单体欠压保护延时-mS
+    const monomerUnderVoltageProtectionDelay = format([data[22], data[23]], 1, 0, 0);
+
+    /* ********** 总体过压********** */
+    // 总体过压告警值-V
+    const collectivityOverVoltageWarning = format([data[24], data[25]], 0.01, 0, 1);
+    // 总体过压告警恢复值-V
+    const collectivityOverVoltageRecovery = format([data[26], data[27]], 0.01, 0, 1);
+    // 总体过压告警延迟-mS
+    const collectivityOverVoltageDelay = format([data[28], data[29]], 1, 0, 0);
+    // 总体过压保护值-V
+    const collectivityOverVoltageProtection = format([data[30], data[31]], 0.01, 0, 1);
+    // 总体过压保护恢复值-V
+    const collectivityOverVoltageProtectionRecovery = format([data[32], data[33]], 0.01, 0, 1);
+    // 总体过压保护延时-mS
+    const collectivityOverVoltageProtectionDelay = format([data[34], data[35]], 1, 0, 0);
+
+    /* ********** 总体欠压 ********** */
+    // 总体欠压告警值-V
+    const collectivityUnderVoltageWarning = format([data[36], data[37]], 0.01, 0, 1);
+    // 总体欠压告警恢复值-V
+    const collectivityUnderVoltageRecovery = format([data[38], data[39]], 0.01, 0, 1);
+    // 总体欠压告警延迟-mS
+    const collectivityUnderVoltageDelay = format([data[40], data[41]], 1, 0, 0);
+    // 总体欠压保护值-V
+    const collectivityUnderVoltageProtection = format([data[42], data[43]], 0.01, 0, 1);
+    // 总体欠压保护恢复值-V
+    const collectivityUnderVoltageProtectionRecovery = format([data[44], data[45]], 0.01, 0, 1);
+    // 总体欠压保护延时-mS
+    const collectivityUnderVoltageProtectionDelay = format([data[46], data[47]], 1, 0, 0);
+
+    /* ********** 充电过流 ********** */
+    // 充电过流告警值-A
+    const chargeOverElectricityWarning = format([data[48], data[49]], 0.1, 0, 2);
+    // 充电过流告警恢复值-A
+    const chargeOverElectricityRecovery = format([data[50], data[51]], 0.1, 0, 2);
+    // 充电过流告警延迟-mS
+    const chargeOverElectricityDelay = format([data[52], data[53]], 1, 0, 2);
+    // 充电过流保护值-A
+    const chargeOverElectricityProtection = format([data[54], data[55]], 0.1, 0, 2);
+    // 充电过流保护延时-mS
+    const chargeOverElectricityProtectionDelay = format([data[56], data[57]], 1, 0, 0);
+    // 充电过流恢复延迟-S
+    const chargeOverElectricityRecoveryDelay = format([data[58], data[59]], 1, 0, 0);
+    // 充电过流锁定次数
+    const chargeOverElectricityLockNum = format([data[60], data[61]], 1, 0, 0);
+    // 充电过流2保护值-A
+    const chargeOverElectricity2Protection = format([data[62], data[63]], 0.1, 0, 2);
+    // 充电过流2保护延时-mS
+    const chargeOverElectricity2ProtectionDelay = format([data[64], data[65]], 1, 0, 0);
+    // 充电过流2恢复延迟-S
+    const chargeOverElectricity2RecoveryDelay = format([data[66], data[67]], 1, 0, 0);
+
+    /* ********** 放电过流 ********** */
+    // 放电过流告警值-A
+    const dischargeOverElectricityWarning = format([data[68], data[69]], 0.1, 0, 2);
+    // 放电过流告警恢复值-A
+    const dischargeOverElectricityRecovery = format([data[70], data[71]], 0.1, 0, 2);
+    // 放电过流告警延迟-mS
+    const dischargeOverElectricityDelay = format([data[72], data[73]], 1, 0, 0);
+    // 放电过流保护值-A
+    const dischargeOverElectricityProtection = format([data[74], data[75]], 0.1, 0, 2);
+    // 放电过流保护延时-mS
+    const dischargeOverElectricityProtectionDelay = format([data[76], data[77]], 1, 0, 0);
+    // 放电过流恢复延迟-S
+    const dischargeOverElectricityRecoveryDelay = format([data[78], data[79]], 1, 0, 0);
+    // 放电过流锁定次数
+    const dischargeOverElectricityLockNum = format([data[80], data[81]], 1, 0, 0);
+    // 放电过流2保护值-A
+    const dischargeOverElectricity2Protection = format([data[82], data[83]], 0.1, 0, 2);
+    // 放电过流2保护延时-mS
+    const dischargeOverElectricity2ProtectionDelay = format([data[84], data[85]], 1, 0, 0);
+    // 放电过流2恢复延迟-S
+    const dischargeOverElectricity2RecoveryDelay = format([data[86], data[87]], 1, 0, 0);
+
+    /* ********** 充电高温 ********** */
+    // 充电高温告警值-℃
+    const chargeHighTemperatureWarning = format([data[88], data[89]], 0.1, -50, 2);
+    // 充电高温告警恢复值-℃
+    const chargeHighTemperatureRecovery = format([data[90], data[91]], 0.1, -50, 2);
+    // 充电高温告警延迟-mS
+    const chargeHighTemperatureDelay = format([data[92], data[93]], 1, 0, 0);
+    // 充电高温保护值-℃
+    const chargeHighTemperatureProtection = format([data[94], data[95]], 0.1, -50, 2);
+    // 充电高温保护恢复值-℃
+    const chargeHighTemperatureProtectionRecovery = format([data[96], data[97]], 0.1, -50, 2);
+    // 充电高温保护延时-mS
+    const chargeHighTemperatureProtectionDelay = format([data[98], data[99]], 1, 0, 0);
+
+    /* ********** 充电低温 ********** */
+    // 充电低温告警值-℃
+    const chargeLowTemperatureWarning = format([data[100], data[101]], 0.1, -50, 2);
+    // 充电低温告警恢复值-℃
+    const chargeLowTemperatureRecovery = format([data[102], data[103]], 0.1, -50, 2);
+    // 充电低温告警延迟-mS
+    const chargeLowTemperatureDelay = format([data[104], data[105]], 1, 0, 0);
+    // 充电低温保护值-℃
+    const chargeLowTemperatureProtection = format([data[106], data[107]], 0.1, -50, 2);
+    // 充电低温保护恢复值-℃
+    const chargeLowTemperatureProtectionRecovery = format([data[108], data[109]], 0.1, -50, 2);
+    // 充电低温保护延时-mS
+    const chargeLowTemperatureProtectionDelay = format([data[110], data[111]], 1, 0, 0);
+
+    /* ********** 放电高温 ********** */
+    // 放电高温告警值-℃
+    const dischargeHighTemperatureWarning = format([data[112], data[113]], 0.1, -50, 2);
+    // 放电高温告警恢复值-℃
+    const dischargeHighTemperatureRecovery = format([data[114], data[115]], 0.1, -50, 2);
+    // 放电高温告警延迟-mS
+    const dischargeHighTemperatureDelay = format([data[116], data[117]], 1, 0, 0);
+    // 放电高温保护值-℃
+    const dischargeHighTemperatureProtection = format([data[118], data[119]], 0.1, -50, 2);
+    // 放电高温保护恢复值-℃
+    const dischargeHighTemperatureProtectionRecovery = format([data[120], data[121]], 0.1, -50, 2);
+    // 放电高温保护延时-mS
+    const dischargeHighTemperatureProtectionDelay = format([data[122], data[123]], 1, 0, 0);
+
+    /* ********** 放电低温 ********** */
+    // 放电低温告警值-℃
+    const dischargeLowTemperatureWarning = format([data[124], data[125]], 0.1, -50, 2);
+    // 放电低温告警恢复值-℃
+    const dischargeLowTemperatureRecovery = format([data[126], data[127]], 0.1, -50, 2);
+    // 放电低温告警延迟-mS
+    const dischargeLowTemperatureDelay = format([data[128], data[129]], 1, 0, 0);
+    // 放电低温保护值-℃
+    const dischargeLowTemperatureProtection = format([data[130], data[131]], 0.1, -50, 2);
+    // 放电低温保护恢复值-℃
+    const dischargeLowTemperatureProtectionRecovery = format([data[132], data[133]], 0.1, -50, 2);
+    // 放电低温保护延时-mS
+    const dischargeLowTemperatureProtectionDelay = format([data[134], data[135]], 1, 0, 0);
+
+    /* ********** MOS高温 ********** */
+    // MOS高温告警值-℃
+    const mosHighTemperatureWarning = format([data[136], data[137]], 0.1, -50, 2);
+    // MOS高温告警恢复值-℃
+    const mosHighTemperatureRecovery = format([data[138], data[139]], 0.1, -50, 2);
+    // MOS高温告警延迟-mS
+    const mosHighTemperatureDelay = format([data[140], data[141]], 1, 0, 0);
+    // MOS高温保护值-℃
+    const mosHighTemperatureProtection = format([data[142], data[143]], 0.1, -50, 2);
+    // MOS高温保护恢复值-℃
+    const mosHighTemperatureProtectionRecovery = format([data[144], data[145]], 0.1, -50, 2);
+    // MOS高温保护延时-mS
+    const mosHighTemperatureProtectionDelay = format([data[146], data[147]], 1, 0, 0);
+
+    /* ********** 环境高温 ********** */
+    const n = 148;
+    // 环境高温告警值-℃
+    const envHighTemperatureWarning = format([data[n], data[n + 1]], 0.1, -50, 2);
+    // 环境高温告警恢复值-℃
+    const envHighTemperatureRecovery = format([data[n + 2], data[n + 3]], 0.1, -50, 2);
+    // 环境高温告警延迟-mS
+    const envHighTemperatureDelay = format([data[n + 4], data[n + 5]], 1, 0, 0);
+    // 环境高温保护值-℃
+    const envHighTemperatureProtection = format([data[n + 6], data[n + 7]], 0.1, -50, 2);
+    // 环境高温保护恢复值-℃
+    const envHighTemperatureProtectionRecovery = format([data[n + 8], data[n + 9]], 0.1, -50, 2);
+    // 环境高温保护延时-mS
+    const envHighTemperatureProtectionDelay = format([data[n + 10], data[n + 11]], 1, 0, 0);
+
+    /* ********** 环境低温 ********** */
+    const m = 160;
+    // 环境低温告警值-℃
+    const envLowTemperatureWarning = format([data[m], data[m + 1]], 0.1, -50, 2);
+    // 环境低温告警恢复值-℃
+    const envLowTemperatureRecovery = format([data[m + 2], data[m + 3]], 0.1, -50, 2);
+    // 环境低温告警延迟-mS
+    const envLowTemperatureDelay = format([data[m + 4], data[m + 5]], 1, 0, 0);
+    // 环境低温保护值-℃
+    const envLowTemperatureProtection = format([data[m + 6], data[m + 7]], 0.1, -50, 2);
+    // 环境低温保护恢复值-℃
+    const envLowTemperatureProtectionRecovery = format([data[m + 8], data[m + 9]], 0.1, -50, 2);
+    // 环境低温保护延时-mS
+    const envLowTemperatureProtectionDelay = format([data[m + 10], data[m + 11]], 1, 0, 0);
+
+    /* ********** 温差过大 ********** */
+    const q = 172;
+    // 温差过大告警值-℃
+    const overTemperatureRangeWarning = format([data[q], data[q + 1]], 0.1, 0, 2);
+    // 温差过大告警恢复值-℃
+    const overTemperatureRangeRecovery = format([data[q + 2], data[q + 3]], 0.1, 0, 2);
+    // 温差过大告警延迟-mS
+    const overTemperatureRangeDelay = format([data[q + 4], data[q + 5]], 1, 0, 0);
+    // 温差过大保护值-℃
+    const overTemperatureRangeProtection = format([data[q + 6], data[q + 7]], 0.1, 0, 2);
+    // 温差过大保护恢复值-℃
+    const overTemperatureRangeProtectionRecovery = format([data[q + 8], data[q + 9]], 0.1, 0, 2);
+    // 温差过大保护延时-mS
+    const overTemperatureRangeProtectionDelay = format([data[q + 10], data[q + 11]], 1, 0, 0);
+
+    /* ********** 压差过大 ********** */
+    const o = 184;
+    // 压差过大告警值-mV
+    const overVoltageRangeWarning = format([data[o], data[o + 1]], 1, 0, 0);
+    // 压差过大告警恢复值-mV
+    const overVoltageRangeRecovery = format([data[o + 2], data[o + 3]], 1, 0, 0);
+    // 压差过大告警延迟-mS
+    const overVoltageRangeDelay = format([data[o + 4], data[o + 5]], 1, 0, 0);
+    // 压差过大保护值-mV
+    const overVoltageRangeProtection = format([data[o + 6], data[o + 7]], 1, 0, 0);
+    // 压差过大保护恢复值-mV
+    const overVoltageRangeProtectionRecovery = format([data[o + 8], data[o + 9]], 1, 0, 0);
+    // 压差过大保护延时-mS
+    const overVoltageRangeProtectionDelay = format([data[o + 10], data[o + 11]], 1, 0, 0);
+
+    /* ********** SOC过低 ********** */
+    const p = 196;
+    // SOC过低告警值-%
+    const underSOCRangeWarning = format([data[p], data[p + 1]], 1, 0);
+    // SOC过低告警恢复值-%
+    const underSOCRangeRecovery = format([data[p + 2], data[p + 3]], 1, 0);
+    // SOC过低告警延迟-mS
+    const underSOCRangeDelay = format([data[p + 4], data[p + 5]], 1, 0);
+    // SOC过低保护值-%
+    const underSOCRangeProtection = format([data[p + 6], data[p + 7]], 1, 0);
+    // SOC过低保护恢复值-%
+    const underSOCRangeProtectionRecovery = format([data[p + 8], data[p + 9]], 1, 0);
+    // SOC过低保护延时-mS
+    const underSOCRangeProtectionDelay = format([data[p + 10], data[p + 11]], 1, 0);
+
+    return {
+      monomerOverVoltageWarning,
+      monomerOverVoltageRecovery,
+      monomerOverVoltageDelay,
+      monomerOverVoltageProtection,
+      monomerOverVoltageProtectionRecovery,
+      monomerOverVoltageProtectionDelay,
+      monomerUnderVoltageWarning,
+      monomerUnderVoltageRecovery,
+      monomerUnderVoltageDelay,
+      monomerUnderVoltageProtection,
+      monomerUnderVoltageProtectionRecovery,
+      monomerUnderVoltageProtectionDelay,
+      collectivityOverVoltageWarning,
+      collectivityOverVoltageRecovery,
+      collectivityOverVoltageDelay,
+      collectivityOverVoltageProtection,
+      collectivityOverVoltageProtectionRecovery,
+      collectivityOverVoltageProtectionDelay,
+      collectivityUnderVoltageWarning,
+      collectivityUnderVoltageRecovery,
+      collectivityUnderVoltageDelay,
+      collectivityUnderVoltageProtection,
+      collectivityUnderVoltageProtectionRecovery,
+      collectivityUnderVoltageProtectionDelay,
+      chargeOverElectricityWarning,
+      chargeOverElectricityRecovery,
+      chargeOverElectricityDelay,
+      chargeOverElectricityProtection,
+      chargeOverElectricityProtectionDelay,
+      chargeOverElectricityRecoveryDelay,
+      chargeOverElectricityLockNum,
+      chargeOverElectricity2Protection,
+      chargeOverElectricity2ProtectionDelay,
+      chargeOverElectricity2RecoveryDelay,
+      dischargeOverElectricityWarning,
+      dischargeOverElectricityRecovery,
+      dischargeOverElectricityDelay,
+      dischargeOverElectricityProtection,
+      dischargeOverElectricityProtectionDelay,
+      dischargeOverElectricityRecoveryDelay,
+      dischargeOverElectricityLockNum,
+      dischargeOverElectricity2Protection,
+      dischargeOverElectricity2ProtectionDelay,
+      dischargeOverElectricity2RecoveryDelay,
+      chargeHighTemperatureWarning,
+      chargeHighTemperatureRecovery,
+      chargeHighTemperatureDelay,
+      chargeHighTemperatureProtection,
+      chargeHighTemperatureProtectionRecovery,
+      chargeHighTemperatureProtectionDelay,
+      chargeLowTemperatureWarning,
+      chargeLowTemperatureRecovery,
+      chargeLowTemperatureDelay,
+      chargeLowTemperatureProtection,
+      chargeLowTemperatureProtectionRecovery,
+      chargeLowTemperatureProtectionDelay,
+      dischargeHighTemperatureWarning,
+      dischargeHighTemperatureRecovery,
+      dischargeHighTemperatureDelay,
+      dischargeHighTemperatureProtection,
+      dischargeHighTemperatureProtectionRecovery,
+      dischargeHighTemperatureProtectionDelay,
+      dischargeLowTemperatureWarning,
+      dischargeLowTemperatureRecovery,
+      dischargeLowTemperatureDelay,
+      dischargeLowTemperatureProtection,
+      dischargeLowTemperatureProtectionRecovery,
+      dischargeLowTemperatureProtectionDelay,
+      mosHighTemperatureWarning,
+      mosHighTemperatureRecovery,
+      mosHighTemperatureDelay,
+      mosHighTemperatureProtection,
+      mosHighTemperatureProtectionRecovery,
+      mosHighTemperatureProtectionDelay,
+      envHighTemperatureWarning,
+      envHighTemperatureRecovery,
+      envHighTemperatureDelay,
+      envHighTemperatureProtection,
+      envHighTemperatureProtectionRecovery,
+      envHighTemperatureProtectionDelay,
+      envLowTemperatureWarning,
+      envLowTemperatureRecovery,
+      envLowTemperatureDelay,
+      envLowTemperatureProtection,
+      envLowTemperatureProtectionRecovery,
+      envLowTemperatureProtectionDelay,
+      overTemperatureRangeWarning,
+      overTemperatureRangeRecovery,
+      overTemperatureRangeDelay,
+      overTemperatureRangeProtection,
+      overTemperatureRangeProtectionRecovery,
+      overTemperatureRangeProtectionDelay,
+      overVoltageRangeWarning,
+      overVoltageRangeRecovery,
+      overVoltageRangeDelay,
+      overVoltageRangeProtection,
+      overVoltageRangeProtectionRecovery,
+      overVoltageRangeProtectionDelay,
+      underSOCRangeWarning,
+      underSOCRangeRecovery,
+      underSOCRangeDelay,
+      underSOCRangeProtection,
+      underSOCRangeProtectionRecovery,
+      underSOCRangeProtectionDelay,
+    };
+  }
+  // #region 解析储能pack基本参数
+  /**
+   * 解析pack基本参数
+   * @param {Array} values 数据
+   * @returns {Object} 参数
+   */
+  // 参数(0xXX 0x78 1C 00 1C 86 00 00 ...)
+  getParams(values) {
+    if (values[1] != 0x78 || values[2] != 0x1c) return null;
+    const d_0x02_0x78_0x1C00 = ['01', '78', '1C', '00', '1C', '86', /**/ '00', '86', /**/ '00', '00', '00', '00', '0D', '48', '00', '1E', '01', 'F4', '02', '58', '16', '30', '05', 'DC', '55', '50', '31', '36', '53', '30', '31', '35', '30', '30', '30', '31', '33', '30', '37', '32', '34', '30', '35', '30', '35', '30', '30', '38', '36', '31', '00', '00', '00', '00', '07', 'E8', '00', '06', '00', '01', '4A', '42', '44', '34', '38', '31', '35', '30', '30', '30', '31', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '07', 'E8', '00', '02', '00', '12', '4A', '42', '44', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '01', '0B', 'B8', '0B', '40', '00', '00', '00', '00', '00', '00', '00', '00', '00', '0A', /**/ '9A', '6C'];
+    const data = values.slice(8, values.length - 2).map((x) => ('00' + x.toString(16)).toUpperCase().slice(-2));
+    let i = 0;
+    // 电池类型
+    const batteryType = format(data.slice(i, (i += 2)), 1, 0);
+    const batteryTypeName = batteryType == 0 ? '铁锂' : batteryType == 1 ? '三元' : '';
+    // 电池厂家
+    const batteryFactory = format(data.slice(i, (i += 2)), 1, 0);
+    // 均衡开启电压
+    const equilibriumOpenedVoltage = format(data.slice(i, (i += 2)), 1, 0);
+    // 均衡开启压差
+    const equilibriumOpenedVoltageDeviation = format(data.slice(i, (i += 2)), 1, 0);
+    // 加热开启温度-℃
+    const hotOpenedTemperature = format(data.slice(i, (i += 2)), 0.1, -50, 2);
+    // 加热关闭温度-℃
+    const hotClosedTemperature = format(data.slice(i, (i += 2)), 0.1, -50, 2);
+    // 满充校准电压-V
+    const fullyChargedCalibrationVoltage = format(data.slice(i, (i += 2)), 0.01, 0);
+    // 满充校准电流-mA
+    // FIXME:
+    const fullyChargedCalibrationElectricity = format(data.slice(i, (i += 2)), 1, 0);
+    // BMS条码
+    const bmsBarcode = hexToAscii(data.slice(i, (i += 30)).join(''));
+    // BMS生产日期
+    const bmsProductionDate_Year = format(data.slice(i, (i += 2)), 1, 0);
+    const bmsProductionDate_Month = format(data.slice(i, (i += 2)), 1, 0);
+    const bmsProductionDate_Day = format(data.slice(i, (i += 2)), 1, 0);
+    const bmsProductionDate = [bmsProductionDate_Year, bmsProductionDate_Month, bmsProductionDate_Day].join('-');
+    // SN码
+    const snBarcode = hexToAscii(data.slice(i, (i += 30)).join(''));
+
+    // PACK生产日期
+    const packProductionData_Year = format(data.slice(i, (i += 2)), 1, 0);
+    const packProductionData_Month = format(data.slice(i, (i += 2)), 1, 0);
+    const packProductionData_Day = format(data.slice(i, (i += 2)), 1, 0);
+    // 厂家代号
+    const factoryCode = hexToAscii(data.slice(i, (i += 30)).join(''));
+    // CAN协议
+    const can = format(data.slice(i, (i += 2)), 1, 0);
+    // 待机休眠电压-mV
+    const standbySleepVoltage = format(data.slice(i, (i += 2)), 1, 0);
+    // 待机休眠延时
+    const standbySleepDelay = format(data.slice(i, (i += 2)), 1, 0);
+    // 均衡模式
+    const equilibriumMode = format(data.slice(i, (i += 2)), 1, 0);
+    const equilibriumModeName = equilibriumMode == 0 ? '充电均衡' : batteryType == 1 ? '静态与充电均衡' : '';
+    // RS485协议
+    const rs485 = format(data.slice(i, (i += 2)), 1, 0);
+    // CAN特波特设置
+    const canTeport = format(data.slice(i, (i += 2)), 1, 0);
+    // RS485特波特设置
+    const rs385Teport = format(data.slice(i, (i += 2)), 1, 0);
+    // 待机休眠电流-A
+    const standbySleepElectricity = format(data.slice(i, (i += 2)), 0.1, 0);
+    return {
+      batteryType,
+      batteryTypeName,
+      batteryFactory,
+      equilibriumOpenedVoltage,
+      equilibriumOpenedVoltageDeviation,
+      hotOpenedTemperature,
+      hotClosedTemperature,
+      fullyChargedCalibrationVoltage,
+      fullyChargedCalibrationElectricity,
+      bmsBarcode,
+      bmsProductionDate_Year,
+      bmsProductionDate_Month,
+      bmsProductionDate_Day,
+      bmsProductionDate,
+      snBarcode,
+      packProductionData_Year,
+      packProductionData_Month,
+      packProductionData_Day,
+      factoryCode,
+      can,
+      standbySleepVoltage,
+      standbySleepDelay,
+      equilibriumMode,
+      equilibriumModeName,
+      rs485,
+      canTeport,
+      rs385Teport,
+      standbySleepElectricity,
+    };
+  }
+  // #region 解析pack校准参数
+  /**
+   * 解析pack校准参数
+   * @param {*} values 
+   * @returns 
+   */
+  // 校准信息(0xXX 0x78 20 00 20 36 00 00 ...)
+  getCalibrationInfo(values) {
+    if (values[1] != 0x78 || values[2] != 0x20) return null;
+    const d_0x02_0x78_0x2000 = ['01', '78', '20', '00', '20', '36', /**/ '00', '40', /**/ '3A', '98', '3A', '98', '14', '96', '0D', 'B9', '00', '64', '00', '00', '00', '96', '00', '50', '00', '00', '00', '00', '00', '00', '00', '12', '00', '14', '0C', '1C', '00', '14', '0C', '80', '00', '1E', '0D', '7A', '00', '50', '0D', 'DE', '00', '5A', '02', '40', '02', 'EE', '01', 'A4', '05', 'DC', '00', '10', '00', 'D2', '00', '04', '00', '04', '00', '04', '00', '00', '00', '00', /**/ 'A2', 'B5'];
+    const data = values.slice(8, values.length - 2).map((x) => ('00' + x.toString(16)).toUpperCase().slice(-2));
+    let i = 0;
+
+    // 标称容量-Ah
+    const nominalCapacity = format(data.slice(i, (i += 2)), 0.01, 0, 2);
+    // 满充容量-Ah
+    const fullCapacity = format(data.slice(i, (i += 2)), 0.01, 0, 2);
+    // 剩余容量-Ah
+    const restCapacity = format(data.slice(i, (i += 2)), 0.01, 0, 2);
+    // SOC-%
+    const soc = socFormat(data.slice(i, (i += 2)), 0.01, 0, 0);
+    // SOH
+    const soh = format(data.slice(i, (i += 2)), 1, 0, 0);
+    // 循环次数
+    const cycleNum = format(data.slice(i, (i += 2)), 1, 0, 0);
+    // 循环衰减系数-衰减1%循环次数
+    const cycleAttenuationFactor = format(data.slice(i, (i += 2)), 1, 0, 0);
+    // 循环系数-%
+    const cycleFactor = format(data.slice(i, (i += 2)), 1, 0);
+    // 累计充电-Ah
+    const cumulativeCharge = format(data.slice(i, (i += 4)), 0.1, 0);
+    // 累计放电-Ah
+    const cumulativeDisharge = format(data.slice(i, (i += 4)), 0.1, 0);
+    // 电池自功耗系数-多少天1%
+    const batterySelfConsumptionFactor = format(data.slice(i, (i += 2)), 1, 0);
+    // OCV校准电压1
+    const ocvCalibrationVoltage1 = format(data.slice(i, (i += 2)), 1, 0);
+    // OCV校准SOC1-%
+    const ocvCalibrationSOC1 = format(data.slice(i, (i += 2)), 1, 0);
+    // OCV校准电压2
+    const ocvCalibrationVoltage2 = format(data.slice(i, (i += 2)), 1, 0);
+    // OCV校准SOC2-%
+    const ocvCalibrationSOC2 = format(data.slice(i, (i += 2)), 1, 0);
+    // OCV校准电压3
+    const ocvCalibrationVoltage3 = format(data.slice(i, (i += 2)), 1, 0);
+    // OCV校准SOC3-%
+    const ocvCalibrationSOC3 = format(data.slice(i, (i += 2)), 1, 0);
+    // OCV校准电压4
+    const ocvCalibrationVoltage4 = format(data.slice(i, (i += 2)), 1, 0);
+    // OCV校准SOC4-%
+    const ocvCalibrationSOC4 = format(data.slice(i, (i += 2)), 1, 0);
+    // 充电需求电压-V
+    const chargeDemandVoltage = format(data.slice(i, (i += 2)), 0.1, 0, 2);
+    // 充电需求电流-A
+    const chargeDemandElectricity = format(data.slice(i, (i += 2)), 0.1, 0, 2);
+    // 放电需求电压-V
+    const dischargeDemandVoltage = format(data.slice(i, (i += 2)), 0.1, 0, 2);
+    // 放电需求电流-A
+    const dischargeDemandElectricity = format(data.slice(i, (i += 2)), 0.1, 0, 2);
+    // 电池串数
+    const batterySerial = format(data.slice(i, (i += 1)), 1, 0);
+
+    return { nominalCapacity, fullCapacity, restCapacity, soc, soh, cycleNum, cycleAttenuationFactor, cycleFactor, cumulativeCharge, cumulativeDisharge, batterySelfConsumptionFactor, ocvCalibrationVoltage1, ocvCalibrationSOC1, ocvCalibrationVoltage2, ocvCalibrationSOC2, ocvCalibrationVoltage3, ocvCalibrationSOC3, ocvCalibrationVoltage4, ocvCalibrationSOC4, chargeDemandVoltage, chargeDemandElectricity, dischargeDemandVoltage, dischargeDemandElectricity, batterySerial };
+  }
+  // #region 解析pack版本参数
+  /**
+   * 解析pack版本参数
+   * @param {*} values 
+   * @returns 
+   */
+  // 版本信息(0xXX 0x78 28 10 28 40 00 00 ...)
+  getVersionInfo(values) {
+    if (values[1] != 0x78 || values[2] != 0x28) return null;
+    const d_0x02_0x78_0x2810 = ['01', '78', '28', '10', '28', '40', /**/ '00', '2C', /**/ '00', '0E', '00', '03', '00', '0A', '00', '01', '00', '05', '00', '24', '55', '50', '31', '36', '53', '30', '31', '35', '00', '00', '00', '00', '00', '00', '00', '00', '4A', '42', '44', '2D', '4C', '31', '36', '53', '31', '30', '30', '41', '00', '00', '00', '00', /**/ 'D2', '3C'];
+    const data = values.slice(8, values.length - 2).map((x) => ('00' + x.toString(16)).toUpperCase().slice(-2));
+    let i = 0;
+
+    // BOOT版本
+    const bootVersion = format(data.slice(i, (i += 2)), 1, 0);
+    // 硬件版本
+    const hardwareVersion = format(data.slice(i, (i += 2)), 1, 0);
+    // APP版本
+    const appMajorVersion = format(data.slice(i, (i += 2)), 1, 0);
+    const appMinorVersion = format(data.slice(i, (i += 2)), 1, 0);
+    const appBetaVersion = format(data.slice(i, (i += 2)), 1, 0);
+
+    // 协议版本
+    const protocolVersion = format(data.slice(i, (i += 2)), 1, 0);
+    // 硬件名称
+    const hardwareName = hexToAscii(data.slice(i, (i += 16)).join(''));
+    // 项目名称
+    const projectName = hexToAscii(data.slice(i, (i += 16)).join(''));
+
+    const appVersion = [projectName, appMajorVersion, appMinorVersion, appBetaVersion].join('.');
+    const firmwaeVersion = appVersion;
+    return { bootVersion, hardwareVersion, appBetaVersion, appVersion, protocolVersion, hardwareName, projectName, firmwaeVersion };
+  }
+}