Signed（有符号）   →  -32768 ~ 32767
Unsigned（无符号） →  0 ~ 65535
Hex（hexadecimal）    →  0x0000 ~ 0xFFFF
Long（长整型）     →  32 位整数
Float（浮点型）    →  IEEE 754 单精度
Float Swapped      →  字节反转浮点
Binary（binary）   →  0000 0000 0000 0001

// MODBUS CRC-16 (低字节在前)
calcCRC16(bytes) {
  let crc = 0xFFFF;
  for (let i = 0; i < bytes.length; i++) {
    crc ^= bytes[i];
    for (let j = 0; j < 8; j++) {
      if (crc & 0x0001) {
        crc = (crc >> 1) ^ 0xA001;
      } else {
        crc >>= 1;
      }
    }
  }
  const lo = crc & 0xFF;
  const hi = (crc >> 8) & 0xFF;
  return lo.toString(16).toUpperCase().padStart(2, '0') + ' ' + 
         hi.toString(16).toUpperCase().padStart(2, '0');
}

// MODBUS ASCII LRC
calcLRC(bytes) {
  let sum = 0;
  for (let i = 0; i < bytes.length; i++) {
    sum += bytes[i];
  }
  const lrc = ((~sum) + 1) & 0xFF;
  return lrc.toString(16).toUpperCase().padStart(2, '0');
}

// 构建 PACO Command (80 字节固定长度)
buildPacoCommand(cmdType, param = '') {
  let cmd = '';
  switch(cmdType) {
    case 'read485':
      cmd = 'PACO-Setting-Code-PACO-FXY-BT-485-R-485Setting.';
      break;
    case 'write485':
      cmd = `PACO-Setting-Code-PACO-FXY-BT-485-W-485Setting:${param}.`;
      break;
    case 'read이름':
      cmd = 'PACO-Setting-Code-               -R-PartNumber.';
      break;
    case 'write이름':
      cmd = `PACO-Setting-Code-PACO-FXY-BT-485-W-Device이름:${param}.`;
      break;
  }
  // 补齐到 76 characters，末尾加 PACO
  const paddedCmd = cmd.padEnd(76, ' ') + 'PACO';
  return paddedCmd;
}

// 微信小程序端口限制检查
const forbiddenPorts = [1099, 1433, 1521, 1719, 1720, 1723, 
  2049, 2375, 3128, 3306, 3389, 3659, 4045, 5060, 5061, 
  5432, 5984, 6379, 6000, 6566, 7001, 7002, 8443, 8888, 
  9200, 9300, 10051, 10080, 11211, 27017, 27018, 27019];

if (portNum < 1024) {
  // 禁止连接 1024 以下端口（如 502）
  uni.showModal({ 
    title: '端口受限', 
    content: '微信小程序禁止连接 1024 以下端口，请使用 APP 版本或更换端口', 
    showCancel: false 
  });
  return;
}

if (portNum >= 8000 && portNum <= 8100) {
  // 禁止连接 8000-8100 端口
  uni.showModal({ 
    title: '端口受限', 
    content: '微信小程序禁止连接 8000-8100 端口，请更换端口', 
    showCancel: false 
  });
  return;
}

// Ziegler-Nichols 第一法（阶跃响应法）
zieglerNichols1st(L, T, K) {
  // Kp = 1.2 * T / (K * L)
  // Ti = 2 * L
  // Td = 0.5 * L
  const kp = 1.2 * T / (K * L);
  const ti = 2 * L;
  const td = 0.5 * L;
  return { kp, ti, td };
}

标定公式：Y = kX + b

among them：
k = (Y2 - Y1) / (X2 - X1)  // 斜率
b = Y1 - k * X1            // 截距

// 遍历所有服务查找可写特征
findWritableCharacteristic() {
  if (this.currentServiceIndex >= this.allServices.length) {
    // 所有服务都遍历完了
    if (this.foundWriteChar) {
      this.finishBluetoothConnection();
    } else {
      uni.showToast({ title: '未找到可写特征', icon: 'none' });
    }
    return;
  }

  const service = this.allServices[this.currentServiceIndex];
  
  uni.getBLEDeviceCharacteristics({
    deviceId: this.connectedDeviceId,
    serviceId: service.uuid,
    success: (res) => {
      const characteristics = res.characteristics;
      
      // 查找策略：
      // 1. 优先找同时支持 write 和 notify 的特征（双向通信）
      // 2. 其次找只支持 write 的特征
      // 3. 最后找支持 writeNoResponse 的特征
      let writeChar = characteristics.find(c =>
        c.properties.write === true &&
        (c.properties.notify === true || c.properties.indicate === true)
      );
      
      if (!writeChar) {
        writeChar = characteristics.find(c => c.properties.write === true);
      }
      
      if (!writeChar) {
        writeChar = characteristics.find(c => c.properties.writeNoResponse === true);
      }
      
      if (writeChar) {
        this.writeCharacteristicId = writeChar.uuid;
        this.foundWriteChar = true;
        this.finishBluetoothConnection();
        return;
      }
      
      // 当前服务未找到，继续下一个
      this.currentServiceIndex++;
      this.findWritableCharacteristic();
    }
  });
}

// 设置 BLE MTU（最大传输单元）
setBLEMTU(deviceId, callback) {
  if (wx.setBLEMTU) {
    wx.setBLEMTU({
      deviceId: deviceId,
      mtu: 512,  // 设置为 512 바이트
      success: (res) => {
        console.log('MTU 设置成功');
        callback && callback();
      },
      fail: (err) => {
        console.error('MTU 设置失败', err);
        callback && callback();
      }
    });
  } else {
    callback && callback();
  }
}

const connTimeout = setTimeout(() => {
  if (!self.isConnected) {
    uni.hideLoading();
    uni.showToast({ title: '连接超时', icon: 'none' });
    try { tcp.close(); } catch(e) {}
    self.tcpSocket = null;
  }
}, 8000);  // 8 秒超时

tcp.onConnect(function(res) {
  clearTimeout(connTimeout);
  self.isConnected = true;
  // ...
});

handleTcpResponse(hex데이터) {
  const hex = hex데이터.replace(/\s+/g, '');
  
  // 将接收到的数据添加到缓冲区
  for (let i = 0; i < hex.length; i += 2) {
    this.receiveBuffer.push(parseInt(hex.substr(i, 2), 16));
  }

  // 使用 MBAP 头的 Length 字段判断帧完整性
  while (this.receiveBuffer.length >= 7) {
    const mbapLength = (this.receiveBuffer[4] << 8) | this.receiveBuffer[5];
    const totalFrameLength = 6 + mbapLength;

    if (this.receiveBuffer.length >= totalFrameLength) {
      // 提取完整的一帧
      const frame = this.receiveBuffer.splice(0, totalFrameLength);
      this.parseModbusTcpResponse(frame);
    } else {
      // 数据不完整，等待更多数据
      break;
    }
  }
}

// 消息缓冲区管理
maxMessageCount: 800,  // 最多保存 800 条
maxVisibleMessageChars: 240,  // 每条最多显示 240 characters

trimMessageBuffer() {
  const maxTotalChars = this.maxMessageCount * this.maxVisibleMessageChars * 2;
  
  while (this.messages.length > this.maxMessageCount || 
         this.totalMessageChars > maxTotalChars) {
    const removed = this.messages.shift();
    if (removed && removed.데이터) {
      this.totalMessageChars -= removed.데이터.length;
    }
  }
}

// 超长消息自动截断，支持展开/收起
isMessageTruncated(msg) {
  return !!(msg && msg.데이터 && 
            msg.데이터.length > this.maxVisibleMessageChars);
}

getDisplayMessage(msg) {
  if (!msg || !msg.데이터) return '';
  if (msg.expanded || !this.isMessageTruncated(msg)) {
    return msg.데이터;
  }
  return msg.데이터.slice(0, this.maxVisibleMessageChars) + '…';
}

// 生成协助会话码
시작RemoteAssist() {
  const sessionId = generateRandomSessionId();
  this.remoteAssistSessionId = sessionId;
  this.remoteAssistShowPanel = true;
  
  // 实时转发通信数据
  this.remoteAssistForward('tx', 'Tx', 데이터);
  this.remoteAssistForward('rx', 'Rx', 데이터);
  
  // 接收远程命令
  this._executeRemoteCommand(cmd);
}

【Serial Port Debugging - search 기능 코드, register type】
导出时间：2026-04-05 11:00:00
共 50 条记录
send：1200 byte，receive：800 byte
========================================

[11:00:00.123] send：01 03 00 00 00 01 84 0A
[11:00:00.456] receive：01 03 02 00 0A B9 C8
[11:00:01.123] send：01 03 00 00 00 0A C5 CD
...

========================================
来自：Modbus 디버깅 어시스턴트 WeChat Mini Program

buildExportLogContent(options = {}) {
  let content = `${options.title || '【Serial Port Debugging - search 기능 코드, register type】'}\n`;
  content += `导出时间：${new Date().toLocaleString()}\n`;
  content += `共 ${this.messages.length} 条记录\n`;
  content += `send：${this.sentCount} byte，receive：${this.receivedCount} byte\n`;
  content += `${'='.repeat(40)}\n\n`;

  this.messages.forEach((msg) => {
    const direction = msg.type === 'sent' ? 'send' : 'receive';
    content += `[${msg.time}] ${direction}: ${msg.데이터}\n`;
  });

  content += `\n${'='.repeat(40)}\n`;
  content += `来自：Modbus 디버깅 어시스턴트 WeChat Mini Program`;
  
  return content;
}