| 术语 | 时间含义 | 默认 `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
`**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` 重开上行 |
---
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` 代码修改,可以说明优先项。
+
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):
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)
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"
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
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 聚合状态与最终模式
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/任何中间态,立即打断并进入新一轮录音上行
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:
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:
# 若当前不在录音上行,才允许开新一轮
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:
#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
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
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()
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() #播放按键音
# 长对话:蓝牙按键同单按
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,等待按键触发新一轮
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):
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()
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:
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")
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 服务器关闭连接!!!!!!!!!!!!!!!!!!!!!!!!!!!")
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))
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:
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 终止的标识
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())
#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:#没连接的时候请求开始
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
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):
# 协议门控(可用 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
try:
if self.VC_mode == 0:
self.Close_flag = 0
+ self._vc_clear_stale_record_state("RequestToSpeak")
except Exception:
pass
# 只做“打断+清播放队列”,不要在这里关音频队列线程(会导致后续 TTS/提示音不稳定,且触发竞态)
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 = ""
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: