@jiabaida/tools 1.0.7 → 1.0.8

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

package/src/core/mqttServer.js

@@ -9,7 +9,7 @@ import { Transfer } from './Transfer.js';
 
 // 新的MQTT服务类
 export class MqttServer {
-  constructor({ mqttClient = {}, MQTT_HOST = 'wxs://mqtt.jiabaida.com/mqtt', DELAY_TIME = 300, networkModelUrl = 'https://cloud.jiabaida.com/bluetooth/server/device/networkModel', request }) {
+  constructor({ mqttClient = {}, MQTT_HOST = 'wxs://mqtt.jiabaida.com/mqtt', DELAY_TIME = 300, networkModelUrl = 'https://cloud.jiabaida.com/bluetooth/server/device/networkModel', request, store = null }) {
     this.timer = null;
     this.productKey = 'bms_wifi';
     this.is0f = false;
@@ -23,6 +23,7 @@ export class MqttServer {
     this.DELAY_TIME = DELAY_TIME;
     this.networkModelUrl = networkModelUrl;
     this.request = request; // 必须传入的http请求方法
+    this.$store = store;
     // ...existing code...
   }
 
@@ -88,6 +89,7 @@ export class MqttServer {
 
   storeMqttClient(client) {
     this.mqttClient[`${client.options.deviceId}_mqtt`] = client;
+    this.$store?.commit('setMqttClient', this.mqttClient);
     console.log('存储的 MQTT 客户端:', this.mqttClient);
   }
 
@@ -151,6 +153,8 @@ export class MqttServer {
     }
   }
 
+  
+
   async processMessageAsync(client, message) {
     const msg = JSON.parse(message);
     this.callbackId = msg.callbackId;
@@ -212,6 +216,7 @@ export class MqttServer {
       if (isLast) {
         await sleep(300);
         this.mqttPublish = false;
+        this.$store?.commit('setMqttPublish', false);
         uni.removeStorageSync && uni.removeStorageSync(`${deviceId}_mqttPublish`);
       }
     } catch (error) {
@@ -219,10 +224,21 @@ export class MqttServer {
     }
   }
 
+  closeMqttByDeviceId(deviceId) {
+    const client = this.mqttClient[`${deviceId}_mqtt`];
+    if (client) {
+      client.end(() => {
+        this.mqttClient[`${deviceId}_mqtt`] = null;
+        console.log(`MQTT 连接已关闭，设备ID: ${deviceId}`);
+      });
+    }
+  }
+
   handleMqttClose(client, res) {
     console.log('MQTT 连接关闭', res, client);
     client.end(() => {
       this.mqttClient[`${client.options.deviceId}_mqtt`] = null;
+      this.$store?.commit('setMqttClient', this.mqttClient);
     });
   }
 
@@ -243,6 +259,7 @@ export class MqttServer {
     if (this.publishObj.isLast) {
       await sleep(300);
       this.mqttPublish = false;
+      this.$store?.commit('setMqttPublish', false);
       uni.removeStorageSync && uni.removeStorageSync(`${this.publishObj.deviceId}_mqttPublish`);
     }
   }
@@ -266,6 +283,7 @@ export class MqttServer {
   async writePublishInfoCmd(values) {
     clearTimeout(this.timer);
     this.mqttPublish = true;
+    this.$store?.commit('setMqttPublish', true);
     this.mqttCode = values[2];
     let res = null;
     // 下发指令逻辑
@@ -289,6 +307,7 @@ export class MqttServer {
     }
     this.timer = setTimeout(() => {
       this.mqttPublish = false;
+      this.$store?.commit('setMqttPublish', false);
     }, 30000);
   }
 }

package/src/core/tcpServer.js

@@ -0,0 +1,303 @@
+// import store from '@/store/index';
+import {
+  reactive
+} from "vue";
+import { set_PlanCMD_DD } from './BleCmdAnalysis/BleCmdDD';
+import { set_PlanCMD_FFAA } from './BleCmdAnalysis/BleCmdFFAA';
+import { getCMDESInfoAsync } from './BleCmdAnalysis/BleCmdHVES.js';
+import { sleep } from './BleDataProcess.js';
+import Queue from './Queue.js';
+import { Transfer } from './Transfer.js';
+export const tcpSend = reactive({
+  isSending: false, //是否在下发平台指令
+  isLast: false,
+  code: null,
+  hasHeartbeat: false,
+  tcpClose: false,
+  devices: {}
+})
+// / 创建一个队列来存储接收到的消息
+const messageQueue = new Queue();
+let timer = null
+export const tcpServer = {
+  version: '2.8.2', // 每次上传需要手动修改此 版本号
+  socketOpen: false, //是否建立连接
+  macAddr: '',
+  txnNo: '',
+  baseDelay: 1000, // 初始重试延迟（毫秒）
+  maxDelay: 60 * 1000, // 最大重试延迟（毫秒）
+  retryCount: 0, // 重试次数
+  url: {
+    address: 'cloud.jiabaida.com',
+    port: 10241
+  },
+  url1: {
+    address: '192.168.80.36',
+    port: 10240
+  },
+  timers: {},
+  heartBeatTimers: {},
+  tcpSockets: {},
+  isRetryings: {},
+  socketOpens: {},
+  async initTCPConnection(macAddr, deviceId) {
+    console.log('macAddr: init-------tcp', macAddr, deviceId);
+    return new Promise((resolve, reject) => {
+      try {
+        tcpSend.devices[macAddr] = {
+          macAddr,
+          deviceId
+        }
+        this.tcpSockets[`${deviceId}_socket`] = wx.createTCPSocket();
+        console.log('this.tcpSockets[`${deviceId}_socket`]: ', this.tcpSockets[`${deviceId}_socket`]);
+        this.tcpSockets[`${deviceId}_socket`].connect(this.url);
+        this.tcpSockets[`${deviceId}_socket`].onConnect(() => {
+          this.listenerConnect(macAddr, deviceId)
+          resolve(true)
+        });
+
+        this.tcpSockets[`${deviceId}_socket`].onMessage((message) => {
+          console.log('接收到消息：', message);
+          // 处理接收到的消息
+          // 将buffer转为常规数组 十六进制
+          const intArr = Array.prototype.map.call(
+            new Uint8Array(message.message),
+            function (bit) {
+              return bit;
+            }
+          );
+          // 将十六进制转为对应的字符
+          let valueString = String.fromCharCode(...intArr)
+          console.log(valueString, 'valueString');
+          // messageQueue.enqueue(valueString);
+          // this.processQueue()
+          this.processMessageAsync(valueString)
+        });
+
+        this.tcpSockets[`${deviceId}_socket`].onError((error) => {
+          this.listenerError(macAddr, deviceId, error)
+          reject(error)
+        });
+
+        this.tcpSockets[`${deviceId}_socket`].onClose(this.listenerClose(deviceId));
+      } catch (error) {
+        console.error('error: tcp连接失败', error);
+        reject(error)
+      }
+    })
+  },
+  listenerConnect(macAddr, deviceId) {
+    this.socketOpens[`open_${deviceId}`] = true
+    this.isRetryings[`retry_${deviceId}`] = false
+    console.log('TCP 连接已建立');
+    clearInterval(this.timers[`timer_${deviceId}`])
+    this.timers[`timer_${deviceId}`] = null
+    // 连接建立后，开始发送心跳包
+    this.sendHeartbeat(macAddr, deviceId);
+  },
+  listenerError(macAddr, deviceId, error) {
+    this.socketOpens[`open_${deviceId}`] = false
+    console.log('TCP 连接错误：', deviceId, error);
+    this.stopHeartBeat(deviceId)
+    if (!this.isRetryings[`retry_${deviceId}`]) {
+      this.retryCount = 0
+      // 重连
+      this.reConnect(macAddr, deviceId, true)
+    }
+  },
+  listenerClose(deviceId) {
+    this.socketOpens[`open_${deviceId}`] = false
+    console.log('TCP 连接已关闭');
+  },
+  // 关闭tcp连接
+  closeTcpSocket(deviceId) {
+    try {
+      clearInterval(this.timers[`timer_${deviceId}`])
+      this.timers[`timer_${deviceId}`] = null
+      if (this.tcpSockets[`${deviceId}_socket`]) {
+        this.socketOpens[`open_${deviceId}`] = false
+        this.stopHeartBeat(deviceId)
+        this.tcpSockets[`${deviceId}_socket`].offMessage()
+        this.tcpSockets[`${deviceId}_socket`].offConnect()
+        this.tcpSockets[`${deviceId}_socket`].offClose()
+        this.tcpSockets[`${deviceId}_socket`].offError()
+        this.tcpSockets[`${deviceId}_socket`].close()
+        this.tcpSockets[`${deviceId}_socket`] = null
+      }
+    } catch (error) {
+      console.error('error: closeTcpSocket', error);
+    }
+  },
+  async reConnect(macAddr, deviceId, closeSocket = false) {
+    console.log('重连 this.macAddr', macAddr);
+    this.isRetryings[`retry_${deviceId}`] = true
+    // 关闭旧的连接再重连
+    if (closeSocket) this.tcpSockets[`${deviceId}_socket`].close()
+    this.tcpSockets[`${deviceId}_socket`].connect(this.url);
+    const delay = Math.min(this.baseDelay * Math.pow(2, this.retryCount), this.maxDelay);
+    console.log(`准备 ${delay}ms 后重试...`);
+    this.timers[`timer_${deviceId}`] = setTimeout(() => {
+      this.reConnect(macAddr, deviceId);
+    }, delay);
+    this.retryCount++
+  },
+  sendHeartbeat(macAddr, deviceId) {
+    let tokenStr = uni.getStorageSync('token')
+    let token = tokenStr.replace('Bearer ', '')
+    const heartbeatMsg = {
+      command: 96, //业务操作码，96代表心跳包
+      data: {
+        token,
+        appVersion: "xiaoxiang:" + this.version, //小程序版本号
+        macAddr,
+      },
+      txnNo: +new Date(), //当前时间戳
+      isAnonymous: 0, //是否匿名登录
+    };
+    console.log('heartbeatMsg: ', heartbeatMsg);
+    tcpSend.hasHeartbeat = false
+    this.tcpSockets[`${deviceId}_socket`].write(JSON.stringify(heartbeatMsg));
+    this.heartBeatTimers[`heartTimer_${deviceId}`] = setInterval(() => {
+      heartbeatMsg.txnNo = +new Date() //当前时间戳
+      //##console.log(heartbeatMsg, 'heartbeatMsg');
+      tcpSend.hasHeartbeat = false
+      this.tcpSockets[`${deviceId}_socket`].write(JSON.stringify(heartbeatMsg));
+    }, 30000); // 每5秒发送一次心跳包
+  },
+  // 清除心跳上报计时器
+  stopHeartBeat(deviceId) {
+    if (this.heartBeatTimers[`heartTimer_${deviceId}`]) {
+      clearInterval(this.heartBeatTimers[`heartTimer_${deviceId}`]);
+      this.heartBeatTimers[`heartTimer_${deviceId}`] = null;
+    }
+  },
+  //上报基础 信息
+  sendReportData(data) {
+    const reportData = {
+      command: 999, //业务操作码，999代表上报
+      data: {
+        value: data.value,
+        cmdCode: 'jbd0F',
+        bluetoothName: data.bluetoothName,
+      },
+      macAddr: data.macAddr,
+      txnNo: +new Date(), //当前时间戳
+    };
+    console.log(reportData, 'reportData111上报基础数据');
+    this.tcpSockets[`${data.deviceId}_socket`].write(JSON.stringify(reportData));
+  },
+  // 执行完平台下发的指令后上报数据
+  sendWriteReportData(data, deviceId) {
+    console.warn('执行后上报数据data: ', data);
+    const reportData = {
+      command: 121, //业务操作码，代表执行上报
+      data: {
+        macAddr: this.macAddr,
+        content: data,
+      },
+      txnNo: this.txnNo, //callbackId
+    };
+    //##console.log(reportData, 'WriteReportData执行指令后上报数据');
+    this.tcpSockets[`${deviceId}_socket`].write(JSON.stringify(reportData));
+    if (tcpSend.isLast) {
+      tcpSend.isSending = false
+    }
+  },
+  // 处理队列中的消息
+  processQueue() {
+    if (!tcpSend.isSending) {
+      this.processNextMessage();
+    }
+  },
+  async processNextMessage() {
+    //##console.log('messageQueue-------', messageQueue);
+
+    if (!messageQueue.isEmpty()) {
+      const message = messageQueue.dequeue();
+      //##console.log('Processing:', message);
+      // 异步处理消息
+      this.processMessageAsync(message).then(() => {
+        this.processNextMessage();
+      });
+    } else {
+      await sleep(300)
+      tcpSend.isSending = false;
+      //##console.log('tcpSend.isSending发送完成', tcpSend.isSending);
+    }
+  },
+  async processMessageAsync(message) {
+    clearTimeout(timer)
+    // 假设这里是异步操作，例如写入数据库
+    return new Promise(async (resolve) => {
+      try {
+        console.log('Message processed:', message);
+        let msgObj = JSON.parse(message)
+        console.warn('----------msgObj后台下发的指令: -----------', msgObj);
+        // 为120，即接收到后台下发的指令
+        if (msgObj.command == 120) {
+          let value = msgObj.data.content
+          if (!value) return
+
+          // 使用正则表达式将字符串两两分隔为数组
+          let resultArray = value.match(/.{1,2}/g);
+          console.log('resultArray: ', resultArray);
+          // 给蓝牙设备发送指令
+          this.macAddr = msgObj.data.macAddr
+          let deviceId = null
+          for (let key in tcpSend.devices) {
+            if (tcpSend.devices[key].macAddr == this.macAddr) {
+              deviceId = tcpSend.devices[key].deviceId
+            }
+          }
+          console.log('deviceId: ', deviceId);
+          this.txnNo = msgObj.txnNo
+          tcpSend.isLast = msgObj.isLast
+          tcpSend.isSending = true
+          tcpSend.code = resultArray[2]
+          // 向蓝牙设备发送一个0x00的16进制数据，读取指令
+          let length = resultArray.length
+          const buffer = new ArrayBuffer(length);
+          const dataView = new DataView(buffer);
+          resultArray.forEach((el, index) => {
+            // 循环,取每一个十六进制值 添加到buffer
+            dataView.setUint8(index, '0x' + el);
+          })
+          console.log(buffer, "读取指令-----------------------");
+          // store.commit('setPassthroughType', 1);// 设置类型为 被动回复1
+          // BLE.sendMsgToKey(buffer, deviceId)
+
+          // this.mqttCode = resultArray[2];
+          let res = null;
+          // 下发指令逻辑
+          if (resultArray[0]?.toUpperCase() === 'FF' && resultArray[1]?.toUpperCase() === 'AA') {
+            res = await set_PlanCMD_FFAA(deviceId, resultArray.join(''));
+          } else if (resultArray[1]?.toUpperCase() === '78' || resultArray[1]?.toUpperCase() === '50') {
+            res = await getCMDESInfoAsync(deviceId, resultArray.join(''));
+          } else {
+            // DD
+            res = await set_PlanCMD_DD(deviceId, resultArray.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);
+          if (code.toUpperCase() == tcpSend?.code?.toUpperCase()) {
+            this.sendWriteReportData(content, deviceId)
+          }
+        } else if (msgObj.command == 97) {
+          tcpSend.hasHeartbeat = true
+        }
+        // 超时 30s 未收到指令反馈 认为指令发送失败
+        timer = setTimeout(() => {
+          tcpSend.isSending = false
+        }, 30000)
+        resolve(true);
+      } catch (error) {
+        console.log('error: ', error);
+
+      }
+    });
+  },
+}

package/src/index.js

@@ -9,5 +9,6 @@ export * from './core/keyAndPwdManager';
 export * from './core/mqttServer.js';
 export * from './core/OtaUpgrade';
 export * from './core/rsaEncrypt';
+export * from './core/tcpServer.js';
 export * from './core/TelinkApi';
 export * from './core/Transfer';