【微信小程序】处理蓝牙数据相关函数

1、将十六进制数组转换为 ArrayBuffer

function getBuffer(hexArr) {
    
    
  let buffer = new ArrayBuffer(hexArr.length)
  let dataView = new DataView(buffer);
  hexArr.forEach((item, index) => {
    
    
    dataView.setUint8(index, item);
  })
  return buffer
}

• 创建了一个与输入数组长度相同的新的 ArrayBuffer 对象
• 使用 DataView 对象来操作这个新的 ArrayBuffer
• 遍历输入的十六进制数组，将每个元素转换为无符号 8 位整数（Uint8），并将其写入到新的 ArrayBuffer对象中

2、将ArrayBuffer 对象转换为十六进制字符串

function ab2hex(buffer) {
    
    
  let hexArr = Array.prototype.map.call(
    new Uint8Array(buffer),
    function (bit) {
    
    
      return ('00' + bit.toString(16)).slice(-2)
    }
  )
  return hexArr.join('');
}

• 创建一个空数组 hexArr
• 通过调用 Array.prototype.map 方法，将输入的 ArrayBuffer 对象转换为一个由十六进制字符串组成的数组
• 在 map 方法的回调函数中，将每个字节转换为两位的十六进制字符串，并将其添加到 hexArr 中
• 使用 join('') 方法将 hexArr 数组中的所有元素连接成一个完整的十六进制字符串，并返回结果

3、将十六进制字符串转换为 ASCII 字符串

function hexToAscii(hex) {
    
    
  var str = '';
  for (var i = 0; i < hex.length; i += 2) {
    
    
    var charCode = parseInt(hex.substr(i, 2), 16);
    str += String.fromCharCode(charCode);
  }
  return str;
}

• 使用一个循环来遍历输入的十六进制字符串 hex。每次迭代，它会处理两个字符（一个字节）
• 使用 parseInt 函数将当前两个字符的十六进制表示转换为一个十进制数值
• 使用 String.fromCharCode 函数将该十进制数值转换为对应的 ASCII 字符，并将其添加到 str 字符串中

4、计算给定十六进制数组的 CRC 校验值

function getCrcData(hexArr) {
    
    
  let crcData = 0;
  for (let i = 0; i < hexArr.length; i++) {
    
    
    crcData ^= hexArr[i];
  }
  return '0x' + crcData.toString(16)
}

• 在循环中，对 crcData 和当前遍历到的十六进制数组元素进行异或操作（^=）
• 循环结束后，将计算得到的 CRC 校验值转换为十六进制字符串

5、将日期转换为十六进制字符串数组

function dateTohexString(date) {
    
    
  var date = new Date(date);
  var timestamp = Math.floor(date.getTime() / 1000); // 将日期转换为时间戳（以秒为单位）
  var buffer = new ArrayBuffer(4);
  var dataView = new DataView(buffer);
  dataView.setUint32(0, timestamp, true);
  var byteArray = new Uint8Array(buffer);
  var hexString = Array.from(byteArray).map(byte => byte.toString(16).padStart(2, '0')).join('');
  let arr = (hexString.match(/.{1,2}/g))
  let hexStringArr = []
  arr.forEach(item => {
    
    
    hexStringArr.push("0x" + item)
  })
  return hexStringArr
}

• 创建一个长度为4的 ArrayBuffer 对象，并使用 DataView 来操作这个缓冲区
• 使用 setUint32() 方法，它将时间戳写入到 ArrayBuffer 中
• 使用 Uint8Array 类型的视图来获取 ArrayBuffer 的字节表示，并将其存储在变量 byteArray 中
• 使用 Array.from() 方法将 byteArray 转换为普通数组，并通过 map() 方法将每个字节转换为两位的十六进制字符串
• 使用 join('') 将所有的十六进制字符串连接成一个完整的字符串，并按每两个字符分割为数组元素

6、将十六进制字符串数组转换为日期对象

function hexStringToDate(hexString) {
    
    
  var byteArray = new Uint8Array(hexString.match(/.{1,2}/g).map(byte => parseInt(byte, 16)));
  var buffer = byteArray.buffer;
  var dataView = new DataView(buffer);
  var timestamp = dataView.getUint32(0, true) * 1000; // 将秒转换为毫秒
  var dateTime = new Date(timestamp);
  return dateTime
}

• 接收一个十六进制字符串 hexString 作为输入
• 使用正则表达式来将每两个字符分割为一个元素，并使用 map()方法将每个元素转换为对应的十进制数
• 使用 Uint8Array 构造函数创建一个新的无符号8位整数数组，将转换得到的十进制数作为参数传递给它
• 使用 byteArray.buffer 获取数组的缓冲区对象，并将其存储在变量 buffer 中
• 使用 DataView对象来操作缓冲区
• 使用 getUint32() 方法，它从缓冲区中读取四个字节，并将其作为以秒为单位的时间戳存储在变量 timestamp 中
• 使用 new Date() 构造函数创建一个新的日期对象，并将时间戳作为参数传递给它，将结果存储在变量 dateTime 中

7、将时间字符串转换为反转的十六进制字符串数组

function timeTohexString(time) {
    
    
  var parts = time.split(":");
  var hours = parseInt(parts[0], 10); // 小时数
  var minutes = parseInt(parts[1], 10); // 分钟数
  // 计算总秒数
  var totalSeconds = hours * 3600 + minutes * 60;
  var hexString = totalSeconds.toString(16);
  while (hexString.length < 6) {
    
    
    hexString = '0' + hexString;
  }
  // 返回反转后的十六进制数组
  let pairs = hexString.match(/.{1,2}/g);
  let littleEndianHex = pairs.reverse();
  let newArr = littleEndianHex.map(item => '0x' + item)
  return newArr;
}

8、将给定的十进制数转换为一个反转的十六进制字符串数组

function decimalToHex(decimal, byteLength) {
    
    
  // 将十进制转换为十六进制字符串
  let hexString = decimal.toString(16);
  // 确保十六进制字符串占byteLength个字节
  while (hexString.length < byteLength) {
    
    
    hexString = '0' + hexString;
  }
  // 返回反转后的十六进制数组
  let pairs = hexString.match(/.{1,2}/g);
  let littleEndianHex = pairs.reverse();
  let newArr = littleEndianHex.map(item => '0x' + item)
  return newArr;
}

• 确保十六进制字符串占据指定的字节长度

9、将十六进制字符串切分为字节数组

function splitHexStringToByteArray(hexString) {
    
    
  // 检查输入字符串的长度是否为偶数，如果不是，则在其前面添加一个0
  if (hexString.length % 2 !== 0) {
    
    
    hexString = '0' + hexString;
  }
  // 将输入字符串切分为一个字节的数组
  const byteArray = [];
  for (let i = 0; i < hexString.length; i += 2) {
    
    
    const byte = hexString.substr(i, 2);
    byteArray.push('0x' + byte);
  }
  return byteArray;
}

• for 循环，每次从 hexString 中取出两个字符，将其转换为一个字节，并将结果存储在变量 byte 中

10、解析 TLV（Tag-Length-Value）数据

function parseTlvData(data) {
    
    
  const tlvArray = [];
  let index = 0;
  while (index < data.length) {
    
    
    const type = data[index];
    const length = data[index + 1];
    const value = data.slice(index + 2, index + 2 + length);
    tlvArray.push({
    
    
      type,
      length,
      value
    });
    index += 2 + length;
  }
  return tlvArray;
}

• 初始化一个变量 index 为 0，表示从数据的起始位置开始解析
• 在循环内部，首先获取当前索引位置的字节作为 TLV 的类型（Tag），并将其存储在变量 type 中
• 获取下一个字节作为 TLV 的长度（Length），并将其存储在变量 length 中
• 使用 slice() 方法从索引位置加 2 开始，截取长度为 length 的部分作为 TLV 的值（Value），并将其存储在变量 value 中
• 将 { type, length, value } 组成的对象添加到 tlvArray 数组中
• 更新 index 的值，以便继续解析下一个 TLV 数据

11、将汉字转换为字符编码数组

function hanziTochart(hanzi) {
    
    
  let chart = [];
  for (let i = 0; i < hanzi.length; i++) {
    
    
    const charCode = hanzi.charCodeAt(i); // 获取每个字符的Unicode编码
    const hexString = (charCode.toString(16)).match(/.{1,2}/g); // 将Unicode编码转换为十六进制字符串
    hexString.map(item => {
    
    
      chart.push('0x' + item);
    })
  }
  return chart
}

12、将字符编码数组转换回汉字

function chartTohanzi(chart) {
    
    
  let chartArr = chart.match(/.{1,4}/g)
  let hanzi = "";
  for (let i = 0; i < chartArr.length; i++) {
    
    
    const hexString = chartArr[i];
    const charCode = parseInt(hexString, 16); // 将十六进制字符串转换为Unicode编码
    const char = String.fromCharCode(charCode); // 将Unicode编码转换为字符
    hanzi += char;
  }
  return hanzi
}