| 单击power键 | tts | 协议发指令取消本次tts播报,close ws,进入休眠状态,清除当前sid,下次开始对话采用新sid| 操作同长对话 | |
| 长按power键3秒 | 任意状态 | 播放关机提示音,关闭设备电源 | 操作同长对话 | |
-
+# ------------------------------------------
+提示音播报逻辑:
+提示音播报(本地,notify tts) 优先级高于 (对话tts) ,对话tts可以被暂停/停止,播完提醒音后继续播放。 本地播放用暂停的,notify tts由于协议冲突,就用停止的。
+本地提示音和notify tts优先级相当,冲突时不能丢弃提醒音,延时播报。
exit /b 1
)
+powershell -NoProfile -ExecutionPolicy Bypass -File "%~dp0tools\ensure_helios_imsl_vad_mk.ps1" -HeliosRoot:"%~dp0..\..\Helios_SDK"
+if errorlevel 1 (
+ echo [ERROR] ensure_helios_imsl_vad_mk.ps1 failed
+ exit /b 1
+)
+
cd /d "%~dp0..\..\Helios_SDK"
helios.exe make services/microPython @EG810MCN_GA_VOLTE EG810MCN_GA_VOLTE
if errorlevel 1 (
--- /dev/null
+# 7PIN_1_5 imsl VAD + DMP 授权(xcopy -> Helios_SDK/services/microPython/microPython_imsl_vad.mk)
+# 由 microPython.mk 在 libimslvad.a 锚点后 -include
+ifeq ($(CONFIG_VAD), y)
+QPY_SRCS += ports/quectel/core/source/transport_imp_asr_mcu.c
+$(NAME)_SRCS += ports/quectel/core/source/transport_imp_asr_mcu.c
+$(NAME)_ARCHIVES += ports/quectel/core/source/libimslnn.a
+endif
# 本地 imsl VAD 能量阈值:越低越灵敏(易触发说话),越高越钝;imsl 推荐 10000。
# 现场若本地 VAD 不出 speech start/end(全靠 asr_silence_fallback 收尾),调低(如 6000)
VAD_ENERGY_THRESHOLD = 10000
+# imsl auth_vad:DMP 区域 0=海外 dmp-global.raisound.com 1=国内正式服务器 dmp.raisound.com 2=国内测试服务器 dmp-dev.raisound.com 3=测试服2 dmp-intl.raisound.com(与 imsl_vad.h AuthInfo.server_addr 一致)
+VAD_DMP_SERVER_ADDR = 2
# 长对话:单轮最长录音(ms)、asr.completed 后续说 merge 窗(ms);0=不限制
# 说明:MAX_TURN_MS 解决"场景②一直说话太久"——强制提交截断输入;
# 本地 imsl VAD 能量阈值:越低越灵敏(易触发说话),越高越钝;imsl 推荐 10000。
# 现场若本地 VAD 不出 speech start/end(全靠 asr_silence_fallback 收尾),调低(如 6000)
VAD_ENERGY_THRESHOLD = 10000
+# imsl auth_vad:DMP 区域 0=海外 dmp-global.raisound.com 1=国内正式服务器 dmp.raisound.com 2=国内测试服务器 dmp-dev.raisound.com 3=测试服2 dmp-intl.raisound.com(与 imsl_vad.h AuthInfo.server_addr 一致)
+VAD_DMP_SERVER_ADDR = 2
# 长对话:单轮最长录音(ms)、asr.completed 后续说 merge 窗(ms);0=不限制
# 说明:MAX_TURN_MS 解决"场景②一直说话太久"——强制提交截断输入;
-#ifndef _IMSL_VAD_DLL
-#define _IMSL_VAD_DLL
-#include <stdint.h>
+/*
+ * Build Information
+ * Git Commit: 1fb180708d2570023e9a300e4456c7c36822a6a2
+ * Branch: bin
+ * Build Date: 2026-06-05 09:28:15
+ */
-struct VadConfig
-{
- int vad_log_level; // 0 不启用 1 INFO 2 INFO、DEBUG
- int sil_threshold; // 静音阈值 推荐值 63 (0-127) (修改意义不大)
- int energy_threshold; // 能量阈值 推荐值 10000
- int min_speech_length; // 最短语音长度 240 (须小于 rule1_min_tailing_silence)
- int silence_detect_length; // vad_silence_detect 接口判定的尾部静音长度, 如果不需要vad_silence_detect接口可以忽略这个参数
- int rule1_min_tailing_silence; // 多长时间没有检测到语音重置VAD状态 (ms) 480
- int rule2_min_tailing_silence; // 0-10s最短多少静音判定语音结束 (ms) 960
- int rule3_min_tailing_silence; // 10s以上最短多少静音判定语音结束 (ms) 960
-};
-
-/* 初始化vad
-详细参数设置参照 imsl_vad.h
-返回值 :
- 0 初始化失败
- 1 试用模式 (最长30分钟)
- 2 授权模型 (授权失败 控制台会打印,同时转为试用模式)
-*/
-int init_vad(struct VadConfig* conf);
-
-// 运行vad函数,data为16khz 16bit的pcm音频数据
-// 注意data_len是int16_t的data_len,如果传入u8*或void* 数据data_len需要 / 2
-void run_vad(const int16_t* data, const int data_len);
-
-// 获取VAD的状态
-// 0 静音 1 语音 2 语音结束
-int vad_detect();
-
-// 获取尾部静音的状态
-// 1 尾部静音超过规定时长,0 尾部静音未超过规定时长
-// 注意如果要调用 vad_silence_detect,需要在vad_clear前调用
-int vad_silence_detect();
-
-// 清除尾部静音,调用这个函数后尾部静音长度会清0
-void vad_silence_clear();
-
-// 重置VAD的状态 每次在vad_detect为2时调用
-void vad_clear();
-
-// 释放VAD内存,不使用VAD或暂停使用VAD时调用
-void free_vad();
-
-#endif
-
-/*example :
- #include "imsl_vad.h"
-
- // 启用VAD时初始化
- struct VadConfig conf;
- conf.sil_threshold = 63;
- conf.energy_threshold = 10000;
- conf.min_speech_length = 240;
- conf.silence_detect_length = 300;
- conf.rule1_min_tailing_silence = 480;
- conf.rule2_min_tailing_silence = 960;
- conf.rule3_min_tailing_silence = 960;
- conf.vad_log_level = 2;
- init_vad(&conf);
-
- // 每次获得语音后调用, 语音长度最好小于100ms
- // wave为u8*或void*指针时需要 / 2
- run_vad(wave, wave_len / 2);
- int status = vad_detect();
- if (status == 2) {
- vad_clear();
- }
-
- // 不使用或暂停使用VAD时调用
- free_vad();
-*/
\ No newline at end of file
+#ifndef _IMSL_VAD_DLL\r
+#define _IMSL_VAD_DLL\r
+#include <stdint.h>\r
+\r
+#ifndef _IMSL_NN_COMMON\r
+#define _IMSL_NN_COMMON\r
+typedef int (*imsl_nn_printf_func)(const char *format, ...);\r
+\r
+struct AuthInfo\r
+{\r
+ char dmp_token[64];\r
+ int server_addr;\r
+};\r
+#endif\r
+\r
+// 注意这个必须要与imsl_vad.h中的定义一致\r
+struct VadConfig\r
+{\r
+ int vad_log_level; // 0 不启用 1 INFO 2 INFO、DEBUG\r
+ int sil_threshold; // 静音阈值 推荐值 63 (0-127) (修改意义不大)\r
+ int energy_threshold; // 能量阈值 推荐值 10000\r
+ int min_speech_length; // 最短语音长度 240 (须小于 rule1_min_tailing_silence)\r
+ int silence_detect_length; // vad_silence_detect 接口判定的尾部静音长度, 如果不需要vad_silence_detect接口可以忽略这个参数\r
+ int rule1_min_tailing_silence; // 多长时间没有检测到语音重置VAD状态 (ms) 480\r
+ int rule2_min_tailing_silence; // 0-10s最短多少静音判定语音结束 (ms) 960 \r
+ int rule3_min_tailing_silence; // 10s以上最短多少静音判定语音结束 (ms) 960\r
+\r
+ struct AuthInfo auth_info;\r
+};\r
+\r
+/* 初始化vad\r
+详细参数设置参照 imsl_vad.h\r
+返回值 :\r
+ 0 初始化失败\r
+ 1 试用模式 (最长30分钟)\r
+ // 2 授权成功 (如果授权失败控制台会打印错误信息,同时转为试用模式)\r
+*/\r
+int init_vad(const struct VadConfig* conf);\r
+\r
+/* 授权vad\r
+返回值:\r
+ 0 初始化失败\r
+ 1 初始化成功\r
+*/\r
+int auth_vad(const struct AuthInfo* auth_info);\r
+\r
+// 运行vad函数,data为16khz 16bit的pcm音频数据 \r
+// 注意data_len是int16_t的data_len,如果传入u8*或void* 数据data_len需要 / 2\r
+void run_vad(const int16_t* data, int data_len);\r
+\r
+// 获取VAD的状态\r
+// 0 静音 1 语音 2 语音结束\r
+int vad_detect();\r
+\r
+// 获取尾部静音的状态\r
+// 1 尾部静音超过规定时长,0 尾部静音未超过规定时长\r
+// 注意如果要调用 vad_silence_detect,需要在vad_clear前调用\r
+int vad_silence_detect();\r
+\r
+// 清除尾部静音,调用这个函数后尾部静音长度会清0\r
+void vad_silence_clear();\r
+\r
+// 重置VAD的状态 每次在vad_detect为2时调用\r
+void vad_clear();\r
+\r
+// 释放VAD内存,不使用VAD或暂停使用VAD时调用\r
+void free_vad();\r
+\r
+#endif\r
+\r
+/*example :\r
+ #include "imsl_vad.h"\r
+\r
+ // 设置log函数\r
+ extern imsl_nn_printf_func imsl_nn_printf;\r
+ imsl_nn_printf = printf;\r
+\r
+ // 启用VAD时初始化\r
+ struct VadConfig conf;\r
+ conf.sil_threshold = 63;\r
+ conf.energy_threshold = 10000;\r
+ conf.min_speech_length = 240;\r
+ conf.silence_detect_length = 300;\r
+ conf.rule1_min_tailing_silence = 480;\r
+ conf.rule2_min_tailing_silence = 960;\r
+ conf.rule3_min_tailing_silence = 960;\r
+ conf.vad_log_level = 2;\r
+ init_vad(&conf);\r
+\r
+ struct AuthInfo auth_info;\r
+ auth_info.server_addr = 0; // 0 表示 国内 1 表示 海外\r
+ strcpy(auth_info.dmp_token, dmp_token);\r
+ auth_vad(&auth_info);\r
+\r
+ // 每次获得语音后调用, 语音长度最好小于100ms\r
+ // wave为u8*或void*指针时需要 / 2\r
+ run_vad(wave, wave_len / 2);\r
+ int status = vad_detect(); \r
+ if (status == 2) {\r
+ vad_clear();\r
+ }\r
+\r
+ // 不使用或暂停使用VAD时调用\r
+ free_vad();\r
+*/\r
#include <stdio.h>
#include <stdint.h>
#include <string.h>
+#include <stdarg.h>
#include "py/runtime.h"
#include "py/stream.h"
static struct VadConfig s_vad_conf;
static int s_vad_ready;
-static int s_vad_init_mode; /* init_vad 返回值:0失败 1试用 2授权 */
+static int s_vad_init_mode; /* init_vad:0失败 1试用;auth_vad 成功后 Python 侧视为 2(授权) */
+static int s_vad_auth_ok; /* auth_vad 返回值 1 时置位,与 init_vad 无关 */
+static int s_vad_init_count; /* init_vad 实际被调用次数(诊断) */
+
+/* 符号由 libimslnn.a(utils.c.o) 提供,此处仅赋值回调 */
+extern imsl_nn_printf_func imsl_nn_printf;
+
+static int vad_imsl_printf(const char *format, ...)
+{
+ va_list ap;
+ char buf[384];
+ va_start(ap, format);
+ vsnprintf(buf, sizeof(buf), format, ap);
+ va_end(ap);
+ custom_log("imsl_vad", "%s", buf);
+ return (int)strlen(buf);
+}
+
+static void vad_setup_printf(void)
+{
+ imsl_nn_printf = vad_imsl_printf;
+}
static void vad_fill_defaults(struct VadConfig *conf)
{
if (s_vad_ready) {
return;
}
+ vad_setup_printf();
vad_fill_defaults(&s_vad_conf);
if (legacy_args) {
vad_apply_legacy_args(&s_vad_conf, legacy_args);
}
+ s_vad_init_count++;
ret = init_vad(&s_vad_conf);
if (ret == 0) {
mp_raise_msg(&mp_type_RuntimeError, MP_ERROR_TEXT("init_vad failed"));
}
s_vad_init_mode = ret;
s_vad_ready = 1;
- QPY_VAD_LOG("init_vad ok, mode=%d", ret);
+ QPY_VAD_LOG("init_vad #%d ret=%d energy=%d sil=%d",
+ s_vad_init_count, ret, s_vad_conf.energy_threshold,
+ s_vad_conf.rule2_min_tailing_silence);
}
STATIC mp_obj_t VAD_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args)
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_custom_vad_reset_obj, mp_custom_vad_reset);
+/* init_mode:仅反映 init_vad 返回值(0失败 1试用可用),不含授权状态 */
STATIC mp_obj_t mp_vad_init_mode(mp_obj_t self_in)
{
(void)self_in;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_vad_init_mode_obj, mp_vad_init_mode);
+/* auth_ok:auth_vad 是否已成功(1=已授权 0=未授权/试用) */
+STATIC mp_obj_t mp_vad_auth_ok(mp_obj_t self_in)
+{
+ (void)self_in;
+ return mp_obj_new_int(s_vad_auth_ok ? 1 : 0);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_vad_auth_ok_obj, mp_vad_auth_ok);
+
+/* auth_vad(dmp_token[, server_addr=0]):联网授权,1=成功 0=失败(与 init_vad 独立) */
+STATIC mp_obj_t mp_vad_auth(size_t n_args, const mp_obj_t *args)
+{
+ struct AuthInfo auth_info;
+ const char *token;
+ int server_addr = 0;
+ int ret;
+ size_t tok_len;
+ char tok_head[8];
+
+ (void)args;
+ if (n_args < 2) {
+ mp_raise_ValueError(MP_ERROR_TEXT("auth(token[, server_addr])"));
+ }
+ vad_ensure_init(NULL);
+ if (s_vad_auth_ok) {
+ return mp_obj_new_int(1);
+ }
+ token = mp_obj_str_get_str(args[1]);
+ if (n_args >= 3) {
+ server_addr = mp_obj_get_int(args[2]);
+ }
+ tok_len = strlen(token);
+ if (tok_len == 0 || tok_len >= sizeof(auth_info.dmp_token)) {
+ mp_raise_ValueError(MP_ERROR_TEXT("invalid dmp token"));
+ }
+ memset(&auth_info, 0, sizeof(auth_info));
+ memcpy(auth_info.dmp_token, token, tok_len);
+ auth_info.server_addr = server_addr;
+ memset(tok_head, 0, sizeof(tok_head));
+ strncpy(tok_head, token, tok_len < 4 ? tok_len : 4);
+ QPY_VAD_LOG("auth begin server=%d token_len=%d head=%s***",
+ server_addr, (int)tok_len, tok_head);
+ MP_THREAD_GIL_EXIT();
+ ret = auth_vad(&auth_info);
+ MP_THREAD_GIL_ENTER();
+ if (ret == 1) {
+ s_vad_auth_ok = 1;
+ QPY_VAD_LOG("auth ok");
+ } else {
+ QPY_VAD_LOG("auth fail ret=%d server=%d", ret, server_addr);
+ }
+ return mp_obj_new_int(ret);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_vad_auth_obj, 1, 3, mp_vad_auth);
+
+/* 诊断用:返回 init_vad 实际被调用的累计次数(不触发初始化)。
+ * 配合 vad.free()+重建判断"联网重授权"是否真的重新调用了 init_vad。 */
+STATIC mp_obj_t mp_vad_init_count(mp_obj_t self_in)
+{
+ (void)self_in;
+ return mp_obj_new_int(s_vad_init_count);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_vad_init_count_obj, mp_vad_init_count);
+
STATIC mp_obj_t mp_vad_free(size_t n_args, const mp_obj_t *args)
{
(void)n_args;
free_vad();
s_vad_ready = 0;
s_vad_init_mode = 0;
+ s_vad_auth_ok = 0;
+ QPY_VAD_LOG("free_vad done, s_vad_ready=0 (next build will re-auth)");
+ } else {
+ QPY_VAD_LOG("free_vad skip (not ready)");
}
return mp_const_none;
}
{ MP_ROM_QSTR(MP_QSTR_silence_clear), MP_ROM_PTR(&mp_vad_silence_clear_obj) },
{ MP_ROM_QSTR(MP_QSTR_clear), MP_ROM_PTR(&mp_vad_clear_obj) },
{ MP_ROM_QSTR(MP_QSTR_init_mode), MP_ROM_PTR(&mp_vad_init_mode_obj) },
+ { MP_ROM_QSTR(MP_QSTR_init_count), MP_ROM_PTR(&mp_vad_init_count_obj) },
+ { MP_ROM_QSTR(MP_QSTR_auth_ok), MP_ROM_PTR(&mp_vad_auth_ok_obj) },
+ { MP_ROM_QSTR(MP_QSTR_auth), MP_ROM_PTR(&mp_vad_auth_obj) },
{ MP_ROM_QSTR(MP_QSTR_free), MP_ROM_PTR(&mp_vad_free_obj) },
{ MP_ROM_QSTR(MP_QSTR_custom_vad_process), MP_ROM_PTR(&mp_custom_vad_process_obj) },
{ MP_ROM_QSTR(MP_QSTR_custom_vad_reset), MP_ROM_PTR(&mp_custom_vad_reset_obj) },
--- /dev/null
+/**
+ * @file transport_imp_asr_mcu.c
+ * @brief IMSL libimslnn.a 网络传输适配(ASR MCU + lwip)
+ */
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+
+#if !defined(PLAT_Qualcomm)
+#include "sockets.h"
+#include "netdb.h"
+#endif
+#include "helios_os.h"
+#include "helios_rtc.h"
+#include "helios_debug.h"
+#include "autoconf.h"
+
+#if CONFIG_VAD
+
+#define TR_LOG(msg, ...) custom_log("imsl_tr", msg, ##__VA_ARGS__)
+
+#define TRANSPORT_OK 0
+#define TRANSPORT_ERROR_CONNECT -1
+#define TRANSPORT_ERROR_SEND -2
+#define TRANSPORT_ERROR_RECV -3
+#define TRANSPORT_ERROR_NOT_CONNECTED -4
+#define TRANSPORT_ERROR_DISCONNECTED -5
+
+typedef struct {
+ int (*init)(void);
+ int (*connect)(const char *host, uint16_t port);
+ int (*send)(const uint8_t *data, uint16_t len);
+ int (*recv)(uint8_t *buffer, uint16_t max_len);
+ int (*disconnect)(void);
+ int (*is_connected)(void);
+ uint32_t (*get_tick)(void);
+ void (*delay)(uint32_t delay_ms);
+} transport_interface_t;
+
+static int sock = -1;
+static int is_connected_flag = 0;
+
+static void imp_delay(uint32_t delay_ms)
+{
+ Helios_msleep(delay_ms);
+}
+
+static int imp_init(void)
+{
+ return TRANSPORT_OK;
+}
+
+static int imp_disconnect(void)
+{
+ if (sock >= 0) {
+ TR_LOG("disconnect sock=%d", sock);
+ lwip_close(sock);
+ sock = -1;
+ }
+ is_connected_flag = 0;
+ return TRANSPORT_OK;
+}
+
+static int imp_connect(const char *host, uint16_t port)
+{
+ const char *host_start = host;
+ char clean_host[256] = {0};
+ uint16_t resolved_port = port;
+ const char *colon_pos;
+ const char *slash_pos;
+ struct sockaddr_in server_addr;
+
+ if (is_connected_flag) {
+ imp_disconnect();
+ }
+
+ if (strncmp(host, "http://", 7) == 0) {
+ host_start = host + 7;
+ } else if (strncmp(host, "https://", 8) == 0) {
+ host_start = host + 8;
+ resolved_port = 80;
+ }
+
+ colon_pos = strchr(host_start, ':');
+ slash_pos = strchr(host_start, '/');
+
+ if (colon_pos && (!slash_pos || colon_pos < slash_pos)) {
+ strncpy(clean_host, host_start, colon_pos - host_start);
+ {
+ const char *port_start = colon_pos + 1;
+ const char *port_end = slash_pos ? slash_pos : (host_start + strlen(host_start));
+ char port_str[16] = {0};
+ int port_val;
+ strncpy(port_str, port_start, port_end - port_start);
+ port_val = atoi(port_str);
+ if (port_val > 0 && port_val <= 65535) {
+ resolved_port = (uint16_t)port_val;
+ }
+ }
+ } else if (slash_pos) {
+ strncpy(clean_host, host_start, slash_pos - host_start);
+ } else {
+ strncpy(clean_host, host_start, strlen(host_start));
+ }
+
+ sock = lwip_socket(AF_INET, SOCK_STREAM, 0);
+ if (sock < 0) {
+ TR_LOG("socket create fail errno=%d", errno);
+ return TRANSPORT_ERROR_CONNECT;
+ }
+
+ memset(&server_addr, 0, sizeof(server_addr));
+ server_addr.sin_family = AF_INET;
+ server_addr.sin_port = htons(resolved_port);
+
+ if (inet_pton(AF_INET, clean_host, &server_addr.sin_addr) <= 0) {
+ struct hostent *he = gethostbyname(clean_host);
+ if (!he) {
+ TR_LOG("connect fail dns host=%s", clean_host);
+ lwip_close(sock);
+ sock = -1;
+ return TRANSPORT_ERROR_CONNECT;
+ }
+ server_addr.sin_addr = *(struct in_addr *)he->h_addr;
+ }
+
+ if (lwip_connect(sock, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
+ TR_LOG("connect fail tcp host=%s port=%d errno=%d", clean_host, resolved_port, errno);
+ lwip_close(sock);
+ sock = -1;
+ return TRANSPORT_ERROR_CONNECT;
+ }
+
+ is_connected_flag = 1;
+ TR_LOG("connect ok host=%s ip=%s port=%d sock=%d",
+ clean_host, inet_ntoa(server_addr.sin_addr), resolved_port, sock);
+ return TRANSPORT_OK;
+}
+
+static int imp_send(const uint8_t *data, uint16_t len)
+{
+ int n = lwip_send(sock, data, len, 0);
+ if (n < 0) {
+ TR_LOG("send fail errno=%d len=%u", errno, (unsigned)len);
+ }
+ return n;
+}
+
+static int imp_recv(uint8_t *buffer, uint16_t max_len)
+{
+ int n = lwip_recv(sock, buffer, max_len, 0);
+ if (n < 0) {
+ TR_LOG("recv fail errno=%d max=%u", errno, (unsigned)max_len);
+ } else if (n == 0) {
+ TR_LOG("recv peer closed");
+ }
+ return n;
+}
+
+static int imp_is_connected(void)
+{
+ int error = 0;
+ socklen_t len = sizeof(error);
+
+ if (sock < 0 || !is_connected_flag) {
+ return 0;
+ }
+ if (lwip_getsockopt(sock, SOL_SOCKET, SO_ERROR, &error, &len) < 0) {
+ is_connected_flag = 0;
+ return 0;
+ }
+ if (error != 0) {
+ is_connected_flag = 0;
+ imp_disconnect();
+ return 0;
+ }
+ return 1;
+}
+
+static uint32_t imp_get_tick(void)
+{
+ return (uint32_t)Helios_RTC_GetTicks();
+}
+
+transport_interface_t imp_transport = {
+ .init = imp_init,
+ .connect = imp_connect,
+ .send = imp_send,
+ .recv = imp_recv,
+ .disconnect = imp_disconnect,
+ .is_connected = imp_is_connected,
+ .get_tick = imp_get_tick,
+ .delay = imp_delay,
+};
+
+#endif /* CONFIG_VAD */
data_tmp = data["data"]
if "token" in data_tmp: #token
self.dev_token = data_tmp["token"]
+ try:
+ EventMesh.publish("vad_try_auth", "sign_in")
+ except Exception:
+ pass
else:#报错清空密钥
print("登录失败,清空密钥")
EventMesh.publish("set_storage_config",["dev_pass",""])
bz_dt = headers_data["bz-dt"]
self.dev_token = bz_dt.replace(" ", "") #去掉所有的空格符
print("update_dev_token:{}".format(self.dev_token))
+ try:
+ EventMesh.publish("vad_try_auth", "token_refresh")
+ except Exception:
+ pass
except Exception as e:
print("headers_data!!!!! error\r\n")
if response != None:
self.KeySOS_timer = osTimer()
self.play_imei_timer = osTimer()
self.play_imei_timer_count=0
+ self._montage_defer = [] # 本地提示音延时队列(通道0忙时排队,播完补播,不丢弃)
self.KeySOS_timer_count = 0
self.KeySOS_timer_flag = 0
self._single_power_ai_merged = False
voice_record_satrt_flag = EventMesh.publish("get_voice_record_flag")#获取静默或者语音留言是否在运行
if voice_record_satrt_flag == None:
voice_record_satrt_flag = 0
- if VC_satrt_flag == 0 and voice_record_satrt_flag == 0:
+ # 充电提示属本地提示音(设计稿幻灯片4):仅在“语音留言/静默录音”进行时让路;
+ # VC 会话仅连接(空闲/对话)不再吞掉提示音,交由 audio_montage_play 仲裁(抢占对话TTS)
+ if voice_record_satrt_flag == 0:
self.aud.stop()
#EventMesh.publish("flicker_led_red")#充电闪灯
#self.aud.play(1,1,'U:/static/R_CHARGE_IN.mp3')
voice_record_satrt_flag = EventMesh.publish("get_voice_record_flag")#获取静默或者语音留言是否在运行
if voice_record_satrt_flag == None:
voice_record_satrt_flag = 0
- if VC_satrt_flag == 0 and voice_record_satrt_flag == 0:
+ # 拔出充电提示属本地提示音:同插入逻辑,VC 仅连接不再吞提示音
+ if voice_record_satrt_flag == 0:
self.aud.stop()
try:
if not cfg_bool("USE_MIN_HW_STATUS", True):
self.wakeup_BT()
bat_pri = self._audio_is_battery_priority(msg)
if bat_pri:
+ # 低电/关机提示最高优先级:抢占一切,立即播
try:
EventMesh.publish("battery_priority_mute_vc")
except Exception:
pass
- else:
- # 仅服务端 TTS PCM 在播时跳过;低电/关机提示优先级更高(见上)
- try:
- if EventMesh.publish("get_vc_tts_playback_active") == 1:
- print("[audio-arb] skip local montage_play during tts_pcm")
- return
- except Exception:
- pass
+ self._montage_play_now(msg)
+ return
+ # #4 本地提示音与 notify 等优先级:通道0已有本地短音/montage 在播时延时排队,不丢弃
+ try:
+ if EventMesh.publish("get_audio_play_state") == 1:
+ self._montage_defer_push(msg)
+ return
+ except Exception:
+ pass
+ # #1 本地提示音优先于对话TTS:抢占(停)当前 TTS 流播放后再播,会话保留(不 Close)
+ try:
+ if EventMesh.publish("get_vc_tts_playback_active") == 1:
+ print("[audio-arb] preempt tts_pcm for local montage")
+ EventMesh.publish("local_priority_mute_vc")
+ except Exception:
+ pass
+ self._montage_play_now(msg)
+
+ def _montage_play_now(self, msg):
+ """实际播放 montage(不做仲裁):供 audio_montage_play 与延时队列补播共用。"""
self.aud.stopPlayStream()
self.aud.stopAll()
str_data='mp3files='
self.play_imei_timer_count=1
self.play_imei_timer.stop()
self.play_imei_timer.start(1000,1,self.play_imei_timer_cb)
+
+ def _montage_defer_push(self, msg):
+ """通道0 忙时把本地提示音排队,等播完按序补播(不丢弃);启动轮询定时器驱动补播。"""
+ try:
+ q = self._montage_defer
+ except AttributeError:
+ self._montage_defer = []
+ q = self._montage_defer
+ if len(q) >= 5:
+ print("[audio-arb] defer queue full, drop oldest")
+ q.pop(0)
+ q.append(msg)
+ print("[audio-arb] defer montage (audio busy) queue={}".format(len(q)))
+ # 当前在播的若不是 montage(无 play_imei_timer),需自起轮询以驱动补播
+ self.play_imei_timer_count = 1
+ self.play_imei_timer.stop()
+ self.play_imei_timer.start(1000,1,self.play_imei_timer_cb)
def paly_iccid_imei(self,event,msg):
def play_imei_timer_cb(self,event=None,msg=None):
if self.play_imei_timer_count == 1:
if EventMesh.publish("get_audio_play_state") == 0:
+ # 通道0空闲:若有延时排队的本地提示音,按序补播(不丢弃)
+ try:
+ q = getattr(self, "_montage_defer", None)
+ if q:
+ nxt = q.pop(0)
+ print("[audio-arb] flush deferred montage queue_left={}".format(len(q)))
+ self._montage_play_now(nxt)
+ return
+ except Exception as e:
+ usys.print_exception(e)
print("音频文件播放完成")
self.play_imei_timer_count=0
self.play_imei_timer.stop()
pass
def _vc_build_vad(self):
- """构造 imsl VAD 对象并记录授权模式(self._vad_init_mode)。
- 失败返回 None。init_vad 内部完成联网授权:有网授权成功=2,否则回退试用=1。"""
+ """构造 imsl VAD:init_vad 仅表示能否使用(1=试用可用);授权看 auth_vad/auth_ok。"""
try:
sil_ms = int(self.vad_silence)
# energy_threshold 越低越灵敏(易触发 speech),越高越钝;imsl 推荐 10000。
vad = VAD.VAD(
self.VC_record_samplerate, 1, self.VAD_data_len,
energy, 240, sil_ms, 480)
- mode = vad.init_mode()
- self._vad_init_mode = mode
- print("[VAD] init_mode=", mode, "trial=", VAD.MODE_TRIAL,
- "sil_ms=", sil_ms, "energy=", energy,
- "debug_only=", self._local_vad_debug_only,
- "endpoint=", not self._local_vad_debug_only)
+ init_ret = vad.init_mode()
+ self._vad_init_mode = init_ret
+ try:
+ auth_ok = vad.auth_ok()
+ except Exception:
+ auth_ok = 0
+ try:
+ _icnt = vad.init_count()
+ except Exception:
+ _icnt = -1
+ print("[VAD] init ret={} usable={} auth_ok={} init_count={} sil_ms={} energy={} "
+ "debug_only={} endpoint={}".format(
+ init_ret, init_ret == VAD.MODE_TRIAL, auth_ok, _icnt,
+ sil_ms, energy, self._local_vad_debug_only,
+ not self._local_vad_debug_only))
return vad
except Exception as e:
print("[VAD] init fail:", e)
return None
+ def _vc_vad_on_try_auth(self, event=None, msg=None):
+ """DMP token 就绪后触发 VAD 授权(由 vc_auth 发布 vad_try_auth)。"""
+ reason = msg if isinstance(msg, str) else "event"
+ self._vc_vad_try_activate(reason)
+
def _vc_vad_try_activate(self, reason=""):
- """开机网络就绪后联网激活 VAD:若当前为试用模式且有网络,free 后重建以触发联网授权。
- 一旦拿到授权(mode=2)即置 _vad_activate_done,后续不再重试。无网/失败保留试用,下次再试。"""
+ """auth_vad(DMP token) 联网授权;init_vad 成功只代表试用可用,auth_ret=1 才代表已授权。"""
try:
if getattr(self, "is_VAD", 0) != 1 or self.vad is None:
+ print("[VAD][auth] skip reason={} cause=vad_off is_VAD={} vad={}".format(
+ reason, getattr(self, "is_VAD", 0), self.vad is not None))
return
if getattr(self, "_vad_activate_done", 0) == 1:
+ try:
+ _ao = self.vad.auth_ok()
+ except Exception:
+ _ao = 1
+ print("[VAD][auth] skip reason={} cause=already_licensed auth_ok={} init_ret={}".format(
+ reason, _ao, getattr(self, "_vad_init_mode", 0)))
return
- if getattr(self, "_vad_init_mode", 0) == 2:
- self._vad_activate_done = 1
+ init_ret = getattr(self, "_vad_init_mode", 0)
+ if init_ret == 0:
+ print("[VAD][auth] skip reason={} cause=init_fail init_ret=0".format(reason))
+ return
+ token = None
+ try:
+ token = EventMesh.publish("get_dev_token")
+ except Exception:
+ token = None
+ if not token or len(str(token)) == 0:
+ print("[VAD][auth] defer reason={} cause=no_token init_ret={}".format(reason, init_ret))
return
- # 网络可用性判断:CSQ 有效即认为可联网授权
try:
csq = net.csqQueryPoll()
except Exception:
csq = -1
if csq is None or csq == -1 or csq == 99:
- return # 无网,下次录音再试
- # 有网才执行激活;不论结果只做一次,避免每轮录音重复 free+重建
- self._vad_activate_done = 1
- self.vad.free()
- new_vad = self._vc_build_vad()
- if new_vad is not None:
- self.vad = new_vad
- if self._vad_init_mode == 2:
- print("[VAD] activate ok (licensed) reason=", reason)
- else:
- print("[VAD] activate still trial reason=", reason, "csq=", csq)
+ print("[VAD][auth] defer reason={} cause=no_net csq={} init_ret={}".format(
+ reason, csq, init_ret))
+ return
+ server_addr = cfg_int("VAD_DMP_SERVER_ADDR", 0)
+ try:
+ import constants
+ dmp_base = getattr(constants, "DMP_BASE", "") or ""
+ except Exception:
+ dmp_base = ""
+ print("[VAD][auth] begin reason={} init_ret={} csq={} server={} token_len={} dmp={}".format(
+ reason, init_ret, csq, server_addr, len(str(token)), dmp_base))
+ auth_ret = self.vad.auth(str(token), server_addr)
+ try:
+ auth_ok = self.vad.auth_ok()
+ except Exception:
+ auth_ok = 1 if auth_ret == 1 else 0
+ if auth_ret == 1 and auth_ok == 1:
+ self._vad_activate_done = 1
+ print("[VAD][auth] ok reason={} auth_ret=1 auth_ok=1 (licensed)".format(reason))
+ else:
+ print("[VAD][auth] fail reason={} auth_ret={} auth_ok={} init_ret={} csq={} "
+ "server={} dmp={} (trial still usable, see [imsl_vad]/[imsl_tr])".format(
+ reason, auth_ret, auth_ok, init_ret, csq, server_addr, dmp_base))
except Exception as e:
- print("[VAD] activate fail:", e)
+ print("[VAD][auth] exception:", e)
def _long_dialogue_cancel_preserve_speech(self):
"""长对话 canceled:非用户打断时,录音中或 asr 续说窗内均保持/恢复上行。"""
EventMesh.publish("publish_AI_btnInfo", {"func": self.Close})
except Exception:
pass
+ def local_priority_mute_vc(self, event=None, msg=None):
+ """本地提示音(montage/充电等)优先于对话TTS:仅停当前对话TTS播放,会话保留。
+ 与 battery_priority_mute_vc 区别:不关会话(不 Close)、不置 VC_stop_play_audio_flag,
+ 避免为一次提示音杀掉整段对话与 recv 线程。_drop_tts_audio 在下一轮开录时清 0。"""
+ try:
+ self._drop_tts_audio = 1
+ except Exception:
+ pass
+ try:
+ self._ptt_hard_mute_local_playback()
+ except Exception:
+ pass
+ try:
+ if getattr(self, "VC_Play_flag", 0) == 1 or getattr(self, "play_pcm", None) is not None:
+ self.VC_Play_End()
+ except Exception:
+ pass
def _vc_turn_current(self):
try:
return int(getattr(self, "_vc_turn_gen", 0))
# ARG_silence_start_threshold, // 静音开始阈值(ms) → imsl rule1
self.vad = None
self._vc_vad_pcm_tail = bytearray()
- self._vad_init_mode = 0 # 0失败 1试用 2授权
- self._vad_activate_done = 0 # 已成功联网授权(mode=2)后置1,不再重试
+ self._vad_init_mode = 0 # init_vad 返回值:0失败 1试用可用(非授权状态)
+ self._vad_activate_done = 0 # auth_vad 本开机周期已成功(auth_ok=1)则置1
if self.is_VAD == 1:
self.vad = self._vc_build_vad()
if self.vad is None:
EventMesh.subscribe("get_ptt_led_lock_listening", self.get_ptt_led_lock_listening)
EventMesh.subscribe("get_vc_hold_listening_led", self.get_vc_hold_listening_led)
EventMesh.subscribe("battery_priority_mute_vc", self.battery_priority_mute_vc)
+ EventMesh.subscribe("local_priority_mute_vc", self.local_priority_mute_vc)
+ EventMesh.subscribe("vad_try_auth", self._vc_vad_on_try_auth)
EventMesh.subscribe("VC_error", self.VC_error)
EventMesh.subscribe("audio_test", self.audio_test)
EventMesh.subscribe("audio_test_close", self.audio_test_close)
--- /dev/null
+# xcopy 后确保 Helios microPython.mk 能 -include microPython_imsl_vad.mk(仅补一行锚点,可重复执行)
+param([string]$HeliosRoot)
+$ErrorActionPreference = 'Stop'
+if (-not $HeliosRoot) { $HeliosRoot = Join-Path $PSScriptRoot '..\..\Helios_SDK' }
+$mk = Join-Path $HeliosRoot 'services\microPython\microPython.mk'
+if (-not (Test-Path -LiteralPath $mk)) { Write-Error "missing $mk"; exit 2 }
+$enc = New-Object System.Text.UTF8Encoding @($false)
+$lines = [System.IO.File]::ReadAllLines($mk, $enc)
+if (($lines -join "`n") -match 'services/microPython/microPython_imsl_vad\.mk') { Write-Host 'ensure_helios_imsl_vad_mk: OK (already)'; exit 0 }
+$out = New-Object System.Collections.Generic.List[string]
+$done = $false
+foreach ($line in $lines) {
+ [void]$out.Add($line)
+ if (-not $done -and $line -match 'libimslvad\.a\s*$') {
+ [void]$out.Add('-include services/microPython/microPython_imsl_vad.mk')
+ $done = $true
+ }
+}
+if (-not $done) { Write-Error 'anchor libimslvad.a not found'; exit 3 }
+[System.IO.File]::WriteAllLines($mk, $out.ToArray(), $enc)
+Write-Host 'ensure_helios_imsl_vad_mk: inserted -include microPython_imsl_vad.mk'