1、修复编译autoconfig.h乱码问题
authorsnickersun <snickersun@163.com>
Sat, 16 May 2026 08:12:10 +0000 (16:12 +0800)
committersnickersun <snickersun@163.com>
Sat, 16 May 2026 08:12:10 +0000 (16:12 +0800)
2、休眠 亮灯改为1秒亮2秒灭
3、更新 交互规范_new.md , 主要添加“## 附录 E:AI 对话处理逻辑(单对话 vs 长对话” 方便检查代码实现是否有遗漏。

1.doc/AI吊坠(双按键+三色指示灯)交互规范_new.md
2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/ai_VC.py
2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/default_config.py
2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/products/configs/7PIN/default_config.py
2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/products/configs/7PIN_1_5/default_config.py
2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/versions.py
2.sdk/tools/patch_qp_log.ps1

index d6db6a8..9a1b7af 100644 (file)
@@ -27,7 +27,7 @@
 
 | 术语           | 时间含义            | 默认 `period_ms`(换色间隔) |
 | ------------ | --------------- | -------------------- |
-| **交替/交替闪**    | 约 **0.5 s 换一色** | `500`                |
+| **交替/交替闪**   | 约 **0.5 s 换一色** | `500`                |
 | **慢交替/交替慢闪** | 约 **1 s 换一色**   | `1000`               |
 
 
 ## 第二部分:AI交互操作(AI键)+ 灯光+提示音联动
 
 
-| 操作动作                              | 对话模式  | 设备当前状态              | 指示灯状态               | 提示音                | 执行结果                              |
-| --------------------------------- | ----- | ------------------- | ------------------- | ------------------ | --------------------------------- |
-| AI键 短按1次                          | 长对话模式 | 待机状态                | 立即切换为蓝色慢闪(1次/秒)     | 单声“滴”(短促,清脆)       | 唤醒AI,进入语音聆听状态,开始收音(用户可说话)         |
-| AI键 短按1次                          | 长对话模式 | 语音聆听中(蓝色慢闪)         | 切换为蓝色慢闪             | 单声“滴”(短促)          | 重新进入语音聆听状态,开始收音(用户可说话)            |
-| AI键 短按1次                          | 长对话模式 | TTS播报中(绿色常亮灯)       | 切换为蓝色慢闪             | 单声“滴”(短促)          | 进入语音聆听状态,开始收音(用户可说话)              |
-| AI键 短按1次                          | 长对话模式 | 思考中(蓝绿交替闪)          | 切换为蓝色慢闪             | 单声“滴”(短促)          | 进入语音聆听状态,开始收音(用户可说话)              |
-| AI键 双击(两次短按,间隔≤1秒)-> 可选(根据可实现性而定) |       | 待机状态 & TTS播报结束后1分钟内 | 蓝色灯常亮(与正常TTS播报灯光一致) | “滴、滴”(2声短促,间隔0.5秒) | 复读上一次AI的TTS回复内容,复读结束后回到待机状态(蓝色灯灭) |
-| AI键 双击>>暂时无功能                     |       |                     |                     |                    |                                   |
-| AI键 长按(按下)                        | 单对话模式 | 待机状态/思考状态/播报状态      | 蓝色快闪(频率加快,2次/秒)     | 单声“滴”(短促,清脆)       | 进入收音状态                            |
-| AI键 长按(松开)                        | 单对话模式 | 聆听中                 | 蓝绿交替闪               | “曾——”(长音,持续1秒)     | 进入思考模式                            |
+| 操作动作                              | 对话模式  | 设备当前状态              | 指示灯状态               | 提示音                | 执行结果                                    |
+| --------------------------------- | ----- | ------------------- | ------------------- | ------------------ | --------------------------------------- |
+| AI键 短按1次                          | 长对话模式 | 待机状态                | 立即切换为蓝色慢闪(1次/秒)     | 单声“滴”(短促,清脆)       | 唤醒AI,进入语音聆听状态,开始收音(用户可说话)               |
+| AI键 短按1次                          | 长对话模式 | 语音聆听中(蓝色慢闪)         | 切换为蓝色慢闪             | 单声“滴”(短促)          | 重新进入语音聆听状态,开始收音(用户可说话)                  |
+| AI键 短按1次                          | 长对话模式 | TTS播报中(绿色常亮灯)       | 切换为蓝色慢闪             | 单声“滴”(短促)          | 进入语音聆听状态,开始收音(用户可说话)                    |
+| AI键 短按1次                          | 长对话模式 | 思考中(蓝绿交替闪)          | 切换为蓝色慢闪             | 单声“滴”(短促)          | 进入语音聆听状态,开始收音(用户可说话)                    |
+| AI键 短按1次                          | 单对话模式 | TTS播报中(绿色常亮)        | 灯灭→idle             | 无(或极短停播)           | **仅停播**,不开录;续聊须再 **长按**(见附录 E5.3)       |
+| AI键 短按1次                          | 单对话模式 | 待机/思考/聆听(非TTS播放)    | 无变化(短按吞掉)           | 无                  | 无业务;开录须 **长按**(见附录 E5)                  |
+| AI键 双击(两次短按,间隔≤1秒)-> 可选(根据可实现性而定) |       | 待机状态 & TTS播报结束后1分钟内 | 蓝色灯常亮(与正常TTS播报灯光一致) | “滴、滴”(2声短促,间隔0.5秒) | 复读上一次AI的TTS回复内容,复读结束后回到待机状态(蓝色灯灭)       |
+| AI键 双击>>暂时无功能                     |       |                     |                     |                    |                                         |
+| AI键 长按(按下)                        | 单对话模式 | 待机状态/思考状态/播报状态      | 蓝色快闪(频率加快,2次/秒)     | 开录提示音(start.mp3)   | 进入收音状态;TTS中重开见附录 E5.2                   |
+| AI键 长按(松开)                        | 单对话模式 | 聆听中(蓝快闪)            | 蓝绿交替闪               | “层”(接入拾音/思考提示)     | 结束上行,进入思考;协议 `audio.completed`(附录 E5.6) |
 
 
 ## 第三部分:电量/充电状态 + 灯光+提示音联动
 ### B3 轮次层 `VCTurnState`(`AI_VC.fsm.turn`)
 
 
-| 值   | 名称                | 含义(简述)                   | 当前 `VCStateMachine` 赋值情况                         |
-| --- | ----------------- | ------------------------ | ---------------------------------------------- |
-| `0` | `Idle`            | 本轮空闲                     | 会写入(会话开始/断开等)                                 |
-| `1` | `Listening`       | 聆听 / 等用户说话(长对话侧常见)       | 会写入(`started` / `canceled` / `audio.played` 后等)   |
-| `2` | `SpeechStreaming` | 语音上行中(流式)                | **枚举保留**;上行是否打开见 `fsm.speech_uplink_open`(`asr.started` 置 1) |
-| `3` | `SpeechEnded`     | 本轮说话结束(等 ASR/LLM)        | 会写入(`vad.silence` 等)                          |
-| `4` | `Thinking`        | LLM 思考中                  | 会写入(`llm.created`;`llm.completed` 兜底补位)        |
-| `5` | `TtsReceiving`    | 正在收 TTS 音频流              | 会写入(`tts.started` / `local.synthesis_sent`)   |
-| `6` | `Playing`         | 本地正在播 TTS                | 会写入(`local.play_start`)                       |
+| 值   | 名称                | 含义(简述)                   | 当前 `VCStateMachine` 赋值情况                                                  |
+| --- | ----------------- | ------------------------ | ------------------------------------------------------------------------- |
+| `0` | `Idle`            | 本轮空闲                     | 会写入(会话开始/断开等)                                                             |
+| `1` | `Listening`       | 聆听 / 等用户说话(长对话侧常见)       | 会写入(`started` / `canceled` / `audio.played` 后等)                           |
+| `2` | `SpeechStreaming` | 语音上行中(流式)                | **枚举保留**;上行是否打开见 `fsm.speech_uplink_open`(`asr.started` 置 1)              |
+| `3` | `SpeechEnded`     | 本轮说话结束(等 ASR/LLM)        | 会写入(`vad.silence` 等)                                                      |
+| `4` | `Thinking`        | LLM 思考中                  | 会写入(`llm.created`;`llm.completed` 兜底补位)                                   |
+| `5` | `TtsReceiving`    | 正在收 TTS 音频流              | 会写入(`tts.started` / `local.synthesis_sent`)                               |
+| `6` | `Playing`         | 本地正在播 TTS                | 会写入(`local.play_start`)                                                   |
 | `7` | `AwaitPlayedAck`  | 已播完,等 `audio.played` 等门控 | **枚举保留**;当前以 `fsm.await_played` 布尔门控为主,`turn` 多在 `Playing`/`TtsReceiving` |
 
 
 与 `tts.started` / `tts.completed` 对齐,用于区分服务端下发阶段(本地可能仍在播)。
 
 
-| 值   | 名称                 | 含义            |
-| --- | ------------------ | ------------- |
-| `0` | `Idle`             | 无 TTS 接收相活动   |
-| `1` | `Started`          | 已收到 `tts.started` |
+| 值   | 名称                | 含义                          |
+| --- | ----------------- | --------------------------- |
+| `0` | `Idle`            | 无 TTS 接收相活动                 |
+| `1` | `Started`         | 已收到 `tts.started`           |
 | `2` | `ServerCompleted` | 已收到 `tts.completed`(本地未必播完) |
 
 
-### B4 旧版 `VC_State_*` 整型(已移除,仅作历史对照)
+### B4 旧版 `VC_State_`* 整型(已移除,仅作历史对照)
 
-源码注释:**「原 `VC_State_*` 整型已移除;会话/轮次见 `VCTurnState` / `VCStateMachine`(含 `tts_rx_phase`、`speech_uplink_open`)。」** 下列宏名**不再出现在运行逻辑中**,仅便于对照旧日志或旧文档。
+源码注释:**「原 `VC_State_`* 整型已移除;会话/轮次见 `VCTurnState` / `VCStateMachine`(含 `tts_rx_phase`、`speech_uplink_open`)。」** 下列宏名**不再出现在运行逻辑中**,仅便于对照旧日志或旧文档。
 
 
-| 宏名(历史)                                | 值    | 含义      |
+| 宏名(历史)                                  | 值    | 含义      |
 | --------------------------------------- | ---- | ------- |
 | `VC_State_None`                         | 0    | 无       |
 | `VC_State_Listening`                    | 1    | 听       |
 
 ### B6 状态机层级与典型跳转(实现速查)
 
-- **两层模型**:`session`(WebSocket 会话生命周期)与 `turn`(单轮「听→说→想→播」)。**`[FSM]` 单行日志**(`VCStateMachine.log`)形如:`[FSM] <reason> session=Started turn=Listening await_played=0 tts_rx=0 speech_up=0`(其中 `tts_rx` 为 `VC_TtsRxPhase` 数值,`speech_up` 为 `speech_uplink_open`)。
-- **`[KEY]` 行内片段**(`_vc_fsm_log_snip`):`sess=<int> turn=<int> tts_rx=<int> await=<0|1> sp_up=<0|1>`,与上式含义一致。
+- **两层模型**:`session`(WebSocket 会话生命周期)与 `turn`(单轮「听→说→想→播」)。`**[FSM]` 单行日志**(`VCStateMachine.log`)形如:`[FSM] <reason> session=Started turn=Listening await_played=0 tts_rx=0 speech_up=0`(其中 `tts_rx` 为 `VC_TtsRxPhase` 数值,`speech_up` 为 `speech_uplink_open`)。
+- `**[KEY]` 行内片段**(`_vc_fsm_log_snip`):`sess=<int> turn=<int> tts_rx=<int> await=<0|1> sp_up=<0|1>`,与上式含义一致。
 - **协议约束**(代码注释摘要):对齐《金三服务-语音对话 V2.5》——收到 `started` 后才允许发音频帧;VAD 开时长对话无需 `audio.create`/`completed`;VAD 关时 PTT 必须 `audio.create`→帧→`audio.completed`;`audio.played` 为进入下一轮的门控之一。
 - **可选严格协议行为**:模块级开关 `VC_PROTO_GUARDS`(默认 `0`)控制 started 前 PCM 缓冲/丢弃、PTT 下 `audio.create` 前禁发 PCM、`llm.completed` 后久无 `tts.started` 的会话兜底等;与产品灯效无直接耦合,联调协议时可关注。
-- **详细边条件**:以 `ai_VC.py` 中 `VCStateMachine` 各 `on_server_*` / `on_local_*` 及事件适配 `on_server_event` 为准;下图为**阅读级**总览(与当前赋值路径对齐:`Listening` 可直接到 `SpeechEnded`),非穷举所有分支。
+- **详细边条件**:以 `ai_VC.py` 中 `VCStateMachine` 各 `on_server_`* / `on_local_*` 及事件适配 `on_server_event` 为准;下图为**阅读级**总览(与当前赋值路径对齐:`Listening` 可直接到 `SpeechEnded`),非穷举所有分支。
 
 ```mermaid
 stateDiagram-v2
@@ -307,10 +309,10 @@ stateDiagram-v2
 `**VC_mode` 与 FSM 关系(简述)**
 
 
-| `VC_mode` | 对 `turn` 的影响要点                                                |
-| --------- | ------------------------------------------------------------- |
-| `0` 长对话   | 易在 `Listening` 与上行、`canceled` 自动续听等路径间切换;详见 PTT 与长对话分支        |
-| `1` 单对话   | 依赖 `audio.create` / `audio.completed`;长按 `ptt_begin` 打断后重开上行等 |
+| `VC_mode` | 对 `turn` 的影响要点                                                                                |
+| --------- | --------------------------------------------------------------------------------------------- |
+| `0` 长对话   | 易在 `Listening` 与上行、`canceled` 自动续听等路径间切换;详见 PTT 与长对话分支                                        |
+| `1` 单对话   | 依赖 `audio.create` / `audio.completed`;长按 `ptt_begin`:本地停播 →(忙态)`cancel` → `audio.create` 重开上行 |
 
 
 ---
@@ -390,7 +392,464 @@ stateDiagram-v2
 
 1. 需要 **「异常专用灯」**:应在业务点增加 `**set_led_state` 新键**(如 `alert`)并在 `**AI_led._apply_by_table`** 中插入优先级;当前未做。
 2. 仅依赖 **现有键**:异常后务必 `**ai_state: idle`** 才会重新露出 **充电/电量/信号** 灯;否则用户会一直看到 **AI 阶段灯**。
-3. `**websocket_error`** 内已 `**set_led_state({"ai_state":"idle"})`**,可与 `**get_led_debug_state**` 联调确认 `charging/battery/signal` 是否已刷新。
+3. `**websocket_error`** 内已 `**set_led_state({"ai_state":"idle"})`**,可与 `**get_led_debug_state`** 联调确认 `charging/battery/signal` 是否已刷新。
 
 ---
 
+## 附录 E:AI 对话处理逻辑(单对话 vs 长对话)
+
+> **与正文关系**:第二部分表格描述用户可感知的「按键→灯→音→结果」;本附录描述 **协议与本地执行顺序**,供固件(`ai_VC.py`)联调与评审。实现以当前编译进镜像的 `ai_VC.py` 为准。  
+> **模式存储**:`VC_mode`(`0`=长对话 / `1`=单对话),Power 键双击可切换并 TTS 播报模式名(见正文第一部分)。
+
+### E0 典型场景速查(产品语言)
+
+**单对话 · 场景 1:TTS 播报中,AI 键重新开始对话(长按)**
+
+
+| 步骤  | 要求                                               |
+| --- | ------------------------------------------------ |
+| 1   | **本地立即停播**,清空 `AI_audio_queue` 与 codec 缓冲,杜绝残余尾音 |
+| 2   | 发 **停止当前轮** 消息(`cancel`,服务端停止生成;**不换会话**)        |
+| 3   | 发 **继续对话** 消息(`audio.create`)                    |
+| 4   | 打开录音 → 播 **开录提示音**(start.mp3)→ 开始上传 PCM          |
+| 5   | 松手发 `audio.completed`,进入思考 → TTS 播放              |
+
+
+**长对话 · 对照**:TTS 播报中 **短按** AI 键续聊 → 本地清队列 + `cancel` → 收 `canceled` 后 **直接开麦**(无需 `audio.create`)。详见 **E4.2**、**E6**。
+
+**场景索引**
+
+
+| 模式  | 场景          | 章节        |
+| --- | ----------- | --------- |
+| 长对话 | TTS 中短按打断续聊 | E4.2      |
+| 长对话 | 聆听中短按重开麦    | E4.3      |
+| 长对话 | 思考中短按打断     | E4.4      |
+| 长对话 | 待机唤醒        | E4.5      |
+| 长对话 | VAD 自动多轮    | E4.7      |
+| 单对话 | TTS 中长按重开   | E5.2      |
+| 单对话 | TTS 中短按仅停播  | E5.3      |
+| 单对话 | 待机/思考长按开录   | E5.4      |
+| 单对话 | 标准一轮 PTT    | E5.6      |
+| 单对话 | 播完后再问       | E5.7      |
+| 通用  | 完整状态矩阵      | E4.6、E5.8 |
+| 通用  | 服务端事件对照     | E10       |
+| 可选  | AI 键双击复读    | E9        |
+
+
+### E1 模式总览
+
+
+| 维度        | 长对话 `VC_mode=0`(Realtime)                    | 单对话 `VC_mode=1`(Push-To-Talk / PTT)                                    |
+| --------- | -------------------------------------------- | ---------------------------------------------------------------------- |
+| 用户操作      | **短按** AI 键唤醒 / 打断 / 续聊                      | **长按** 开录、**松开** 结束本轮上行                                                |
+| VAD       | 开(服务端判停)                                     | 关(`disable_vad=true`)                                                  |
+| 上行包裹      | 一般 **无需** `audio.create` / `audio.completed` | **必须** `audio.create` → PCM 帧 → `audio.completed`                      |
+| 打断 TTS 续聊 | 短按:发 `**cancel`** + 本地清队列 → 等 `canceled` 后开麦 | **长按**:本地停播清队列 →(TTS/思考态)发 `**cancel`**(不换 `sid`)→ `audio.create` 开新一轮 |
+| 典型灯效      | 聆听蓝慢闪 / 思考蓝绿交替 / 播放绿常亮                       | 长按聆听蓝快闪;松手后思考蓝绿交替                                                      |
+| 进入下一轮门控   | `audio.played`(播完上报)、`canceled` 后自动开麦等       | 松手 `audio.completed` 后等 ASR/LLM/TTS;再次长按走 `ptt_begin`                  |
+
+
+**设计目标**:用户在任何中间态(TTS 播报、思考、弱网恢复中等)按 AI 键,应 **尽快** 进入「下一轮可说话」或「继续当前会话内的新一轮上行」,且 **无残余 TTS 尾音、无播放队列叠录**。
+
+### E2 协议消息与「停止 / 继续」语义
+
+
+| 产品用语          | WebSocket `event`              | 适用模式                   | 作用                                                       |
+| ------------- | ------------------------------ | ---------------------- | -------------------------------------------------------- |
+| 停止当前轮次 / 打断播报 | `cancel`                       | **长对话**(短按打断 TTS、思考中等) | 通知服务端撤销当前响应;端侧随后收 `canceled`,再开麦                         |
+| 本地停止播放(非协议)   | —(`VC_init` + `VC_Play_End`)   | **单对话、长对话**            | 立即停止 PCM/流播放,**清空 `AI_audio_queue`**,必要时 `aud.stopAll()` |
+| 继续对话 / 开新一轮上行 | 长对话:开麦上行 PCM(无 `audio.create`) | 长对话                    | `request_uplink_start` → `VC_Speech_Start_now`           |
+| 继续对话 / 开新一轮上行 | 单对话:`audio.create`             | 单对话                    | `AI_client_VC_send_speech` → 录音 → 帧上行                    |
+| 本轮说话结束        | `audio.completed`              | 单对话                    | 松手触发 `AI_client_VC_end_speech`                           |
+| 本地 TTS 播完     | `audio.played`                 | 长对话为主                  | 播完后上报,服务端进入下一轮 ASR(门控之一)                                 |
+
+
+> **「停止对话」与 `cancel` 的分工**:`cancel` 仅撤销**当前轮**服务端响应(LLM/TTS 生成),**不断开 WebSocket、不换 `sid`**;与 Power 键 `Close`(换会话)区分。单对话在 TTS/思考态 **长按重开** 时也会发 `cancel`,避免旧轮下行与新一轮 `audio.create` 竞态;须 **先本地停播清队列**(用户侧立即静音),再发 `cancel`,再发 `audio.create`。
+
+### E3 本地停播与清缓存(凡打断 TTS 必做)
+
+无论哪种模式,只要用户打断 **TTS/本地播报**,须在同一按键处理链内完成(顺序不可颠倒):
+
+
+| 步骤  | 动作                                             | 说明                                             |
+| --- | ---------------------------------------------- | ---------------------------------------------- |
+| L1  | `VC_Play_End()` / `VC_init()`                  | 停播放流、`VC_Play_flag=0`;`AI_audio_queue.clear()` |
+| L2  | `aud.stopPlayStream()` + `aud.stopAll()`       | 避免 DMA/codec 缓冲残留                              |
+| L3  | `_drop_tts_audio = 1`(可选窗口)                    | 打断后短时 **丢弃** 服务端仍下发的 TTS 帧,防「断断续续继续播」          |
+| L4  | `fsm.await_played = false`(若曾等 `audio.played`) | 避免门控卡死,无法开麦                                    |
+| L5  | 灯 `ai_state: idle` 或 `listening`               | 打断瞬间可先 `idle`;开录后切 `listening`                 |
+
+
+TTS 自然播完:队列读空后 `VC_Play_End`;若本轮需门控,再在适当时机发 `audio.played`。
+
+### E4 长对话(`VC_mode=0`)— AI 键处理
+
+#### E4.1 状态 → 动作
+
+
+| 设备状态(用户视角)  | FSM 近似                          | AI 键 **短按**   | 协议 / 本地顺序                                                                     |
+| ----------- | ------------------------------- | ------------- | ----------------------------------------------------------------------------- |
+| 待机、未建会话     | `session≠Started`               | 唤醒            | `AI_VC_start` → `Start` → 等 `started` → 开麦 → 蓝慢闪 + 开录提示                       |
+| 聆听中         | `turn=Listening`                | 重新聆听          | `request_uplink_start("key.press/continue")` → 清僵死录音态 → `VC_Speech_Start_now` |
+| 思考中         | `turn=Thinking`                 | 打断并开麦         | 见 **E4.4**(宜 `cancel`;管线忙时同 E4.2)                                             |
+| **TTS 播报中** | `turn=Playing` / `TtsReceiving` | **打断并续聊**     | 见 **E4.2**                                                                    |
+| 弱网 / 异常     | `signal=weak` 等                 | 同待机或 Close 策略 | 以异常附录 D 为准                                                                    |
+
+
+#### E4.2 场景:TTS 播报中短按 — 打断并进入下一轮聆听
+
+**目标**:尽快停播、通知服务端停止当前响应、开麦。
+
+```text
+用户短按 AI 键
+  → (1) is_ruppt_tts = 1
+  → (2) VC_init(立即停播 + 清空 AI_audio_queue)
+  → (3) 发 cancel(RequestToSpeak)
+  → (4) 等 server.canceled
+  → (5) FSM: uplink_start(canceled) → VC_Speech_Start_now
+  → (6) 蓝慢闪 + 开录提示音(start.mp3 等)+ 上行 PCM(VAD,无 audio.create)
+```
+
+**灯与音**:发 `cancel` 前后本地已无 TTS;开录时蓝慢闪 + 「滴」类开录提示(与正文第二部分一致)。  
+**注意**:`Close_flag` 须在 `RequestToSpeak` 路径清零,否则 `canceled` 后 `_uplink_request_start` 会拒开麦。
+
+#### E4.3 场景:会话已建立、聆听中短按 — 重新开麦
+
+**用户意图**:上一轮 VAD 已判停或仍在聆听,希望 **再说一段**。
+
+```text
+用户短按 AI 键(session=Started,turn=Listening/SpeechEnded,非 TTS 忙)
+  → request_uplink_start("key.press/continue")
+  → _vc_clear_stale_record_state(若 record_flag 僵死)
+  → VC_Speech_Start_now
+  → 蓝慢闪 + 开录提示音 + PCM 上行(VAD,无 audio.create)
+```
+
+不发 `cancel`(当前轮无服务端 TTS/播放占用)。
+
+#### E4.4 场景:思考中短按 — 打断并开麦
+
+**用户意图**(正文第二部分):不等 LLM/TTS 完成,直接说话。
+
+```text
+用户短按 AI 键(turn=Thinking 或 TTS 管线忙)
+  → 若 _vc_tts_pipeline_busy()(含 _tts_pending / tts_rx / Playing 等):
+       同 E4.2:VC_init → cancel → canceled → uplink_start
+  → 否则(纯 Thinking、管线不忙):
+       产品应 cancel 打断;当前实现可能仅 request_uplink_start,
+       若 turn≠Listening/SpeechEnded 会被门控拒绝(串口 Deny START by key.press/continue)
+       → 联调时建议统一走 RequestToSpeak
+```
+
+**灯与音**:打断成功后蓝慢闪 + 开录提示。
+
+#### E4.5 场景:待机 / 未建会话短按 — 唤醒
+
+```text
+用户短按 AI 键(未连接或未 started)
+  → 落入 AI_key_press 兜底:AI_VC_start → Start → 等 started
+  → started 后:request_uplink_start("server.started/idle")
+  → 蓝慢闪 + 开录提示 + VAD 上行
+```
+
+**注意**:此路径含 `utime.sleep_ms(500)` 与历史 `Close` 兼容逻辑,与「已连接续聊」分支不同;联调以 `[KEY]`、`[VC][uplink_ctrl]` 为准。
+
+#### E4.6 长对话 — 完整状态矩阵(AI 键短按)
+
+
+| 设备状态(用户视角) | FSM 近似                   | 短按动作       | 协议要点                                 | 灯效    |
+| ---------- | ------------------------ | ---------- | ------------------------------------ | ----- |
+| 待机、未建会话    | `session≠Started`        | 唤醒开麦       | `Start` → `started` → 上行 PCM         | 蓝慢闪   |
+| 聆听中        | `Listening`              | 重开麦        | `uplink_start`,无 `cancel`            | 蓝慢闪   |
+| 用户说完等 ASR  | `SpeechEnded`            | 可重开麦       | `uplink_start`(若门控允许)                | 蓝慢闪   |
+| 思考中        | `Thinking`               | 打断开麦       | **宜** `cancel`→`canceled`→开麦(见 E4.4) | 蓝慢闪   |
+| TTS 接收/播报  | `TtsReceiving`/`Playing` | 打断续聊       | E4.2:`cancel` + 清队列                  | 蓝慢闪   |
+| TTS 自然播完   | → `audio.played`         | 无需按键       | 自动 `uplink_start`(长对话)               | 蓝慢闪   |
+| 弱网         | `signal=weak`            | 同唤醒或 Close | 附录 D                                 | 蓝绿慢交替 |
+
+
+#### E4.7 长对话 — 无按键自动轮次(VAD 闭环)
+
+```text
+开麦聆听(Listening)
+  → 用户说话,PCM 上行
+  → 服务端 vad.silence → uplink_stop,turn=SpeechEnded
+  → llm.created → Thinking(蓝绿交替)
+  → tts.started → TtsReceiving → local.play_start → Playing(绿常亮)
+  → 本地播完 → audio.played(若 _need_audio_played_ack)
+  → on_local_audio_played → Listening,可自动 uplink_start 进入下一轮
+```
+
+**门控**:`await_played` 为真时,禁止 `completed`/`canceled` 抢跑开麦;`Close_flag=1` 时拒绝 `canceled`/`audio.played` 触发的自动开麦。
+
+### E5 单对话(`VC_mode=1`)— AI 键处理
+
+#### E5.1 操作分工
+
+
+| 操作         | 作用                   | 说明                                                                                         |
+| ---------- | -------------------- | ------------------------------------------------------------------------------------------ |
+| **短按**     | 仅在 **TTS/播放管线忙** 时有效 | 仅 **本地** `VC_Play_End` + 清队列;**不** 开录、**不** 发 `audio.create`;非播放态短按无业务(由 `ptt_begin` 承担开录) |
+| **长按(按下)** | 开始 / **重新开始** 一轮对话   | 走 `ptt_begin`(`AI_key_long_press`)                                                         |
+| **长按(松开)** | 结束本轮上行               | `AI_client_VC_end_speech`(`audio.completed`)→ 思考灯 + 「层」提示音                                 |
+
+
+#### E5.2 场景 1:TTS 播报中 **长按** — 重新开始一轮对话(核心示例)
+
+**用户意图**:不等 TTS 播完,尽快进入下一轮「按住说话」或继续当前会话内的新一轮上行。
+
+**产品要求(执行顺序不可颠倒)**:
+
+1. **先本地停播并清空播放缓存**(用户侧须立即静音,防止残余 TTS 尾音)。
+2. **再发停止当前轮次消息**(WebSocket `cancel`,仅当服务端仍在 TTS/思考等中间态)。
+3. **再发继续对话协议**(`audio.create`,不换 `sid`)。
+4. **打开录音** → **播开录提示音** → **上行 PCM 帧**(`audio.create` 与开麦顺序受 `VC_PROTO_GUARDS` 约束)。
+
+**固件链路(`ptt_begin`,与 `ai_VC.py` 对齐)**:
+
+```text
+用户长按 AI 键(ptt_begin)
+  → (1) Close_flag = 0;_drop_tts_audio = 1
+  → (2) VC_init()                         // 立即停播 + 清空 AI_audio_queue(VC_Play_End)
+  → (3) 若仍在播:再次 VC_Play_End()       // 兜底 codec/DMA 缓冲
+  → (4) 若上一轮录音未结束:VC_Speech_End()
+  → (5) 若 turn∈{Thinking,TtsReceiving,Playing} 或 TTS 管线忙:
+         发 cancel(停止当前轮服务端响应,不换 sid)
+  → (6) 若 WebSocket 未连接 / 未 started:
+         AI_VC_start 或 Start;_ptt_force_record_on_started,等 started 后自动 (7)~(11)
+      否则(会话已 started):
+  → (7) 发 audio.create(AI_client_VC_send_speech)   // 继续对话 / 新一轮上行
+  → (8) VC_Speech_Start_now()                         // 开硬件录音
+  → (9) 开录提示音(RECORD_START_TONE_FILE / start.mp3,由 VC_Speech_Start 路径播放)
+  → (10) 蓝灯聆听态(长按按下:蓝快闪,见正文第二部分)
+  → (11) 上行 PCM 帧(须在 audio.create 之后)
+```
+
+**为何本地停播优先于 `cancel`**:用户按下 AI 键后 **≤100ms** 内应听不到旧 TTS;若先发 `cancel` 再等本地清队列,DMA/队列中已缓冲的 PCM 仍会播出。本地 `VC_init` 后再 `cancel`,可同时满足「马上静音」与「服务端停止生成」。
+
+**与产品描述的对应**:
+
+
+| 产品描述          | 单对话实现                                                     |
+| ------------- | --------------------------------------------------------- |
+| 「停止对话消息」      | TTS/思考态:`**cancel`**;并 **必先** 完成 E3 本地 L1~L3              |
+| TTS 立即停止或自然结束 | **以 L1~L2 立即停播为准**;无新数据后播放线程退出;`_drop_tts_audio` 丢弃迟到的下行帧 |
+| 「继续对话协议」      | `**audio.create`**(保持当前 `sid` / `dialog_id`)              |
+| 打开录音          | `VC_Speech_Start_now`                                     |
+| 开录提示音         | `RECORD_START_TONE_FILE` / start.mp3                      |
+| 上传录音          | 录音线程 → WS 发 PCM 帧 → 松手发 `audio.completed`                 |
+
+
+**松开手指**:`audio.completed` → 服务端 ASR/LLM/TTS → 思考蓝绿交替 + 「层」音 → 播放绿常亮。
+
+#### E5.3 场景 2:TTS 播报中 **短按** — 仅打断播放
+
+```text
+短按 → VC_Play_End + 清队列 + await_played=false + 灯 idle
+     → 不 audio.create、不开麦(_ptt_short_press_stop 标记,松手不触发 end_speech)
+```
+
+用于「只想闭嘴、暂不继续说」;要续聊须 **再次长按**。
+
+#### E5.4 场景 3:待机 / 思考中 **长按** — 开始或重开一轮
+
+- **待机、未连接**:`AI_VC_start` → 等 `started` → 自动 `audio.create` + 开录(`_ptt_force_record_on_started`)。
+- **思考中、无 TTS 播放**:同 E5.2 的 (1)~(11);`turn=Thinking` 时发 `cancel`,再 `audio.create`。
+
+#### E5.5 场景 4:聆听中 **长按** — 重录当前轮
+
+用户按下时尚未松手、或希望 **覆盖本轮录音**:
+
+```text
+长按(ptt_begin)
+  → VC_init / 停上一轮录音(VC_Speech_End 若 flag≠0)
+  → cancel(若仍在 Thinking/TTS 管线)
+  → audio.create + VC_Speech_Start_now + 开录提示
+  → 松手 → audio.completed
+```
+
+**说明**:单对话一轮以「按下→松开」为边界;聆听中再次长按视为 **新开一轮** `audio.create`,非长对话式续麦。
+
+#### E5.6 场景 5:标准一轮 PTT(按下 → 松开 → 应答)
+
+**用户操作**:待机或上轮结束后 **长按说话,松手结束**。
+
+```text
+长按按下(ptt_begin)
+  → audio.create → VC_Speech_Start_now → 蓝快闪 + start.mp3
+  → 上行 PCM 帧…
+长按松开(_ai_key_release_handle_ptt,record_flag≠0)
+  → AI_client_VC_end_speech(audio.completed)
+  → uplink_stop,turn 经 SpeechEnded → Thinking
+  → 灯:蓝绿交替 + 「层」提示音
+服务端 asr.result → llm → tts.started
+  → 绿常亮播放 TTS
+  → 播完:本地 VC_Play_End;单对话一般 **不等** audio.played 门控下一轮
+  → 用户可再次长按开始新一轮(E5.2 / E5.4)
+```
+
+**与长对话差异**:松手后 **不会** 自动开麦;必须再次 **长按** 才能说下一句话。
+
+#### E5.7 场景 6:TTS 自然播完 → 待机后再问
+
+```text
+TTS 队列读空 → VC_Play_End → ai_state 回 idle(或绿灯慢闪待机)
+  → 用户长按 ptt_begin
+  → 若 session 仍 started:直接 audio.create + 开录
+  → 若会话已 Close/超时:AI_VC_start → started → 再开录
+```
+
+无 `cancel`(除非上轮服务端仍在 Thinking/TTS 下行)。
+
+#### E5.8 单对话 — 完整状态矩阵(AI 键)
+
+
+| 设备状态(用户视角) | 短按            | 长按按下                    | 长按松开              | 协议要点                             |
+| ---------- | ------------- | ----------------------- | ----------------- | -------------------------------- |
+| 待机、未连接     | 无             | 建链+开录                   | —                 | `Start`→`started`→`audio.create` |
+| 聆听中(蓝快闪)   | 吞掉            | 重开一轮(E5.5)              | `audio.completed` | 松手结束上行                           |
+| 思考中        | 吞掉            | 打断+`audio.create`(E5.4) | 若已开录则 completed   | `cancel`(忙态)                     |
+| TTS 播报中    | **仅停播**(E5.3) | **重开一轮**(E5.2)          | 停播后松手无 completed  | 长按:cancel+create                 |
+| TTS 播完待机   | 吞掉            | 新一轮(E5.7)               | completed         | `audio.create`                   |
+| 弱网 / 异常    | 无             | 同待机尝试                   | —                 | 附录 D                             |
+
+
+#### E5.9 单对话时序简图(长按打断 TTS)
+
+```mermaid
+sequenceDiagram
+    participant U as 用户
+    participant D as 设备端
+    participant S as 服务端
+
+  Note over D,S: turn=Playing,TTS 下行中
+  U->>D: 长按 AI 键
+  D->>D: VC_init / VC_Play_End,清空播放队列
+  D->>D: _drop_tts_audio=1
+  D->>S: cancel(TTS/思考态)
+  D->>S: audio.create
+  D->>D: VC_Speech_Start_now,开录提示音
+  D->>S: PCM 音频帧…
+  U->>D: 松开
+  D->>S: audio.completed
+  S-->>D: asr / llm / tts 事件
+```
+
+
+
+### E6 长对话打断 TTS 时序(对照)
+
+```mermaid
+sequenceDiagram
+    participant U as 用户
+    participant D as 设备端
+    participant S as 服务端
+
+  U->>D: 短按 AI 键
+  D->>D: VC_init(立即停播,清播放队列)
+  D->>S: cancel
+  S-->>D: canceled
+  D->>D: uplink_start → VC_Speech_Start_now,开录提示音
+  D->>S: PCM 上行(VAD,无 audio.create)
+```
+
+
+
+### E7 与电源键、模式切换的边界
+
+
+| 操作            | 行为                                                          |
+| ------------- | ----------------------------------------------------------- |
+| Power 短按(交互中) | `Close`:断会话 / 清 `sid`,进待机;**不是** 续聊                         |
+| Power 双击      | 切换 `VC_mode` 并 TTS 播报「单对话/长对话」;若正在对话先 `Close`               |
+| 单对话 ↔ 长对话切换后  | 须重新 `Start` / 按键建会话;避免沿用上一种模式的 `cancel` / `audio.create` 假设 |
+
+
+### E8 联调检查清单
+
+
+| #   | 检查项                        | 长对话                                                | 单对话                                           |
+| --- | -------------------------- | -------------------------------------------------- | --------------------------------------------- |
+| 1   | TTS 中按键后 **500ms 内** 无残余播报 | 短按+cancel 路径                                       | 长按 `ptt_begin` 路径                             |
+| 2   | `AI_audio_queue` 深度为 0     | `VC_init` 后打印 `[VC] init audio_queue`              | 同左                                            |
+| 3   | 开录前已 `started`             | 是                                                  | 是;否则 `audio.create` 被 SKIP(`VC_PROTO_GUARDS`) |
+| 4   | 开录提示音不叠按键音                 | 短按提示音已关                                            | `ptt_begin` 内不再叠短嘟                            |
+| 5   | 打断后能快速第二轮                  | `canceled`→开麦                                      | 松手→播完→再长按;或 TTS 中直接长按                         |
+| 6   | 串口日志                       | `[KEY]`、`[PTT]`、`[FSM]`、`[VC][proto] audio.create` | 同左                                            |
+
+
+### E9 AI 键双击(复读,可选)
+
+正文第二部分:**待机且上轮 TTS 结束 1 分钟内**,双击 AI 键复读上一段 TTS。
+
+
+| 项目   | 说明                                                                                              |
+| ---- | ----------------------------------------------------------------------------------------------- |
+| 产品行为 | 蓝常亮播复读内容 → 结束回待机(灯灭)                                                                            |
+| 工程现状 | `ai_VC` 内 **AI 键双击业务未实现**;`pwk_key_double_press` 为 **Power 键双击切模式**(`VC_mode` 0↔1 + TTS 提示),勿混淆 |
+| 若需落地 | 缓存末轮 TTS PCM/文本;双击时本地 `play_tts` 或重放队列;期间 `ai_state=playing`;不与 `ptt_begin`/`cancel` 并发         |
+
+
+### E10 服务端事件与端侧动作对照(联调)
+
+
+| 服务端 `event`                     | 长对话典型端侧动作                | 单对话典型端侧动作                                               |
+| ------------------------------- | ------------------------ | ------------------------------------------------------- |
+| `started`                       | `uplink_start` 或等用户按键    | PTT:`audio.create`+开麦(若 `_ptt_force_record_on_started`) |
+| `vad.silence`                   | `uplink_stop`,停上行        | 一般不走(VAD 关)                                             |
+| `asr.started` / `asr.completed` | 更新 FSM,可能提示音             | 松手后 ASR                                                 |
+| `llm.created`                   | `turn=Thinking`,蓝绿交替     | 同左                                                      |
+| `tts.started`                   | 停上行、`play_start`、绿常亮     | 同左                                                      |
+| `tts.completed`                 | 标记服务端下发结束;本地可能仍播         | 同左                                                      |
+| `canceled`                      | `uplink_start` 自动开麦(长对话) | **不**自动开麦(`VC_mode≠0` 门控)                               |
+| `completed`                     | 无 TTS 时可能 `uplink_start` | 不自动开麦                                                   |
+| `config.update`                 | `uplink_stop`            | `uplink_stop`                                           |
+
+
+本地 `**audio.played`**:长对话播完上报后门控下一轮;单对话以用户 **长按** 开始下一轮为主。
+
+### E11 实现差异与待对齐项(评审用)
+
+
+| #   | 场景        | 产品/正文     | 当前 `ai_VC.py` 要点                                        |
+| --- | --------- | --------- | ------------------------------------------------------- |
+| 1   | 长对话·思考中短按 | 打断并开麦     | 仅 TTS 管线忙时走 `cancel`;纯 `Thinking` 可能 `Deny START`(E4.4) |
+| 2   | 长对话·待机短按  | 直接唤醒      | 未命中分支时走 `AI_VC_start` 兜底(含 500ms sleep)                 |
+| 3   | 单对话·短按    | 非 TTS 无操作 | `_ai_key_press_ptt_mode` 非播放态 **return True 吞掉**        |
+| 4   | AI 键双击复读  | 可选        | **未实现**;Power 双击为切模式(E9)                                |
+| 5   | 待机灯       | 正文灯灭      | 工程绿灯慢闪(附录 A)                                            |
+
+
+若产品要求单对话 **短按即开录**,须改 `_ai_key_press_ptt_mode` 并同步正文第二部分表格。
+
+### E12 联调日志关键字(补充 E8)
+
+
+| 日志                                               | 含义                            |
+| ------------------------------------------------ | ----------------------------- |
+| `[KEY] AI_key_press VC_mode=`                    | 按键模式与 FSM 快照                  |
+| `[PTT] cancel before new uplink`                 | 单对话长按前已发 cancel               |
+| `[PTT] wait server.started`                      | 等 `started` 后再 `audio.create` |
+| `[VC][proto] audio.create send` / `SKIP`         | PTT 开轮是否成功                    |
+| `[VC][uplink_ctrl] Request START` / `Deny START` | 长对话开麦门控                       |
+| `[FSM] server.canceled`                          | 打断成功,长对话可续麦                   |
+| `[VC] init audio_queue`                          | 清播放队列成功                       |
+
+
+---
+
+
+
+
+
+## **要点摘要**
+
+**长对话**:短按打断 TTS → `VC_init` → `cancel` → `canceled` → 自动开麦;VAD 判停后可多轮自动循环(E4.7)。
+
+**单对话**:长按开录 / 松手 `audio.completed`;TTS 中 **短按只停播**,续聊须 **再长按**;标准流程见 E5.6。
+
+**实现差异(E11)**:长对话在纯 `Thinking` 且 TTS 管线不忙时,短按可能被 `uplink` 门控拒绝,产品要求打断时应统一走 `cancel`;AI 键双击复读尚未实现。
+
+如需下一步把 E11 中的差异落实到 `ai_VC.py` 代码修改,可以说明优先项。
+
index 6211982..3623398 100644 (file)
@@ -83,6 +83,25 @@ VC_HEARTBEAT_LOG = 0
 VC_PROTO_GUARDS = 0
 # 1=打印 VC WebSocket 每条收发的完整文本(流量大、易刷屏);0 仅一行 event 摘要(llm.delta 省略)
 VC_WS_IO_LOG = 0
+# 长对话「无业务下行」idle:下列 JSON event/type 及裸文本 ping/pong 不重置 close_timerout。
+# 帧级 WebSocket PING/PONG 在 uwebsocket.recv() 内已处理,不会进入 AI_client_VC_recv。
+# 金三 V2.5 文档示例:WebSocket 文本帧 "ping" 保活;对端可能回 pong / heartbeat 类事件。
+_VC_KEEPALIVE_RX_EVENTS = frozenset(("pong", "ping", "heartbeat", "keepalive"))
+
+
+def _vc_out_json_event_meta(s):
+    """解析 WS 出站 JSON:event 可能在 header 或顶层(Start/audio.create vs synthesis)。"""
+    try:
+        jd = ujson.loads(s)
+        h = jd.get("header")
+        if isinstance(h, dict):
+            ev = h.get("event") or ""
+            if ev:
+                return ev, h.get("trace_id") or ""
+        ev = jd.get("event") or ""
+        return ev, ""
+    except Exception:
+        return "", ""
 
 
 class AI_led(Abstract):
@@ -114,6 +133,8 @@ class AI_led(Abstract):
         self._blink_on = 0
         self._bg_phase = 0
         self._period_ms = 1000
+        self._gb_on_ms = 1000
+        self._gb_off_ms = 1000
 
         EventMesh.subscribe("set_led_state", self.set_led_state)
         EventMesh.subscribe("get_led_debug_state", self.get_led_debug_state)
@@ -181,20 +202,27 @@ class AI_led(Abstract):
         self._timer_stop()
         self._set_rgb(0, 1, 0)
 
-    def _set_green_blink(self, period_ms=1000):
-        """待机/空闲:绿灯慢闪(替代呼吸灯,数字 GPIO 整颗亮灭)。"""
-        period_ms = period_ms or 1000
+    def _set_green_blink(self, on_ms=1000, off_ms=None):
+        """待机/空闲:绿灯慢闪(替代呼吸灯,数字 GPIO 整颗亮灭)。off_ms 缺省则与 on_ms 对称。"""
+        on_ms = int(on_ms or 1000)
+        if off_ms is None:
+            off_ms = on_ms
+        else:
+            off_ms = int(off_ms or on_ms)
         try:
-            if self._mode == "green_blink" and int(self._period_ms) == int(period_ms):
+            if (self._mode == "green_blink" and int(self._gb_on_ms) == int(on_ms)
+                    and int(self._gb_off_ms) == int(off_ms)):
                 return
         except Exception:
             pass
         self._mode = "green_blink"
-        self._period_ms = period_ms
+        self._gb_on_ms = on_ms
+        self._gb_off_ms = off_ms
+        self._period_ms = on_ms
         self._blink_on = 1
         self._timer_stop()
         self._set_rgb(0, 1, 0)
-        self._timer.start(self._period_ms, 1, self._timer_cb)
+        self._timer.start(self._gb_on_ms, 0, self._timer_cb)
 
     def _set_blue_blink(self, period_ms=1000):
         self._mode = "blue_blink"
@@ -227,6 +255,11 @@ class AI_led(Abstract):
         if self._mode == "green_blink":
             self._blink_on = 0 if self._blink_on else 1
             self._set_rgb(0, 1 if self._blink_on else 0, 0)
+            next_ms = self._gb_on_ms if self._blink_on else self._gb_off_ms
+            try:
+                self._timer.start(next_ms, 0, self._timer_cb)
+            except Exception:
+                pass
             return
         if self._mode == "blue_blink":
             self._blink_on = 0 if self._blink_on else 1
@@ -308,16 +341,26 @@ class AI_led(Abstract):
                 return
         except Exception:
             pass
-        # 空闲待机:绿灯慢闪(整周期约 2×idle_ms,默认对齐「慢闪 ≈2 s 一亮灭」)
+        # 空闲待机:绿灯慢闪(亮 LED_IDLE_GREEN_BLINK_MS / 灭 LED_IDLE_GREEN_BLINK_OFF_MS;未配 OFF 则与亮时间对称)
         try:
-            idle_ms = 1000
+            idle_on = 1000
             if "vc_config" in globals() and vc_config:
-                idle_ms = int(vc_config.get_int("LED_IDLE_GREEN_BLINK_MS", 1000))
-            if idle_ms < 400:
-                idle_ms = 400
-            self._set_green_blink(idle_ms)
+                idle_on = int(vc_config.get_int("LED_IDLE_GREEN_BLINK_MS", 1000))
+            idle_off = idle_on
+            if "vc_config" in globals() and vc_config:
+                _ioff = vc_config.get_attr("LED_IDLE_GREEN_BLINK_OFF_MS", None)
+                if _ioff is not None:
+                    try:
+                        idle_off = int(_ioff)
+                    except Exception:
+                        idle_off = idle_on
+            if idle_on < 400:
+                idle_on = 400
+            if idle_off < 400:
+                idle_off = 400
+            self._set_green_blink(idle_on, idle_off)
         except Exception:
-            self._set_green_blink(1000)
+            self._set_green_blink(1000, 2000)
 
     def get_led_debug_state(self, event=None, msg=None):
         # 供按键/状态机打印当前 LED 聚合状态与最终模式
@@ -3352,6 +3395,211 @@ class AI_VC(Abstract):
         except Exception:
             return False
 
+    def _vc_is_business_idle(self):
+        # Level2:LED ai_state 为 idle,且无录音/流播/音乐闹钟等(与 WS ping 无关)
+        try:
+            if getattr(self, "music_play_flag", 0) == 1:
+                return False
+            if getattr(self, "alarm_play_flag", 0) == 1:
+                return False
+        except Exception:
+            pass
+        try:
+            if getattr(self, "VC_record_state_flag", 0) != 0:
+                return False
+            if getattr(self, "VC_Play_flag", 0) != 0:
+                return False
+        except Exception:
+            pass
+        try:
+            if EventMesh.publish("get_vc_stream_active") == 1:
+                return False
+        except Exception:
+            pass
+        try:
+            st = EventMesh.publish("get_led_debug_state")
+            if st and isinstance(st, dict):
+                if (st.get("ai") or "") != "idle":
+                    return False
+        except Exception:
+            return False
+        return True
+
+    def _vc_idle_deep_sleep_impl(self):
+        try:
+            _need_close = (self.VC_satrt_flag == 1) or (getattr(self, "AI_client_VC_isconnect", 0) == 1)
+            print("[VC][idle_L2] 触发休眠流程 need_Close={} VC_mode={}".format(
+                1 if _need_close else 0, getattr(self, "VC_mode", -1)))
+        except Exception:
+            pass
+        try:
+            if self.VC_satrt_flag == 1 or getattr(self, "AI_client_VC_isconnect", 0) == 1:
+                try:
+                    print("[VC][idle_L2] 调用 Close 断开会话/链路")
+                except Exception:
+                    pass
+                self.Close()
+        except Exception:
+            pass
+        try:
+            utime.sleep_ms(100)
+        except Exception:
+            pass
+        try:
+            print("[VC][idle_L2] 发布 Hsensor_set_sleep")
+            EventMesh.publish("Hsensor_set_sleep")
+        except Exception:
+            pass
+        try:
+            print("[VC][idle_L2] 发布 SYSTEM_SLEEP ({})".format(constants.EVENT.SYSTEM_SLEEP))
+            EventMesh.publish(constants.EVENT.SYSTEM_SLEEP)
+        except Exception:
+            pass
+
+    def _vc_rx_resets_long_idle_timer(self, recv_data):
+        """是否应因本帧下行清零 close_timerout(排除保活/心跳,含 V2.5 文本 ping 对端应答)。"""
+        try:
+            if recv_data is None:
+                return False
+            if isinstance(recv_data, (bytes, bytearray)):
+                return True
+            if not isinstance(recv_data, str):
+                return False
+            t = recv_data.strip()
+            if not t:
+                return False
+            tl = t.lower()
+            if tl in ("ping", "pong"):
+                return False
+            try:
+                jd = ujson.loads(t)
+            except Exception:
+                return True
+            ev = jd.get("event")
+            if ev is None or ev == "":
+                ev = jd.get("type")
+            if ev is None:
+                return True
+            if str(ev).strip().lower() in _VC_KEEPALIVE_RX_EVENTS:
+                return False
+            return True
+        except Exception:
+            return True
+
+    # -------------------------------------------------------------------------
+    # 电源键 / AI 键:按 VC_mode 拆函数,便于阅读与修改(长对话 vs 单对话 PTT)
+    # -------------------------------------------------------------------------
+    def _handle_pwk_short_release(self, event=None, msg=None):
+        """电源键短按:读留言标志、退会议/翻译;否则 Close 结束对话(清 sid,下次再 Start)。"""
+        print("pwk_key_release")
+        if EventMesh.publish("get_recv_voice") == 1:
+            EventMesh.publish("update_play_new_voice_info")
+            self.recv_voice = 0
+        EventMesh.publish("set_history_voice_flag", 0)
+        self.AI_new_voice_url = ""
+        if self.trans_flag == 1 or self.meet_flag == 1:
+            EventMesh.publish("exit_meet_mode")
+            EventMesh.publish("exit_trans_mode")
+            return
+        EventMesh.publish("publish_AI_btnInfo", {"func": self.Close})
+        EventMesh.publish("stop_sos_call")
+
+    def _ai_key_press_ptt_mode(self):
+        """单对话 PTT:短按仅停 TTS(不换 sid);非播放态短按吞掉;长按由 AI_key_long_press→ptt_begin。"""
+        if self.VC_mode != 1:
+            return False
+        try:
+            playing = False
+            try:
+                t = getattr(self.fsm, "turn", VCTurnState.Idle)
+                playing = t in (VCTurnState.TtsReceiving, VCTurnState.Playing)
+            except Exception:
+                playing = False
+            if playing or self._vc_tts_pipeline_busy():
+                self._ptt_short_press_stop = 1
+                try:
+                    self.VC_Play_End()
+                except Exception:
+                    pass
+                try:
+                    self.fsm.await_played = False
+                except Exception:
+                    pass
+                try:
+                    EventMesh.publish("set_led_state", {"ai_state": "idle"})
+                except Exception:
+                    pass
+                return True
+        except Exception:
+            pass
+        return True
+
+    def _ai_key_press_long_dialogue_tts_busy(self):
+        """长对话:播放态短按打断续聊(RequestToSpeak)。"""
+        if not self._vc_tts_pipeline_busy():
+            return False
+        print("【打断播放】设备正在说话,仅中断播放,不发起新对话")
+        self.is_ruppt_tts = 1
+        EventMesh.publish("publish_AI_btnInfo", {"func": self.AI_client_VC_RequestToSpeak})
+        return True
+
+    def _vc_clear_stale_record_state(self, reason=""):
+        """record_state_flag 非 0 但可能无真实录音时先停录复位,避免 uplink 门控拒开麦。"""
+        try:
+            if getattr(self, "VC_record_state_flag", 0) != 0:
+                self.VC_Speech_End()
+        except Exception:
+            try:
+                self.VC_record_state_flag = 0
+            except Exception:
+                pass
+
+    def _ai_key_press_long_dialogue_when_session_ready(self):
+        """长对话已连接且 session 已 started:非播放态直接开麦续聊(勿 idle 时发 cancel)。"""
+        if self.VC_mode != 0:
+            return False
+        try:
+            if getattr(self, "AI_client_VC_isconnect", 0) == 1 and getattr(self, "_vc_session_started", 0) == 1:
+                self._vc_clear_stale_record_state("key.press/continue")
+                self.request_uplink_start("key.press/continue")
+                return True
+        except Exception:
+            pass
+        return False
+
+    def _ai_key_release_handle_ptt(self):
+        """单对话 PTT 松手:仅在上行录音中时 end_speech;禁止误触发 AI_VC_start(否则新 sid / cancel 竞态)。"""
+        if self.AI_key_long_press_flag == 1:
+            if getattr(self, "VC_record_state_flag", 0) != 0:
+                print("AI_key_release:asr_str:{}".format(self.AI_ASR_str))
+                self.AI_client_VC_end_speech()
+            else:
+                self.AI_key_long_press_flag = 0
+                try:
+                    if getattr(self, "_ptt_short_press_stop", 0) == 1:
+                        self._ptt_short_press_stop = 0
+                except Exception:
+                    pass
+                print("[PTT] release_no_uplink_skip")
+            return
+        try:
+            if getattr(self, "_ptt_short_press_stop", 0) == 1:
+                self._ptt_short_press_stop = 0
+        except Exception:
+            pass
+        print("[PTT] release_short_no_long")
+
+    def _ai_key_long_press_route(self, event=None, msg=None):
+        """长按:翻译先 Close 再开翻译录音;单对话→ptt_begin;长对话→与短按一致走 AI_key_press 链路。"""
+        if self.trans_flag == 1:
+            self.Close()
+            EventMesh.publish("start_voice_record", 4)
+        self.AI_key_long_press_flag = 1
+        if self.VC_mode == 1:
+            EventMesh.publish("publish_AI_btnInfo", {"func": self.ptt_begin})
+        else:
+            EventMesh.publish("publish_AI_btnInfo", {"func": self.AI_key_press})
+
     # ===== Push-To-Talk(单对话模式)=====
     # 语义:
     # - 长按:无论当前处于 TTS/Thinking/任何中间态,立即打断并进入新一轮录音上行
@@ -3400,6 +3648,26 @@ class AI_VC(Abstract):
         except Exception:
             pass
 
+        # 服务端仍在出 TTS/思考:发 cancel 打断本轮回复(不换 sid),避免与新一轮 audio.create 竞态
+        try:
+            turn = getattr(self.fsm, "turn", VCTurnState.Idle)
+            if self._vc_tts_pipeline_busy() or turn in (
+                VCTurnState.Thinking, VCTurnState.TtsReceiving, VCTurnState.Playing
+            ):
+                json_data = {"event": "cancel", "payload": {}}
+                self.AI_client_VC_send(ujson.dumps(json_data))
+                try:
+                    self.fsm.reset_rx_phases()
+                except Exception:
+                    pass
+                try:
+                    self._drop_tts_audio = 1
+                except Exception:
+                    pass
+                print("[PTT] cancel before new uplink turn={}".format(turn))
+        except Exception:
+            pass
+
         # 会话未连接:先建链并发 Start,等待 started 后再自动开麦
         try:
             if getattr(self, "AI_client_VC_isconnect", 0) != 1:
@@ -3428,16 +3696,15 @@ class AI_VC(Abstract):
                 pass
             return
 
-        # 打断服务端当前 turn(如正在 tts/思考),然后开启新一轮 PTT
+        # 不打 cancel:保持当前会话 sid/dialog,仅本地停播后用 audio.create 开新一轮上行
+        # (cancel 会导致服务端撤销本轮,与「打断 TTS 不换 sid」及电源键 Close 才换会话矛盾)
+        # 开录提示音仅由 VC_Speech_Start/RECORD_START_TONE_FILE 播放,此处不再叠短嘟声以免冲突
         try:
-            cancel = {"event": "cancel", "payload": {}}
-            self.AI_client_VC_send(ujson.dumps(cancel))
+            self._ptt_audio_created = 0
         except Exception:
             pass
-
-        # 新一轮:先发 audio.create,再开麦(record_thread 以 _ptt_audio_created 门控)
         try:
-            self._ptt_audio_created = 0
+            self.AI_ASR_flag = 0
         except Exception:
             pass
         try:
@@ -3502,13 +3769,20 @@ class AI_VC(Abstract):
 
         # 若当前不在录音上行,才允许开新一轮
         if getattr(self, "VC_record_state_flag", 0) != 0:
-            try:
-                if reason in ("canceled", "local.play_end", "audio.played"):
-                    print("[VC][uplink_ctrl] Deny START by {} cause=VC_record_state_flag({})".format(
-                        reason, getattr(self, "VC_record_state_flag", 0)))
-            except Exception:
-                pass
-            return
+            # canceled 打断后:可能是僵死 flag=2(started 未真开麦),先停录复位再开麦
+            if reason == "canceled":
+                try:
+                    self._vc_clear_stale_record_state("uplink_start/canceled")
+                except Exception:
+                    pass
+            if getattr(self, "VC_record_state_flag", 0) != 0:
+                try:
+                    if reason in ("canceled", "local.play_end", "audio.played"):
+                        print("[VC][uplink_ctrl] Deny START by {} cause=VC_record_state_flag({})".format(
+                            reason, getattr(self, "VC_record_state_flag", 0)))
+                except Exception:
+                    pass
+                return
 
         # 新一轮开始录音:允许上行(上一轮可能已置 silence 闸门)
         if getattr(self, "record_data_save_flag", 0) == 0:
@@ -3987,6 +4261,8 @@ class AI_VC(Abstract):
         #self.aud.setVolume(self.VC_TTS_volume //10)
         self.audio_play_state = 1 #音频播放完状态
         self.close_timerout = 0
+        self._idle_deep_sec = 0
+        self._vc_idle_deep_armed_suppress = 0
         self.LocalRespondingEnded_timerout = 0
 
         self.VC_Play_flag = 0
@@ -4416,73 +4692,17 @@ class AI_VC(Abstract):
                     getattr(self, "VC_mode", -1), self._vc_fsm_log_snip(), t, led))
         except Exception:
             pass
-        # 按键提示音(设备差异由 default_config.py 控制)
+        # 单对话 PTT / 长对话分支(按键短按提示音已关,避免与开录等提示音叠在一起)
         try:
-            tone_file = None
-            if "vc_config" in globals() and vc_config:
-                tone_file = vc_config.get_attr("KEY_PRESS_TONE_FILE", None)
-            if tone_file:
-                if EventMesh.publish("get_vc_stream_active") != 1:
-                    self.aud.play(1, 1, tone_file)
-        except Exception:
-            pass
-        # 单对话(PTT,VC_mode==1):
-        # - 短按用于“停止当前播报/打断当前回合”,不自动开麦(必须长按才录音)
-        # - 防止和长对话的 cancel→canceled→自动开麦逻辑混用
-        try:
-            if self.VC_mode == 1:
-                # 若正在播放/接收 TTS:本地立刻停播 + 通知服务端 cancel,回到 idle
-                try:
-                    playing = False
-                    try:
-                        t = getattr(self.fsm, "turn", VCTurnState.Idle)
-                        playing = (t in (VCTurnState.TtsReceiving, VCTurnState.Playing))
-                    except Exception:
-                        playing = False
-                    if playing or self._vc_tts_pipeline_busy():
-                        self._ptt_short_press_stop = 1
-                        try:
-                            cancel = {"event": "cancel", "payload": {}}
-                            self.AI_client_VC_send(ujson.dumps(cancel))
-                        except Exception:
-                            pass
-                        try:
-                            self.VC_Play_End()
-                        except Exception:
-                            pass
-                        try:
-                            self.fsm.await_played = False
-                        except Exception:
-                            pass
-                        try:
-                            EventMesh.publish("set_led_state", {"ai_state": "idle"})
-                        except Exception:
-                            pass
-                        return
-                except Exception:
-                    pass
-                # 非播放态:短按不做任何事
+            if self._ai_key_press_ptt_mode():
                 return
         except Exception:
             pass
-
-        # 长对话播放态:短按打断并续聊(复用 dialog_id)
-        if self._vc_tts_pipeline_busy():
-            print("【打断播放】设备正在说话,仅中断播放,不发起新对话")    
-            self.is_ruppt_tts = 1
-            EventMesh.publish("publish_AI_btnInfo",{"func":self.AI_client_VC_RequestToSpeak})#打断
+        if self._ai_key_press_long_dialogue_tts_busy():
             return
-
-        # 长对话(VC_mode==0):
-        # - 对话进行中:短按 AI 键只打断/续聊,复用本次会话的 dialog_id(不重连、不新建会话)
-        # - 已停止/未 started:短按 AI 键发起新会话(会产生新的 dialog_id)
         try:
-            if self.VC_mode == 0:
-                if getattr(self, "AI_client_VC_isconnect", 0) == 1 and getattr(self, "_vc_session_started", 0) == 1:
-                    # 若服务端返回 canceled,则会在 canceled 分支自动触发开麦(见 recv 里的 FSM uplink_start:canceled)
-                    EventMesh.publish("publish_AI_btnInfo", {"func": self.AI_client_VC_RequestToSpeak})
-                    return
-                # 否则走下方“新会话”流程
+            if self._ai_key_press_long_dialogue_when_session_ready():
+                return
         except Exception:
             pass
 
@@ -4510,15 +4730,6 @@ class AI_VC(Abstract):
         self.key_state = 1
             # EventMesh.publish("audio_montage_play",["chenggong.mp3"])  
             # self.chenggong_tone() #播放按键音
-        try:
-            delay_ms = 0
-            if "vc_config" in globals() and vc_config:
-                delay_ms = vc_config.get_int("KEY_PRESS_TONE_DELAY_MS", 0)
-            if delay_ms and delay_ms > 0:
-                self.ai_key_press_audio.stop()
-                self.ai_key_press_audio.start(delay_ms, 0, self.ai_key_press_audio_cb1)
-        except Exception:
-            pass
         utime.sleep_ms(500)
         self.Close()
 
@@ -4552,7 +4763,6 @@ class AI_VC(Abstract):
         print("AI_key_press")
         self.get_config_timer_count = 0
         self.key_state = 1
-        self.aud.aud_tone_play(10,400)#播放按键音
         # EventMesh.publish("audio_montage_play",["chenggong.mp3"])  
         # self.chenggong_tone() #播放按键音
         # 长对话:蓝牙按键同单按
@@ -4640,53 +4850,9 @@ class AI_VC(Abstract):
             self.voice_flag=0
             EventMesh.publish("play_tts",[tts_play_str,1])
             return
-        if self.AI_key_long_press_flag == 1 :#有长按(或上一轮未清干净的残留)
-            if self.VC_mode == 1 :#长按单次问答模式
-                # 仅在本轮确实仍在录音上行时发 audio.completed;否则视为短按「提示音」路径
-                if getattr(self, "VC_record_state_flag", 0) != 0:
-                    print("AI_key_release:asr_str:{}".format(self.AI_ASR_str))
-                    self.AI_client_VC_end_speech()
-                else:
-                    self.AI_key_long_press_flag = 0
-                    try:
-                        if getattr(self, "_ptt_short_press_stop", 0) == 1:
-                            self._ptt_short_press_stop = 0
-                            return
-                    except Exception:
-                        pass
-                    try:
-                        if "vc_config" in globals() and vc_config:
-                            self.AI_TTS_str = vc_config.get_attr("PTT_HINT", None)
-                    except Exception:
-                        pass
-                    if not self.AI_TTS_str:
-                        self.AI_TTS_str = "请您按住圆形的按钮开始讲话,讲完松开即可 "
-                    EventMesh.publish("publish_AI_btnInfo",{"func":self.AI_VC_start})
-        else :
-            if self.VC_mode == 1 :#长按单次问答模式
-                # 若刚刚短按用于“停止播报”,则不再触发提示音 TTS,直接回到 idle
-                try:
-                    if getattr(self, "_ptt_short_press_stop", 0) == 1:
-                        self._ptt_short_press_stop = 0
-                        return
-                except Exception:
-                    pass
-                # try:
-                #     EventMesh.publish("publish_AI_btnInfo",{"func":self.Close}) 
-                # except Exception as e:
-                #     usys.print_exception(e)
-                #EventMesh.publish("publish_AI_btnInfo",{"func":self.key_prompt})  #提示请您按住中间的按钮开始讲话,讲完松开即可   
-                try:
-                    if "vc_config" in globals() and vc_config:
-                        self.AI_TTS_str = vc_config.get_attr("PTT_HINT", None)
-                except Exception:
-                    pass
-                if not self.AI_TTS_str:
-                    self.AI_TTS_str = "请您按住圆形的按钮开始讲话,讲完松开即可 "
-                EventMesh.publish("publish_AI_btnInfo",{"func":self.AI_VC_start})
-                pass
-                
-                #self.VC_Speech_End()
+        if self.VC_mode == 1:
+            self._ai_key_release_handle_ptt()
+            return
     def pwk_key_double_press(self,event,msg):#pwk双击
         print("come 双击")
         # 切换模式:必须打断当前对话/录音/播放,回到 idle,等待按键触发新一轮
@@ -4732,33 +4898,10 @@ class AI_VC(Abstract):
         except Exception:
             pass
         print("AI_key_long_press")
-        # 单对话(PTT):任何中间态都允许打断并开启新一轮录音上行
-        if self.trans_flag == 1:#AI翻译模式
-            self.Close()
-            EventMesh.publish("start_voice_record",4)#开始翻译录音
-        self.AI_key_long_press_flag = 1
-        if self.VC_mode == 1:
-            EventMesh.publish("publish_AI_btnInfo", {"func": self.ptt_begin})
-        else:
-            # 长对话:长按与单按一致——打断当前并继续对话(开麦上行)
-            EventMesh.publish("publish_AI_btnInfo", {"func": self.AI_key_press})
+        self._ai_key_long_press_route(event, msg)
 
     def pwk_key_release(self, event, msg):#电源键短按,关闭
-        print("pwk_key_release")
-        # EventMesh.publish("set_temp")
-        # return
-        if EventMesh.publish("get_recv_voice") == 1:
-            EventMesh.publish("update_play_new_voice_info")#更新已读状态
-            self.recv_voice = 0#退出留言以及留言查看
-        EventMesh.publish("set_history_voice_flag",0)#修改标志位
-        self.AI_new_voice_url = ""
-        if self.trans_flag == 1 or self.meet_flag == 1:
-            EventMesh.publish("exit_meet_mode")#退出会议纪要
-            EventMesh.publish("exit_trans_mode")#退出AI翻译
-            return
-        EventMesh.publish("publish_AI_btnInfo",{"func":self.Close}) 
-        EventMesh.publish("stop_sos_call")
-        #EventMesh.publish("sleep_BT")#休眠蓝牙
+        self._handle_pwk_short_release(event, msg)
 
 
     def key_prompt(self):
@@ -4823,11 +4966,33 @@ class AI_VC(Abstract):
                     usys.print_exception(e) 
                 
                 self.VC_record_state_flag = 1
+                # 录音硬件已起:协议侧应对应 audio.create(PTT)或长对话直传 PCM
+                try:
+                    print("[VC][proto] record_start sr={} pcm_type={} VC_mode={} session_started={} "
+                          "ptt_audio_created={} thread_id={}".format(
+                              self.VC_record_samplerate, self.VC_record_TYPE, self.VC_mode,
+                              getattr(self, "_vc_session_started", -1),
+                              getattr(self, "_ptt_audio_created", -1),
+                              self.VC_record_thread_id))
+                except Exception:
+                    pass
                 # 录音开始:聆听灯(蓝慢闪)
                 try:
                     EventMesh.publish("set_led_state", {"ai_state": "listening"})
                 except Exception:
                     pass
+                # 单对话长按开麦:可选开录提示音(RECORD_START_TONE_FILE)
+                try:
+                    if self.VC_mode == 1 and "vc_config" in globals() and vc_config:
+                        rtf = vc_config.get_attr("RECORD_START_TONE_FILE", None)
+                        if rtf:
+                            try:
+                                if EventMesh.publish("get_vc_stream_active") != 1:
+                                    self.aud.play(1, 1, rtf)
+                            except Exception:
+                                pass
+                except Exception:
+                    pass
                 
         except Exception as e:
             self.websocket_error()
@@ -5441,14 +5606,19 @@ class AI_VC(Abstract):
                                         except Exception:
                                             pass
                                 elif not VC_WS_IO_LOG:
-                                    try:
-                                        if s == "ping":
-                                            pass
-                                        else:
-                                            jd = ujson.loads(s)
-                                            print("[VC] tx event={}".format(jd.get("event", "?")))
-                                    except Exception:
-                                        print("[VC] tx len={} (non-json)".format(len(s)))
+                                    if s == "ping":
+                                        pass
+                                    else:
+                                        try:
+                                            ev, tid = _vc_out_json_event_meta(s)
+                                            if ev:
+                                                print("[VC][proto] tx event={} trace_id={} len={} ws_conn={}".format(
+                                                    ev, tid or "-", len(s), self.AI_client_VC_isconnect))
+                                            else:
+                                                print("[VC][proto] tx unknown_json len={} ws_conn={}".format(
+                                                    len(s), self.AI_client_VC_isconnect))
+                                        except Exception:
+                                            print("[VC][proto] tx parse_fail len={}".format(len(s)))
                             else:
                                 pass
                                 # if VC_AUDIO_FRAME_LOG:
@@ -5457,7 +5627,15 @@ class AI_VC(Abstract):
                             if self.AI_client_VC != None and self.AI_client_VC_isconnect == 1:
                                 self.AI_client_VC.send(data[1])
                             else:
-                                print("VC VC: send_data:ERROR:{}".format(len(data[1])))
+                                try:
+                                    if isinstance(data[1], str) and data[1] != "ping":
+                                        _ev, _tid = _vc_out_json_event_meta(data[1])
+                                        print("VC VC: send_data:ERROR len={} event={} trace_id={}".format(
+                                            len(data[1]), _ev or "?", _tid or "-"))
+                                    else:
+                                        print("VC VC: send_data:ERROR:{}".format(len(data[1])))
+                                except Exception:
+                                    print("VC VC: send_data:ERROR:{}".format(len(data[1])))
                             #print("VC: send_data end")
     
                         #print("VC: send_data end")
@@ -5521,7 +5699,8 @@ class AI_VC(Abstract):
                     print("AI_client_VC_recv 该退出了")
                     break
                 self.AI_client_VC_recv_lock = 1
-                self.close_timerout = 0#服务器有返回清零退出时间
+                if self._vc_rx_resets_long_idle_timer(recv_data):
+                    self.close_timerout = 0
                 if recv_data == "websocket close":
                     # 服务器关闭连接
                     print("VC 服务器关闭连接!!!!!!!!!!!!!!!!!!!!!!!!!!!")
@@ -5584,10 +5763,12 @@ class AI_VC(Abstract):
                             if self.VC_mode == 0 and getattr(self, "Close_flag", 0) == 0:
                                 # 会话已 started:若此时上行未启动,则在这里补一次开麦,避免“Start 前开麦被 Close 停掉”后
                                 # 出现首轮无音频上行导致“第一次对话没有”的情况。
-                                if self.record_data_save_flag == 0 and self.VC_record_state_flag == 0:
-                                    self.request_uplink_start("server.started")
-                                else:
-                                    self.VC_record_state_flag = 2
+                                if self.record_data_save_flag == 0:
+                                    if self.VC_record_state_flag == 0:
+                                        self.request_uplink_start("server.started")
+                                    else:
+                                        self._vc_clear_stale_record_state("server.started")
+                                        self.request_uplink_start("server.started/retry")
                             
                             print("VC:Started!!!!!!!!\r\n")
                             print("TTS音频为:{},语音下发地址为:{}".format(self.AI_TTS_str,self.AI_new_voice_url))
@@ -5647,11 +5828,16 @@ class AI_VC(Abstract):
                                         self.chenggong_tone()
                                 except Exception:
                                     pass
-                                if self.VC_mode == 0    :
-                                    self.VC_record_state_flag  =2
+                                if self.VC_mode == 0:
+                                    self.request_uplink_start("server.started/idle")
                                 else:
-                                    # Push-To-Talk:会话 started 后再发 audio.create(协议要求)
-                                    self.request_send_audio_create()
+                                    # Push-To-Talk:必须先同步发出 audio.create,再开麦。
+                                    # request_send_audio_create() 走 EventMesh 异步队列,会导致录音线程先于
+                                    # audio.create 上行,深度睡眠唤醒后首轮 ASR 空结果、第二轮才正常。
+                                    try:
+                                        self.AI_client_VC_send_speech()
+                                    except Exception:
+                                        self.request_send_audio_create()
                                     # 若长按发生在“未 started”窗口,收到 started 后立即开麦进入新一轮 PTT
                                     try:
                                         if getattr(self, "_ptt_force_record_on_started", 0) == 1:
@@ -5689,11 +5875,17 @@ class AI_VC(Abstract):
                                 self._drop_tts_audio = 0
                             except Exception:
                                 pass
-                            if self.VC_mode == 1    :
-                                self.VC_record_state_flag = 2
+                            # 单对话:勿在 asr.started 置 flag=2(未真开麦会僵死);由 VC_Speech_Start 维护
                             self.LocalRespondingEnded_timerout = 0
                         elif jsload_data["event"] == "asr.result" :#asr结果
-                            self.AI_ASR_str = jsload_data["payload"]["content"]
+                            try:
+                                self.AI_ASR_str = jsload_data["payload"]["content"]
+                            except Exception:
+                                try:
+                                    self.AI_ASR_str = jsload_data.get("payload", {}).get("text", "") or ""
+                                except Exception:
+                                    self.AI_ASR_str = ""
+                            print("[VC][ASR] {}".format(self.AI_ASR_str))
                             if self.AI_ASR_str == "":#没识别到
                                 self.AI_TTS_str = "我没听清,请再说一遍"
                         elif jsload_data["event"] == "asr.completed" :#asr 终止的标识 
@@ -7006,23 +7198,85 @@ class AI_VC(Abstract):
     def _1S_timer_cb_(self):    
     
         EventMesh.publish("system_sleep_rest")#防止黑屏
-        self.close_timerout += 1
-        if self.close_timerout > 20 and self.VC_mode != 1 :#:#20秒没数据就close 长按单次问答模式不关
+        # --- Level 1:仅长对话(VC_mode==0),无业务下行 idle_sec 后结束会话(需再次按键进入)
+        # close_timerout:保活清除策略见 _vc_rx_resets_long_idle_timer(排除文本 ping/pong、heartbeat 等)
+        # 与浅休眠/灭屏解耦;单对话不走本计时
+        idle_sec = 20
+        try:
+            if "vc_config" in globals() and vc_config:
+                idle_sec = int(vc_config.get_int("VC_IDLE_AUTO_CLOSE_SEC", 20))
+        except Exception:
+            idle_sec = 20
+        if idle_sec < 5:
+            idle_sec = 5
+        if self.VC_mode == 0 and self.VC_satrt_flag == 1 and getattr(self, "AI_client_VC_isconnect", 0) == 1:
+            self.close_timerout += 1
+        else:
+            self.close_timerout = 0
+        if self.VC_mode == 0 and idle_sec > 0 and self.close_timerout > idle_sec:
             try:
-                print("[VC][long_idle] timeout_20s_gate close_timerout={} VC_mode={} {} (thr=SpeechIng)".format(
-                    self.close_timerout, self.VC_mode, self._vc_fsm_log_snip()))
+                print("[VC][idle_L1] 长对话无业务下行超时: elapsed={}s thr={}s VC_mode={} VC_satrt={} ws_conn={} {}".format(
+                    self.close_timerout, idle_sec, self.VC_mode,
+                    getattr(self, "VC_satrt_flag", -1), getattr(self, "AI_client_VC_isconnect", -1),
+                    self._vc_fsm_log_snip()))
             except Exception:
                 pass
             if self._vc_long_idle_active_speech_or_later():
+                try:
+                    print("[VC][idle_L1] 处理=websocket_error(对话中无服务端响应)")
+                except Exception:
+                    pass
                 print("[VC][long_idle] branch=speech_no_rsp -> websocket_error + ud_error")
                 print("接口无响应,超时退出")
                 EventMesh.publish("publish_AI_btnInfo",{"func":self.websocket_error,"data":"接口超时了。请重试"}) 
                 self.ud_error(["VC",self.VC_taskid])
             else:
+                try:
+                    print("[VC][idle_L1] 处理=Close(结束对话,需再次按键进入)")
+                except Exception:
+                    pass
                 print("[VC][long_idle] branch=idle_timeout -> Close")
                 EventMesh.publish("publish_AI_btnInfo",{"func":self.Close}) 
                 #EventMesh.publish("sleep_BT")#休眠蓝牙
-        
+
+        # --- Level 2:长对话+单对话,业务 idle 累计 VC_IDLE_DEEP_SLEEP_SEC → 断开(若仍连)+ 深睡事件
+        deep_sec = 60
+        deep_en = 1
+        try:
+            if "vc_config" in globals() and vc_config:
+                deep_sec = int(vc_config.get_int("VC_IDLE_DEEP_SLEEP_SEC", 60))
+                deep_en = int(vc_config.get_int("VC_IDLE_DEEP_SLEEP_ENABLE", 1))
+        except Exception:
+            deep_sec, deep_en = 60, 1
+        active_deep = bool(deep_en) and deep_sec > 0
+        if active_deep and deep_sec < 10:
+            deep_sec = 10
+        if not active_deep:
+            self._idle_deep_sec = 0
+        elif not self._vc_is_business_idle():
+            self._idle_deep_sec = 0
+            try:
+                self._vc_idle_deep_armed_suppress = 0
+            except Exception:
+                pass
+        elif getattr(self, "_vc_idle_deep_armed_suppress", 0):
+            pass
+        else:
+            self._idle_deep_sec += 1
+        if active_deep and self._idle_deep_sec > deep_sec:
+            try:
+                print("[VC][idle_L2] 业务idle累计超时: elapsed={}s thr={}s VC_mode={} VC_satrt={} ws_conn={}".format(
+                    self._idle_deep_sec, deep_sec, self.VC_mode,
+                    getattr(self, "VC_satrt_flag", -1), getattr(self, "AI_client_VC_isconnect", -1)))
+            except Exception:
+                pass
+            try:
+                self._vc_idle_deep_armed_suppress = 1
+            except Exception:
+                pass
+            self._idle_deep_sec = 0
+            EventMesh.publish("publish_AI_btnInfo", {"func": self._vc_idle_deep_sleep_impl})
+
         # 统一兜底表(按状态机状态触发)
         try:
             self._fsm_timeout_table_tick(utime.ticks_ms())
@@ -7122,6 +7376,8 @@ class AI_VC(Abstract):
         #self.aud.aud_tone_play(16,200)#播放按键音
         self.LocalRespondingEnded_timerout = 0
         self.close_timerout = 0
+        self._idle_deep_sec = 0
+        self._vc_idle_deep_armed_suppress = 0
         
         #
         if self.AI_client_VC_isconnect == 0:#没连接的时候请求开始
@@ -7134,14 +7390,20 @@ class AI_VC(Abstract):
         if self.AI_client_VC_isconnect == 0:
             #self.Close()
             return
-        # self.aud.stopPlayStream()
-        # self.aud.stopAll()
-        self.AI_client_VC_start_requset()
+        # 单对话 PTT:会话已 started 时勿重复发 Start(否则第二轮起上行/ASR 易乱)
+        _ptt_skip_start = False
+        try:
+            if self.VC_mode == 1 and getattr(self, "_vc_session_started", 0) == 1:
+                _ptt_skip_start = True
+                print("[PTT] AI_VC_start skip duplicate Start (session active)")
+        except Exception:
+            pass
+        if not _ptt_skip_start:
+            self.AI_client_VC_start_requset()
         print("AI_VC_start3")
          
-        if self.AI_TTS_str == "" and self.AI_new_voice_url == "":#没有tts要播放的时候才开始录音 并音频路径为空
-            #开始asr录音
-            self._uplink_request_start("AI_VC_start")#开启线程获取录音数据(统一入口)
+        if (not _ptt_skip_start) and self.AI_TTS_str == "" and self.AI_new_voice_url == "":
+            self._uplink_request_start("AI_VC_start")
            
                 
         #     pass
@@ -7357,6 +7619,15 @@ class AI_VC(Abstract):
         except Exception:
             pass
         self.AI_client_VC_send(ujson.dumps(json_data))
+        try:
+            _tid = json_data.get("header", {}).get("trace_id", "")
+            print("[VC][proto] Start enqueued trace_id={} VC_mode={} disable_vad={} ws_conn={}".format(
+                _tid or "-",
+                self.VC_mode,
+                json_data.get("payload", {}).get("inbound_attributes", {}).get("disable_vad", "?"),
+                self.AI_client_VC_isconnect))
+        except Exception:
+            pass
  
     #开始上传语音
     def AI_client_VC_send_speech(self):
@@ -7372,7 +7643,18 @@ class AI_VC(Abstract):
             # 协议门控(可用 VC_PROTO_GUARDS 临时关闭)
             if (not VC_PROTO_GUARDS) or (self._vc_session_started == 1):
                 self._ptt_audio_created = 1
+                try:
+                    print("[VC][proto] audio.create send session_started={} proto_guards={}".format(
+                        self._vc_session_started, VC_PROTO_GUARDS))
+                except Exception:
+                    pass
                 self.AI_client_VC_send(ujson.dumps(json_data))
+            else:
+                try:
+                    print("[VC][proto] audio.create SKIP session_started={} VC_PROTO_GUARDS={} "
+                          "(等对端 started 后再开麦)".format(self._vc_session_started, VC_PROTO_GUARDS))
+                except Exception:
+                    pass
         
 
             
@@ -7410,6 +7692,7 @@ class AI_VC(Abstract):
         try:
             if self.VC_mode == 0:
                 self.Close_flag = 0
+                self._vc_clear_stale_record_state("RequestToSpeak")
         except Exception:
             pass
         # 只做“打断+清播放队列”,不要在这里关音频队列线程(会导致后续 TTS/提示音不稳定,且触发竞态)
@@ -8054,6 +8337,8 @@ class AI_VC(Abstract):
         self.VC_Thinking_timerout = 0
         self.AI_ASR_timer.stop()
         self._1S_timer.stop()
+        self.close_timerout = 0
+        self._idle_deep_sec = 0
         self.factory_timer.stop()
         self.AI_TTS_str = ""
         self.AI_ASR_str = ""
@@ -8158,6 +8443,17 @@ class AI_VC(Abstract):
         EventMesh.publish("set_led_state", {"ai_state": "idle"})
         self.VC_init()
         self.VC_satrt_flag = 0
+        # Level2:会话结束后仍可继续 1s 节拍累计 idle 直至深睡(依赖 VC_IDLE_DEEP_SLEEP_SEC)
+        try:
+            _dsec = 60
+            _den = 1
+            if "vc_config" in globals() and vc_config:
+                _dsec = int(vc_config.get_int("VC_IDLE_DEEP_SLEEP_SEC", 60))
+                _den = int(vc_config.get_int("VC_IDLE_DEEP_SLEEP_ENABLE", 1))
+            if _den and _dsec > 0:
+                self._1S_timer.start(1000, 1, self._1S_timer_cb)
+        except Exception:
+            pass
         # try:
         #     while True:
         #         if self.AI_WS_connect_Queue.empty()!=True:
index 4d1e3f6..0ba4676 100644 (file)
@@ -26,8 +26,9 @@ LED_ACTIVE_LOW = False
 LED_ACTIVE_LOW_RGB = None  # 例如 (True, False, False) 表示仅红灯反相\r
 # LED_ACTIVE_LOW_RGB = (True, False, False)\r
 \r
-# 待机空闲绿灯慢闪半周期(ms)\r
+# idle 绿灯长慢闪:常亮 / 熄灭(ms);仅配 LED_IDLE_GREEN_BLINK_MS 时灭灯时长与常亮相同(对称慢闪)\r
 LED_IDLE_GREEN_BLINK_MS = 1000\r
+LED_IDLE_GREEN_BLINK_OFF_MS = 2000\r
 \r
 # 是否支持 UART 相关能力(例如 7PIN_1_5 才允许走串口)\r
 UART_SUPPORTED = False\r
@@ -53,6 +54,8 @@ AUDIO_QDAI_CFG = None      # 例如 (1,0,0,2,0,1,1,1)
 MOTOR_PIN_GPIO = "GPIO20"          # 例如 "GPIO36";无马达硬件可保持 None\r
 MOTOR_TICK_MS = 100\r
 MOTOR_ACTIVE_LOW = False\r
+MOTOR_BOOT_VIBRATE_MS = 200 # 马达开机震动时间 200ms\r
+\r
 \r
 # AI 按键中断与电源键中断引脚(ExtInt.GPIOxx)\r
 EXTINT_AI_GPIO = "GPIO22"   # ai按键\r
@@ -84,6 +87,17 @@ SOS_ENABLED = False
 # VC WebSocket 文本保活 ping 间隔(秒)。原逻辑约每 4 秒一次,空闲功耗偏高;拉大间隔可降低唤醒与发包频率\r
 VC_WS_PING_INTERVAL_SEC = 55\r
 \r
+# --------------------\r
+# VC 空闲/超时(ai_VC._1S_timer_cb_ 每秒累计)\r
+# --------------------\r
+# 长对话:无有效业务下行累计达此秒数后结束会话;代码侧最小 5\r
+VC_IDLE_AUTO_CLOSE_SEC = 20\r
+# 单对话侧预留(当前与 idle+深睡统一处理,与 7PIN_1_5 对齐)\r
+VC_IDLE_AUTO_CLOSE_SEC_PTT = 0\r
+# 业务 idle 累计达此秒数触发深睡断开;代码侧最小 10;0 关闭请改 ENABLE\r
+VC_IDLE_DEEP_SLEEP_SEC = 60\r
+VC_IDLE_DEEP_SLEEP_ENABLE = 1\r
+\r
 # --------------------\r
 # 开机提示/语音参数默认值(与具体产品绑定,编译期决定)\r
 # --------------------\r
@@ -147,11 +161,14 @@ KEYWORDS_FROM_VOICE_TYPE = False
 # 按键音/提示音策略(设备差异项)\r
 # --------------------\r
 \r
-# AI 键按下时:若设置了该文件路径,则在“无 VC 流播放中”时播放该提示音(例如 7PIN 用 start.mp3)\r
-KEY_PRESS_TONE_FILE = None  # 例如 "U:/static/start.mp3"\r
+# AI 键按下时:若设置了该文件路径,则在“无 VC 流播放中”时播放该提示音(例如 "U:/static/start.mp3")\r
+KEY_PRESS_TONE_FILE = None\r
+\r
+# AI 键按下时:延迟播放按键音(ms),规避蓝牙刚连上不出声等(与 7PIN_1_5 一致)\r
+KEY_PRESS_TONE_DELAY_MS = 300\r
 \r
-# AI 键按下时:延迟播放按键音(ms),用于规避蓝牙连接瞬间不出声等问题(例如 7PIN_1_5 取 300)\r
-KEY_PRESS_TONE_DELAY_MS = 0\r
+# 单对话长按开麦:短提示音路径(与短按 KEY_PRESS_TONE 分离,见 ai_VC)\r
+RECORD_START_TONE_FILE = "U:/static/start.mp3"\r
 \r
 # PTT 提示语(单对话模式,未长按时的提示;是什么语言就写什么)\r
 PTT_HINT = "请您按住圆形的按钮开始讲话,讲完松开即可 "\r
index ac30ac6..0ba4676 100644 (file)
@@ -26,8 +26,9 @@ LED_ACTIVE_LOW = False
 LED_ACTIVE_LOW_RGB = None  # 例如 (True, False, False) 表示仅红灯反相\r
 # LED_ACTIVE_LOW_RGB = (True, False, False)\r
 \r
-# 待机空闲绿灯慢闪半周期(ms)\r
+# idle 绿灯长慢闪:常亮 / 熄灭(ms);仅配 LED_IDLE_GREEN_BLINK_MS 时灭灯时长与常亮相同(对称慢闪)\r
 LED_IDLE_GREEN_BLINK_MS = 1000\r
+LED_IDLE_GREEN_BLINK_OFF_MS = 2000\r
 \r
 # 是否支持 UART 相关能力(例如 7PIN_1_5 才允许走串口)\r
 UART_SUPPORTED = False\r
@@ -86,6 +87,17 @@ SOS_ENABLED = False
 # VC WebSocket 文本保活 ping 间隔(秒)。原逻辑约每 4 秒一次,空闲功耗偏高;拉大间隔可降低唤醒与发包频率\r
 VC_WS_PING_INTERVAL_SEC = 55\r
 \r
+# --------------------\r
+# VC 空闲/超时(ai_VC._1S_timer_cb_ 每秒累计)\r
+# --------------------\r
+# 长对话:无有效业务下行累计达此秒数后结束会话;代码侧最小 5\r
+VC_IDLE_AUTO_CLOSE_SEC = 20\r
+# 单对话侧预留(当前与 idle+深睡统一处理,与 7PIN_1_5 对齐)\r
+VC_IDLE_AUTO_CLOSE_SEC_PTT = 0\r
+# 业务 idle 累计达此秒数触发深睡断开;代码侧最小 10;0 关闭请改 ENABLE\r
+VC_IDLE_DEEP_SLEEP_SEC = 60\r
+VC_IDLE_DEEP_SLEEP_ENABLE = 1\r
+\r
 # --------------------\r
 # 开机提示/语音参数默认值(与具体产品绑定,编译期决定)\r
 # --------------------\r
@@ -149,11 +161,14 @@ KEYWORDS_FROM_VOICE_TYPE = False
 # 按键音/提示音策略(设备差异项)\r
 # --------------------\r
 \r
-# AI 键按下时:若设置了该文件路径,则在“无 VC 流播放中”时播放该提示音(例如 7PIN 用 start.mp3)\r
-KEY_PRESS_TONE_FILE = None  # 例如 "U:/static/start.mp3"\r
+# AI 键按下时:若设置了该文件路径,则在“无 VC 流播放中”时播放该提示音(例如 "U:/static/start.mp3")\r
+KEY_PRESS_TONE_FILE = None\r
+\r
+# AI 键按下时:延迟播放按键音(ms),规避蓝牙刚连上不出声等(与 7PIN_1_5 一致)\r
+KEY_PRESS_TONE_DELAY_MS = 300\r
 \r
-# AI 键按下时:延迟播放按键音(ms),用于规避蓝牙连接瞬间不出声等问题(例如 7PIN_1_5 取 300)\r
-KEY_PRESS_TONE_DELAY_MS = 0\r
+# 单对话长按开麦:短提示音路径(与短按 KEY_PRESS_TONE 分离,见 ai_VC)\r
+RECORD_START_TONE_FILE = "U:/static/start.mp3"\r
 \r
 # PTT 提示语(单对话模式,未长按时的提示;是什么语言就写什么)\r
 PTT_HINT = "请您按住圆形的按钮开始讲话,讲完松开即可 "\r
index 188c750..a06287d 100644 (file)
@@ -4,6 +4,8 @@
 DEV_TYPE = "7PIN_1_5"\r
 \r
 LED_GPIO = ("GPIO28", "GPIO44", "GPIO30")  # (R, G, B)\r
+LED_IDLE_GREEN_BLINK_MS = 1000   # idle 绿灯常亮时长(ms)\r
+LED_IDLE_GREEN_BLINK_OFF_MS = 2000  # idle 绿灯熄灭时长(ms)\r
 UART_SUPPORTED = True\r
 LANG = "zh"\r
 \r
@@ -52,5 +54,12 @@ KEYWORDS_FROM_VOICE_TYPE = False
 # ---- 按键音/提示音策略 ----\r
 KEY_PRESS_TONE_FILE = None\r
 KEY_PRESS_TONE_DELAY_MS = 300\r
+RECORD_START_TONE_FILE = "U:/static/start.mp3"\r
+# VC 空闲/超时(ai_VC._1S_timer_cb_);长对话无下行超时\r
+VC_IDLE_AUTO_CLOSE_SEC = 20\r
+# 单对话不再用「无 WS 帧」单独关会话;统一用 idle 累计 + VC_IDLE_DEEP_SLEEP_SEC\r
+VC_IDLE_AUTO_CLOSE_SEC_PTT = 0\r
+VC_IDLE_DEEP_SLEEP_SEC = 60\r
+VC_IDLE_DEEP_SLEEP_ENABLE = 1\r
 PTT_HINT = "请您按住圆形的按钮开始讲话,讲完松开即可 "\r
 \r
index c01c5a6..2c74b2f 100644 (file)
@@ -18,12 +18,24 @@ if ($Enable -notin @('0', '1')) {
 }
 $qpLogOn = ($Enable -eq '1')
 
+# Kconfig outputs UTF-8; WinPS 5.1 Get-Content uses system ANSI and corrupts autoconf.h (used by new_clean.bat).
+
+function Read-ConfigTextLines([string]$path) {
+    $enc = New-Object System.Text.UTF8Encoding @($false)
+    return [System.IO.File]::ReadAllLines($path, $enc)
+}
+
+function Write-ConfigTextLines([string]$path, [string[]]$lines) {
+    $enc = New-Object System.Text.UTF8Encoding @($false)
+    [System.IO.File]::WriteAllLines($path, $lines, $enc)
+}
+
 function Patch-Mk([string]$path) {
     if (-not (Test-Path -LiteralPath $path)) {
         Write-Error "missing $path"
         exit 2
     }
-    $lines = @(Get-Content -LiteralPath $path | Where-Object { $_ -notmatch 'CONFIG_QP_LOG' })
+    $lines = @(Read-ConfigTextLines $path | Where-Object { $_ -notmatch 'CONFIG_QP_LOG' })
     $out = New-Object System.Collections.Generic.List[string]
     $done = $false
     foreach ($line in $lines) {
@@ -44,7 +56,7 @@ function Patch-Mk([string]$path) {
             [void]$out.Add('# CONFIG_QP_LOG is not set')
         }
     }
-    [System.IO.File]::WriteAllLines($path, $out.ToArray())
+    Write-ConfigTextLines $path $out.ToArray()
 }
 
 function Patch-H([string]$path) {
@@ -52,7 +64,7 @@ function Patch-H([string]$path) {
         Write-Error "missing $path"
         exit 2
     }
-    $lines = @(Get-Content -LiteralPath $path | Where-Object { $_ -notmatch 'CONFIG_QP_LOG' })
+    $lines = @(Read-ConfigTextLines $path | Where-Object { $_ -notmatch 'CONFIG_QP_LOG' })
     $out = New-Object System.Collections.Generic.List[string]
     $done = $false
     foreach ($line in $lines) {
@@ -67,7 +79,7 @@ function Patch-H([string]$path) {
     if ($qpLogOn -and -not $done) {
         [void]$out.Add('#define CONFIG_QP_LOG 1')
     }
-    [System.IO.File]::WriteAllLines($path, $out.ToArray())
+    Write-ConfigTextLines $path $out.ToArray()
 }
 
 $boardCfg = [System.IO.Path]::Combine(