From f479f9916d4b466d0f2a51c06b747db17beae125 Mon Sep 17 00:00:00 2001
From: liwei1dao <liwei1dao@gmail.com>
Date: Tue, 14 Jul 2026 20:55:31 +0800
Subject: [PATCH] =?UTF-8?q?=E4=B8=8A=E4=BC=A0=E6=96=B0=E7=89=88=E6=9C=AC?=
 =?UTF-8?q?=E7=9A=84=E9=80=9A=E8=AF=9D=E7=BF=BB=E8=AF=91=E9=80=BB=E8=BE=91?=
 =?UTF-8?q?=E4=BB=A3=E7=A0=81?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...�翻译-BLE�议规范-v2-固件对接.md | 437 ++++++++++++++++++
 docs/通�翻译-�程与控��议.md    |   6 +-
 lib/data/services/ble_manager.dart            |  11 +-
 .../call_translation_debug_controller.dart    | 105 ++++-
 .../views/call_translation_debug_view.dart    | 143 ++++--
 .../yunqiinnovation/ble_service/BleService.kt | 286 +++++++++---
 .../ble_service/BleServicePlugin.kt           |   7 +-
 .../Sources/ble_service/BleService.swift      | 239 ++++++++--
 .../ble_service/SwiftBleServicePlugin.swift   |   4 +-
 .../ble_service/lib/ble_service.dart          |  25 +-
 10 files changed, 1088 insertions(+), 175 deletions(-)
 create mode 100644 docs/通�翻译-BLE�议规范-v2-固件对接.md

diff --git a/docs/通�翻译-BLE�议规范-v2-固件对接.md b/docs/通�翻译-BLE�议规范-v2-固件对接.md
new file mode 100644
index 000000000..1609ed4c3
--- /dev/null
+++ b/docs/通�翻译-BLE�议规范-v2-固件对接.md
@@ -0,0 +1,437 @@
+# 通�翻译 BLE �议规范 v2（APP ↔ 固件 对接版）
+
+> **用途**：APP 与耳机固件�新�调通�翻译的接�契约。本文��述**�方约定的线上格�与时�**。
+> **代�基准**：分支 `newdev_chengguofeng`，`local_plugins/ble_service/`（Android / iOS 行为一致）。
+> **兼容性**：**下行音频格�为 v2 新格�，与 v1 �兼容**，APP 与固件必须�时�级。
+
+---
+
+## 目录
+
+1. [v2 �更摘�](#1-v2-�更摘�固件�点看这里)
+2. [链路总览与声�语义](#2-链路总览与声�语义)
+3. [GATT �务与特�](#3-gatt-�务与特�)
+4. [�率与帧长（贯穿全文的基础）](#4-�率与帧长贯穿全文的基础)
+5. [指令�议](#5-指令�议)
+6. [会�时�](#6-会�时�)
+7. [上行音频（设备 → APP）](#7-上行音频设备--app)
+8. [下行音频（APP → 设备）★ 核心](#8-下行音频app--设备--核心)
+9. [��置�数](#9-��置�数app-侧�行时�调)
+10. [异常与边界约定](#10-异常与边界约定)
+11. [�调验收清�](#11-�调验收清�)
+12. [待�方确认](#12-待�方确认)
+13. [附：APP 侧实现�置](#13-附app-侧实现�置备查)
+
+---
+
+## 1. v2 �更摘�（固件�点看这里）
+
+| 项 | v1（旧） | **v2（新）** |
+|---|---|---|
+| 下行包头 | `[4B ��(�端)][1B 声�]` 共 5 字节 | **无包头**，整包纯 opus 帧数� |
+| 下行声�组织 | 一包�装一个声�（左包 / �包分别�） | **一包�时装左�**，帧级交替 `L R L R …` |
+| 下行包长 | `5 + N×40`，�长 | **�定 `2 × N × F` 字节** |
+| 下行帧数 | 5 帧/包（�声�） | **2 帧/声�/�**（默认，�调 1–20） |
+| 下行节� | 80 ms，左�两路��一包�错峰 40 ms | **40 ms**（默认），�路统一�� |
+| �声�无数� | 该声���包 | **�音帧补�**，��左�严格对��长度�定 |
+| 完全无音频时 | �� | ��置**�续��**全�音包（默认关） |
+| �帧字节数 | 固定 40 B | **由�率决定的�� `F`**，上下行�自�� |
+| F4/F5 �馈调速 | 曾设计过 | **已移除**，固件无需上报解�空余 |
+
+**固件唯一必须�写的是下行解包逻辑**：���剥 5 字节包头，改为按�帧字节数 `F` 切分�左�交替�帧。指令�议�上行音频�UUID �**��**。
+
+---
+
+## 2. 链路总览与声�语义
+
+```
+                          BLE
+   ┌──────────�  上行原声（立体声 opus）   ┌──────────�
+   │          │ ───────── notify ───────▶ │          │
+   │  耳机    │                           │   APP    │ → 端到端语音翻译（ASR+翻译+TTS）
+   │  固件    │ ◀──────── write ───────── │          │
+   │          │  下行译音（左�交替 opus）  └──────────┘
+   └──────────┘
+```
+
+- **上行**：耳机把「本端麦克风原声 + 对方通�原声���**立体声 opus** 上报给 APP。
+- **下行**：APP 把两路译音编��写回耳机播放。
+
+**声�语义（上下行�义��，务必区分）：**
+
+| | 左声� | �声� |
+|---|---|---|
+| **上行**（设备→APP） | 本端麦克风原声 | 对方通�原声 |
+| **下行**（APP→设备） | **本端译音**（说给对方�） | **对端译音**（说给本端�） |
+
+APP �负责按上表填左�；最终左/�播到哪�耳�如何与通�原声混音，**由固件决定**。
+
+---
+
+## 3. GATT �务与特�
+
+| �务 | UUID | 特� | UUID | 方� | 属性 |
+|---|---|---|---|---|---|
+| 主�务 | `0000ABC0-0000-1111-2222-123456789ABC` | WRITE | `0000ABC1-0000-…` | APP → 设备 | Write No Response |
+| | | NOTIFY | `0000ABC2-0000-…` | 设备 → APP | Notify |
+| **通�音频�务** | `0000ABC0-0001-1111-2222-123456789ABC` | **CALL_WRITE** | `0000ABC1-0001-…` | **APP → 设备（下行译音）** | **Write No Response** |
+| | | **CALL_RECEIVE** | `0000ABC2-0001-…` | **设备 → APP（上行原声）** | **Notify** |
+
+- CCCD：`00002902-0000-1000-8000-00805f9b34fb`
+- **MTU**：APP 连接�请求 **517**（→ �次写净�上� **514 B**）
+- APP 还会�试 `CONNECTION_PRIORITY_HIGH` 与 **PHY 2M**（失败自动回退 1M）
+
+---
+
+## 4. �率与帧长（贯穿全文的基础）
+
+opus 帧时长**�为 20 ms**（与�率无关）。CBR 模�下：
+
+```
+�帧字节数 F = �率(kbps) × 20 ms ÷ 8
+```
+
+| �率 | **�帧字节 F** | 一次 BLE 写最多几帧（514 ÷ 2F） |
+|---|---|---|
+| 8 kbps | 20 B | 12 |
+| **16 kbps（默认）** | **40 B** | **6** |
+| 24 kbps | 60 B | 4 |
+| 32 kbps | 80 B | 3 |
+
+**上行�下行�有独立�率**，��在 APP 侧�置：
+
+- `F_down`：下行�帧字节，APP 编�器用，固件解�器用。
+- `F_up`：上行�帧字节，固件编�器用，APP 解�器用 —— **必须与固件实际编��率一致**（� §7）。
+
+> ⚠� **固件��把 40 硬编�。** 请按�率推算 `F`，或按 `F = 包长 ÷ (2 × N)` 推算。这样 APP 侧调�率时固件无需改代�。
+
+---
+
+## 5. 指令�议
+
+### 5.1 帧格�
+
+```
+APP 请求    : 0xAA [CMD] [LEN] [DATA…] [CRC8]
+设备�应    : 0xBB [CMD] [LEN] [DATA…] [CRC8]
+设备主动上报: 0xCC [CMD] [LEN] [DATA…] [CRC8]
+```
+
+- `LEN` = DATA 字节数（��帧头/CMD/LEN/CRC）；整帧长 = `LEN + 4`。
+- `CRC8` 覆盖**从帧头（�）到 DATA 末尾**，�� CRC 自身。
+
+### 5.2 CRC8 算法（勿套用标准库的 "CRC-8/MAXIM"）
+
+APP 代�里函数�� `calculateCrc8Maxim`，但**实现是��射版**：多项� `0x31`��值 `0x00`�MSB-first���射输入输出�无最终异或。
+标准 CRC-8/MAXIM 是**�射版**（0x8C），**结果��**。请直接照抄下�的实现：
+
+```c
+uint8_t crc8(const uint8_t *data, int len) {
+    uint8_t crc = 0x00;
+    for (int i = 0; i < len; i++) {
+        crc ^= data[i];
+        for (int j = 0; j < 8; j++) {
+            crc = (crc & 0x80) ? (uint8_t)((crc << 1) ^ 0x31) : (uint8_t)(crc << 1);
+        }
+    }
+    return crc;
+}
+```
+
+### 5.3 通�翻译相关指令
+
+| CMD | �称 | 方� | 说明 |
+|---|---|---|---|
+| **0x05** | CONTROL_CODEC | APP → 设备 | 编解�控制（�下） |
+| **0x16** | CALL_TRANSLATION_ON | 设备 → APP（`0xCC`） | 设备侧（按键等）请求**开�**通�翻译 |
+| **0x17** | CALL_TRANSLATION_OFF | 设备 → APP（`0xCC`） | 设备侧请求**关闭**通�翻译 |
+
+**0x05 的 DATA = `[�命令, 声�模�]`**
+
+| �命令 | 值 | �义 |
+|---|---|---|
+| CLOSE | `0x00` | 关闭编解�（结�通�翻译） |
+| **A2DP_PLAY** | **`0xA2`** | **开�通�翻译**：mic + dac 声音上行，并接收翻译�音频 |
+| DECODE_ON | `0xA1` | 仅解�（音�/通�远端），�通�翻译 |
+| CALL_RECORD_PLAY | `0xA3` | 通�录音，�通�翻译 |
+
+声�模�：`0x01`=左 / `0x02`=� / **`0x03`=立体声（通�翻译固定用这个）**
+
+**实际收�字节：**
+
+```
+开�：APP → AA 05 02 A2 03 [CRC]
+      设备 → BB 05 02 A2 03 [CRC]      � 期望回显�命令与声�
+关闭：APP → AA 05 02 00 03 [CRC]
+      设备 → BB 05 02 00 03 [CRC]
+```
+
+### 5.4 ACK 约定
+
+APP 侧指令**串行**：�出一��等 `0xBB` �应��下一�，**超时 1 秒**自动放行队列。
+请确��� `0xAA` 请求都回一� `0xBB`，�则会拖慢�续指令。
+
+---
+
+## 6. 会�时�
+
+```mermaid
+sequenceDiagram
+    participant D as 耳机固件
+    participant A as APP
+
+    Note over A,D: ① 开�（APP 主动 或 设备按键触�）
+    D-->>A: 0xCC 16 …（�选：设备侧请求开�）
+    A->>A: �动上行解�器 + 下行编�器 + ��线程
+    A->>D: AA 05 02 A2 03（CONTROL_CODEC / A2DP_PLAY / 立体声）
+    D-->>A: BB 05 02 A2 03
+
+    Note over A,D: ② 会�中（��音频�并行）
+    loop �续
+        D-->>A: notify CALL_RECEIVE：上行立体声 opus（本端 mic + 对方声）
+        A->>A: 拆左� → 两路端到端翻译 → 两路译音 PCM → opus 编�
+        A->>D: write CALL_WRITE：下行 opus（左�帧级交替，无包头）
+    end
+
+    Note over A,D: ③ 关闭
+    D-->>A: 0xCC 17 …（�选：设备侧请求关闭）
+    A->>D: AA 05 02 00 03（CONTROL_CODEC / CLOSE）
+    D-->>A: BB 05 02 00 03
+    A->>A: ���线程��编解��清空队列
+```
+
+> ⚠� APP 在**�出 `0xA2` 之�**就已�动下行��线程。若「�续���开关是开的，固件�能在收到 `0xA2` �就收到下行写入 —— **固件应能安全丢弃未进入翻译�时收到的音频包**。
+
+---
+
+## 7. 上行音频（设备 → APP）
+
+| 项 | 约定 |
+|---|---|
+| 特� | `CALL_RECEIVE`（`0000ABC2-0001-…`）notify |
+| 编� | Opus，CBR，帧时长 20 ms |
+| 采样率 | 16 kHz |
+| 声� | 立体声（左 = 本端麦克风原声，� = 对方通�原声） |
+| 包头 | **无** |
+| �帧字节 | `F_up`（由上行�率决定，默认 16 kbps → 40 B） |
+| APP 解��置 | `hasHeader=false, channel=2, sampleRate=16000, packetSize = 2 × F_up`（默认 80） |
+| 包长校验 | APP **丢弃长度�是 `F_up` 整数�**的包（防止错�污染��解�器） |
+
+**上行�率必须�方一致。** APP 用它推 `F_up` ��收包校验和解�器切分。固件若改了上行�率而 APP 没�步，**所有上行包都会被判��包丢掉**（表现：完全收�到对方声音）。
+
+> ⚠� **待固件确认**：APP 按 `packetSize = 2 × F_up` 的�声��解�，�� `2 × F_up` 字节为一个立体声�元。请确认固件上行的实际组织方�是 **`[左 F_up][� F_up]` 交替**（与下行对称）。若�是，APP 侧解��数需相应调整。
+
+---
+
+## 8. 下行音频（APP → 设备）★ 核心
+
+| 项 | 约定 |
+|---|---|
+| 特� | `CALL_WRITE`（`0000ABC1-0001-…`）**Write Without Response** |
+| 编� | Opus，**CBR**，�声�编�器 ×2（左��一路，互相独立） |
+| 采样率 | 16 kHz |
+| 帧时长 | **�定 20 ms/帧** |
+| �帧字节 | **`F`**（由下行�率决定，默认 16 kbps → **40 B**） |
+| 包头 | **无** |
+| 包结构 | 左�**帧级交替** |
+| 一�字节数 | **`2 × N × F`**（N = �声�帧数，默认 N=2�F=40 → **160 B**） |
+
+### 8.1 包结构
+
+通�（N 帧/声�，�帧 F 字节）：
+
+```
+[L0][R0][L1][R1] … [L(N-1)][R(N-1)]        �个 [] �为 F 字节
+```
+
+默认�置（N=2，F=40B，16 kbps）→ 160 字节：
+
+```
+�移:  0        40       80       120      160
+      ┌────────┬────────┬────────┬────────�
+      │  L0    │  R0    │  L1    │  R1    │
+      │ 40B    │ 40B    │ 40B    │ 40B    │
+      └────────┴────────┴────────┴────────┘
+       左      �       左       �
+```
+
+�样 N=2，但下行�率�到 8 kbps（F=20B）→ �有 80 字节：
+
+```
+�移:  0    20   40   60   80
+      ┌────┬────┬────┬────�
+      │ L0 │ R0 │ L1 │ R1 │        �帧 20B
+      └────┴────┴────┴────┘
+```
+
+- �帧都是**完整�独立�解**的 opus 帧。
+- 左�两路��进**两个独立的 opus 解�器**（��用一个立体声解�器解）。
+
+### 8.2 固件解包伪代�
+
+```c
+#define OPUS_FRAME_MS 20
+
+// 由�率推�帧字节：16→40, 8→20, 24→60, 32→80
+static inline int frame_bytes_of(int bitrate_kbps) {
+    return bitrate_kbps * OPUS_FRAME_MS / 8;
+}
+
+// g_downlink_frame_bytes = frame_bytes_of(约定的下行�率)
+void on_downlink_packet(const uint8_t *packet, int len) {
+    const int F = g_downlink_frame_bytes;
+    if (F <= 0 || len % (2 * F) != 0) { /* 异常包，丢弃 */ return; }
+
+    int n = len / (2 * F);                      // 本包帧数/声�，动�推算
+    for (int i = 0; i < n; i++) {
+        const uint8_t *left  = packet + (i * 2)     * F;
+        const uint8_t *right = packet + (i * 2 + 1) * F;
+        opus_decode(dec_left,  left,  F, pcm_left,  FRAME_SAMPLES, 0);
+        opus_decode(dec_right, right, F, pcm_right, FRAME_SAMPLES, 0);
+        // 播放 / 混音
+    }
+}
+```
+
+> **���设 N 固定为 2，也���设 F 固定为 40。** N 按 `len / (2×F)` 推，F 按�率推。这样 APP 调�时固件无需改代�。
+
+### 8.3 一��能被拆�多个 BLE 写
+
+BLE �次写净�上�是 `MTU-3`（**514 B**）。当一�的数�（`2 × N × F`）超过它时，**APP 按「左�一对�(`2 × F`) 对�拆�多个 BLE 写连续�出**。
+
+例：N=20�F=40B → 一� 1600 B → 拆 4 个写（6 + 6 + 6 + 2 帧）。
+
+**这对固件完全�明，�需�任何特殊处�：**
+
+- �个分片本身�是 `2 × F` 的整数�，左�交替顺���；
+- 所以固件无论「�个 BLE 包独立解��还是「当�连续字节�解��，结果都正确；
+- §8.2 的解包函数原样适用。
+
+### 8.4 �音填充（关键约定）
+
+APP 的左�两路译音是**异步产生**的，任何一�都�能�有一边有数�。此时 APP **�会缩短包长**，而是用一帧**编�好的�音 opus 帧**填满缺的�置。
+
+这�味�：
+
+- 包长永远�定�左�永远严格对�，**固件�无�件按固定�移切分**；
+- �音帧是**�法的 opus 帧**（由编�器编�零 PCM 得到，**�是全 0 字节**），正常解��得�音 PCM；
+- �有一边说�时，�一边�续收到�音帧 —— 这是**正常现象，�是丢包**。
+
+### 8.5 �续��开关
+
+| 状� | 行为 |
+|---|---|
+| **关**（默认） | 左�都没有译音时，该�**��包**，链路空闲 |
+| **开** | 左�都没有译音时，�按节��**全�音包**，��设备侧音频��断 |
+
+> 若固件的解�/播放管线**�求音频��能断**（断�会导致 underrun�PLL 失��时基丢失等），告诉我们，把默认值改�「开�。
+
+### 8.6 带宽
+
+| �置 | 一�字节 / 节� | 带宽 |
+|---|---|---|
+| 16 kbps，N=2，40 ms | 160 B / 40 ms | 4000 B/s = 32 kbps（左�� 16k） |
+| 8 kbps，N=2，40 ms | 80 B / 40 ms | 2000 B/s = 16 kbps（左�� 8k） |
+
+---
+
+## 9. ��置�数（APP 侧�行时�调）
+
+APP 内置调试页（通�翻译调试）�实时下�，**无需�连**，�调时�现场改：
+
+| �数 | 默认 | 范围 | 说明 |
+|---|---|---|---|
+| `downlinkBitrateKbps` | **16** | 8 / 16 / 24 / 32 | **下行**�率 → `F = kbps × 2.5` |
+| `uplinkBitrateKbps` | **16** | 8 / 16 / 24 / 32 | **上行**�率，**必须与固件实际编�一致** |
+| `bundleFrameCount` | **2** | **1 – 20** | �声���帧数 N；一� = `2 × N × F` 字节 |
+| `sendIntervalMs` | **40** | **5 – 200**（步长 5） | ��节� |
+| `continuousSend` | **关** | 开 / 关 | 无译音时是��续��音包 |
+
+### 9.1 节�必须与帧数匹�
+
+�帧�为 20 ms 音频（与�率无关），所以：
+
+```
+节�(ms) == N × 20     → 下�速率与真实语速 1:1（推�）
+节�     >  N × 20     → �慢，译音在 APP 侧积压，延迟越�越大
+节�     <  N × 20     → �快，设备侧解�缓存�续上涨，�能溢出
+```
+
+速查（16 kbps / F=40B）：
+
+| N（帧/声�） | 一�字节 | 匹�节� | BLE 写次数 |
+|---|---|---|---|
+| 1 | 80 B | 20 ms | 1 |
+| **2（默认）** | **160 B** | **40 ms** | **1** |
+| 4 | 320 B | 80 ms | 1 |
+| 6 | 480 B | 120 ms | 1 |
+| 10 | 800 B | 200 ms | 2 |
+| 20 | 1600 B | 400 ms | 4 |
+
+> ⚠� **N > 10 ��出 1:1 节�**：节�上�是 200 ms，而 N=20 需� 400 ms。此时�能超�（设备侧缓存会涨）。若确实�用大 N，需把节�上�放开 —— 告诉我们��。
+
+### 9.2 改�率会��编�器
+
+opus 编�器的 packetSize 在�动时固化。APP 改下行�率时会：**�编�� → 清空左���队列 → 作废旧�音模� → 用新帧长��编��**。
+��新旧帧长混进�一包导致整包错�。表现为下行有一次**�短（数�毫秒）�顿**，属正常。�顿之�**包长按新 F �化**，固件需按新�率�步更新 `F`。
+
+---
+
+## 10. 异常与边界约定
+
+| 场景 | APP 侧行为 | 对固件的影� / �求 |
+|---|---|---|
+| BLE 写拥塞（底层缓冲满） | 该分片��，**尚未�出的**帧退回队头，下一�续�。**�丢译音** | 已�出的分片自身对��顺�正确，字节��错�；剩余帧下一�补上 |
+| �帧长度异常（≠ 当� F） | 入队时**直接丢弃**该帧 | ��固件收到的包长永远是 `2 × F` 的整数� |
+| �音帧模�未就绪（编�器刚�动的�短窗�） | 整�**��**，帧退回队列 | 会�最开始�能有几� ms 无下行，属正常 |
+| �行中改�率 | ��编�器�清队列��建�音模� | 短暂�顿；之�包长按新 `F` �化 |
+| �外断连 | 1 s �主动回连（最多 5 次）；期间**译音继续缓存�丢**；回连�功� **1600 ms** �下 `0xA2` 并续� | 固件回连�需能�新接� `0xA2` 并��播放 |
+| 会�结� | ���线程�清空左�队列 | 下行立��止 |
+| 未进翻译�就收到下行包 | 「�续���开�时�能�生（� §6） | **固件应容�并丢弃** |
+
+---
+
+## 11. �调验收清�
+
+按顺��项验�，�项都能独立定�问题：
+
+- [ ] **0. �率对�**：�方确认上�下行�率�是多少，�此�自算出 `F`（16 kbps → 40 B）。**这是一切的��。**
+- [ ] **1. 指令通路**：APP � `AA 05 02 A2 03`，固件回 `BB 05 02 A2 03`；关闭��。CRC �方一致。
+- [ ] **2. 上行通路**：固件上报立体声 opus，APP 能解出左�两路（左=本端 mic，�=对方声），无「长度� `F_up` �数�告警。
+- [ ] **3. 下行包长**：固件收到的�包长度�为 `2 × N × F`（默认 160 B），且始终是 `2 × F` 的整数�。
+- [ ] **4. 下行对�**：固件按 `F` 切分，�数�喂左解�器�奇数�喂�解�器，**两路都解��功**（`opus_decode` 无错误返回）。
+- [ ] **5. �边说�**：�有本端说�时，�声�收到�音帧（�解��内容为�音），**�应报错或丢包**。
+- [ ] **6. ���传**：本端说� → 对方�到译音；对方说� → 本端�到译音；左��串�。
+- [ ] **7. 节�稳定**：固件侧收包间隔稳定在 40 ms 附近，解�缓存水���续上涨�也�饿死。
+- [ ] **8. 长时间跑**：连续 10 分钟无缓存溢出��顿�左�错�。
+- [ ] **9. 断连��**：手动断连�自动回连，`0xA2` �下�，音频��。
+- [ ] **10. �续��开关**：打开�，无人说�时固件��续收到全�音包，播放无�音。
+- [ ] **11. 大帧数拆写**（�选）：把 N 调到 20，固件收到的是多个 480 B/160 B 的包，解�播放�正常。
+- [ ] **12. 切�率**（�选）：APP 切到 8 kbps �包长� 80 B，固件按新 `F=20B` 切分�正常。
+
+> �调时 APP 侧日志会打���的：包��左�真实帧数��音补�数�总字节�拆写次数�队列积压。出问题�直接对时间戳定�是哪一侧。
+
+---
+
+## 12. 待�方确认
+
+1. **上下行�率�定多少？**（§4/§9）APP 默认上下行� 16 kbps（F=40 B），支� 8/16/24/32。**上行�率必须与固件实际编�一致**，�则 APP 会把所有上行包判��包。
+2. **上行结构？**（§7）是�为 `[左 F_up][� F_up]` 交替？APP 当�按 `packetSize = 2 × F_up` / �声�解。
+3. **�续�����默认打开？**（§8.5）固件是��求下行�断�？
+4. **节�与帧数怎么定？**（§9）默认 2 帧 / 40 ms（160 B）是�符�固件解�缓存的期望？需�大包低频（如 4 帧/80 ms）或�包高频（1 帧/20 ms）都�以，告知目标值��。
+5. **�音帧能�正常解�？**（§8.4）是标准 opus 帧，�是全 0 字节。
+6. **未进翻译�的下行写入能�安全丢弃？**（§6）
+
+---
+
+## 13. 附：APP 侧实现�置（备查）
+
+| 内容 | 文件 · 符� |
+|---|---|
+| 下行组包 / 分片写 / �音补� | `ble_service/android/…/BleService.kt` → `trySendMixedChunk` / `buildInterleavedPacket` / `maxFramesPerWrite` |
+| iOS �构实现 | `ble_service/ios/…/BleService.swift` → ��方法 |
+| �率 ↔ 帧长�算�改�率��编�器 | `BleService.kt` → `bitrateToFrameBytes` / `applyDownlinkBitrate` / `applyUplinkBitrate` |
+| 上行收包校验 | `BleService.kt` → `onCharacteristicChanged` / `isValidUplinkAudioLen` |
+| 指令�议 / CRC8 | `ble_service/android/…/BleCommandSender.kt` → `createCommandPacket` / `calculateCrc8Maxim` |
+| UUID / 指令常� | `ble_service/android/…/BleConst.kt` |
+| 调试页（现场调�） | `lib/modules/call_translation_debug/` |
diff --git a/docs/通�翻译-�程与控��议.md b/docs/通�翻译-�程与控��议.md
index 0698aa2fc..41ff08949 100644
--- a/docs/通�翻译-�程与控��议.md
+++ b/docs/通�翻译-�程与控��议.md
@@ -1,8 +1,12 @@
 # 通�翻译：�程与控��议
 
+> ⚠� **下行部分已过时（v2 改版�）**。下行音频现已改为**无包头�左�帧级交替**的新格�，且 **F4/F5 �馈调速已从代�中移除**。
+> 本文第 **8 章（下行链路与控�）**�**10.2 节的 F4/F5 部分**�**11 章的默认�数**�**���映当�代�**，勿�此对接。
+> 下行的��定义� → **[`通�翻译-BLE�议规范-v2-固件对接.md`](./通�翻译-BLE�议规范-v2-固件对接.md)**
+> 本文其余部分（术语与声�语义�上行链路�端到端翻译层�指令�议�连接层优化）�然有效。
+
 > 适用分支：`newdev_chengguofeng`（以当� HEAD 实际代�为准）
 > 关键�：Jieli 耳机 · BLE �声� · 端到端语音翻译(AST/STS) · 下行�控
-> 维护�示：本文�述的是**当���下行**实现（累帧�包 + 固定节� + F4/F5 三档调速 + 背压�试）。历�上讨论过的「整� gate + 编�器�默确认 flush�方案**当�代�未采用**，�在本文范围。
 
 ---
 
diff --git a/lib/data/services/ble_manager.dart b/lib/data/services/ble_manager.dart
index 40e6f6ebe..fe3cc8f45 100644
--- a/lib/data/services/ble_manager.dart
+++ b/lib/data/services/ble_manager.dart
@@ -1249,18 +1249,24 @@ class BleManager extends GetxService {
 
   /// 设置通�翻译调试�数（�行时生效）
   /// [sendIntervalMs] 音频下行��间隔(ms)
-  /// [bundleFrameCount] �包�声�的 opus 帧数(1..6)，包长 = 2*帧数*40B
+  /// [bundleFrameCount] �包�声�的 opus 帧数，包长 = 2*帧数*�帧字节
   /// [continuousSend] 是��续���音（无译音时也��音频��断）
+  /// [downlinkBitrateKbps] 下行 opus �率(kbps)：�帧字节 = �率×20ms÷8（16k→40B / 8k→20B）
+  /// [uplinkBitrateKbps] 上行 opus �率(kbps)，必须与固件实际编��率一致
   Future<bool> setCallTranslationDebugParams({
     int? sendIntervalMs,
     int? bundleFrameCount,
     bool? continuousSend,
+    int? downlinkBitrateKbps,
+    int? uplinkBitrateKbps,
   }) async {
     try {
       return await _bleService.setCallTranslationDebugParams(
         sendIntervalMs: sendIntervalMs,
         bundleFrameCount: bundleFrameCount,
         continuousSend: continuousSend,
+        downlinkBitrateKbps: downlinkBitrateKbps,
+        uplinkBitrateKbps: uplinkBitrateKbps,
       );
     } catch (e) {
       Logger.e('CALL_TRANS_DEBUG', '设置通�翻译调试�数失败: ${e.toString()}');
@@ -1269,7 +1275,8 @@ class BleManager extends GetxService {
   }
 
   /// 获�当�通�翻译调试�数
-  /// {'sendIntervalMs': int, 'bundleFrameCount': int, 'continuousSend': bool}
+  /// {'sendIntervalMs','bundleFrameCount','continuousSend','downlinkBitrateKbps',
+  ///  'uplinkBitrateKbps','downlinkFrameBytes','uplinkFrameBytes','maxBundleFrameCount','packetSizeBytes'}
   Future<Map<String, dynamic>> getCallTranslationDebugParams() async {
     try {
       return await _bleService.getCallTranslationDebugParams();
diff --git a/lib/modules/call_translation_debug/controllers/call_translation_debug_controller.dart b/lib/modules/call_translation_debug/controllers/call_translation_debug_controller.dart
index 32fe6d9ac..64d1390dd 100644
--- a/lib/modules/call_translation_debug/controllers/call_translation_debug_controller.dart
+++ b/lib/modules/call_translation_debug/controllers/call_translation_debug_controller.dart
@@ -5,11 +5,12 @@ import '../../../data/services/ble_manager.dart';
 import '../../../core/utils/logger.dart';
 
 /// 通�翻译调试控制器
-/// 负责调试�数（音频下行��间隔��声��包帧数�是��续��）的读���存�下�，
+/// 负责调试�数（上/下行 opus �率�音频下行��间隔��声��包帧数�是��续��）的读���存�下�，
 /// 以�通�翻译编解�的�动/�止。
 ///
-/// 下行包为无包头�左�帧级交替格�：[L0 40B][R0 40B]...[L(n-1)][R(n-1)]，包长 = 2*n*40B。
-/// �帧 opus 承载 20ms 音频，故「间隔 == 帧数 × 20ms�时下�速率与实时语速 1:1。
+/// 下行包为无包头�左�帧级交替格�：[L0][R0]...[L(n-1)][R(n-1)]，包长 = 2 × n × �帧字节。
+/// **�帧字节�是常�**，由�率决定：`�帧字节 = �率kbps × 20ms ÷ 8`（16k→40B / 8k→20B / 24k→60B）。
+/// �帧 opus �承载 20ms 音频，故「间隔 == 帧数 × 20ms�时下�速率与实时语速 1:1（与�率无关）。
 class CallTranslationDebugController extends GetxController {
   final BleManager _bleManager = Get.find<BleManager>();
   final GetStorage _storage = GetStorage();
@@ -18,22 +19,33 @@ class CallTranslationDebugController extends GetxController {
   static const String _kSendInterval = 'call_trans_debug_send_interval';
   static const String _kBundleFrameCount = 'call_trans_debug_bundle_frames';
   static const String _kContinuousSend = 'call_trans_debug_continuous_send';
+  static const String _kDownlinkBitrate = 'call_trans_debug_downlink_bitrate';
+  static const String _kUplinkBitrate = 'call_trans_debug_uplink_bitrate';
 
-  // �帧 opus 承载的音频时长(ms)，用于推算与实时语速匹�的��间隔
+  // �帧 opus 承载的音频时长(ms)：固定 20ms，与�率无关
   static const int frameDurationMs = 20;
 
-  // 默认值（与原生默认��一致：2 帧/声� + 40ms 一� = 实时 1:1）
+  // �次 BLE 写的净�上�（MTU 517 → 514B）。一�的数�超过它时，原生会按 2×帧长 对�
+  // 拆�多个 BLE 写连续�出，故帧数上��� MTU 约�。这里仅用于界��示拆分数。
+  static const int bleWriteLimitBytes = 514;
+
+  // 默认值（与原生默认��一致：16kbps(40B/帧) + 2 帧/声� + 40ms 一� = 实时 1:1）
   static const int defaultSendIntervalMs = 40;
   static const int defaultBundleFrameCount = 2;
   static const bool defaultContinuousSend = false;
+  static const int defaultBitrateKbps = 16;
 
   // �值范围
-  static const int minSendIntervalMs = 20;
-  static const int maxSendIntervalMs = 1000;
-  static const int sendIntervalStepMs = 20; // 音频下行间隔步长 20ms
+  static const int minSendIntervalMs = 5;
+  static const int maxSendIntervalMs = 200;
+  static const int sendIntervalStepMs = 5; // 音频下行间隔步长 5ms
   static const int minBundleFrameCount = 1;
-  // 包长 2*n*40B 必须塞得进一次 BLE 写（MTU 517 → �写 514B），6 帧=480B 是安全上�
-  static const int maxBundleFrameCount = 6;
+  static const int maxBundleFrameCount = 20;
+  // �选�率档�（kbps）：�档对应的�帧字节 = 档� × 2.5
+  static const List<int> bitrateOptions = [8, 16, 24, 32];
+
+  /// �率(kbps) → �帧 opus 字节数（与原生 bitrateToFrameBytes 一致）
+  static int frameBytesOf(int bitrateKbps) => bitrateKbps * frameDurationMs ~/ 8;
 
   /// 音频下行��间隔(ms)
   final RxInt sendIntervalMs = defaultSendIntervalMs.obs;
@@ -44,8 +56,30 @@ class CallTranslationDebugController extends GetxController {
   /// 是��续��音频（无译音时也按�下�全�音包，��设备侧音频��断）
   final RxBool continuousSend = defaultContinuousSend.obs;
 
-  /// 当��置下的下行包长(字节)：左�交替��声� n 帧��帧 40B
-  int get packetSizeBytes => 2 * bundleFrameCount.value * 40;
+  /// 下行(APP→设备) opus �率(kbps)
+  final RxInt downlinkBitrateKbps = defaultBitrateKbps.obs;
+
+  /// 上行(设备→APP) opus �率(kbps)——必须与固件实际编��率一致
+  final RxInt uplinkBitrateKbps = defaultBitrateKbps.obs;
+
+  /// 当�下行�帧字节数（由下行�率推导）
+  int get downlinkFrameBytes => frameBytesOf(downlinkBitrateKbps.value);
+
+  /// 当�上行�帧字节数（由上行�率推导）
+  int get uplinkFrameBytes => frameBytesOf(uplinkBitrateKbps.value);
+
+  /// 一���的总字节数：左�交替��声� n 帧
+  int get packetSizeBytes => 2 * bundleFrameCount.value * downlinkFrameBytes;
+
+  /// 一次 BLE 写最多能装几帧/声�（净�上� ÷ 2×�帧字节）
+  int get framesPerWrite =>
+      (bleWriteLimitBytes ~/ (2 * downlinkFrameBytes)).clamp(1, maxBundleFrameCount);
+
+  /// 一�会被拆�几个 BLE 写：超过�次写上�时原生按 2×帧长 对�自动拆分
+  int get writesPerTick {
+    final perWrite = framesPerWrite;
+    return (bundleFrameCount.value + perWrite - 1) ~/ perWrite;
+  }
 
   /// 与实时语速 1:1 匹�的��间隔(ms) = 帧数 × 20ms；供界��示用
   int get realtimeIntervalMs => bundleFrameCount.value * frameDurationMs;
@@ -66,6 +100,16 @@ class CallTranslationDebugController extends GetxController {
 
   /// 从本地存储加载�数
   void _loadFromStorage() {
+    // �率�先加载：帧数上��赖它推出的�帧字节数
+    final savedDownBitrate = _storage.read<int>(_kDownlinkBitrate);
+    final savedUpBitrate = _storage.read<int>(_kUplinkBitrate);
+    if (savedDownBitrate != null && bitrateOptions.contains(savedDownBitrate)) {
+      downlinkBitrateKbps.value = savedDownBitrate;
+    }
+    if (savedUpBitrate != null && bitrateOptions.contains(savedUpBitrate)) {
+      uplinkBitrateKbps.value = savedUpBitrate;
+    }
+
     final savedInterval = _storage.read<int>(_kSendInterval);
     final savedFrames = _storage.read<int>(_kBundleFrameCount);
     final savedContinuous = _storage.read<bool>(_kContinuousSend);
@@ -87,6 +131,19 @@ class CallTranslationDebugController extends GetxController {
     try {
       final params = await _bleManager.getCallTranslationDebugParams();
       if (params.isEmpty) return;
+      // �样先�步�率，��步�赖它的帧数
+      if (_storage.read<int>(_kDownlinkBitrate) == null) {
+        final nb = params['downlinkBitrateKbps'] as int?;
+        if (nb != null && bitrateOptions.contains(nb)) {
+          downlinkBitrateKbps.value = nb;
+        }
+      }
+      if (_storage.read<int>(_kUplinkBitrate) == null) {
+        final nb = params['uplinkBitrateKbps'] as int?;
+        if (nb != null && bitrateOptions.contains(nb)) {
+          uplinkBitrateKbps.value = nb;
+        }
+      }
       if (_storage.read<int>(_kSendInterval) == null) {
         final ni = params['sendIntervalMs'] as int?;
         if (ni != null && ni > 0) {
@@ -123,8 +180,24 @@ class CallTranslationDebugController extends GetxController {
     continuousSend.value = value;
   }
 
+  /// 设置下行�率：帧长�之�化，帧数上�也会�，需把当�帧数夹回新的�法区间
+  void setDownlinkBitrate(int kbps) {
+    if (!bitrateOptions.contains(kbps)) return;
+    downlinkBitrateKbps.value = kbps;
+    bundleFrameCount.value =
+        bundleFrameCount.value.clamp(minBundleFrameCount, maxBundleFrameCount);
+  }
+
+  /// 设置上行�率（必须与固件实际编��率一致，�则上行收包校验与解�切分都会错）
+  void setUplinkBitrate(int kbps) {
+    if (!bitrateOptions.contains(kbps)) return;
+    uplinkBitrateKbps.value = kbps;
+  }
+
   /// ��默认值
   void resetDefaults() {
+    downlinkBitrateKbps.value = defaultBitrateKbps;
+    uplinkBitrateKbps.value = defaultBitrateKbps;
     sendIntervalMs.value = defaultSendIntervalMs;
     bundleFrameCount.value = defaultBundleFrameCount;
     continuousSend.value = defaultContinuousSend;
@@ -135,13 +208,19 @@ class CallTranslationDebugController extends GetxController {
     _storage.write(_kSendInterval, sendIntervalMs.value);
     _storage.write(_kBundleFrameCount, bundleFrameCount.value);
     _storage.write(_kContinuousSend, continuousSend.value);
+    _storage.write(_kDownlinkBitrate, downlinkBitrateKbps.value);
+    _storage.write(_kUplinkBitrate, uplinkBitrateKbps.value);
     final ok = await _bleManager.setCallTranslationDebugParams(
       sendIntervalMs: sendIntervalMs.value,
       bundleFrameCount: bundleFrameCount.value,
       continuousSend: continuousSend.value,
+      downlinkBitrateKbps: downlinkBitrateKbps.value,
+      uplinkBitrateKbps: uplinkBitrateKbps.value,
     );
     Logger.i('CALL_TRANS_DEBUG',
-        '下�调试�数 interval=${sendIntervalMs.value}ms frames=${bundleFrameCount.value}/声� '
+        '下�调试�数 下行=${downlinkBitrateKbps.value}kbps(${downlinkFrameBytes}B/帧) '
+        '上行=${uplinkBitrateKbps.value}kbps(${uplinkFrameBytes}B/帧) '
+        'interval=${sendIntervalMs.value}ms frames=${bundleFrameCount.value}/声� '
         '包长=${packetSizeBytes}B �续��=${continuousSend.value} result=$ok');
     Get.snackbar(
       '通�翻译调试',
diff --git a/lib/modules/call_translation_debug/views/call_translation_debug_view.dart b/lib/modules/call_translation_debug/views/call_translation_debug_view.dart
index a22f974f9..1998d0516 100644
--- a/lib/modules/call_translation_debug/views/call_translation_debug_view.dart
+++ b/lib/modules/call_translation_debug/views/call_translation_debug_view.dart
@@ -33,6 +33,8 @@ class CallTranslationDebugView
         children: [
           _buildStatusCard(isDark),
           SizedBox(height: 16.h),
+          _buildBitrateCard(isDark),
+          SizedBox(height: 16.h),
           _buildSendIntervalCard(isDark),
           SizedBox(height: 16.h),
           _buildBundleFrameCard(isDark),
@@ -153,61 +155,134 @@ class CallTranslationDebugView
     );
   }
 
+  // 上/下行 opus �率（决定�帧字节数）
+  Widget _buildBitrateCard(bool isDark) {
+    return _card(
+      isDark,
+      child: Column(
+        crossAxisAlignment: CrossAxisAlignment.start,
+        children: [
+          _title(isDark, 'Opus �率',
+              '决定�帧字节数：�帧字节 = �率 × 20ms ÷ 8（16k→40B / 8k→20B / 24k→60B）。上行�率必须与固件实际编��率一致，�则收包会被判为�包'),
+          SizedBox(height: 12.h),
+          Obx(() => _bitrateRow(
+                isDark,
+                '下行 (APP→设备)',
+                controller.downlinkBitrateKbps.value,
+                controller.downlinkFrameBytes,
+                controller.setDownlinkBitrate,
+              )),
+          SizedBox(height: 10.h),
+          Obx(() => _bitrateRow(
+                isDark,
+                '上行 (设备→APP)',
+                controller.uplinkBitrateKbps.value,
+                controller.uplinkFrameBytes,
+                controller.setUplinkBitrate,
+              )),
+        ],
+      ),
+    );
+  }
+
+  Widget _bitrateRow(bool isDark, String label, int current, int frameBytes,
+      void Function(int) onSelect) {
+    return Row(
+      children: [
+        SizedBox(
+          width: 96.w,
+          child: Text(
+            label,
+            style: TextStyle(
+              fontSize: 12.sp,
+              color: isDark ? Colors.white70 : Colors.black87,
+            ),
+          ),
+        ),
+        Expanded(
+          child: Wrap(
+            spacing: 6.w,
+            children: CallTranslationDebugController.bitrateOptions.map((kbps) {
+              final selected = kbps == current;
+              return ChoiceChip(
+                label: Text('$kbps k', style: TextStyle(fontSize: 11.sp)),
+                selected: selected,
+                onSelected: (_) => onSelect(kbps),
+              );
+            }).toList(),
+          ),
+        ),
+        _valueChip(isDark, '$frameBytes B/帧'),
+      ],
+    );
+  }
+
   // �包�声�帧数
   Widget _buildBundleFrameCard(bool isDark) {
+    const minFrames = CallTranslationDebugController.minBundleFrameCount;
+    const maxFrames = CallTranslationDebugController.maxBundleFrameCount;
     return _card(
       isDark,
       child: Column(
         crossAxisAlignment: CrossAxisAlignment.start,
         children: [
           _title(isDark, '�声��包帧数',
-              '一包里左�声��放多少帧 opus，按 左/�/左/� 交替写入�无包头（${CallTranslationDebugController.minBundleFrameCount}~${CallTranslationDebugController.maxBundleFrameCount} 帧）'),
+              '一�里左�声��放多少帧 opus，按 左/�/左/� 交替写入�无包头（$minFrames~$maxFrames 帧）。'
+              '超过�次 BLE 写上�时会自动按「左�一对�对�拆�多个写，设备侧解���影�'),
           SizedBox(height: 8.h),
-          Obx(
-            () => Row(
+          Obx(() {
+            // 显�读��赖的 Rx，确��率�化时本��建
+            final frames = controller.bundleFrameCount.value;
+            return Row(
               children: [
                 Expanded(
                   child: Slider(
-                    value: controller.bundleFrameCount.value
-                        .clamp(
-                          CallTranslationDebugController.minBundleFrameCount,
-                          CallTranslationDebugController.maxBundleFrameCount,
-                        )
-                        .toDouble(),
-                    min: CallTranslationDebugController.minBundleFrameCount
-                        .toDouble(),
-                    max: CallTranslationDebugController.maxBundleFrameCount
-                        .toDouble(),
-                    divisions:
-                        CallTranslationDebugController.maxBundleFrameCount -
-                            CallTranslationDebugController.minBundleFrameCount,
-                    label: '${controller.bundleFrameCount.value} 帧',
-                    onChanged: (v) =>
-                        controller.setBundleFrameCount(v.round()),
+                    value: frames.clamp(minFrames, maxFrames).toDouble(),
+                    min: minFrames.toDouble(),
+                    max: maxFrames.toDouble(),
+                    divisions: maxFrames - minFrames,
+                    label: '$frames 帧',
+                    onChanged: (v) => controller.setBundleFrameCount(v.round()),
                   ),
                 ),
-                _valueChip(isDark, '${controller.bundleFrameCount.value} 帧'),
+                _valueChip(isDark, '$frames 帧'),
               ],
-            ),
-          ),
+            );
+          }),
           SizedBox(height: 4.h),
-          // 包长与实时节��示：�帧 20ms，间隔 == 帧数×20ms 时下�速率与语速 1:1
-          Obx(
-            () => Text(
-              '包长 ${controller.packetSizeBytes} 字节（左�� ${controller.bundleFrameCount.value} 帧 × 40B）'
-              '，与实时语速匹�的间隔为 ${controller.realtimeIntervalMs} ms'
-              '${controller.sendIntervalMs.value == controller.realtimeIntervalMs ? '（当�已匹�）' : '（当� ${controller.sendIntervalMs.value} ms，'
-                  '${controller.sendIntervalMs.value > controller.realtimeIntervalMs ? '�慢，音频会积压' : '�快，会超�'}）'}',
+          // 包长与实时节��示：�帧� 20ms（与�率无关），间隔 == 帧数×20ms 时下�速率与语速 1:1
+          Obx(() {
+            // 显�读�三个 Rx：�率� → 帧长� → 包长�，缺一个订阅这里就�会刷新
+            final frames = controller.bundleFrameCount.value;
+            final bitrate = controller.downlinkBitrateKbps.value;
+            final interval = controller.sendIntervalMs.value;
+            final frameBytes =
+                CallTranslationDebugController.frameBytesOf(bitrate);
+            final totalBytes = 2 * frames * frameBytes;
+            final writes = controller.writesPerTick;
+            final realtime =
+                frames * CallTranslationDebugController.frameDurationMs;
+            final matched = interval == realtime;
+
+            final splitText = writes > 1
+                ? '，超出�次 BLE 写上� → 拆 $writes 个写（�写 ${controller.framesPerWrite} 帧）'
+                : '';
+            final paceText = matched
+                ? '（当�已匹�）'
+                : '（当� $interval ms，${interval > realtime ? '�慢，音频会积压' : '�快，会超�'}）';
+
+            return Text(
+              '一� $totalBytes 字节（左�� $frames 帧 × $frameBytes B）$splitText\n'
+              '与实时语速匹�的间隔为 $realtime ms $paceText',
               style: TextStyle(
                 fontSize: 11.sp,
-                color: controller.sendIntervalMs.value ==
-                        controller.realtimeIntervalMs
+                color: matched
                     ? (isDark ? Colors.white38 : Colors.black38)
                     : Colors.orange,
-                height: 1.3,
+                height: 1.4,
               ),
-            ),
-          ),
+            );
+          }),
         ],
       ),
     );
diff --git a/local_plugins/ble_service/android/src/main/kotlin/com/yunqiinnovation/ble_service/BleService.kt b/local_plugins/ble_service/android/src/main/kotlin/com/yunqiinnovation/ble_service/BleService.kt
index 999d30548..54dad8aa4 100644
--- a/local_plugins/ble_service/android/src/main/kotlin/com/yunqiinnovation/ble_service/BleService.kt
+++ b/local_plugins/ble_service/android/src/main/kotlin/com/yunqiinnovation/ble_service/BleService.kt
@@ -206,16 +206,36 @@ object BleService {
     // 声�缓存安全上�（纯防 OOM 兜底）：缓存元素是�帧 opus，超�丢最旧帧并告警。
     private const val CHANNEL_HOLD_BUFFER_MAX = 10000
 
+    // ---- Opus �率与帧长（上下行�自��，切勿写死字节数） ----
+    // opus 帧时长固定 20ms；CBR 下 �帧字节数 = �率(kbps) × 20ms ÷ 8：
+    //   16kbps → 40B(默认) / 8kbps → 20B / 24kbps → 60B / 32kbps → 80B
+    // 帧长是��：��或调试页改�率�帧长�之�化，所有组包/校验/补�都必须引用下�两个字段。
+    private const val OPUS_FRAME_DURATION_MS = 20
+    private const val DEFAULT_OPUS_BITRATE_KBPS = 16
+    private const val MIN_OPUS_BITRATE_KBPS = 6
+    private const val MAX_OPUS_BITRATE_KBPS = 64
+    // 下行(APP→设备)�帧 opus 字节数。编�器 packetSize 在 startEncodeStream 时固化，
+    // 故改它必须��编��并�建�音模�(� applyDownlinkBitrate)。
+    @Volatile
+    private var downlinkFrameBytes = bitrateToFrameBytes(DEFAULT_OPUS_BITRATE_KBPS)
+    // 上行(设备→APP)�帧 opus 字节数：用于收包长度校验；解�器 packetSize = 2×它(立体声一�元�左��一帧)。
+    @Volatile
+    private var uplinkFrameBytes = bitrateToFrameBytes(DEFAULT_OPUS_BITRATE_KBPS)
+
     // ---- 下行�包：左�交替�无包头 ----
-    // �帧 opus 固定长度(编�器 CBR packetSize=40B)。无包头�议�固定帧长切分，长度必须严格�定，
-    // �则设备侧整包错� —— 故入队�校验帧长，� 40B 一律丢弃。
-    private const val OPUS_FRAME_BYTES = 40
+    // 无包头�议�固定帧长切分，帧长必须严格�定，�则设备侧整包错� —— 故入队�校验帧长，
+    // 长度�等于当� downlinkFrameBytes 的帧一律丢弃。
     // �包�声�的 opus 帧数(默认2，调试界��调 1..MAX_BUNDLE_FRAME_COUNT)。
-    // 组包布局(无包头)：[L0 40B][R0 40B][L1 40B][R1 40B]...[L(n-1)][R(n-1)]，包长�为 2*n*40B。
+    // 组包布局(无包头)：[L0][R0][L1][R1]...[L(n-1)][R(n-1)]，�帧 downlinkFrameBytes 字节，
+    // 一�的总字节 = 2*n*downlinkFrameBytes（默认 2×2×40 = 160B）。
     @Volatile
     private var bundleFrameCount = 2
-    // �包帧数上�：包长 2*n*40 必须塞得进一次 BLE 写(MTU 517 → �写 514B)，6 帧=480B 已是安全上�。
-    private const val MAX_BUNDLE_FRAME_COUNT = 6
+    // �声�帧数上�。�� MTU 约�：一�的数�若超过�次 BLE 写上�(MTU-3)，会按 2×帧长对�
+    // 拆�多个 BLE 写连续�出(� trySendMixedChunk)。�个分片�是 2×帧长的整数��左�交替顺���，
+    // 故设备侧无论按包解�还是按�解�都正确。
+    private const val MAX_BUNDLE_FRAME_COUNT = 20
+    // MTU 尚未�商时(currentMtu 还是默认 23)�次 BLE 写的�守字节上�，��用 23-3=20 算出�谬的分片数
+    private const val FALLBACK_BLE_WRITE_BYTES = 480
     // �续��开关：为 true 时�使左�队列都空也按��全�音包，��设备侧音频��断�；
     // 为 false 时两侧皆空则跳过该���（默认，�链路�用）。
     @Volatile
@@ -363,9 +383,10 @@ object BleService {
 
             override fun onSilenceFrameReady(frame: ByteArray) {
                 // 缓存�音帧模�，用于�包时�足帧补�。
-                // 无包头�议按固定 40B 切分，模�长度�对会让整包左�对�全错，故�接��好 OPUS_FRAME_BYTES 的模�
-                if (frame.size != OPUS_FRAME_BYTES) {
-                    CallLog.w(TAG, "�音帧模�长度异常 size=${frame.size}B (期望 ${OPUS_FRAME_BYTES}B)，拒�采用")
+                // 无包头�议按固定帧长切分，模�长度�对会让整包左�对�全错，
+                // 故�接�长度�好等于当� downlinkFrameBytes 的模�（改�率�编�器会�新生�新长度的模�）
+                if (frame.size != downlinkFrameBytes) {
+                    CallLog.w(TAG, "�音帧模�长度异常 size=${frame.size}B (期望 ${downlinkFrameBytes}B)，拒�采用")
                     return
                 }
                 silenceFrame = frame
@@ -1443,16 +1464,16 @@ object BleService {
     }
 
     /**
-     * 上行音频收包长度�护：普通� opus 帧=40B；通��(8kbps/60ms)立体声一帧=120B=2×60B。
-     * 两��共用此校验，故按其公约数 40 判：40 与 120 �为 40 的整数�，�法包应是 40 的整数�且�空。
-     * 注���改� % 60——那会把普通�声��(40B)误判为�包。
-     * � 40 整数�或空包视为异常(�包/字节�错�)，返回 false —— 调用方�此直接丢弃�
+     * 上行音频收包长度�护：�法包应是「当�上行�帧字节数�的整数�且�空。
+     * 帧长�上行�率�化(16kbps→40B / 8kbps→20B)，故按 uplinkFrameBytes 判，�能写死 40。
+     * �整数�或空包视为异常(�包/字节�错�)，返回 false —— 调用方�此直接丢弃�
      * 且�计入接收统计��喂解�器；���包喂进定长��解�器把�续整段字节��错��全部解错。
      * @return true=长度�法�继续处�；false=异常包(已打�告警)，应丢弃
      */
     private fun isValidUplinkAudioLen(data: ByteArray): Boolean {
-        if (data.isNotEmpty() && data.size % 40 == 0) return true
-        CallLog.w(TAG, "上行收到异常长度音频包，已丢弃: size=${data.size}B (� opus 帧长 40B 整数�)")
+        val frameBytes = uplinkFrameBytes
+        if (data.isNotEmpty() && data.size % frameBytes == 0) return true
+        CallLog.w(TAG, "上行收到异常长度音频包，已丢弃: size=${data.size}B (�上行帧长 ${frameBytes}B 整数�)")
         return false
     }
 
@@ -1503,14 +1524,35 @@ object BleService {
     // Opus 编�相关 - 委托给OpusAudioManager
     // ======================================================================================================
 
+    /**
+     * �率(kbps) → �帧 opus 字节数。CBR + 固定 20ms 帧：字节 = kbps × 1000 × 0.02 ÷ 8 = kbps × 20 ÷ 8。
+     * 16→40B / 8→20B / 24→60B / 32→80B
+     */
+    private fun bitrateToFrameBytes(bitrateKbps: Int): Int =
+        bitrateKbps.coerceIn(MIN_OPUS_BITRATE_KBPS, MAX_OPUS_BITRATE_KBPS) * OPUS_FRAME_DURATION_MS / 8
+
+    /** �帧字节数 → �率(kbps)，仅用于日志与�数回读 */
+    private fun frameBytesToBitrate(frameBytes: Int): Int = frameBytes * 8 / OPUS_FRAME_DURATION_MS
+
+    /**
+     * 一次 BLE 写最多能装几帧/声�：净�上�(MTU-3) ÷ (2 × 帧长)。
+     * 一���的帧数超过它时按此拆分�多个写（�个分片� 2×帧长 对�，设备侧解���影�）。
+     * MTU 未�商时用 FALLBACK_BLE_WRITE_BYTES，��用默认 MTU(23) 算出 0 帧。
+     */
+    private fun maxFramesPerWrite(frameBytes: Int): Int {
+        val writeLimit = if (currentMtu > 23) currentMtu - 3 else FALLBACK_BLE_WRITE_BYTES
+        return (writeLimit / (2 * frameBytes)).coerceAtLeast(1)
+    }
+
     /**
      * 开始Opus数��编�（通�翻译模�：左�声�独立编�）
-     * 输出下行包格�(无包头，左�交替)：[L0 40B][R0 40B]...[L(n-1)][R(n-1)]，n=bundleFrameCount(默认2 → 160B)
+     * 输出下行包格�(无包头，左�交替)：[L0][R0]...[L(n-1)][R(n-1)]，�帧 downlinkFrameBytes 字节，
+     * n=bundleFrameCount（默认 2 帧 × 40B → 160B/包）
      * @return 是��功开始编�
      */
     private fun startOpusEncodeStream(): Boolean {
         startAudioSendThread()
-        return opusAudioManager.startDualEncodeStream(false, 16000, OPUS_FRAME_BYTES)
+        return opusAudioManager.startDualEncodeStream(false, 16000, downlinkFrameBytes)
     }
 
     /**
@@ -1530,14 +1572,14 @@ object BleService {
      * �连窗�内�丢弃：继续入队暂存，回连�功�续�；仅超 OOM 兜底上��丢最旧帧。
      *
      * 无包头�议下设备侧按固定 40B 切分左�声�，任何一帧长度异常都会让整包�之�的声�对�全错，
-     * 故� OPUS_FRAME_BYTES 的帧在入队处直接拦掉，��队列里的帧长�定。
+     * 故长度�等于当� downlinkFrameBytes 的帧在入队处直接拦掉，��队列里的帧长�定。
      * @param channelPrefix 声�标识(CHANNEL_LEFT=0 / CHANNEL_RIGHT=1)
      * @param frame 一帧 opus 编�数�
      */
     private fun enqueueOpusFrame(channelPrefix: Byte, frame: ByteArray) {
         if (frame.isEmpty()) return
-        if (frame.size != OPUS_FRAME_BYTES) {
-            CallLog.w(TAG, "丢弃异常长度 opus 帧 ch=$channelPrefix size=${frame.size}B (期望 ${OPUS_FRAME_BYTES}B)")
+        if (frame.size != downlinkFrameBytes) {
+            CallLog.w(TAG, "丢弃异常长度 opus 帧 ch=$channelPrefix size=${frame.size}B (期望 ${downlinkFrameBytes}B)")
             return
         }
         val buffer = when (channelPrefix) {
@@ -1566,7 +1608,9 @@ object BleService {
         audioSendThread = createAudioSendThread().apply { start() }
         val n = bundleFrameCount.coerceIn(1, MAX_BUNDLE_FRAME_COUNT)
         CallLog.i(TAG, "音频��线程已�动(左��包/无包头) 间隔=${audioSendIntervalNormal}ms " +
-                "帧数=$n/声� 包长=${2 * n * OPUS_FRAME_BYTES}B �续��=$continuousSendEnabled")
+                "帧数=$n/声� 帧长=${downlinkFrameBytes}B(${frameBytesToBitrate(downlinkFrameBytes)}kbps) " +
+                "一�=${2 * n * downlinkFrameBytes}B �写上�=${maxFramesPerWrite(downlinkFrameBytes)}帧 " +
+                "�续��=$continuousSendEnabled")
     }
 
     /**
@@ -1622,14 +1666,18 @@ object BleService {
         // 两路皆空且未开�续��：本���
         if (!hasRealAudio && !continuousSendEnabled) return false
 
-        // 无包头�议�固定帧长切分，缺帧必须补�音�能��包长�定；模�未就绪则本�放弃，帧退回队列�丢
+        // 帧长在本�内�一次快照：改�率是异步的，中途�化会让�一包里的帧长�一致(整包错�)
+        val frameBytes = downlinkFrameBytes
+        // 无包头�议�固定帧长切分，缺帧必须补�音�能��包长�定；模�未就绪(或长度与当��率�匹�)
+        // 则本�放弃，帧退回队列�丢
         val silence = silenceFrame
-        if (silence == null) {
+        if (silence == null || silence.size != frameBytes) {
             for (i in leftFrames.indices.reversed()) leftSendBuffer.offerFirst(leftFrames[i])
             for (i in rightFrames.indices.reversed()) rightSendBuffer.offerFirst(rightFrames[i])
             silenceNotReadyCount++
             if (silenceNotReadyCount == 1 || silenceNotReadyCount % 50 == 0) {
-                CallLog.w(TAG, "�音帧模�未就绪，暂缓下�(累计 $silenceNotReadyCount �)，译音已退回队列�丢")
+                CallLog.w(TAG, "�音帧模�未就绪(或与当�帧长 ${frameBytes}B �匹�)，暂缓下�" +
+                        "(累计 $silenceNotReadyCount �)，译音已退回队列�丢")
             }
             return false
         }
@@ -1637,44 +1685,63 @@ object BleService {
 
         val padLeft = n - leftFrames.size
         val padRight = n - rightFrames.size
-        val packet = buildInterleavedPacket(n, leftFrames, rightFrames, silence)
 
-        // �步写入，拿到真实的�功/失败：false=底层��缓冲已满(拥塞)，作为背压信�
-        val sent = sendAudioChunkBlocking(packet)
-        if (!sent) {
-            // 写失败：真实帧按原顺�退回�自队头(倒� offerFirst)，下一��组�试；�音补�帧丢弃
-            for (i in leftFrames.indices.reversed()) leftSendBuffer.offerFirst(leftFrames[i])
-            for (i in rightFrames.indices.reversed()) rightSendBuffer.offerFirst(rightFrames[i])
+        // 一�的数�(2×n×帧长)�能超过�次 BLE 写的净�上�(MTU-3)，按 2×帧长 对�拆�多个写连续�出。
+        // �个分片�是 2×帧长的整数��左�交替顺��� → 设备侧按包或按�解�都正确。
+        val framesPerWrite = maxFramesPerWrite(frameBytes).coerceAtMost(n)
+        var sentFrames = 0
+        var sentBytes = 0
+        var writeCount = 0
+        var congested = false
+        while (sentFrames < n) {
+            val chunkFrames = minOf(framesPerWrite, n - sentFrames)
+            val packet = buildInterleavedPacket(sentFrames, chunkFrames, frameBytes, leftFrames, rightFrames, silence)
+            // �步写入，拿到真实的�功/失败：false=底层��缓冲已满(拥塞)，作为背压信�
+            if (!sendAudioChunkBlocking(packet)) {
+                congested = true
+                break
+            }
+            sentFrames += chunkFrames
+            sentBytes += packet.size
+            writeCount++
+        }
+
+        if (congested) {
+            // 拥塞：把**尚未�出**的真实帧按原顺�退回�自队头，下一��组�试；�音补�帧丢弃。
+            // 已�出的分片无法撤回，但它们自身 2×帧长 对��顺�正确，设备侧字节��会错�；
+            // 剩余帧下一�继续�，音频�连续。
+            for (i in (leftFrames.size - 1) downTo sentFrames) leftSendBuffer.offerFirst(leftFrames[i])
+            for (i in (rightFrames.size - 1) downTo sentFrames) rightSendBuffer.offerFirst(rightFrames[i])
             writeFailRetryCount++
             if (writeFailRetryCount == 1 || writeFailRetryCount % 50 == 0) {
                 CallLog.w(TAG, "下行写入拥塞，�试中 seq=$packetSeq 连续失败=$writeFailRetryCount " +
-                        "buf(L=${leftSendBuffer.size},R=${rightSendBuffer.size})")
+                        "已�=${sentFrames}/${n}帧 buf(L=${leftSendBuffer.size},R=${rightSendBuffer.size})")
             }
-            return false
-        }
-        if (writeFailRetryCount > 0) {
+            if (sentFrames == 0) return false
+        } else if (writeFailRetryCount > 0) {
             CallLog.i(TAG, "下行写入已��，之�连续失败=$writeFailRetryCount")
             writeFailRetryCount = 0
         }
         val seq = packetSeq++
 
-        // 调试录音：按声��自�地(真实帧+�音补�，与该路实际下�内容一致，�辨��音)
-        recordfile1Left?.saveAudioDataToWav(padToFrames(n, leftFrames, silence))
-        recordfile1Right?.saveAudioDataToWav(padToFrames(n, rightFrames, silence))
+        // 调试录音：按声��自�地已实际�出的帧(真实帧+�音补�，与下�内容一致，�辨��音)
+        recordfile1Left?.saveAudioDataToWav(padToFrames(sentFrames, frameBytes, leftFrames, silence))
+        recordfile1Right?.saveAudioDataToWav(padToFrames(sentFrames, frameBytes, rightFrames, silence))
 
         // ��节�统计与包�日志；�续��的纯�音包按 25 �节�，��刷�
         val now = System.currentTimeMillis()
         val deltaMs = if (lastAudioSendTime < 0) 0 else now - lastAudioSendTime
         lastAudioSendTime = now
+        val splitTag = if (writeCount > 1) " 拆$writeCount 写" else ""
         if (hasRealAudio) {
             silentPacketCount = 0
             CallLog.i(TAG, "音频下行�� seq=$seq Δ=${deltaMs}ms L=${leftFrames.size}+�音$padLeft " +
-                    "R=${rightFrames.size}+�音$padRight size=${packet.size}B " +
+                    "R=${rightFrames.size}+�音$padRight 帧=${sentFrames}/${n} size=${sentBytes}B$splitTag " +
                     "buf(L=${leftSendBuffer.size},R=${rightSendBuffer.size})")
         } else {
             silentPacketCount++
             if (silentPacketCount % 25 == 1) {
-                CallLog.i(TAG, "音频下行�续��(全�音) seq=$seq Δ=${deltaMs}ms size=${packet.size}B 累计=$silentPacketCount 包")
+                CallLog.i(TAG, "音频下行�续��(全�音) seq=$seq Δ=${deltaMs}ms size=${sentBytes}B$splitTag 累计=$silentPacketCount 包")
             }
         }
 
@@ -1689,33 +1756,40 @@ object BleService {
     }
 
     /**
-     * 组下行包(无包头，左�帧级交替)：[L0][R0][L1][R1]...[L(n-1)][R(n-1)]
-     * �帧�为 OPUS_FRAME_BYTES 字节，包长�为 2*n*OPUS_FRAME_BYTES；�侧该�缺帧则填�音帧，��左�严格对�。
+     * 组下行分片(无包头，左�帧级交替)：�第 startFrame 起的 count 帧，拼�
+     * [L(s)][R(s)][L(s+1)][R(s+1)]...，�帧�为 frameBytes 字节，分片长度�为 2*count*frameBytes。
+     * �侧该�缺帧则填�音帧，��左�严格对��长度�定。
+     * @param startFrame 本分片从第几帧开始（一�拆多写时用�续接，�拆分时为 0）
+     * @param count 本分片装几帧/声�
+     * @param frameBytes �帧字节数快照(调用方从 downlinkFrameBytes �，一�内统一)
      */
     private fun buildInterleavedPacket(
-        n: Int,
+        startFrame: Int,
+        count: Int,
+        frameBytes: Int,
         leftFrames: List<ByteArray>,
         rightFrames: List<ByteArray>,
         silence: ByteArray
     ): ByteArray {
-        val packet = ByteArray(2 * n * OPUS_FRAME_BYTES)
+        val packet = ByteArray(2 * count * frameBytes)
         var offset = 0
-        for (i in 0 until n) {
-            System.arraycopy(leftFrames.getOrNull(i) ?: silence, 0, packet, offset, OPUS_FRAME_BYTES)
-            offset += OPUS_FRAME_BYTES
-            System.arraycopy(rightFrames.getOrNull(i) ?: silence, 0, packet, offset, OPUS_FRAME_BYTES)
-            offset += OPUS_FRAME_BYTES
+        for (k in 0 until count) {
+            val i = startFrame + k
+            System.arraycopy(leftFrames.getOrNull(i) ?: silence, 0, packet, offset, frameBytes)
+            offset += frameBytes
+            System.arraycopy(rightFrames.getOrNull(i) ?: silence, 0, packet, offset, frameBytes)
+            offset += frameBytes
         }
         return packet
     }
 
     /** 把�一路的真实帧补�音至 n 帧�顺次拼接（仅供调试录音�地，内容与该路实际下�的一致） */
-    private fun padToFrames(n: Int, frames: List<ByteArray>, silence: ByteArray): ByteArray {
-        val out = ByteArray(n * OPUS_FRAME_BYTES)
+    private fun padToFrames(n: Int, frameBytes: Int, frames: List<ByteArray>, silence: ByteArray): ByteArray {
+        val out = ByteArray(n * frameBytes)
         var offset = 0
         for (i in 0 until n) {
-            System.arraycopy(frames.getOrNull(i) ?: silence, 0, out, offset, OPUS_FRAME_BYTES)
-            offset += OPUS_FRAME_BYTES
+            System.arraycopy(frames.getOrNull(i) ?: silence, 0, out, offset, frameBytes)
+            offset += frameBytes
         }
         return out
     }
@@ -2009,27 +2083,38 @@ object BleService {
     /**
      * 设置通�翻译调试�数（�行时生效，无需�连）。任一�数为 null 或�法值则�修改。
      * @param sendIntervalMs 音频下行��间隔(ms)
-     * @param bundleFrameCount �包�声�的 opus 帧数(1..MAX_BUNDLE_FRAME_COUNT)，包长 = 2*n*40B
+     * @param bundleFrameCount �包�声�的 opus 帧数(1..maxBundleFrameCount())，包长 = 2*n*下行帧长
      * @param continuousSend 是��续��：true 时无译音也按�下�全�音包，��设备侧音频��断
+     * @param downlinkBitrateKbps 下行(APP→设备)opus �率(kbps)，决定�帧字节数；改动会��编��
+     * @param uplinkBitrateKbps 上行(设备→APP)opus �率(kbps)，须与固件实际编��率一致；改动会��解��
      */
     fun setCallTranslationDebugParams(
         sendIntervalMs: Long?,
         bundleFrameCount: Int?,
-        continuousSend: Boolean?
+        continuousSend: Boolean?,
+        downlinkBitrateKbps: Int? = null,
+        uplinkBitrateKbps: Int? = null
     ) {
+        // 先应用�率：帧长会�，��的�包帧数上��赖它
+        if (downlinkBitrateKbps != null && downlinkBitrateKbps > 0) {
+            applyDownlinkBitrate(downlinkBitrateKbps)
+        }
+        if (uplinkBitrateKbps != null && uplinkBitrateKbps > 0) {
+            applyUplinkBitrate(uplinkBitrateKbps)
+        }
         if (sendIntervalMs != null && sendIntervalMs > 0) {
             audioSendIntervalNormal = sendIntervalMs.coerceIn(1L, 1000L)
             Log.i(TAG, "[CALL_TRANS_DEBUG] 设置音频下行��间隔: ${audioSendIntervalNormal}ms")
         }
         if (bundleFrameCount != null && bundleFrameCount > 0) {
             this.bundleFrameCount = bundleFrameCount.coerceIn(1, MAX_BUNDLE_FRAME_COUNT)
-            val packetSize = 2 * this.bundleFrameCount * OPUS_FRAME_BYTES
-            Log.i(TAG, "[CALL_TRANS_DEBUG] 设置�声��包帧数: ${this.bundleFrameCount} (包长 ${packetSize}B)")
-            // 一次 BLE 写的净�上�是 MTU-3，超了底层会写失败/截断，这里��告警。
-            // 仅在 MTU 已�商时�判（未连接时 currentMtu 还是默认 23，判了必然误报）
-            if (currentMtu > 23 && packetSize > currentMtu - 3) {
-                CallLog.w(TAG, "[CALL_TRANS_DEBUG] 包长 ${packetSize}B 超出当� MTU �写上�(${currentMtu - 3}B)，下行会写失败")
-            }
+            val totalBytes = 2 * this.bundleFrameCount * downlinkFrameBytes
+            // 超过�次 BLE 写上�时会自动按 2×帧长 对�拆�多个写，这里把拆分数算出�记日志
+            val framesPerWrite = maxFramesPerWrite(downlinkFrameBytes).coerceAtMost(this.bundleFrameCount)
+            val writes = (this.bundleFrameCount + framesPerWrite - 1) / framesPerWrite
+            val splitTag = if (writes > 1) "，超出�次 BLE 写上� → 拆 $writes 个写(�写 ${framesPerWrite} 帧)" else ""
+            Log.i(TAG, "[CALL_TRANS_DEBUG] 设置�声��包帧数: ${this.bundleFrameCount} " +
+                    "(帧长 ${downlinkFrameBytes}B → 一� ${totalBytes}B$splitTag)")
         }
         if (continuousSend != null) {
             continuousSendEnabled = continuousSend
@@ -2037,15 +2122,70 @@ object BleService {
         }
     }
 
+    /**
+     * 应用下行�率：帧长�之�化。
+     * 编�器的 packetSize 在 startEncodeStream 时就固化了，改�率必须**��编��**�能生效；
+     * �时必须清空左�队列并作废旧�音模� —— �则旧帧长的残留帧会混进新包，导致设备侧整包错�。
+     */
+    private fun applyDownlinkBitrate(bitrateKbps: Int) {
+        val newFrameBytes = bitrateToFrameBytes(bitrateKbps)
+        if (newFrameBytes == downlinkFrameBytes) return
+
+        val wasEncoding = opusAudioManager.isDualEncoding()
+        CallLog.i(TAG, "[CALL_TRANS_DEBUG] 设置下行�率: ${bitrateKbps}kbps " +
+                "(帧长 ${downlinkFrameBytes}B → ${newFrameBytes}B, 编���行中=$wasEncoding)")
+
+        if (wasEncoding) opusAudioManager.stopDualEncodeStream()
+
+        // 作废旧帧长的一切残留：队列里的旧帧 + 旧�音模�
+        downlinkFrameBytes = newFrameBytes
+        silenceFrame = null
+        leftSendBuffer.clear()
+        rightSendBuffer.clear()
+
+        // ��编��：新 packetSize 生效，并�新生�对应长度的�音模�
+        if (wasEncoding) {
+            opusAudioManager.startDualEncodeStream(false, 16000, downlinkFrameBytes)
+        }
+    }
+
+    /**
+     * 应用上行�率：必须与**固件实际编��率**一致，�则收包长度校验和解�器切分都会错。
+     * 解�器 packetSize = 2 × 帧长（立体声一�元�左��一帧），改动需��解��。
+     */
+    private fun applyUplinkBitrate(bitrateKbps: Int) {
+        val newFrameBytes = bitrateToFrameBytes(bitrateKbps)
+        if (newFrameBytes == uplinkFrameBytes) return
+
+        val wasDecoding = isCallTranslating
+        CallLog.i(TAG, "[CALL_TRANS_DEBUG] 设置上行�率: ${bitrateKbps}kbps " +
+                "(帧长 ${uplinkFrameBytes}B → ${newFrameBytes}B, 会�中=$wasDecoding)")
+        uplinkFrameBytes = newFrameBytes
+
+        // 会�中改动�需�立刻��解��；�则下次 openA2DPDecoder 时自然带上新值
+        if (wasDecoding) {
+            startOpusStreamDecoding(false, 2, 16000, 2 * uplinkFrameBytes)
+        }
+    }
+
     /**
      * 获�当�通�翻译调试�数。
-     * @return Map: sendIntervalMs(Long) / bundleFrameCount(Int) / continuousSend(Boolean)
+     * @return Map: sendIntervalMs / bundleFrameCount / continuousSend /
+     *              downlinkBitrateKbps / uplinkBitrateKbps / downlinkFrameBytes / uplinkFrameBytes /
+     *              maxBundleFrameCount / packetSizeBytes
      */
     fun getCallTranslationDebugParams(): Map<String, Any> {
         return mapOf(
             "sendIntervalMs" to audioSendIntervalNormal,
             "bundleFrameCount" to bundleFrameCount,
-            "continuousSend" to continuousSendEnabled
+            "continuousSend" to continuousSendEnabled,
+            "downlinkBitrateKbps" to frameBytesToBitrate(downlinkFrameBytes),
+            "uplinkBitrateKbps" to frameBytesToBitrate(uplinkFrameBytes),
+            "downlinkFrameBytes" to downlinkFrameBytes,
+            "uplinkFrameBytes" to uplinkFrameBytes,
+            "maxBundleFrameCount" to MAX_BUNDLE_FRAME_COUNT,
+            "packetSizeBytes" to (2 * bundleFrameCount * downlinkFrameBytes),
+            "maxFramesPerWrite" to maxFramesPerWrite(downlinkFrameBytes)
         )
     }
 
@@ -2119,7 +2259,9 @@ object BleService {
      */
     fun openDecoder(channelMode: Int = BleConst.AUDIO_CHANNEL_STEREO): Boolean {
         Log.i(TAG, "打开解�器...")
-        startOpusStreamDecoding(false, 1, 16000, 40)
+        // 普通�声��(�通�翻译)固定 16kbps/40B 帧；�步收包校验基准，��沿用通�翻译的上行帧长把它误判��包
+        uplinkFrameBytes = bitrateToFrameBytes(DEFAULT_OPUS_BITRATE_KBPS)
+        startOpusStreamDecoding(false, 1, 16000, uplinkFrameBytes)
         val cmdData = byteArrayOf(
             BleConst.CODEC_CONTROL_DECODE_ON.toByte(),
             channelMode.toByte()
@@ -2144,9 +2286,9 @@ object BleService {
         startOpusEncodeStream()
         recordfile1Left?.creatingFiles();
         recordfile1Right?.creatingFiles();
-        // 设备端通�上行 opus �数：8kbps/60ms/8kHz 立体声。
-        // packetSize=�帧字节数=�率×帧长÷8=8000×0.06÷8=60B(�声�)，立体声打包 2×60=120B。
-        startOpusStreamDecoding(false, 2, 16000, 80)
+        // 上行：设备立体声 opus。解�器 packetSize = 一个立体声�元的字节数 = 2 × �声�帧长，
+        // 帧长由上行�率决定(16kbps→40B → �元 80B；8kbps→20B → �元 40B)，�能写死。
+        startOpusStreamDecoding(false, 2, 16000, 2 * uplinkFrameBytes)
         val cmdData = byteArrayOf(
             BleConst.CODEC_CONTROL_A2DP_PLAY.toByte(),
             channelMode.toByte()
@@ -2163,8 +2305,8 @@ object BleService {
      */
     fun openCallRecordDecoder(channelMode: Int = BleConst.AUDIO_CHANNEL_STEREO): Boolean {
         Log.i(TAG, "打开通�录音解�器...")
-        // 通�录音与通�翻译走�一�设备上行�：8kbps/60ms/8kHz 立体声，packetSize=2×60=120B。
-        startOpusStreamDecoding(false, 2, 16000, 80)
+        // 通�录音与通�翻译走�一�设备上行�(立体声)：packetSize = 2 × 上行�声�帧长，�上行�率�化
+        startOpusStreamDecoding(false, 2, 16000, 2 * uplinkFrameBytes)
         val cmdData = byteArrayOf(
             BleConst.CODEC_CONTROL_CALL_RECORD_PLAY.toByte(),
             channelMode.toByte()
@@ -2188,7 +2330,9 @@ object BleService {
      */
     fun openEncoder(channelMode: Int = BleConst.AUDIO_CHANNEL_STEREO): Boolean {
         Log.i(TAG, "打开编�器...")
-        startOpusStreamDecoding(false, 1, 16000, 40)
+        // 普通�声��(�通�翻译)固定 16kbps/40B 帧；�步收包校验基准，�由� openDecoder
+        uplinkFrameBytes = bitrateToFrameBytes(DEFAULT_OPUS_BITRATE_KBPS)
+        startOpusStreamDecoding(false, 1, 16000, uplinkFrameBytes)
         // val cmdData = byteArrayOf(
         //     BleConst.CODEC_CONTROL_ENCODE_ON.toByte(),
         //     channelMode.toByte()
diff --git a/local_plugins/ble_service/android/src/main/kotlin/com/yunqiinnovation/ble_service/BleServicePlugin.kt b/local_plugins/ble_service/android/src/main/kotlin/com/yunqiinnovation/ble_service/BleServicePlugin.kt
index 43b0affd9..3b1e2862c 100644
--- a/local_plugins/ble_service/android/src/main/kotlin/com/yunqiinnovation/ble_service/BleServicePlugin.kt
+++ b/local_plugins/ble_service/android/src/main/kotlin/com/yunqiinnovation/ble_service/BleServicePlugin.kt
@@ -250,7 +250,12 @@ class BleServicePlugin : FlutterPlugin, MethodCallHandler, ActivityAware,
                 val sendIntervalMs = (call.argument<Number>("sendIntervalMs"))?.toLong()
                 val bundleFrameCount = (call.argument<Number>("bundleFrameCount"))?.toInt()
                 val continuousSend = call.argument<Boolean>("continuousSend")
-                BleService.setCallTranslationDebugParams(sendIntervalMs, bundleFrameCount, continuousSend)
+                val downlinkBitrateKbps = (call.argument<Number>("downlinkBitrateKbps"))?.toInt()
+                val uplinkBitrateKbps = (call.argument<Number>("uplinkBitrateKbps"))?.toInt()
+                BleService.setCallTranslationDebugParams(
+                    sendIntervalMs, bundleFrameCount, continuousSend,
+                    downlinkBitrateKbps, uplinkBitrateKbps
+                )
                 result.success(true)
             }
             "getCallTranslationDebugParams" -> {
diff --git a/local_plugins/ble_service/ios/ble_service/Sources/ble_service/BleService.swift b/local_plugins/ble_service/ios/ble_service/Sources/ble_service/BleService.swift
index 0ef8bc467..f92d554c4 100644
--- a/local_plugins/ble_service/ios/ble_service/Sources/ble_service/BleService.swift
+++ b/local_plugins/ble_service/ios/ble_service/Sources/ble_service/BleService.swift
@@ -112,7 +112,7 @@ public class BleService: NSObject {
     // MARK: - 音频下行��（与 Android BleService 对�）
     // 左�声��一�缓存队列，共用**一�**��定时器：��从左�队列�� N 帧，
     // 按 [L0][R0][L1][R1]... 帧级交替拼�一个无包头包下�；�侧�足的�用�音帧补�。
-    // 队列元素是�帧 opus(� OPUS_FRAME_BYTES=40B)。
+    // 队列元素是�帧 opus，长度�为 downlinkFrameBytes（由下行�率决定，16kbps→40B）。
     private var leftSendBuffer = [Data]()
     private var rightSendBuffer = [Data]()
     private let sendBufferLock = NSLock()
@@ -131,12 +131,17 @@ public class BleService: NSObject {
     private var _writeFailRetryCount = 0
     /// 上一包音频实际��的时间戳，仅用于��节�日志统计间隔；-1 表示尚未��过
     private var _lastAudioSendTime: TimeInterval = -1
-    /// �包�声�的 opus 帧数(1..MAX_BUNDLE_FRAME_COUNT)，�行时�调
+    /// �包�声�的 opus 帧数(1..maxBundleFrameCount)，�行时�调
     private var _bundleFrameCount = 2
     /// 音频下行��间隔(秒)，�行时�调
     private var _audioSendInterval: TimeInterval = 0.04
     /// �续��开关：true 时�使左�队列都空也按��全�音包，��设备侧音频��断
     private var _continuousSendEnabled = false
+    /// 下行(APP→设备)�帧 opus 字节数，由下行�率决定。编�器 packetSize 在�动时固化，
+    /// 改它必须��编��并�建�音模�（� applyDownlinkBitrate）。
+    private var _downlinkFrameBytes = 40
+    /// 上行(设备→APP)�帧 opus 字节数，由上行�率决定（须与固件实际编��率一致）
+    private var _uplinkFrameBytes = 40
 
     /// 下行包��（��功�一包自增）；无包头�议下�写入包内，仅用于日志核对节�连续性。
     /// �被��队列访问，无需加�。
@@ -165,13 +170,47 @@ public class BleService: NSObject {
         get { sendStateLock.lock(); defer { sendStateLock.unlock() }; return _continuousSendEnabled }
         set { sendStateLock.lock(); _continuousSendEnabled = newValue; sendStateLock.unlock() }
     }
-
-    // 音频���置常�（与 Android 默认值对�）
-    /// �帧 opus 固定长度(编�器 CBR)。无包头�议�固定帧长切分，长度必须严格�定，�则设备侧整包错�。
-    private let OPUS_FRAME_BYTES = 40
-    /// �包帧数上�：包长 2*n*40 必须塞得进一次 BLE 写，6 帧=480B 已是安全上�
-    private let MAX_BUNDLE_FRAME_COUNT = 6
+    private var downlinkFrameBytes: Int {
+        get { sendStateLock.lock(); defer { sendStateLock.unlock() }; return _downlinkFrameBytes }
+        set { sendStateLock.lock(); _downlinkFrameBytes = newValue; sendStateLock.unlock() }
+    }
+    private var uplinkFrameBytes: Int {
+        get { sendStateLock.lock(); defer { sendStateLock.unlock() }; return _uplinkFrameBytes }
+        set { sendStateLock.lock(); _uplinkFrameBytes = newValue; sendStateLock.unlock() }
+    }
+
+    // 音频编��置（与 Android 对�）
+    /// opus 帧时长固定 20ms；CBR 下 �帧字节数 = �率(kbps) × 20ms ÷ 8：
+    /// 16kbps→40B(默认) / 8kbps→20B / 24kbps→60B。**帧长是��，��写死 40。**
+    private let OPUS_FRAME_DURATION_MS = 20
+    private let DEFAULT_OPUS_BITRATE_KBPS = 16
+    private let MIN_OPUS_BITRATE_KBPS = 6
+    private let MAX_OPUS_BITRATE_KBPS = 64
+    /// �声�帧数上�。�� MTU 约�：一�的数�若超过�次 BLE 写上�，会按 2×帧长 对�拆�多个写连续�出
+    /// （�个分片�是 2×帧长的整数��左�交替顺���，设备侧按包或按�解�都正确）。
+    private let MAX_BUNDLE_FRAME_COUNT = 20
+    /// �次 BLE 写的净�字节上�（iOS 用 maximumWriteValueLength 查询，查�到时的兜底值）
+    private let FALLBACK_BLE_WRITE_BYTES = 480
     private let CHANNEL_HOLD_BUFFER_MAX = 10000                  // 声�缓存安全上�（防 OOM 兜底）
+
+    /// �率(kbps) → �帧 opus 字节数
+    private func bitrateToFrameBytes(_ bitrateKbps: Int) -> Int {
+        let clamped = min(max(bitrateKbps, MIN_OPUS_BITRATE_KBPS), MAX_OPUS_BITRATE_KBPS)
+        return clamped * OPUS_FRAME_DURATION_MS / 8
+    }
+
+    /// �帧字节数 → �率(kbps)，仅用于日志与�数回读
+    private func frameBytesToBitrate(_ frameBytes: Int) -> Int {
+        return frameBytes * 8 / OPUS_FRAME_DURATION_MS
+    }
+
+    /// 一次 BLE 写最多能装几帧/声�：净�上� ÷ (2 × 帧长)。
+    /// 一���的帧数超过它时按此拆�多个写（�个分片� 2×帧长 对�，设备侧解���影�）。
+    private func maxFramesPerWrite(_ frameBytes: Int) -> Int {
+        let limit = peripheralDevice?.maximumWriteValueLength(for: .withoutResponse) ?? FALLBACK_BLE_WRITE_BYTES
+        let writeLimit = limit > 0 ? limit : FALLBACK_BLE_WRITE_BYTES
+        return max(writeLimit / (2 * frameBytes), 1)
+    }
    
     //private var currentCommand: Command?
       // 命令结构体
@@ -820,9 +859,10 @@ public class BleService: NSObject {
          // 确�Opus解�器处于活跃状�（如果�是则�动）
 
         startOpusDecoding(sampleRate: 16000, channels: 2, frameSize: 1280)
-        // 通�翻译：左�声�独立编�，�帧 40B/20ms（与 Android setPacketSize(40) 对�）
-        // 下行包格�(无包头，左�交替)：[L0 40B][R0 40B]...[L(n-1)][R(n-1)]，n=bundleFrameCount(默认2 → 160B)
-        _ = opusProcessor?.startDualEncodeStream(sampleRate: 16000, packetBytes: Int32(OPUS_FRAME_BYTES))
+        // 通�翻译：左�声�独立编�，�帧 20ms，帧长由下行�率决定(16kbps→40B，与 Android 对�)
+        // 下行包格�(无包头，左�交替)：[L0][R0]...[L(n-1)][R(n-1)]，n=bundleFrameCount(默认 2 帧 → 160B)
+        _ = opusProcessor?.startDualEncodeStream(sampleRate: 16000,
+                                                 packetBytes: Int32(downlinkFrameBytes))
         startAudioSendThreads()
 
         os_log("[CALL_TRANS_CMD] 打开A2DP解�并开始录制(通�翻译)...", log: logger, type: .info)
@@ -1584,11 +1624,13 @@ extension BleService: SwiftOpusAudioProcessor.AudioDataCallback {
     }
 
     /// �音帧模�就绪，缓存起�用于�包时�足帧补�。
-    /// 无包头�议按固定 40B 切分，模�长度�对会让整包左�对�全错，故�接��好 OPUS_FRAME_BYTES 的模�。
+    /// 无包头�议按固定帧长切分，模�长度�对会让整包左�对�全错，
+    /// 故�接�长度�好等于当� downlinkFrameBytes 的模�（改�率�编�器会�新生�新长度的模�）。
     func onSilenceFrameReady(frame: Data) {
-        guard frame.count == OPUS_FRAME_BYTES else {
+        let expected = downlinkFrameBytes
+        guard frame.count == expected else {
             os_log("�音帧模�长度异常 size=%dB (期望 %dB)，拒�采用",
-                   log: logger, type: .error, frame.count, OPUS_FRAME_BYTES)
+                   log: logger, type: .error, frame.count, expected)
             return
         }
         silenceFrame = frame
@@ -1603,12 +1645,13 @@ extension BleService {
     /// 仅超 OOM 兜底上��丢最旧帧。
     ///
     /// 无包头�议下设备侧按固定 40B 切分左�声�，任何一帧长度异常都会让整包�之�的声�对�全错，
-    /// 故� OPUS_FRAME_BYTES 的帧在入队处直接拦掉，��队列里的帧长�定。
+    /// 故长度�等于当� downlinkFrameBytes 的帧在入队处直接拦掉，��队列里的帧长�定。
     private func enqueueOpusFrame(channel: UInt8, frame: Data) {
         guard !frame.isEmpty else { return }
-        guard frame.count == OPUS_FRAME_BYTES else {
+        let expected = downlinkFrameBytes
+        guard frame.count == expected else {
             os_log("丢弃异常长度 opus 帧 ch=%d size=%dB (期望 %dB)",
-                   log: logger, type: .error, Int(channel), frame.count, OPUS_FRAME_BYTES)
+                   log: logger, type: .error, Int(channel), frame.count, expected)
             return
         }
         sendBufferLock.lock()
@@ -1638,9 +1681,12 @@ extension BleService {
         isAudioSending = true
         audioSendTimer = makeAudioSendTimer()
         let n = min(max(bundleFrameCount, 1), MAX_BUNDLE_FRAME_COUNT)
-        os_log("音频��定时器已�动(左��包/无包头) 间隔=%.0fms 帧数=%d/声� 包长=%dB �续��=%{public}@",
+        let frameBytes = downlinkFrameBytes
+        os_log("音频��定时器已�动(左��包/无包头) 间隔=%.0fms 帧数=%d/声� 帧长=%dB(%dkbps) 一�=%dB �写上�=%d帧 �续��=%{public}@",
                log: logger, type: .info, audioSendInterval * 1000, n,
-               2 * n * OPUS_FRAME_BYTES, continuousSendEnabled ? "å¼€" : "å…³")
+               frameBytes, frameBytesToBitrate(frameBytes),
+               2 * n * frameBytes, maxFramesPerWrite(frameBytes),
+               continuousSendEnabled ? "å¼€" : "å…³")
     }
 
     /// �止��定时器并清空缓存
@@ -1688,6 +1734,8 @@ extension BleService {
     /// - 写失败(拥塞)：�出的真实帧按原�退回�自队头，�音补�帧丢弃，下一��组�试，��丢帧
     private func trySendMixedChunk() -> Bool {
         let n = min(max(bundleFrameCount, 1), MAX_BUNDLE_FRAME_COUNT)
+        // 帧长在本�内�一次快照：改�率是异步的，中途�化会让�一包里的帧长�一致(整包错�)
+        let frameBytes = downlinkFrameBytes
 
         // 左���最多 n 帧真实数�
         sendBufferLock.lock()
@@ -1705,16 +1753,18 @@ extension BleService {
         // 两路皆空且未开�续��：本���
         if !hasRealAudio && !continuousSendEnabled { return false }
 
-        // 无包头�议�固定帧长切分，缺帧必须补�音�能��包长�定；模�未就绪则本�放弃，帧退回队列�丢
-        guard let silence = silenceFrame else {
+        // 无包头�议�固定帧长切分，缺帧必须补�音�能��包长�定；
+        // 模�未就绪(或长度与当��率�匹�)则本�放弃，帧退回队列�丢
+        let silenceOrNil = silenceFrame
+        guard let silence = silenceOrNil, silence.count == frameBytes else {
             sendBufferLock.lock()
             leftSendBuffer.insert(contentsOf: leftFrames, at: 0)
             rightSendBuffer.insert(contentsOf: rightFrames, at: 0)
             sendBufferLock.unlock()
             silenceNotReadyCount += 1
             if silenceNotReadyCount == 1 || silenceNotReadyCount % 50 == 0 {
-                os_log("�音帧模�未就绪，暂缓下�(累计 %d �)，译音已退回队列�丢",
-                       log: logger, type: .error, silenceNotReadyCount)
+                os_log("�音帧模�未就绪(或与当�帧长 %dB �匹�)，暂缓下�(累计 %d �)，译音已退回队列�丢",
+                       log: logger, type: .error, frameBytes, silenceNotReadyCount)
             }
             return false
         }
@@ -1722,14 +1772,40 @@ extension BleService {
 
         let padLeft = n - leftFrames.count
         let padRight = n - rightFrames.count
-        let packet = buildInterleavedPacket(n: n, leftFrames: leftFrames, rightFrames: rightFrames, silence: silence)
 
-        // �步写入，拿到真实的�功/失败：false=底层��缓冲已满(拥塞)，作为背压信�
-        guard sendAudioPacket(packet) else {
-            // 写失败：真实帧按原顺�退回�自队头，下一��组�试；�音补�帧丢弃
+        // 一�的数�(2×n×帧长)�能超过�次 BLE 写的净�上�，按 2×帧长 对�拆�多个写连续�出。
+        // �个分片�是 2×帧长的整数��左�交替顺��� → 设备侧按包或按�解�都正确。
+        let framesPerWrite = min(maxFramesPerWrite(frameBytes), n)
+        var sentFrames = 0
+        var sentBytes = 0
+        var writeCount = 0
+        var congested = false
+        while sentFrames < n {
+            let chunkFrames = min(framesPerWrite, n - sentFrames)
+            let packet = buildInterleavedPacket(startFrame: sentFrames, count: chunkFrames,
+                                                frameBytes: frameBytes,
+                                                leftFrames: leftFrames, rightFrames: rightFrames,
+                                                silence: silence)
+            // �步写入，拿到真实的�功/失败：false=底层��缓冲已满(拥塞)，作为背压信�
+            guard sendAudioPacket(packet) else {
+                congested = true
+                break
+            }
+            sentFrames += chunkFrames
+            sentBytes += packet.count
+            writeCount += 1
+        }
+
+        if congested {
+            // 拥塞：把**尚未�出**的真实帧按原顺�退回�自队头，下一��组�试；�音补�帧丢弃。
+            // 已�出的分片无法撤回，但它们自身 2×帧长 对��顺�正确，设备侧字节��会错�。
             sendBufferLock.lock()
-            leftSendBuffer.insert(contentsOf: leftFrames, at: 0)
-            rightSendBuffer.insert(contentsOf: rightFrames, at: 0)
+            if sentFrames < leftFrames.count {
+                leftSendBuffer.insert(contentsOf: leftFrames[sentFrames...], at: 0)
+            }
+            if sentFrames < rightFrames.count {
+                rightSendBuffer.insert(contentsOf: rightFrames[sentFrames...], at: 0)
+            }
             sendBufferLock.unlock()
 
             sendStateLock.lock()
@@ -1737,19 +1813,20 @@ extension BleService {
             let fails = _writeFailRetryCount
             sendStateLock.unlock()
             if fails == 1 || fails % 50 == 0 {
-                os_log("下行写入拥塞，�试中 seq=%u 连续失败=%d", log: logger, type: .error, packetSeq, fails)
+                os_log("下行写入拥塞，�试中 seq=%u 连续失败=%d 已�=%d/%d帧",
+                       log: logger, type: .error, packetSeq, fails, sentFrames, n)
             }
-            return false
+            if sentFrames == 0 { return false }
         }
 
         sendStateLock.lock()
         let prevFails = _writeFailRetryCount
-        _writeFailRetryCount = 0
+        if !congested { _writeFailRetryCount = 0 }
         let now = Date().timeIntervalSince1970
         let deltaMs = _lastAudioSendTime < 0 ? 0 : Int((now - _lastAudioSendTime) * 1000)
         _lastAudioSendTime = now
         sendStateLock.unlock()
-        if prevFails > 0 {
+        if !congested, prevFails > 0 {
             os_log("下行写入已��，之�连续失败=%d", log: logger, type: .info, prevFails)
         }
 
@@ -1764,25 +1841,34 @@ extension BleService {
         // �续��的纯�音包按 25 �节�，��刷�
         if hasRealAudio {
             silentPacketCount = 0
-            os_log("音频下行�� seq=%u Δ=%dms L=%d+�音%d R=%d+�音%d size=%dB buf(L=%d,R=%d)",
+            os_log("音频下行�� seq=%u Δ=%dms L=%d+�音%d R=%d+�音%d 帧=%d/%d size=%dB 写=%d buf(L=%d,R=%d)",
                    log: logger, type: .debug, seq, deltaMs,
-                   leftFrames.count, padLeft, rightFrames.count, padRight, packet.count, lBuf, rBuf)
+                   leftFrames.count, padLeft, rightFrames.count, padRight,
+                   sentFrames, n, sentBytes, writeCount, lBuf, rBuf)
         } else {
             silentPacketCount += 1
             if silentPacketCount % 25 == 1 {
-                os_log("音频下行�续��(全�音) seq=%u Δ=%dms size=%dB 累计=%d 包",
-                       log: logger, type: .debug, seq, deltaMs, packet.count, silentPacketCount)
+                os_log("音频下行�续��(全�音) seq=%u Δ=%dms size=%dB 写=%d 累计=%d 包",
+                       log: logger, type: .debug, seq, deltaMs, sentBytes, writeCount, silentPacketCount)
             }
         }
         return true
     }
 
-    /// 组下行包(无包头，左�帧级交替)：[L0][R0][L1][R1]...[L(n-1)][R(n-1)]
-    /// �帧�为 OPUS_FRAME_BYTES 字节，包长�为 2*n*OPUS_FRAME_BYTES；�侧该�缺帧则填�音帧，��左�严格对�。
-    private func buildInterleavedPacket(n: Int, leftFrames: [Data], rightFrames: [Data], silence: Data) -> Data {
+    /// 组下行分片(无包头，左�帧级交替)：�第 startFrame 起的 count 帧，拼�
+    /// [L(s)][R(s)][L(s+1)][R(s+1)]...，�帧�为 frameBytes 字节，分片长度�为 2*count*frameBytes。
+    /// �侧该�缺帧则填�音帧，��左�严格对��长度�定。
+    /// - Parameters:
+    ///   - startFrame: 本分片从第几帧开始（一�拆多写时用�续接，�拆分时为 0）
+    ///   - count: 本分片装几帧/声�
+    ///   - frameBytes: �帧字节数快照(调用方从 downlinkFrameBytes �，一�内统一)
+    private func buildInterleavedPacket(startFrame: Int, count: Int, frameBytes: Int,
+                                        leftFrames: [Data], rightFrames: [Data],
+                                        silence: Data) -> Data {
         var packet = Data()
-        packet.reserveCapacity(2 * n * OPUS_FRAME_BYTES)
-        for i in 0..<n {
+        packet.reserveCapacity(2 * count * frameBytes)
+        for k in 0..<count {
+            let i = startFrame + k
             packet.append(i < leftFrames.count ? leftFrames[i] : silence)
             packet.append(i < rightFrames.count ? rightFrames[i] : silence)
         }
@@ -1792,8 +1878,17 @@ extension BleService {
     // MARK: - 通�翻译调试�数（�行时�调，与 Android 对�）
 
     /// 设置通�翻译调试�数（�行时生效）。任一�数为 nil 或�法值则�修改。
-    /// 改动��间隔会�建定时器（若正在��）。
-    func setCallTranslationDebugParams(sendIntervalMs: Int?, bundleFrameCount: Int?, continuousSend: Bool?) {
+    /// 改动��间隔会�建定时器；改动下行�率会��编��（帧长�了）。
+    func setCallTranslationDebugParams(sendIntervalMs: Int?, bundleFrameCount: Int?, continuousSend: Bool?,
+                                       downlinkBitrateKbps: Int? = nil, uplinkBitrateKbps: Int? = nil) {
+        // 先应用�率：帧长会�，��的�包帧数上��赖它
+        if let kbps = downlinkBitrateKbps, kbps > 0 {
+            applyDownlinkBitrate(kbps)
+        }
+        if let kbps = uplinkBitrateKbps, kbps > 0 {
+            applyUplinkBitrate(kbps)
+        }
+
         var intervalChanged = false
         if let ms = sendIntervalMs, ms > 0 {
             let clamped = TimeInterval(min(max(ms, 1), 1000)) / 1000.0
@@ -1805,8 +1900,13 @@ extension BleService {
         }
         if let frames = bundleFrameCount, frames > 0 {
             self.bundleFrameCount = min(max(frames, 1), MAX_BUNDLE_FRAME_COUNT)
-            os_log("[CALL_TRANS_DEBUG] 设置�声��包帧数: %d (包长 %dB)", log: logger, type: .info,
-                   self.bundleFrameCount, 2 * self.bundleFrameCount * OPUS_FRAME_BYTES)
+            // 超过�次 BLE 写上�时会自动按 2×帧长 对�拆�多个写
+            let perWrite = min(maxFramesPerWrite(downlinkFrameBytes), self.bundleFrameCount)
+            let writes = (self.bundleFrameCount + perWrite - 1) / perWrite
+            os_log("[CALL_TRANS_DEBUG] 设置�声��包帧数: %d (帧长 %dB → 一� %dB, 拆 %d 个写)",
+                   log: logger, type: .info,
+                   self.bundleFrameCount, downlinkFrameBytes,
+                   2 * self.bundleFrameCount * downlinkFrameBytes, writes)
         }
         if let continuous = continuousSend {
             continuousSendEnabled = continuous
@@ -1820,12 +1920,57 @@ extension BleService {
         }
     }
 
+    /// 应用下行�率：帧长�之�化。
+    /// 编�器的 packetSize 在�动时固化，改�率必须**��编��**�能生效；
+    /// �时必须清空左�队列并作废旧�音模� —— �则旧帧长的残留帧会混进新包，导致设备侧整包错�。
+    private func applyDownlinkBitrate(_ bitrateKbps: Int) {
+        let newFrameBytes = bitrateToFrameBytes(bitrateKbps)
+        guard newFrameBytes != downlinkFrameBytes else { return }
+
+        let wasEncoding = isAudioSending
+        os_log("[CALL_TRANS_DEBUG] 设置下行�率: %dkbps (帧长 %dB → %dB, 编���行中=%{public}@)",
+               log: logger, type: .info, bitrateKbps, downlinkFrameBytes, newFrameBytes,
+               wasEncoding ? "是" : "�")
+
+        if wasEncoding { _ = opusProcessor?.stopDualEncodeStream() }
+
+        // 作废旧帧长的一切残留：队列里的旧帧 + 旧�音模�
+        downlinkFrameBytes = newFrameBytes
+        silenceFrame = nil
+        sendBufferLock.lock()
+        leftSendBuffer.removeAll()
+        rightSendBuffer.removeAll()
+        sendBufferLock.unlock()
+
+        // ��编��：新 packetSize 生效，并�新生�对应长度的�音模�
+        if wasEncoding {
+            _ = opusProcessor?.startDualEncodeStream(sampleRate: 16000,
+                                                     packetBytes: Int32(downlinkFrameBytes))
+        }
+    }
+
+    /// 应用上行�率：必须与**固件实际编��率**一致，�则收包切分会错。
+    private func applyUplinkBitrate(_ bitrateKbps: Int) {
+        let newFrameBytes = bitrateToFrameBytes(bitrateKbps)
+        guard newFrameBytes != uplinkFrameBytes else { return }
+        os_log("[CALL_TRANS_DEBUG] 设置上行�率: %dkbps (帧长 %dB → %dB)",
+               log: logger, type: .info, bitrateKbps, uplinkFrameBytes, newFrameBytes)
+        uplinkFrameBytes = newFrameBytes
+    }
+
     /// 获�当�通�翻译调试�数
     func getCallTranslationDebugParams() -> [String: Any] {
         return [
             "sendIntervalMs": Int((audioSendInterval * 1000).rounded()),
             "bundleFrameCount": bundleFrameCount,
-            "continuousSend": continuousSendEnabled
+            "continuousSend": continuousSendEnabled,
+            "downlinkBitrateKbps": frameBytesToBitrate(downlinkFrameBytes),
+            "uplinkBitrateKbps": frameBytesToBitrate(uplinkFrameBytes),
+            "downlinkFrameBytes": downlinkFrameBytes,
+            "uplinkFrameBytes": uplinkFrameBytes,
+            "maxBundleFrameCount": MAX_BUNDLE_FRAME_COUNT,
+            "packetSizeBytes": 2 * bundleFrameCount * downlinkFrameBytes,
+            "maxFramesPerWrite": maxFramesPerWrite(downlinkFrameBytes)
         ]
     }
 
diff --git a/local_plugins/ble_service/ios/ble_service/Sources/ble_service/SwiftBleServicePlugin.swift b/local_plugins/ble_service/ios/ble_service/Sources/ble_service/SwiftBleServicePlugin.swift
index 719bcb1a7..0eb432069 100644
--- a/local_plugins/ble_service/ios/ble_service/Sources/ble_service/SwiftBleServicePlugin.swift
+++ b/local_plugins/ble_service/ios/ble_service/Sources/ble_service/SwiftBleServicePlugin.swift
@@ -123,7 +123,9 @@ public class SwiftBleServicePlugin: NSObject, FlutterPlugin {
             BleService.shared.setCallTranslationDebugParams(
                 sendIntervalMs: (arguments?["sendIntervalMs"] as? NSNumber)?.intValue,
                 bundleFrameCount: (arguments?["bundleFrameCount"] as? NSNumber)?.intValue,
-                continuousSend: arguments?["continuousSend"] as? Bool
+                continuousSend: arguments?["continuousSend"] as? Bool,
+                downlinkBitrateKbps: (arguments?["downlinkBitrateKbps"] as? NSNumber)?.intValue,
+                uplinkBitrateKbps: (arguments?["uplinkBitrateKbps"] as? NSNumber)?.intValue
             )
             result(true)
 
diff --git a/local_plugins/ble_service/lib/ble_service.dart b/local_plugins/ble_service/lib/ble_service.dart
index 340ffb076..8ddc17d6b 100644
--- a/local_plugins/ble_service/lib/ble_service.dart
+++ b/local_plugins/ble_service/lib/ble_service.dart
@@ -174,12 +174,16 @@ class BleService {
 
   /// 设置通�翻译调试�数（�行时生效）
   /// [sendIntervalMs] 音频下行��间隔(ms)
-  /// [bundleFrameCount] �包�声�的 opus 帧数(1..6)；下行包无包头�左�帧级交替，包长 = 2*帧数*40B
+  /// [bundleFrameCount] �包�声�的 opus 帧数；下行包无包头�左�帧级交替，包长 = 2*帧数*�帧字节
   /// [continuousSend] 是��续��：true 时无译音也按�下�全�音包，��设备侧音频��断
+  /// [downlinkBitrateKbps] 下行(APP→设备)opus �率；�帧字节 = �率×20ms÷8（16k→40B / 8k→20B）
+  /// [uplinkBitrateKbps] 上行(设备→APP)opus �率，必须与固件实际编��率一致
   Future<bool> setCallTranslationDebugParams({
     int? sendIntervalMs,
     int? bundleFrameCount,
     bool? continuousSend,
+    int? downlinkBitrateKbps,
+    int? uplinkBitrateKbps,
   }) async {
     try {
       final result = await _methodChannel
@@ -187,6 +191,9 @@ class BleService {
         if (sendIntervalMs != null) 'sendIntervalMs': sendIntervalMs,
         if (bundleFrameCount != null) 'bundleFrameCount': bundleFrameCount,
         if (continuousSend != null) 'continuousSend': continuousSend,
+        if (downlinkBitrateKbps != null)
+          'downlinkBitrateKbps': downlinkBitrateKbps,
+        if (uplinkBitrateKbps != null) 'uplinkBitrateKbps': uplinkBitrateKbps,
       });
       return result ?? false;
     } catch (e) {
@@ -195,17 +202,25 @@ class BleService {
     }
   }
 
-  /// 获�当�通�翻译调试�数
-  /// 返回 {'sendIntervalMs': int, 'bundleFrameCount': int, 'continuousSend': bool}，失败返回空 Map
+  /// 获�当�通�翻译调试�数，失败返回空 Map
+  /// {'sendIntervalMs','bundleFrameCount','continuousSend','downlinkBitrateKbps',
+  ///  'uplinkBitrateKbps','downlinkFrameBytes','uplinkFrameBytes','maxBundleFrameCount','packetSizeBytes'}
   Future<Map<String, dynamic>> getCallTranslationDebugParams() async {
     try {
       final result = await _methodChannel
           .invokeMethod<Map>('getCallTranslationDebugParams');
       if (result == null) return {};
+      int readInt(String k) => (result[k] as num?)?.toInt() ?? 0;
       return {
-        'sendIntervalMs': (result['sendIntervalMs'] as num?)?.toInt() ?? 0,
-        'bundleFrameCount': (result['bundleFrameCount'] as num?)?.toInt() ?? 0,
+        'sendIntervalMs': readInt('sendIntervalMs'),
+        'bundleFrameCount': readInt('bundleFrameCount'),
         'continuousSend': result['continuousSend'] as bool? ?? false,
+        'downlinkBitrateKbps': readInt('downlinkBitrateKbps'),
+        'uplinkBitrateKbps': readInt('uplinkBitrateKbps'),
+        'downlinkFrameBytes': readInt('downlinkFrameBytes'),
+        'uplinkFrameBytes': readInt('uplinkFrameBytes'),
+        'maxBundleFrameCount': readInt('maxBundleFrameCount'),
+        'packetSizeBytes': readInt('packetSizeBytes'),
       };
     } catch (e) {
       print('获�通�翻译调试�数失败: $e');