@jiabaida/tools 1.0.0 → 1.0.1

package/src/core/OtaUpgrade.js

@@ -0,0 +1,338 @@
+import { getOS } from './commonfun';
+import { TelinkApi } from './TelinkApi';
+import Transfer, { BLE } from './Transfer';
+
+const max = BLE.PACKAGE_MAX_LENGTH;
+const delayDefault = BLE.WRITE_DELAY;
+const { isIOS, isAndroid } = getOS();
+
+function getBuffer(hexArr) {
+  const buffer = new ArrayBuffer(hexArr.length);
+  const dataView = new DataView(buffer);
+  hexArr.forEach((hex, i) => dataView.setUint8(i, hex));
+  return buffer;
+}
+
+/**
+ * const ota = new OTAUpgrade({
+ * deviceId,
+ * macAddr,
+ * filePath,
+ * otaInfo,
+ * otaStart,
+ * otaReStart,
+ * isTeLink, // 是否 Telink 升级
+ * onProgress, // 升级进度回调
+ * onSuccess, // 升级成功回调
+ * onError, // 升级失败回调
+ * delay, // 写入延时，默认20ms，iOS可适当调大一些
+ * });
+ * ota.start();
+ **/
+
+export class OTAUpgrade {
+  constructor({ deviceId, filePath, otaInfo, otaStart, otaReStart, macAddr, onProgress, onSuccess, onError, delay, platform = 'APP' }) {
+    this.deviceId = deviceId;
+    this.filePath = filePath;
+    this.otaInfo = otaInfo;
+    this.otaStart = otaStart;
+    this.otaReStart = otaReStart;
+    this.macAddr = macAddr;
+    this.platform = platform; // 'APP' | 'MP' | 'H5'
+    // 自动判断是否Telink，入参为macAddr
+    this.isTeLink = TelinkApi.isTeLink ? TelinkApi.isTeLink(macAddr) : false;
+    this.onProgress = onProgress;
+    this.onSuccess = onSuccess;
+    this.onError = onError;
+    this.delay = delay || delayDefault;
+    this.fileHexArray = [];
+    this.totalTimes = 1;
+    this.finishedTimes = 0;
+    this.succeed = false;
+    this.ready = true;
+    this.timer = null;
+    this.s_progress = 0;
+    this.progressType = 'download'; // 当前进度类型: 'download' | 'upgrade'
+  }
+
+  async start() {
+    this.progressType = 'download';
+    try {
+      await this.download();
+    } catch (e) {
+      this.fail('下载失败: ' + e.message);
+    }
+  }
+
+  async download() {
+    const that = this;
+    return new Promise((resolve, reject) => {
+      const downloadTask = uni.downloadFile({
+        url: that.filePath,
+        success: ({ tempFilePath }) => {
+          that.resolve(tempFilePath).then(resolve).catch(reject);
+        },
+        fail: (res) => {
+          that.fail('固件下载失败');
+          reject(res);
+        },
+      });
+      downloadTask.onProgressUpdate &&
+        downloadTask.onProgressUpdate(({ progress }) => {
+          that.onProgress && that.onProgress({ type: 'download', percent: progress });
+        });
+    });
+  }
+
+  async resolve(tempFilePath) {
+    const that = this;
+    return new Promise((resolve, reject) => {
+      uni.saveFile({
+        tempFilePath,
+        success: ({ savedFilePath }) => {
+          if (this.platform === 'APP') {
+            plus.io.resolveLocalFileSystemURL(
+              savedFilePath,
+              (entry) => {
+                entry.file((file) => {
+                  var fileReader = new plus.io.FileReader();
+                  fileReader.readAsDataURL(file);
+                  fileReader.onloadend = (e) => {
+                    let base64 = e.target.result.split(',')[1];
+                    const hexArray = Transfer.base64ToHexArray(base64);
+                    const times = Math.ceil(hexArray.length / (that.isTeLink ? 16 : max));
+                    that.fileHexArray = hexArray;
+                    that.totalTimes = times;
+                    that.finishedTimes = 0;
+                    // 切换进度类型为升级
+                    that.progressType = 'upgrade';
+                    that.isTeLink ? that.telinkUpgrade() : that.normalUpgrade();
+                    resolve();
+                  };
+                  fileReader.onerror = (e) => {
+                    that.fail('固件解析失败');
+                    reject(e);
+                  };
+                });
+              },
+              (err) => {
+                that.fail('固件保存失败');
+                reject(err);
+              }
+            );
+          } else if (this.platform === 'MP') {
+            // 微信小程序读取本地文件为base64
+            const fs = wx.getFileSystemManager();
+            fs.readFile({
+              filePath: savedFilePath,
+              encoding: 'base64',
+              success: (res) => {
+                // res.data 为 base64 字符串
+                let base64 = res.data;
+                const hexArray = Transfer.base64ToHexArray(base64);
+                const times = Math.ceil(hexArray.length / (that.isTeLink ? 16 : max));
+                that.fileHexArray = hexArray;
+                that.totalTimes = times;
+                that.finishedTimes = 0;
+                // 切换进度类型为升级
+                that.progressType = 'upgrade';
+                that.isTeLink ? that.telinkUpgrade() : that.normalUpgrade();
+                resolve();
+              },
+              fail: (err) => {
+                console.error('[OTA] resolve failed:', JSON.stringify(err));
+                that.failed('文件解析失败');
+              },
+            });
+          }
+        },
+        fail: (res) => {
+          that.fail('固件保存失败');
+          reject(res);
+        },
+      });
+    });
+  }
+
+  // 普通升级流程
+  normalUpgrade() {
+    setTimeout(() => {
+      BLE.writeATCmd(this.otaInfo, this.deviceId, this.fail.bind(this));
+      this.addBLECharValueChangeListener();
+    }, 2600);
+  }
+
+  // Telink 升级流程
+  telinkUpgrade() {
+    this.write(['0x00', '0xff'], 0);
+  }
+
+  write(pkg, type) {
+    const value = getBuffer(pkg.map((o) => parseInt(o, 16)));
+    const opt = {
+      deviceId: this.deviceId,
+      serviceId: '00010203-0405-0607-0809-0a0b0c0d1912',
+      characteristicId: '00010203-0405-0607-0809-0a0b0c0d2b12',
+      value,
+      success: () => this.onSucceed(type),
+      fail: async () => {
+        await this.sleep(this.delay * 2);
+        uni.writeBLECharacteristicValue({
+          ...opt,
+          fail: async () => {
+            await this.sleep(this.delay * 2);
+            uni.writeBLECharacteristicValue({ ...opt, fail: this.fail.bind(this) });
+          },
+        });
+      },
+    };
+    uni.writeBLECharacteristicValue(opt);
+    if (isIOS) setTimeout(() => this.onSucceed(type), 5);
+  }
+
+  onSucceed(type) {
+    if (type == 0) {
+      this.write(['0x01', '0xff'], 1);
+    } else if (type == 1) {
+      this.sendNextOtaPacketCommand();
+    } else if (type == 2) {
+      this.finishedTimes++;
+      this.sendNextOtaPacketCommand();
+    } else if (type == 3) {
+      this.sendNextOtaPacketCommand();
+    } else if (type == 4) {
+      this.sendOtaEndCommand();
+    } else if (type == 5) {
+      this.finishedTimes++;
+      this.succeed = true;
+      this.onSuccess && this.onSuccess();
+    }
+    this.onProgress && this.onProgress({ type: 'upgrade', percent: Math.floor((this.finishedTimes * 100) / this.totalTimes) });
+  }
+
+  async sendNextOtaPacketCommand() {
+    const i = this.finishedTimes;
+    const maxLen = 16;
+    const index = TelinkApi.getIndexHexArr(i);
+    let pkgValue = this.fileHexArray.slice(i * maxLen, (i + 1) * maxLen);
+    if (pkgValue.length < maxLen) {
+      pkgValue = pkgValue.concat([...Array(maxLen - pkgValue.length)].map(() => '0xFF'));
+    }
+    const crc = TelinkApi.genCheck([...index, ...pkgValue]);
+    const pkg = [...index, ...pkgValue, ...crc];
+    const type = i >= this.totalTimes - 1 ? 4 : 2;
+    await this.sleep(this.delay);
+    this.write(pkg, type);
+  }
+
+  sendOtaEndCommand() {
+    function genEnd(i, c = 0xff02) {
+      return [c & 0xff, (c >> 8) & 0xff, i & 0xff, (i >> 8) & 0xff, ~i & 0xff, (~i >> 8) & 0xff].map((o) => `0x${`00${o.toString(16)}`.slice(-2)}`.toUpperCase());
+    }
+    const pkgValue = genEnd(this.totalTimes - 1);
+    const crc = TelinkApi.genCheck([...pkgValue]);
+    const pkg = [...pkgValue, ...crc];
+    this.write(pkg, 5);
+  }
+
+  addBLECharValueChangeListener() {
+    const that = this;
+    uni.notifyBLECharacteristicValueChange({
+      deviceId: that.deviceId,
+      serviceId: BLE.serviceId,
+      characteristicId: BLE.readUUID,
+      state: true,
+      success: () => {},
+      fail: () => {},
+    });
+    that.ready = true;
+    that.readValue = [];
+    that.receiveLength = null;
+    uni.onBLECharacteristicValueChange(({ deviceId, serviceId, characteristicId, value }) => {
+      if (!that.ready) return;
+      if (deviceId == that.deviceId && serviceId == BLE.serviceId) {
+        const intArr = Array.prototype.map.call(new Uint8Array(value), (x) => x);
+        if (intArr.length > 0) {
+          if (that.receiveLength == null && intArr[0] == 0xff && intArr[1] == 0xaa) {
+            that.receiveLength = intArr[3] + 5;
+          }
+          if (that.receiveLength) {
+            that.readValue = that.readValue.concat(intArr);
+            if (that.readValue.length == that.receiveLength) {
+              that.doWithResponse([...that.readValue]);
+              that.readValue = [];
+              that.receiveLength = null;
+            }
+          } else {
+            that.readValue = [];
+            that.receiveLength = null;
+          }
+        }
+      }
+    });
+  }
+
+  async doWithResponse(intArr) {
+    if (intArr[2] == 0x80) {
+      let str = String.fromCharCode(...intArr.slice(4, -1));
+      if (str.indexOf(this.otaInfo) > -1) {
+        this.finishedTimes = 0;
+        this.transferFirmwareFile();
+      }
+      if (str.indexOf(this.otaStart) > -1) {
+        if (str.toUpperCase().includes('ERROR')) {
+          this.fail(str);
+          return;
+        }
+        if (str.toUpperCase().indexOf('S100') > -1) {
+          this.succeed = true;
+          this.onSuccess && this.onSuccess();
+        }
+      }
+    }
+    if (intArr[2] == 0x50) {
+      if (intArr[4] == 0) {
+        this.finishedTimes++;
+        this.transferFirmwareFile();
+      } else {
+        this.transferFirmwareFile();
+      }
+    }
+    if (intArr[2] == 0x51) {
+      if (intArr[4] == 0) {
+        this.startOTA();
+      } else {
+        this.fail('升级失败');
+      }
+    }
+  }
+
+  transferFirmwareFile() {
+    let nextTime = this.finishedTimes + 1;
+    const timeFor51 = nextTime > this.totalTimes;
+    if (timeFor51) {
+      const pkg = [0x00];
+      BLE.transferFirmwareFileCmd(this.deviceId, pkg, true, this.fail.bind(this));
+    } else {
+      const pkg = this.fileHexArray.slice(this.finishedTimes * max, nextTime * max);
+      const index = Transfer.decimalToTwoByteHexArray(nextTime);
+      BLE.transferFirmwareFileCmd(this.deviceId, index.concat(pkg), false, this.fail.bind(this));
+    }
+    this.onProgress && this.onProgress({ type: 'upgrade', percent: Math.floor((this.finishedTimes * 100) / this.totalTimes) });
+  }
+
+  async startOTA() {
+    BLE.writeATCmd(this.otaStart, this.deviceId, this.fail.bind(this));
+  }
+
+  fail(msg) {
+    this.succeed = false;
+    this.onError && this.onError(msg);
+  }
+
+  sleep(n = 50) {
+    return new Promise((r) => setTimeout(() => r(true), n));
+  }
+}
+
+export default OTAUpgrade;

package/src/core/TelinkApi.js

@@ -0,0 +1,73 @@
+import { getChipTypeAsync, getDDA503Async, resolveDDA500, resolveDDA503 } from './BleCmdAnalysis/BleCmdDD';
+const serviceId = '00010203-0405-0607-0809-0a0b0c0d1912';
+const characteristicId = '00010203-0405-0607-0809-0a0b0c0d2b12';
+export class TelinkApi {
+  static async checkOTAAvailable({ deviceId, macAddr }) {
+    const prefix = macAddr.slice(0, 8).toUpperCase();
+    try {
+      if (prefix == 'A5:C2:37') {
+        const socRes = await getChipTypeAsync(deviceId);
+        console.warn('芯片类型', socRes);
+        if (socRes && socRes?.type == 5) {
+          const versionHex = await getDDA503Async(deviceId);
+          const versionRes = resolveDDA503(versionHex);
+          console.warn('版本信息', versionRes);
+          return true;
+        }
+      }
+    } catch (error) {}
+
+    return false;
+  }
+  static isTeLink({ macAddr = '' } = { macAddr: '' }) {
+    const prefix1 = macAddr.slice(0, 2).toUpperCase();
+    const prefix = macAddr.slice(0, 8).toUpperCase();
+    // 内置板
+    return (prefix1 == 'A5' || prefix == 'A4:C1:38');
+  }
+  static getIndexHexArr(i) {
+    return i
+      .toString(16)
+      .padStart(4, '0')
+      .match(/(.{2})/g)
+      ?.reverse()
+      .map((o) => `0x${o.toUpperCase()}`);
+  }
+  static crc16modbus(data, swapNeed = false) {
+    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;
+        }
+      }
+    }
+    // swap crc
+    if (swapNeed) crc = ((crc & 0xff) << 8) | ((crc >> 8) & 0xff);
+    return crc & 0xffff;
+  }
+  static decimalToHex(decimal, padding = 4) {
+    const hexDigits = [];
+    const hexMap = { 10: 'A', 11: 'B', 12: 'C', 13: 'D', 14: 'E', 15: 'F' };
+
+    while (decimal > 0) {
+      const remainder = decimal % 16;
+      if (remainder >= 10) {
+        // @ts-ignore
+        hexDigits.unshift(hexMap[remainder]);
+      } else {
+        hexDigits.unshift(`${remainder}`);
+      }
+      decimal = Math.floor(decimal / 16);
+    }
+    return hexDigits.join('').padStart(padding, '0');
+  }
+  static genCheck(data) {
+    const hex = this.crc16modbus(data, true);
+    const hexStr = this.decimalToHex(hex);
+    return [`0x${hexStr.slice(0, 2)}`, `0x${hexStr.slice(2, 4)}`];
+  }
+}