@jiabaida/tools 1.0.0 → 1.0.1

package/src/core/dataJson/index.js

@@ -0,0 +1 @@
+export * from './baseParamsJson'

package/src/core/keyAndPwdManager.js

@@ -0,0 +1,346 @@
+import { getFFAAKeyAsync, getFFAA17Async, resolveFFAAKey, getBroadcastDataCmd } from "./BleCmdAnalysis/BleCmdFFAA";
+import { string2hexArr, decimalToHex0x } from './BleDataProcess';
+
+/** 旧密码功能只有外挂蓝牙版及WiFi蓝牙一体才有，需要验证appkey */
+export const ALLOWED_MAC_PREFIX = "A5:C2"; //内置旧版本 不支持密码功能
+export const APP_KEY_STATUS = {
+  /** 00 未启用key 未启用密码 */
+  NOT_ENABLED_NO_PASSWORD: "00",
+  /** 02 未启用key 已启用密码 */
+  NOT_ENABLED_WITH_PASSWORD: "02",
+  /** 01 已启用key 未启用密码 */
+  ENABLED_NO_PASSWORD: "01",
+  /** 03 已启用key 已启用密码 */
+  ENABLED_WITH_PASSWORD: "03",
+};
+//#region 加密mac地址和appkey
+/**
+ * 使用随机数对 MAC 地址和 appkey(key值或者密码) 进行加密，生成密码指令数组。
+ * @param {string} verifyMacAddr - 设备的 MAC 地址，格式如 "XX:XX:XX:XX:XX:XX"。
+ * @param {string} key - 用于验证的 appkey 字符串。
+ * @param {number} randomNum - 1 到 99 之间的随机整数，用于加密计算。
+ * @returns {string[]} - 包含加密后十六进制值的密码指令数组。
+ */
+export const verifyMacAddrAndKey = (verifyMacAddr, key, randomNum) => {
+  // 密码做如下验证：
+  // XX为随机数
+  // Z1 = MAC1^密码第一位+XX
+  // Z2 = MAC2^密码第二位+XX
+  // Z3 = MAC3^密码第三位+XX
+  // Z4 = MAC4^密码第四位+XX
+  // Z5 = MAC5^密码第五位+XX
+  // Z6 = MAC6^密码第六位+XX
+  let psdCode = []; // 密码指令数组（计算后的结果）
+  // Mac地址分隔成数组
+  let macArr = verifyMacAddr.split(":");
+  // 密码ASC码转化为十六进制数组
+  let psdHex = string2hexArr(key);
+  // 遍历 MAC 地址数组，进行加密计算
+  macArr.forEach((el, index) => {
+    // 将 MAC 地址的当前项转换为十六进制格式
+    let macDec = "0x" + el;
+    // 获取密码十六进制数组中对应位置的值
+    let psdDec = psdHex[index];
+    // 将 MAC 地址的当前项与密码对应项进行异或运算，再加上随机数
+    // 注意：这里的 macDec 和 psdDec 是字符串，需要转换为数字进行运算
+    let codeDec = (parseInt(macDec, 16) ^ parseInt(psdDec, 16)) + randomNum;
+    // 转为带0x的十六进制
+    let codeHex = decimalToHex0x(codeDec);
+    // 取低8位，先将 codeHex 转换为数字再进行位运算
+    codeHex = parseInt(codeHex, 16) & 0xff;
+    // 转为十六进制 即为指令值
+    psdCode.push(decimalToHex0x(codeHex));
+  });
+  return psdCode;
+};
+
+//#region 新版key 启用或验证appkey
+/**
+ * 异步发送启用或验证 appkey 的指令。
+ * @param {Object} deviceData - 包含设备信息的对象，应包含 deviceId 和 macAddr 属性。
+ * @param {string} key - 用于验证或启用的 appkey 字符串。
+ * @param {string} code - 指令代码，'0x22' 表示启用，'0x21' 表示验证。
+ * @returns - 调用 getFFAAKeyAsync 方法返回的十六进制数据。
+ */
+export const sendEnableOrVerifyKey = async (deviceData, key, code) => {
+  //发送启用验证appkey指令
+  console.warn("发送code appkey指令", code, key);
+  const randomNum = Math.floor(Math.random() * 99) + 1; // 生成1 - 99之间的随机整数
+  console.warn("randomNum: 随机数", randomNum);
+  // 使用随机数与macAddr加密 appkey
+  const psdCode = verifyMacAddrAndKey(deviceData.macAddr, key, randomNum);
+  console.log("psdCode: ", psdCode);
+  // 指令内容加上随机数
+  psdCode.push(decimalToHex0x(randomNum));
+  // '22'启用 '21'验证
+  const hex = await getFFAAKeyAsync(deviceData.deviceId, code, psdCode, `验证或启用key${code}`);
+  return hex;
+};
+
+//#region 验证旧版appkey
+/**
+ * 异步发送旧版 appkey 验证指令。
+ * @param {Object} deviceData - 包含设备信息的对象，应包含 deviceId 和 macAddr 属性。
+ * @param {string} key - 用于验证的旧版 appkey 字符串。
+ * @returns - 一个 Promise，解析为调用 getFFAAKeyAsync 方法返回的十六进制数据。
+ */
+export const sendOldAppKey = async (deviceData, key) => {
+  // 密码ASC码转化为十六进制 数组
+  let psdHex = string2hexArr(key);
+  const hex = await getFFAAKeyAsync(deviceData.deviceId, "0x15", psdHex, `验证旧appkey`);
+  return hex;
+};
+
+//#region 写入一级密码
+/**
+ * 异步发送一级密码写入指令。
+ * @param {Object} deviceData - 包含设备信息的对象，应包含 deviceId 和 macAddr 属性。
+ * @param {string} pwd - 用于写入的一级密码字符串。
+ * @returns {*} - 写入指令返回的十六进制数据。
+ */
+export const sendWrite1LevelPwd = async (deviceData, pwd) => {
+  if(deviceData.isNewAppKey) {
+    const randomNum = await getRandomNum(deviceData);
+    const psdCode = verifyMacAddrAndKey(deviceData.macAddr, pwd, randomNum);
+    psdCode.push(decimalToHex0x(randomNum));
+    const hex = await getFFAAKeyAsync(deviceData.deviceId, "0x16", psdCode, `写入一级密码`);
+    console.log('hex:写入一级密码 ', hex);
+    return hex;
+  }
+  // 密码ASC码转化为十六进制 数组
+  let psdHex = string2hexArr(pwd);
+  const hex = await getFFAAKeyAsync(deviceData.deviceId, "0x16", psdHex, `写入一级密码`);
+  return hex;
+};
+
+  //#region 验证一、二级密码
+/**
+ * 异步发送一、二级密码验证指令。
+ * @param {Object} deviceData - 包含设备信息的对象，应包含 deviceId 和 macAddr 属性。
+ * @param {string} pwd - 用于验证的旧版密码字符串。
+ * @param {string} code - 指令代码，'0x1B'-验证二级密码  '0x18'-验证一级密码。
+ * @returns {Promise} - 一个 Promise，解析为调用 getFFAAKeyAsync 方法返回的十六进制数据。
+ */
+export const sendVerifyPwd = async (deviceData, pwd, code) => {
+  console.warn("deviceData: -----------", deviceData);
+  const randomNum = await getRandomNum(deviceData);
+  const psdCode = verifyMacAddrAndKey(deviceData.macAddr, pwd, randomNum);
+  if (deviceData.isNewAppKey) {
+    psdCode.push(decimalToHex0x(randomNum));
+  }
+  const hex = await getFFAAKeyAsync(deviceData.deviceId, code, psdCode, `验证密码`);
+  console.log("hex: 验证密码", hex);
+  return hex;
+};
+
+ //#region 获取随机数
+/**
+ * 获取随机数。
+ * @returns {Promise<number>} - 1 到 99 之间的随机整数。
+ */
+export const getRandomNum = async (deviceData) => {
+  if (deviceData.isNewAppKey) {
+    return Math.floor(Math.random() * 99) + 1; // 生成1 - 99之间的随机整数
+  } else {
+    const hex = await getFFAA17Async(deviceData.deviceId);
+    const data = resolveFFAAKey(hex);
+    return data?.response;
+  }
+};
+
+ //#region 验证三级密码
+/** 验证三级密码
+ * @param {Object} deviceData - 包含设备信息的对象，应包含 deviceId 和 macAddr 属性。
+ * @returns {Promise} - 一个 Promise，解析为调用 getFFAAKeyAsync 方法返回的十六进制数据。
+ */
+export const verify3LevelPassword = async (deviceData, ciphertext, randomNum) => {
+  return new Promise(async (resolve, reject) => {
+    const regex = /(\w{2})/g;
+    // 两位分隔为数组 去掉空格
+    const psdCode = ciphertext
+      .split(regex)
+      .filter((item) => item !== "")
+      .map((item) => `0x${item}`); // 密文十六进制数组
+    console.log(psdCode, "psdCode");
+    let code = "";
+    if (deviceData.isNewAppKey) {
+      psdCode.push(decimalToHex0x(randomNum));
+      code = "0x24";
+    } else {
+      code = "0x1D";
+    }
+    const hex = await getFFAAKeyAsync(deviceData.deviceId, code, psdCode, `验证三级密码`);
+    resolve(hex);
+  });
+};
+
+ //#region 提取广播数据
+/**
+ * 从广播数据中提取模块类型、产品类型、协议版本和 appkey 状态。
+ * @param {string} hexString - 包含广播数据的十六进制字符串。
+ * @returns {Object} - 包含模块类型、产品类型、协议版本和 appkey 状态的对象。
+ */
+export const extractModuleInfo = (hexString) => {
+  // FFAA2505000400010130
+  const moduleType = hexString.slice(8, 12);
+  const productType = hexString.slice(12, 14);
+  const protocolVersion = hexString.slice(14, 16);
+  const appkeyStatus = hexString.slice(16, 18);
+  return {
+    moduleType,
+    productType,
+    protocolVersion,
+    appkeyStatus,
+  };
+};
+
+ //#region 获取模块版本等信息 更新设备信息
+/**
+ * 异步根据设备指令获取设备类型相关信息并更新设备数据。
+ * @param {Object} deviceData - 包含设备信息的对象，至少应包含 deviceId 属性。
+ * @returns {Promise<Object>} - 更新后的设备信息对象。
+ */
+export const getTypeBuyCmd = async (deviceData) => {
+  // 异步获取设备的广播数据（十六进制字符串）
+  const hex = await getBroadcastDataCmd(deviceData.deviceId);
+  const data = resolveFFAAKey(hex);
+  let moduleInfo = null;
+  if (data && data.dataStr.length >= 20) {
+    // 从数据字符串中提取模块信息
+    moduleInfo = extractModuleInfo(data?.dataStr);
+  }
+  console.log("moduleInfo: 广播数据", moduleInfo);
+  if (moduleInfo) {
+    const { moduleType, productType, protocolVersion, appkeyStatus } = moduleInfo;
+    // 合并原设备数据和新获取的模块信息，同时添加 isNewAppKey 和 isConnect 属性
+    deviceData.isNewAppKey = true;
+    deviceData.isConnect = true;
+    deviceData.appkeyStatus = appkeyStatus;
+    deviceData.productType = productType;
+    deviceData.protocolVersion = protocolVersion;
+    deviceData.moduleType = moduleType;
+  }
+  console.warn("data: 获取模块产品类型等信息", moduleInfo);
+  // 返回更新后的设备信息对象
+  return deviceData;
+};
+
+//#region key及密码处理逻辑
+/**
+ * 异步发送 appkey 并验证，根据设备类型和状态执行不同的验证逻辑。
+ * @param {Object} deviceData - 包含设备信息的对象，应包含 deviceId、macAddr、isNewAppKey、appkeyStatus 等属性。
+ * @param {string} appkeyValue - 用于新密码验证或启用的 appkey 字符串。
+ * @param {string} oldKey - 用于旧版密码验证的 appkey 字符串。
+ * @param {boolean} canEnable - 是否可以启用 key，默认为 false(客户端app和小程序都不启用key，检测才需启用)。
+
+ * @returns {Promise<Object>} - 解析为包含验证结果的对象，包含 verifyAppkey（是否验证成功）、hasPwd（是否有一级密码）、isEnableKey（是否是启用 key 指令）、isBlueKey（是否有密码功能）、enableSuccess(是否启用成功)。
+ */
+export const sendAppKey = async (deviceData, appkeyValue, oldKey, canEnable = false) => {
+  console.log("deviceData: ------------------", deviceData);
+  try {
+    let isAppKeyVerified = true; //验证key结果（是否验证成功）
+    let hasPassword = false; //是否有一级密码
+    let isEnableKey = false; //是否是启用key指令
+    let supportsBlueKey = false; //是否有密码功能
+    let enableSuccess = false; //是否启用成功
+
+    if (deviceData.isNewAppKey) {
+      ({ isAppKeyVerified, hasPassword, isEnableKey, supportsBlueKey, enableSuccess } = await handleNewAppKey(
+        deviceData,
+        appkeyValue,
+        canEnable,
+      ));
+    } else {
+      ({ isAppKeyVerified, hasPassword, supportsBlueKey } = await handleOldAppKey(deviceData, oldKey));
+    }
+
+    return {
+      verifyAppkey: isAppKeyVerified,
+      hasPwd: hasPassword,
+      isEnableKey,
+      isBlueKey: supportsBlueKey,
+      enableSuccess,
+    };
+  } catch (error) {
+    console.error("Error in sendAppKey:", error);
+    throw error;
+  }
+};
+
+//#region 新密码处理逻辑
+export const handleNewAppKey = async (deviceData, appkeyValue, canEnable) => {
+  const { appkeyStatus } = deviceData;
+  let isAppKeyVerified = true;
+  let hasPassword = false;
+  let isEnableKey = false;
+  let supportsBlueKey = true;
+  let enableSuccess = false;
+
+  switch (appkeyStatus) {
+    case APP_KEY_STATUS.NOT_ENABLED_NO_PASSWORD:
+      if (canEnable) {
+        const enableHex = await sendEnableOrVerifyKey(deviceData, appkeyValue, "0x22");
+        if (!enableHex) {
+          console.log("启用key失败: ------------------", enableHex);
+          isAppKeyVerified = false;
+        } else {
+          enableSuccess = enableHex[enableHex.length - 2] === 0;
+        }
+        console.log(enableSuccess ? "启用key成功" : "启用key失败");
+      }
+      isEnableKey = true;
+      break;
+
+    case APP_KEY_STATUS.NOT_ENABLED_WITH_PASSWORD:
+      hasPassword = true;
+      break;
+
+    case APP_KEY_STATUS.ENABLED_NO_PASSWORD:
+      break;
+
+    case APP_KEY_STATUS.ENABLED_WITH_PASSWORD:
+      hasPassword = true;
+      break;
+
+    default:
+      console.log("无appkeyStatus-----------------");
+  }
+
+  if ([APP_KEY_STATUS.ENABLED_NO_PASSWORD, APP_KEY_STATUS.ENABLED_WITH_PASSWORD].includes(appkeyStatus)) {
+    const hex = await sendEnableOrVerifyKey(deviceData, appkeyValue, "0x21");
+    if (!hex) {
+      isAppKeyVerified = false;
+    } else {
+      isAppKeyVerified = hex[hex.length - 2] === 0;
+    }
+  }
+
+  return { isAppKeyVerified, hasPassword, isEnableKey, supportsBlueKey, enableSuccess };
+};
+
+//#region 旧密码处理逻辑
+export const handleOldAppKey = async (deviceData, oldKey) => {
+  const prefix = deviceData.macAddr.slice(0, 5).toUpperCase();
+  if (prefix === ALLOWED_MAC_PREFIX) {
+    return { isAppKeyVerified: true, hasPassword: false, supportsBlueKey: false };
+  }
+
+  const oldHex = await sendOldAppKey(deviceData, oldKey);
+  console.log("oldHex: 验证旧key", oldHex);
+
+  if (!oldHex) {
+    console.log("验证旧key无响应: 无密码功能");
+    return { isAppKeyVerified: true, hasPassword: false, supportsBlueKey: false };
+  }
+
+  switch (oldHex[oldHex.length - 2]) {
+    case 0:
+      return { isAppKeyVerified: true, hasPassword: true, supportsBlueKey: true };
+    case 1: // 旧密码验证失败允许读
+      return { isAppKeyVerified: true, hasPassword: false, supportsBlueKey: false };
+    case 2:
+      return { isAppKeyVerified: true, hasPassword: false, supportsBlueKey: true };
+    default:
+      return { isAppKeyVerified: true, hasPassword: false, supportsBlueKey: false };
+  }
+};

package/src/core/mqttServer.js

@@ -0,0 +1,296 @@
+import { sleep } from './BleDataProcess.js';
+import { decrypt } from './rsaEncrypt.js';
+import CryptoJS from 'crypto-js/crypto-js.js';
+import mqtt from 'mqtt/dist/mqtt.js';
+import { set_PlanCMD_DD } from './BleCmdAnalysis/BleCmdDD';
+import { getFFAA80Async, resolveFFAA80, set_PlanCMD_FFAA } from './BleCmdAnalysis/BleCmdFFAA';
+import { Transfer } from './Transfer.js';
+import { getCMDESInfoAsync } from './BleCmdAnalysis/BleCmdHVES.js';
+
+// 新的MQTT服务类
+class MqttServer {
+  constructor({ mqttClient = {}, MQTT_HOST = 'wx://mqtt.jiabaida.com:8083/mqtt', DELAY_TIME = 300, networkModelUrl = 'https://cloud.jiabaida.com/bluetooth/server/device/networkModel', request }) {
+    this.timer = null;
+    this.productKey = 'bms_wifi';
+    this.is0f = false;
+    this.publishObj = {};
+    this.cmdCode = '';
+    this.callbackId = '';
+    this.mqttCode = '';
+    this.mqttPublish = false;
+    this.mqttClient = mqttClient;
+    this.MQTT_HOST = MQTT_HOST;
+    this.DELAY_TIME = DELAY_TIME;
+    this.networkModelUrl = networkModelUrl;
+    this.request = request; // 必须传入的http请求方法
+    // ...existing code...
+  }
+
+  // 获取参数方法
+  async getParams(item) {
+    try {
+      return await this.request({
+        url: `${this.networkModelUrl}?macAddr=${item.macAddr}`,
+        method: 'get',
+      });
+    } catch (error) {
+      console.error('getnetworkModel-error', error);
+      throw error;
+    }
+  }
+
+  // 封装 MQTT 连接逻辑
+  async connectMqtt(deviceObj) {
+    try {
+      const modalData = await this.getParams(deviceObj);
+      if (!modalData || modalData.data.code !== 200) {
+        return;
+      }
+      const mqttParam = modalData.data.data;
+      const clientId = decrypt(mqttParam.clientId);
+      const username = mqttParam.mqttUsername;
+      const password = decrypt(mqttParam.mqttSecret);
+      console.log('连接 MQTT...');
+      const options = {
+        clean: true,
+        connectTimeout: 4000,
+        clientId,
+        username,
+        password: CryptoJS.SHA256(password).toString(),
+        deviceId: deviceObj.deviceId,
+      };
+      const client = mqtt.connect(this.MQTT_HOST, options);
+      console.log('MQTT 客户端创建成功:', client);
+      client.on('connect', (res) => {
+        console.log('res连接成功', res);
+        client.productKey = this.productKey;
+        this.handleMqttConnect(client, deviceObj);
+      });
+      client.on('message', (topic, message) => {
+        this.handleMqttMessage(topic, message, client);
+      });
+      client.on('reconnect', (res) => console.log('MQTT 重连中...', res, client));
+      client.on('close', (res) => this.handleMqttClose(client, res));
+      client.on('offline', (res) => console.log('MQTT 脱机状态', res, client));
+      client.on('error', (res) => console.error('MQTT 连接错误', res, client));
+      client.on('disconnect', (res) => console.log('MQTT 断开连接', res, client));
+    } catch (e) {
+      console.error('MQTT 连接异常:', e);
+    }
+  }
+
+  handleMqttConnect(client, deviceObj) {
+    console.log('MQTT 连接成功 client', client);
+    console.log('MQTT 连接成功 deviceObj', deviceObj);
+    this.storeMqttClient(client);
+    this.publishInOrder(client, deviceObj).then(() => this.subscribeInOrder(client));
+  }
+
+  storeMqttClient(client) {
+    this.mqttClient[`${client.options.deviceId}_mqtt`] = client;
+    console.log('存储的 MQTT 客户端:', this.mqttClient);
+  }
+
+  getTopicsAndMessages(client, deviceObj) {
+    const { productType, soc, moduleType, macAddr } = deviceObj;
+    const message = JSON.stringify({ productKey: productType, soc, moduleTypeKey: moduleType, macAddr });
+    return [
+      {
+        topic: `/${client.productKey}/${client.options.clientId}/device/login`,
+        message,
+      },
+    ];
+  }
+
+  async publishInOrder(client, deviceObj) {
+    const topicsAndMessages = this.getTopicsAndMessages(client, deviceObj);
+    try {
+      for (const item of topicsAndMessages) {
+        await new Promise((resolve) => {
+          client.publish(item.topic, item.message, () => {
+            resolve();
+          });
+        });
+      }
+    } catch (error) {
+      console.error(`处理发布时出现错误: ${error}`);
+    }
+  }
+
+  getSubscribeTopics(client) {
+    const { productKey } = client;
+    const clientId = client.options.clientId;
+    return [`/${productKey}/${clientId}/device/login/reply`, `/${productKey}/${clientId}/device/passthrough/reply`, `/${productKey}/${clientId}/plat/cmd`, `/${productKey}/${clientId}/plat/passthrough`];
+  }
+
+  async subscribeInOrder(client) {
+    const subscribeTopics = this.getSubscribeTopics(client);
+    try {
+      for (const topic of subscribeTopics) {
+        await new Promise((resolve, reject) => {
+          client.subscribe(topic, (err) => {
+            if (!err) {
+              resolve();
+            } else {
+              reject(err);
+            }
+          });
+        });
+      }
+    } catch (error) {
+      console.error(`订阅主题时出现错误: ${error}`);
+    }
+  }
+
+  handleMqttMessage(topic, message, client) {
+    const arr = topic.split('/');
+    const clientId = arr[2];
+    client = Object.values(this.mqttClient).find((c) => c?.options?.clientId === clientId) || client;
+    if (topic === `/${client.productKey}/${client.options.clientId}/plat/passthrough` || topic === `/${client.productKey}/${client.options.clientId}/plat/cmd`) {
+      this.processMessageAsync(client, message.toString());
+    }
+  }
+
+  async processMessageAsync(client, message) {
+    const msg = JSON.parse(message);
+    this.callbackId = msg.callbackId;
+    this.cmdCode = msg.cmdCode;
+    let resultArray = [];
+    let codeValue = [];
+    if (this.cmdCode === 'jbdPWD') {
+      const cmdMap = {
+        2: 'FFAA23010125',
+        3: 'FFAA1F010121',
+        4: 'FFAA20010122',
+        5: 'FFAA23010226',
+      };
+      const cmdContent = cmdMap[msg.value];
+      codeValue = cmdContent ? cmdContent.split(',') : [];
+    } else {
+      codeValue = msg.value ? msg.value.split(',') : [];
+      this.is0f = codeValue.length === 2;
+    }
+    resultArray = codeValue[0] ? codeValue[0].match(/.{1,2}/g) : [];
+    try {
+      if (resultArray[0]?.toUpperCase() === 'FF' && resultArray[1]?.toUpperCase() === 'AA') {
+      } else if (resultArray[1]?.toUpperCase() === '78' || resultArray[1]?.toUpperCase() === '50') {
+      } else {
+      }
+      const publishObj = {
+        deviceId: client.options.deviceId,
+        clientId: client.options.clientId,
+        productKey: client.productKey,
+        callbackId: this.callbackId,
+        cmdCode: this.cmdCode,
+        is0f: this.is0f,
+        isLast: msg.isLast,
+      };
+      this.publishObj = publishObj;
+      if (this.cmdCode.toLowerCase().includes('wifi_')) {
+        await this.publishATHandle(msg.value);
+      } else {
+        this.writePublishInfoCmd(resultArray);
+        await sleep(this.DELAY_TIME);
+      }
+    } catch (error) {
+      console.error('error: 处理后台发指令错误', error);
+    }
+  }
+
+  async publishATHandle(ATvalue) {
+    const { deviceId, cmdCode, callbackId, productKey, clientId, isLast } = this.publishObj;
+    const client = this.mqttClient[`${deviceId}_mqtt`];
+    try {
+      if (client) {
+        const hex = await getFFAA80Async(deviceId, ATvalue);
+        const res = resolveFFAA80(hex);
+        if (res && res.moduleVersion) {
+          const value = res.moduleVersion;
+          client.publish(`/${productKey}/${clientId}/plat/cmd/reply`, JSON.stringify({ value, cmdCode, callbackId }), () => {});
+        }
+      }
+      if (isLast) {
+        await sleep(300);
+        this.mqttPublish = false;
+        uni.removeStorageSync && uni.removeStorageSync(`${deviceId}_mqttPublish`);
+      }
+    } catch (error) {
+      console.error(error);
+    }
+  }
+
+  handleMqttClose(client, res) {
+    console.log('MQTT 连接关闭', res, client);
+    client.end(() => {
+      this.mqttClient[`${client.options.deviceId}_mqtt`] = null;
+    });
+  }
+
+  // baseValue/voltageValue 作为参数传入
+  async publishHandle(value, baseValue, voltageValue) {
+    const client = this.mqttClient[`${this.publishObj.deviceId}_mqtt`];
+    if (this.publishObj.is0f) {
+      value = baseValue + ',' + voltageValue;
+    }
+    const msg = JSON.stringify({
+      value,
+      cmdCode: this.publishObj.cmdCode,
+      callbackId: this.publishObj.callbackId,
+    });
+    if (client) {
+      client.publish(`/${this.publishObj.productKey}/${this.publishObj.clientId}/plat/passthrough/reply`, msg, () => {});
+    }
+    if (this.publishObj.isLast) {
+      await sleep(300);
+      this.mqttPublish = false;
+      uni.removeStorageSync && uni.removeStorageSync(`${this.publishObj.deviceId}_mqttPublish`);
+    }
+  }
+
+  publishPassthroughHandle({ value, cmdCode }, deviceId, timeOffset = 30000) {
+    const client = this.mqttClient[`${deviceId}_mqtt`];
+    if (client) {
+      const clientTime = new Date().getTime();
+      const { laseCmdCode, lastPassthroughTime, clientId } = client?.options;
+      if (laseCmdCode != cmdCode || !(lastPassthroughTime && clientTime - lastPassthroughTime < timeOffset)) {
+        const topic = `/${client?.productKey}/${clientId}/device/passthrough`;
+        const payload = JSON.stringify({ value, cmdCode, clientTime });
+        client.publish(topic, payload, () => {
+          client.options['lastPassthroughTime'] = clientTime;
+          client.options['laseCmdCode'] = cmdCode;
+        });
+      }
+    }
+  }
+
+  async writePublishInfoCmd(values) {
+    clearTimeout(this.timer);
+    this.mqttPublish = true;
+    this.mqttCode = values[2];
+    let res = null;
+    // 下发指令逻辑
+    if (values[0]?.toUpperCase() === 'FF' && values[1]?.toUpperCase() === 'AA') {
+      res = await set_PlanCMD_FFAA(this.publishObj.deviceId, values.join(''));
+    } else if (values[1]?.toUpperCase() === '78' || values[1]?.toUpperCase() === '50') {
+      res = await getCMDESInfoAsync(this.publishObj.deviceId, values.join(''));
+    } else {
+      // DD
+      res = await set_PlanCMD_DD(this.publishObj.deviceId, values.join(''));
+    }
+    const content = res?.data || []
+    let code = Transfer.decimalToHex(content[1]);
+    if (content[0] == 0xff && content[1] == 0xaa) {
+      code = Transfer.decimalToHex(content[2]);
+    }
+    console.log('code: 回复的code', code);
+    // mqtt连接正常且是平台下发的指令 需上报数据到后端
+    if (code.toUpperCase() == this.mqttCode.toUpperCase()) {
+      this.publishHandle(res?.dataStr);
+    }
+    this.timer = setTimeout(() => {
+      this.mqttPublish = false;
+    }, 30000);
+  }
+}
+
+export default MqttServer;

package/src/core/rsaEncrypt.js

@@ -0,0 +1,45 @@
+import JSEncrypt from 'jsencrypt/bin/jsencrypt.min'
+
+// 密钥对生成 http://web.chacuo.net/netrsakeypair
+
+const publicKey = 'MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBANL378k3RiZHWx5AfJqdH9xRNBmD9wGD\n' +
+  '2iRe41HdTNF8RUhNnHit5NpMNtGL0NPTSSpPjjI1kJfVorRvaQerUgkCAwEAAQ=='
+
+const privateKey = 'MIIBVgIBADANBgkqhkiG9w0BAQEFAASCAUAwggE8AgEAAkEA4cWDRXldfRIqc2Mg\n' +
+  'JSAiKqvRGa0v7a4fC0j3YjzpxcIArm1Ui5d9DN8Ly7vGdUnltPuy7yC9nVQuW89+\n' +
+  'J6PnowIDAQABAkEApgP1/l07KJ/2BTkrxwD0/smvDaFzL+QswcCa4GsIP7iBvPna\n' +
+  '003yp3UGSXfEZWiQzHfehW2UHB5DIh5YbghaqQIhAPkB8LWgJlsaC8WP90ztg0nl\n' +
+  '+6VBLiunF6dV0Q7eJzMlAiEA6ByIpg2ZvT+X8Zzmkw32Si/Aw5VZ/ulJ5D6/MKuS\n' +
+  'mScCIAjcRNBxrmu3dYvGH6qhGPbcNCQhOZ9cBr9xkkrRJNvxAiEAvVapUWs+wdWi\n' +
+  'SIFIxSRah+G0SNcH9pyunfVhWH5cs3kCIQDGArpiAGQ4WOO+tFDqUVaDXwhQnx2H\n' +
+  '5OGt/FZJpmDnUw=='
+
+// 加密
+export function encrypt(txt) {
+  const encryptor = new JSEncrypt()
+  encryptor.setPublicKey(publicKey) // 设置公钥
+  return encryptor.encrypt(txt) // 对需要加密的数据进行加密
+}
+
+// 解密
+export function decrypt(txt) {
+  const encryptor = new JSEncrypt()
+  encryptor.setPrivateKey(privateKey)
+  return encryptor.decrypt(txt)
+}
+
+export function decrypt2(txt) {
+  const encryptor = new JSEncrypt()
+  encryptor.setPrivateKey(publicKey)
+  return encryptor.decrypt(txt)
+}
+
+export const decryptUsername = (txt) => {
+  const text = decrypt(txt);
+  if (!text) {
+    return;
+  }
+  return text.substring(0, text.length - 13);
+}
+
+