@jiabaida/tools 1.0.6 → 1.0.8

package/src/core/BleCmdAnalysis/BaseParamProtocol.js

@@ -1,7 +1,7 @@
-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'
+import { batteryInfoJson, capInfoJson, capVolInfoJson, currentInfoJson, equalizerFunJson, funcAndTempFuncJson, funcJson, systemJson, tempFuncJson, tempInfoJson, voltageInfoJson } from '../dataJson/baseParamsJson.js';
+import { enterFactory, getProtectCountCmd, readExistFactory } from './BleCmdDD.js';
+import { getSysParamCmd } from './readAndSetParam';
 
 /**
  * 
@@ -117,13 +117,22 @@ export const getBaseParams = async (chipType, deviceData, index, paramObj) => {
       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)
+
+          /**读取标称容量：需要读取paramNo 0（低16位）和155（高16位） */
+          const normCapLow = await getSysParamCmd(chipType, deviceId, { paramNo: 0, paramLength: 2 })
+          const normCapHigh = await getSysParamCmd(chipType, deviceId, { paramNo: 155, paramLength: 2 })
+          console.log('normCapLow: ', normCapLow, 'normCapHigh: ', normCapHigh);
+          // 合并高低位，每个都只取前2个字节
+          datasInfo2['normCap'] = [...(normCapLow?.slice(0, 2) || []), ...(normCapHigh?.slice(0, 2) || [])]
+
+          const cycleCapData = await getSysParamCmd(chipType, deviceId, capInfoJson[1])
+          datasInfo2['cycleCap'] = cycleCapData?.slice(0, 2)
+
+          /**读取满充容量：需要读取paramNo 112（低16位）和156（高16位） */
+          const fullCapLow = await getSysParamCmd(chipType, deviceId, { paramNo: 112, paramLength: 2 })
+          const fullCapHigh = await getSysParamCmd(chipType, deviceId, { paramNo: 156, paramLength: 2 })
+          console.log('fullCapLow: ', fullCapLow, 'fullCapHigh: ', fullCapHigh);
+          datasInfo2['fullCap'] = [...(fullCapLow?.slice(0, 2) || []), ...(fullCapHigh?.slice(0, 2) || [])]
         } else {
           await sendCmdSeq(datasInfo2, chipType, deviceId, capInfoJson)
         }
@@ -378,9 +387,59 @@ function toHexString(arr) {
 }
 const getCapInfo = async (datas) => {
   console.log('datas: ', datas);
-  const normCap = format(datas.normCap, 0.01, 0, 2)
+  // 标称容量：低16位（前2字节）+ 高16位（后2字节），单位是0.01AH
+  let normCap = null;
+  if (datas.normCap && datas.normCap.length >= 4) {
+    console.log('normCap原始数据: ', datas.normCap);
+    // 读取低16位（前两个字节）- 大端序
+    const lowBytes = datas.normCap.slice(0, 2);
+    const lowValue = (lowBytes[0] << 8) | lowBytes[1];
+    console.log('normCap lowValue: ', lowValue);
+
+    // 读取高16位（后两个字节）- 大端序
+    const highBytes = datas.normCap.slice(2, 4);
+    const highValue = (highBytes[0] << 8) | highBytes[1];
+    console.log('normCap highValue: ', highValue);
+
+    // 合并高低位：(高位 << 16) | 低位
+    const totalValue = (highValue << 16) | lowValue;
+    console.log('normCap totalValue: ', totalValue);
+    normCap = Number((totalValue * 0.01).toFixed(2));
+    console.log('normCap最终值: ', normCap);
+  } else if (datas.normCap && datas.normCap.length >= 2) {
+    // 兼容旧协议，只有低16位 - 大端序
+    const lowBytes = datas.normCap.slice(0, 2);
+    const lowValue = (lowBytes[0] << 8) | lowBytes[1];
+    normCap = Number((lowValue * 0.01).toFixed(2));
+  }
+
   const cycleCap = format(datas.cycleCap, 0.01, 0, 2)
-  const fullCap = format(datas.fullCap, 0.01, 0, 2)
+
+  // 满充容量：低16位（前2字节）+ 高16位（后2字节），单位是0.01AH
+  let fullCap = null;
+  if (datas.fullCap && datas.fullCap.length >= 4) {
+    console.log('fullCap原始数据: ', datas.fullCap);
+    // 读取低16位（前两个字节）- 大端序
+    const lowBytes = datas.fullCap.slice(0, 2);
+    const lowValue = (lowBytes[0] << 8) | lowBytes[1];
+    console.log('fullCap lowValue: ', lowValue);
+
+    // 读取高16位（后两个字节）- 大端序
+    const highBytes = datas.fullCap.slice(2, 4);
+    const highValue = (highBytes[0] << 8) | highBytes[1];
+    console.log('fullCap highValue: ', highValue);
+
+    // 合并高低位：(高位 << 16) | 低位
+    const totalValue = (highValue << 16) | lowValue;
+    console.log('fullCap totalValue: ', totalValue);
+    fullCap = Number((totalValue * 0.01).toFixed(2));
+    console.log('fullCap最终值: ', fullCap);
+  } else if (datas.fullCap && datas.fullCap.length >= 2) {
+    // 兼容旧协议，只有低16位 - 大端序
+    const lowBytes = datas.fullCap.slice(0, 2);
+    const lowValue = (lowBytes[0] << 8) | lowBytes[1];
+    fullCap = Number((lowValue * 0.01).toFixed(2));
+  }
   return {
     normCap,
     cycleCap,

package/src/core/BleCmdAnalysis/BleCmdAnalysis.js

@@ -1,5 +1,5 @@
-import { hexArr2ab, ab2decimalArr, hexArr2string, sleep } from '../BleDataProcess';
-import { getOS, eventBus, getPlatform } from '../commonfun';
+import { ab2decimalArr, hexArr2ab, hexArr2string, sleep } from '../BleDataProcess';
+import { eventBus, getOS, getPlatform } from '../commonfun';
 
 const BLE_RESPONSE_TIMEOUT = 300; // 蓝牙指令响应超时
 const STORE_MUTATION_NAME = 'setBleChangedCharacteristicValue';
@@ -21,6 +21,7 @@ async function _writeAsync(deviceId, value) {
     console.log('platform: ', platform);
     console.log('isAndroid, isIOS: ', isAndroid, isIOS);
     const writeType = platform === 'mp-weixin' ? 'writeNoResponse' : isAndroid ? 'writeNoResponse' : 'write';
+    console.log('writeType: ', writeType);
     uni.writeBLECharacteristicValue({
       deviceId,
       serviceId,

package/src/core/BleCmdAnalysis/BleCmdDD.js

@@ -1,7 +1,8 @@
 import { decimalToHex, fromBCD, generateCrc16modbusCheck, generateCrcCheckSum, hex2string, hexArr2Assic, hexArr2string, hexToDecimal, isWithin30Minutes, sleep, stringToTwoHexArray, toBCD } from '../BleDataProcess';
 import { getData } from './BleCmdAnalysis.js';
 import { getFFAA80Async, resolveFFAA80 } from './BleCmdFFAA.js';
-
+import { controlSwitch } from './readAndSetParam.js';
+ 
 // #region 进出工厂
 /**进工厂 */
 export const enterFactory = async (deviceId) => {
@@ -358,6 +359,9 @@ export const resolveDDA503 = (data) => {
     name: index + 1,
     value: item,
   }));
+  const hasProtocol = 
+    data[3] + 7 >= humidityIndex + 11 + 3 + 1;
+  const protocolVersion = data[humidityIndex + 11];
   return {
     cmdResp03,
     status: hex2string(data[2]),
@@ -391,6 +395,8 @@ export const resolveDDA503 = (data) => {
     fahTempList,
     fet,
     seriesNum,
+    hasProtocol,
+    protocolVersion
   };
 }
 
@@ -1245,18 +1251,71 @@ export const get3B3CInfo = ({ deviceId, macAddr, moduleType, productType }) => {
 
 // #region 发送设备激活指令
 export const activateAsync = async (deviceId) => {
-  const startTime = +new Date();
-  const disChargMOSHex = await getDD5AFBAsync(deviceId, '0x00', '0x00');
-  const disChargMOSRes = resolveBaseDD(disChargMOSHex)?.dataStr;
-  const disChargEndTime = +new Date();
-  const activeHex = await getDD5AFBAsync(deviceId, '0x05', '0x01');
-  const activeRes = resolveBaseDD(disChargMOSHex)?.dataStr;
-  let baseInfo = null
-  const endTime = +new Date();
-  await sleep(300)
-  baseInfo = await getDDA503Async(deviceId);
-  const voltageInfo = await getDDA504Async(deviceId);
-  return { disChargMOSHex, disChargMOSRes, activeHex, activeRes, baseInfo, voltageInfo, startTime, disChargEndTime, endTime };
+  // const startTime = +new Date();
+  // const disChargMOSHex = await getDD5AFBAsync(deviceId, '0x00', '0x00');
+  // const disChargMOSRes = resolveBaseDD(disChargMOSHex)?.dataStr;
+  // const disChargEndTime = +new Date();
+  // const activeHex = await getDD5AFBAsync(deviceId, '0x05', '0x01');
+  // const activeRes = resolveBaseDD(disChargMOSHex)?.dataStr;
+  // let baseInfo = null
+  // const endTime = +new Date();
+  // await sleep(300)
+  // baseInfo = await getDDA503Async(deviceId);
+  // const voltageInfo = await getDDA504Async(deviceId);
+  // return { disChargMOSHex, disChargMOSRes, activeHex, activeRes, baseInfo, voltageInfo, startTime, disChargEndTime, endTime };
+  try {
+    const startTime = +new Date();
+    let acStatus = false // 激活结果
+    // 发送打开放电MOS指令
+    const mosRes = await controlSwitch(
+      deviceId,
+      '0x00',
+      true,
+      true,
+    );
+    const disChargMOSRes = mosRes?.dataStr;
+    const disChargEndTime = +new Date();
+    // 发送激活指令
+    const activeHex = await getDD5AFBAsync(deviceId, '0x05', '0x01');
+    const activeResult = resolveBaseDD(activeHex);
+    console.log('激活指令结果: ', { activeHex, activeResult });
+    const activeRes = activeResult?.dataStr;
+    let endTime = +new Date();
+    let baseInfo = null
+    let voltageInfo = null
+    let steps = []
+    if (activeResult?.status == '00') {
+      steps.push(4)
+      acStatus = true
+    } else if (activeResult?.status == '81' || activeResult?.status == '84') {//不支持激活指令，判断开关执行结果
+      if (mosRes?.status == '00') {
+        acStatus = true
+        steps.push(5)
+      } else {
+        acStatus = false
+        steps.push(10)
+      }
+    } else if (activeResult?.status == '82' || activeResult?.status == '83') { // 激活指令执行失败
+      acStatus = false
+      steps.push(6)
+    } else if (!activeResult || activeResult == null) { //激活无响应
+      await sleep(300)
+      const baseInfo = await getDDA503Async(deviceId);
+      // 读取03指令后判断放电MOS是否打开，若打开则激活成功
+      if (baseInfo?.dischargeSwitch) {
+        acStatus = true
+        steps.push(7)
+      } else {
+        acStatus = false
+        steps.push(8)
+      }
+      endTime = +new Date()
+    }
+    return { disChargMOSRes, activeHex, activeRes, baseInfo, voltageInfo, startTime, disChargEndTime, endTime, acStatus, steps };
+  } catch (error) {
+    console.log("🚀 ~ BleApiManager ~ activateAsync ~ error:", error)
+    return null
+  }
 }
 
 // #region 获取均衡线电阻 DC 指令

package/src/core/BleCmdAnalysis/BleCmdDDA4.js

@@ -1,9 +1,9 @@
-import { decimalToHex, generateCheckSum, generateCrcCheckSum, hex2string, hexArr2string, hexToDecimal } from '../BleDataProcess';
+import { decimalToHex, generateCrcCheckSum, hex2string, hexArr2string, hexToDecimal } from '../BleDataProcess';
 import { getData } from './BleCmdAnalysis.js';
 
 export const getDDA420Async = async (deviceId) => {
     const _command = ['0x20', '0x00'];
-    const checks = generateCheckSum(_command);
+    const checks = generateCrcCheckSum(_command);
     const command = ['0xdd', '0xa4', ..._command, ...checks, '0x77'];
 
     const response = 'DD03002313E10000199D27100000310F00000000000014410310060BB60BC60BC10BBA0BBD0BC1F89777';
@@ -15,7 +15,7 @@ export const getDDA420Async = async (deviceId) => {
         commandVerifyHandler: (hexArr) => ({ verified: hexArr[0] == 0xdd && hexArr[1] == 0x20, pkgLen: hexArr[3] + 7 }),
         pkgVerifyHandler: (pkg) => {
           const len = pkg.length;
-          const [c1, c2] = generateCheckSum(pkg.slice(2, len - 3));
+          const [c1, c2] = generateCrcCheckSum(pkg.slice(2, len - 3));
           const [_c1, _c2] = [pkg[len - 3], pkg[len - 2]];
           return { verified: c1 == _c1 && c2 == _c2 };
         },
@@ -29,7 +29,7 @@ export const getDDA420Async = async (deviceId) => {
    * @param {number[]} data DDA420十六进制数据数组
    * @returns {Object} 解析后的充电器工作信息对象
    * @returns {string} dataStr 十六进制数据数组转换后的字符串
-   * @returns {number} workStatus 工作状态：1=待机，2=就绪，3=激活电池中，4=通讯充电中，5=调试充电中，6=盲充中，7=结束充电
+   * @returns {number} workStatus 工作状态：1=待机，2=就绪，3=激活电池中，4=通讯充电中，5=调试充电中，6=盲充中，7=结束充电 8=停止充电（异常） 9=充电比对中 10=校准中 11=老化中 12=握手充电中 13=小电流充电中
    * @returns {number} chargeStatus 充电状态：1=恒流，2=恒压，3=涓流
    * @returns {number} chargeVoltage 充电电压，单位毫伏(mV)
    * @returns {number} chargeElectricity 充电电流，单位毫安(mA)
@@ -51,7 +51,7 @@ export const getDDA420Async = async (deviceId) => {
    * @returns {number} ratedPower 充电器额定功率，单位瓦特(W)
    * @returns {number} inputVoltage 输入电压，单位毫伏(mV)
    */
-  export const resolveDDA420 = async (data) => {
+  export const resolveDDA420 = (data) => {
     if (!data) return null;
     const dataStr = hexArr2string(data);
     let n = 4; // 起始偏移
@@ -251,7 +251,7 @@ export const getDDA420Async = async (deviceId) => {
    * @param {number[]} data DDA421十六进制数据数组
    * @returns {Object} 解析后的充电电池信息对象
    */
-  export const resolveDDA421 = async (data) => {
+  export const resolveDDA421 = (data) => {
     if (!data) return null;
     const dataStr = hexArr2string(data);
     // 电池电压 4BYTE [4,5,6,7]
@@ -335,7 +335,7 @@ export const getDDA420Async = async (deviceId) => {
       'DDA425'
     );
   }
-  export const resolveDDA425 = async (data) => {
+  export const resolveDDA425 = (data) => {
     if (!data) return null;
     const dataStr = hexArr2string(data);
     return {
@@ -384,7 +384,7 @@ export const getDDA420Async = async (deviceId) => {
    * @param {number[]} data DDA422响应数据
    * @returns {Object} 解析结果
    */
-  export const resolveDDA422 = async (data) => {
+  export const resolveDDA422 = (data) => {
     if (!data) return null;
     const dataStr = hexArr2string(data);
     // 起始地址 2BYTE [4,5]
@@ -447,14 +447,77 @@ export const getDDA420Async = async (deviceId) => {
       'DDA423'
     );
   }
-  export const resolveDDA423 = async (data) => {
+  export const resolveDDA423 = (data) => {
     if (!data) return null;
     const dataStr = hexArr2string(data);
     return {
       dataStr,
       status: hex2string(data[2])
     };
+}
+  /** 充电器充电测试 26 指令
+   * 发送: DD A4 26 09 <测试模式1B> <输出电压4B mV> <输出电流4B mA> CRC_H CRC_L 77
+   * 响应: DD 26 <状态位1B> 00 CRC_H CRC_L 77  (或: DD 26 <状态位> 00 ...)
+   * @param {string} deviceId 设备ID
+   * @param {number} testMode 测试模式 1=调试模式 2=老化模式
+   * @param {number} outputVoltage 输出目标电压(mV) 0~4294967295
+   * @param {number} outputCurrent 输出目标电流(mA) 0~4294967295
+   * @returns {Promise<number[]|null>} 原始响应数据数组; 失败返回 null
+   */
+  export const getDDA426Async = async (deviceId, testMode = 0, outputVoltage = 0, outputCurrent = 0) => {
+    // 保护参数范围（简单防御，防止生成溢出字节/异常写入）
+    const clamp32 = (v) => {
+      v = Number(v) || 0; if (v < 0) v = 0; if (v > 0xFFFFFFFF) v = 0xFFFFFFFF; return v;
+    };
+    testMode = testMode === 2 ? 2 : 0; // 只允许 0 / 2
+    outputVoltage = clamp32(outputVoltage);
+    outputCurrent = clamp32(outputCurrent);
+
+    // 转 4 字节 (大端) 十六进制 -> 数组
+    const to4Bytes = (val) => {
+      const hex = commonfun.decimalToHex(val, 8); // 8位十六进制字符串
+      return [0, 2, 4, 6].map(i => parseInt(hex.slice(i, i + 2), 16));
+    };
+    const voltageArr = to4Bytes(outputVoltage);
+    const currentArr = to4Bytes(outputCurrent);
+
+    // 长度 = 1(模式) +4(电压)+4(电流) = 9
+    const lengthHex = commonfun.decimalToHex(9, 2); // '09'
+    const _command = ['0x26', `0x${lengthHex}`, testMode & 0xFF, ...voltageArr, ...currentArr].map(o => typeof o === 'number' ? `0x${('00' + o.toString(16)).slice(-2)}` : o);
+    // 去掉 0x 前缀转成数值数组生成 CRC
+    const _commandNums = _command.map(h => parseInt(h, 16));
+    const checks = generateCrcCheckSum(_commandNums);
+    const command = ['0xDD', '0xA4', ..._command, ...checks, '0x77'];
+
+    return getData(
+      deviceId,
+      {
+        command,
+        commandVerifyHandler: (hexArr) => ({ verified: hexArr[0] == 0xdd && hexArr[1] == 0x26, pkgLen: hexArr[3] + 7 }),
+        pkgVerifyHandler: (pkg) => {
+          // const len = pkg.length;
+          // const [c1, c2] = this.generateCrcCheckSum(pkg.slice(2, len - 3));
+          // const [_c1, _c2] = [pkg[len - 3], pkg[len - 2]];
+          // return { verified: c1 == _c1 && c2 == _c2 };
+          return { verified: true }
+        },
+      },
+      'DDA426(充电测试)',
+      3000
+    );
+}
+  
+  /** 解析充电器充电测试 26 指令响应
+   * @param {number[]} data
+   * @returns {{dataStr:string,status:string}|null}
+   */
+
+  export const resolveDDA426 = (data) => {
+    if (!data) return null;
+    const dataStr = hexArr2string(data);
+    return { dataStr, status: hex2string(data[2]) };
   }
+  
   /** 查询充电历史数据27指令
    * @param {*} deviceId
    * @param {number} startTime 充电起始时间（秒，4字节）
@@ -509,7 +572,7 @@ export const getDDA420Async = async (deviceId) => {
    * @param {number[]} data DDA427响应数据
    * @returns {Object} 解析结果
    */
-  export const resolveDDA427 = async (data) => {
+  export const resolveDDA427 = (data) => {
     if (!data) return null;
     const dataStr = hexArr2string(data);
     // 充电起始时间 4BYTE [4,5,6,7]
@@ -605,7 +668,7 @@ export const getDDA420Async = async (deviceId) => {
       'DDA429'
     );
   }
-  export const resolveDDA429 = async (data) => {
+  export const resolveDDA429 = (data) => {
     if (!data) return null;
     const dataStr = hexArr2string(data);
     let n = 4; // 起始偏移

package/src/core/BleCmdAnalysis/index.js

@@ -1,7 +1,8 @@
+export * from './BaseParamProtocol';
 export * from './BleCmdAnalysis';
-export * from './BleCmdFFAA';
 export * from './BleCmdDD';
-export * from './readAndSetParam'
-export * from './BaseParamProtocol'
-export * from './BleCmdHVES'
-export * from './ESHostProtocol'
+export * from './BleCmdDDA4';
+export * from './BleCmdFFAA';
+export * from './BleCmdHVES';
+export * from './ESHostProtocol';
+export * from './readAndSetParam';

package/src/core/BleCmdAnalysis/readAndSetParam.js

@@ -1,5 +1,5 @@
 import { decimalToHex, decimalToTwoByteHexArray } from '../BleDataProcess.js';
-import { enterFactory, existFactory, getDDA5FAAsync, getDDA5OldAsync, readExistFactory, setDDA5FAAsync, setDDA5OldAsync } from './BleCmdDD.js';
+import { enterFactory, existFactory, getDD5AE1Async, getDD5AFBAsync, getDDA5FAAsync, getDDA5OldAsync, readExistFactory, resolveBaseDD, setDDA5FAAsync, setDDA5OldAsync } from './BleCmdDD.js';
 
 // #region 发指令读取参数 
 /**
@@ -89,10 +89,12 @@ export const getSysParamCmd = async (chipType, deviceId, paramInfo, needFactoryM
   }
 }
 
-// #region 系统写参数处理 
+// #region 系统写参数处理 判断wifi或蓝牙
 /**
  * @param {*} chipType 芯片类型
  * @param {*} deviceId 设备deviceId
+ * @param {*} macAddr 设备macAddr
+ * @param {*} blueConnect 是否通过蓝牙连接 默认true
  * @param {Array|Object} paramInfoArray 包含多个参数信息的数组或单个参数信息对象
  * @param {*} paramInfoArray[].newValue 新设置的参数输入值十进制值
  * @param {*} paramInfoArray[].paramValue 新设置的参数值十进制值 部分参数输入的值需单独处理
@@ -102,7 +104,7 @@ export const getSysParamCmd = async (chipType, deviceId, paramInfo, needFactoryM
  * @param {*} paramInfoArray[].divisor 缩放系数（十进制）如 10
  * @param {*} paramInfoArray[].isTemp 是否是温度参数
 */
-export const setSysParamCmd = async (chipType, deviceId, paramInfoArray) => {
+export const setSysParamCmd = async (chipType, deviceId, paramInfoArray, macAddr, blueConnect = true) => {
   try {
     console.log('paramInfoArray: ', paramInfoArray);
 
@@ -113,13 +115,18 @@ export const setSysParamCmd = async (chipType, deviceId, paramInfoArray) => {
     const paramObjs = [];
 
     for (const paramInfo of paramsToProcess) {
-      let value = Math.round(Number(paramInfo?.paramValue || paramInfo.newValue) / Number(paramInfo?.divisor || 1));
+      // 根据系数处理参数值
+      let value = Number(paramInfo?.paramValue || paramInfo.newValue) / Number(paramInfo?.divisor || 1);
       console.log('value: ', value);
-      if (paramInfo.isTemp) {
+      if (paramInfo.isTemp && blueConnect) {
         value = 2731 + (Number(paramInfo.newValue) * 10)
       }
-      const valuesHexs = decimalToTwoByteHexArray(value);
-      console.log('valuesHexs: ', valuesHexs);
+      value = Math.round(value);
+      let valuesHexs = [];
+      if(blueConnect) {
+        valuesHexs = decimalToTwoByteHexArray(value);
+        console.log('valuesHexs: ', valuesHexs);
+      }
 
       // 将处理后的参数对象添加到数组中
       paramObjs.push({
@@ -127,11 +134,14 @@ export const setSysParamCmd = async (chipType, deviceId, paramInfoArray) => {
         length: paramInfo.paramLength / 2,
         values: valuesHexs,
         oldAddress: paramInfo.oldParamNo,
+        newValue: value,
       });
     }
 
     // 一次性将所有参数对象数组传递给setParamCmd函数
+    console.log("chipType: 芯片", chipType);
     await setParamCmd(chipType, deviceId, paramObjs);
+   
   } catch (error) {
     console.error('error: 写系统参数报错 setSysParamCmd', error);
     throw error
@@ -143,6 +153,7 @@ export const setSysParamCmd = async (chipType, deviceId, paramInfoArray) => {
  * 发指令设置参数
  * @param {*} chipType 芯片类型
  * @param {*} deviceId 设备deviceId
+ * @param {*} macAddr 设备macAddr
  * @param {Array} paramInfoArray 参数信息数组 或单个对象
  * @param {*} paramInfoArray[].address 新协议开始写入地址（十进制）如 31
  * @param {*} paramInfoArray[].length 新协议写参数内容长度（写几个）（十进制）如 1
@@ -150,7 +161,7 @@ export const setSysParamCmd = async (chipType, deviceId, paramInfoArray) => {
  * @param {*} paramInfoArray[].oldAddress 旧协议写入地址 默认一个（十六进制字符串）如 '0x1f'
  * @returns {Promise<Array>} 包含所有参数设置结果的数组
  */
-export const setParamCmd = (chipType, deviceId, paramInfoArray) => {
+export const setParamCmd = async (chipType, deviceId, paramInfoArray) => {
   console.log("chipType: 芯片", chipType);
 
   // 确保paramInfoArray是数组
@@ -212,6 +223,84 @@ export const setParamCmd = (chipType, deviceId, paramInfoArray) => {
   });
 }
 
+/** 控制开关 
+ * @param {*} deviceId 
+ * @param {*} typeCmd 0x00 - 放电MOS 0x01 - 充电MOS
+ * @param {*} currentSwitch 当前修改开关状态 true - 打开 false - 关闭
+ * @param {*} anotherSwitch 另一个开关状态
+ * @returns 指令结果 Ooj.status: 00 - 成功 81/84 不支持 82/83 失败
+*/
+export const controlSwitch = async (deviceId, typeCmd, currentSwitch, anotherSwitch) => {
+  //充放电开关
+  const hex = await getDD5AFBAsync(
+    deviceId,
+    typeCmd,
+    currentSwitch ? "0x00" : "0x01",
+  );
+  const mosRes = resolveBaseDD(hex);
+  console.log("hex: ", hex);
+  let dataRes = mosRes
+  //FB指令控制mos失败或无响应，发送E1指令
+  if (!mosRes || mosRes?.status != '00') {
+    const cmd = getE1Cmd(typeCmd, currentSwitch, anotherSwitch);
+    const e1hex = await getDD5AE1Async(
+      deviceId,
+      cmd
+    );
+    dataRes = resolveBaseDD(e1hex);
+  }
+  return dataRes
+}
+/** 计算E1指令
+ * @param {*} typeCmd 0x00 - 放电MOS 0x01 - 充电MOS
+ * @param {*} currentSwitch 当前修改开关状态 true - 打开 false - 关闭
+ * @param {*} anotherSwitch 另一个开关状态 true - 打开 false - 关闭
+ * @returns 0x00 - 充电MOS打开 放电MOS打开
+ * 0x01 - 充电MOS关闭 放电MOS打开
+ * 0x02 - 充电MOS打开 放电MOS关闭
+ * 0x03 - 充电MOS关闭 放电MOS关闭
+*/
+export const getE1Cmd = (typeCmd, currentSwitch, anotherSwitch) => {
+  let cmd = '0x00'
+  // 根据E1指令码定义计算：
+  // 0x00 - 充电MOS打开 放电MOS打开
+  // 0x01 - 充电MOS关闭 放电MOS打开
+  // 0x02 - 充电MOS打开 放电MOS关闭
+  // 0x03 - 充电MOS关闭 放电MOS关闭
+  if (typeCmd === '0x00') {
+    // 当前是放电操作
+    if (currentSwitch && anotherSwitch) {
+      // 放电MOS打开，充电MOS打开
+      cmd = '0x00'
+    } else if (currentSwitch && !anotherSwitch) {
+      // 放电MOS打开，充电MOS关闭
+      cmd = '0x01'
+    } else if (!currentSwitch && anotherSwitch) {
+      // 放电MOS关闭，充电MOS打开
+      cmd = '0x02'
+    } else {
+      // 放电MOS关闭，充电MOS关闭
+      cmd = '0x03'
+    }
+  } else if (typeCmd === '0x01') {
+    // 当前是充电操作
+    if (currentSwitch && anotherSwitch) {
+      // 充电MOS打开，放电MOS打开
+      cmd = '0x00'
+    } else if (!currentSwitch && anotherSwitch) {
+      // 充电MOS关闭，放电MOS打开
+      cmd = '0x01'
+    } else if (currentSwitch && !anotherSwitch) {
+      // 充电MOS打开，放电MOS关闭
+      cmd = '0x02'
+    } else {
+      // 充电MOS关闭，放电MOS关闭
+      cmd = '0x03'
+    }
+  }
+  return cmd
+}
+
 // #region 写入标称容量
 /**写入标称容量 同步写入满充及循环
  * @param {*} chipType 芯片类型

package/src/core/OtaUpgrade.js

@@ -184,7 +184,11 @@ export class OTAUpgrade {
           ...opt,
           fail: async () => {
             await this.sleep(this.delay * 2);
-            uni.writeBLECharacteristicValue({ ...opt, fail: this.fail.bind(this) });
+            uni.writeBLECharacteristicValue({
+              ...opt, fail: () => {
+                console.error('写入失败: ', pkg);
+                this.fail('写入失败');
+            } });
           },
         });
       },
@@ -317,16 +321,18 @@ export class OTAUpgrade {
     }
   }
 
-  transferFirmwareFile() {
+  async transferFirmwareFile() {
     let nextTime = this.finishedTimes + 1;
     const timeFor51 = nextTime > this.totalTimes;
     if (timeFor51) {
       const pkg = [0x00];
+      await BLE.sendDelay(20);
       BLE.transferFirmwareFileCmd(this.deviceId, pkg, true, this.fail.bind(this));
       console.log('[OTA]', '=== Send 51 ===', this.finishedTimes, this.totalTimes, pkg);
     } else {
       const pkg = this.fileHexArray.slice(this.finishedTimes * max, nextTime * max);
       const index = Transfer.decimalToTwoByteHexArray(this.finishedTimes);
+      await BLE.sendDelay(20);
       BLE.transferFirmwareFileCmd(this.deviceId, index.concat(pkg), false, this.fail.bind(this));
       console.log('[OTA]', `S50-${this.finishedTimes}/${this.totalTimes}`);
     }

package/src/core/Queue.js

@@ -0,0 +1,34 @@
+class Queue {
+  constructor() {
+    this._items = [];
+  }
+
+  enqueue(item) {
+    this._items.push(item);
+  }
+
+  dequeue() {
+    return this._items.shift();
+  }
+
+  head() {
+    return this._items[0];
+  }
+
+  tail() {
+    return this._items[this._items.length - 1];
+  }
+
+  isEmpty() {
+    return !this._items.length;
+  }
+
+  size() {
+    return this._items.length;
+  }
+
+  clear() {
+    this._items = [];
+  }
+}
+export default Queue