---\r
+description: 基础规则版本:V2\r
alwaysApply: true\r
---\r
# AI 行为基础规则\r
2. 命名、注释、格式统一\r
3. 必须做边界判断、错误处理\r
4. 不破坏原有功能\r
-5. 回答简洁,直接给代码+关键注释
\ No newline at end of file
+5. 回答简洁,直接给代码+关键注释\r
+6. 给出结论的时候,列出的每一个改动,后面都要附带影响描述\r
+7. try 之类的安全检测要尽量简化,只有必要的部分才加。\r
$(BUILD)/backup_restore.mpy \
$(BUILD)/file_crc32.mpy \
$(BUILD)/system.mpy \
- $(BUILD)/gnss.mpy \
$(BUILD)/unzip.mpy \
$(BUILD)/queue.mpy \
$(BUILD)/sys_bus.mpy \
# 收到 vad.active 是否强制回蓝灯(长对话)
VAD_ACTIVE_BLUE_LED = True
+# 长对话本地 imsl VAD 打断(录音线程 vad.process)
+LOCAL_VAD_ENABLE = True
+# False=本地 VAD 驱动断句;True=仅打日志,仍用云端 VAD
+LOCAL_VAD_DEBUG_ONLY = False
# 收音 listening:长对话蓝慢闪(1000ms)、单对话蓝快闪(250ms) 由 VC_mode 在 AI_led 内切换,无需本文件单独配置
VC_IDLE_DEEP_SLEEP_SEC = 60
VC_IDLE_DEEP_SLEEP_ENABLE = 1
-# æ\9c\8då\8a¡ç«¯æ\96å\8f¥é\9d\99é\9f³(ms)ï¼\9bå\8f¥ä¸ç\9fæ\9a\82å\81\9c顿建议 â\89¥1200;可被 storage vad_silence 覆盖
+# æ\9c¬å\9c° imsl æ\96å\8f¥é\9d\99é\9f³(ms)ï¼\9bæ\98 å°\84 rule2/3;可被 storage vad_silence 覆盖
VAD_SILENCE_DEFAULT = 1000
# 长对话:单轮最长录音(ms)、asr.completed 后续说 merge 窗(ms);0=不限制
# 收到 vad.active 是否强制回蓝灯(长对话)
VAD_ACTIVE_BLUE_LED = True
+# 长对话本地 imsl VAD 打断(录音线程 vad.process)
+LOCAL_VAD_ENABLE = True
+# False=本地 VAD 驱动断句;True=仅打日志,仍用云端 VAD
+LOCAL_VAD_DEBUG_ONLY = False
# 收音 listening:长对话蓝慢闪(1000ms)、单对话蓝快闪(250ms) 由 VC_mode 在 AI_led 内切换,无需本文件单独配置
VC_IDLE_DEEP_SLEEP_SEC = 60
VC_IDLE_DEEP_SLEEP_ENABLE = 1
-# æ\9c\8då\8a¡ç«¯æ\96å\8f¥é\9d\99é\9f³(ms)ï¼\9bå\8f¥ä¸ç\9fæ\9a\82å\81\9c顿建议 â\89¥1200;可被 storage vad_silence 覆盖
+# æ\9c¬å\9c° imsl æ\96å\8f¥é\9d\99é\9f³(ms)ï¼\9bæ\98 å°\84 rule2/3;可被 storage vad_silence 覆盖
VAD_SILENCE_DEFAULT = 1000
# 长对话:单轮最长录音(ms)、asr.completed 后续说 merge 窗(ms);0=不限制
DEV_TYPE=k8v3
SRV_TYPE=beike_dev_v3
-VERSION=V1.3
+VERSION=V1.4
\ No newline at end of file
--- /dev/null
+#ifndef _IMSL_VAD_DLL
+#define _IMSL_VAD_DLL
+#include <stdint.h>
+
+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
--- /dev/null
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "py/runtime.h"
+#include "py/stream.h"
+#include "mperrno.h"
+#include "helios_debug.h"
+#include "autoconf.h"
+#include "imsl_vad.h"
+
+#if CONFIG_VAD
+
+#define QPY_VAD_LOG(msg, ...) custom_log("modvad", msg, ##__VA_ARGS__)
+
+typedef struct _mp_obj_VAD_t {
+ mp_obj_base_t base;
+ int inited;
+} mp_obj_VAD_t;
+
+static struct VadConfig s_vad_conf;
+static int s_vad_ready;
+static int s_vad_init_mode; /* init_vad 返回值:0失败 1试用 2授权 */
+
+static void vad_fill_defaults(struct VadConfig *conf)
+{
+ memset(conf, 0, sizeof(*conf));
+ conf->vad_log_level = 1;
+ 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;
+}
+
+static void vad_apply_legacy_args(struct VadConfig *conf, const mp_arg_val_t *args)
+{
+ /* 兼容 vc_session 构造参数:energy_threshold, voice_time, silence_time, silence_start_threshold */
+ if (args[3].u_int > 0) {
+ conf->energy_threshold = args[3].u_int;
+ }
+ if (args[4].u_int > 0) {
+ conf->min_speech_length = args[4].u_int;
+ }
+ if (args[5].u_int > 0) {
+ conf->silence_detect_length = args[5].u_int;
+ conf->rule2_min_tailing_silence = args[5].u_int;
+ conf->rule3_min_tailing_silence = args[5].u_int;
+ }
+ if (args[6].u_int > 0) {
+ conf->rule1_min_tailing_silence = args[6].u_int;
+ }
+}
+
+static void vad_ensure_init(const mp_arg_val_t *legacy_args)
+{
+ int ret;
+
+ if (s_vad_ready) {
+ return;
+ }
+ vad_fill_defaults(&s_vad_conf);
+ if (legacy_args) {
+ vad_apply_legacy_args(&s_vad_conf, legacy_args);
+ }
+ 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);
+}
+
+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)
+{
+ enum {
+ ARG_sample_rate,
+ ARG_channel,
+ ARG_frame_size,
+ ARG_energy_threshold,
+ ARG_voice_time,
+ ARG_silence_time,
+ ARG_silence_start_threshold,
+ };
+ static const mp_arg_t allowed_args[] = {
+ { MP_QSTR_sample_rate, MP_ARG_INT, {.u_int = 16000} },
+ { MP_QSTR_channel, MP_ARG_INT, {.u_int = 1} },
+ { MP_QSTR_frame_size, MP_ARG_INT, {.u_int = 320} },
+ { MP_QSTR_energy_threshold, MP_ARG_INT, {.u_int = 10000} },
+ { MP_QSTR_voice_time, MP_ARG_INT, {.u_int = 240} },
+ { MP_QSTR_silence_time, MP_ARG_INT, {.u_int = 300} },
+ { MP_QSTR_silence_start_threshold, MP_ARG_INT, {.u_int = 480} },
+ };
+ mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+ mp_obj_VAD_t *self;
+
+ mp_arg_parse_all_kw_array(n_args, n_kw, all_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+ (void)args[ARG_sample_rate];
+ (void)args[ARG_channel];
+ (void)args[ARG_frame_size];
+ vad_ensure_init(args);
+ self = m_new_obj(mp_obj_VAD_t);
+ self->base.type = type;
+ self->inited = 1;
+ return MP_OBJ_FROM_PTR(self);
+}
+
+static mp_obj_t vad_run_pcm(mp_obj_t data, mp_obj_t data_len_obj)
+{
+ mp_buffer_info_t bufinfo;
+ int byte_len;
+ int sample_len;
+ const int16_t *samples;
+
+ vad_ensure_init(NULL);
+ mp_get_buffer_raise(data, &bufinfo, MP_BUFFER_READ);
+ byte_len = mp_obj_get_int(data_len_obj);
+ if (byte_len <= 0 || bufinfo.len <= 0) {
+ return mp_obj_new_int(0);
+ }
+ if (byte_len > (int)bufinfo.len) {
+ byte_len = (int)bufinfo.len;
+ }
+ sample_len = byte_len / (int)sizeof(int16_t);
+ if (sample_len <= 0) {
+ return mp_obj_new_int(0);
+ }
+ samples = (const int16_t *)bufinfo.buf;
+ run_vad(samples, sample_len);
+ return mp_obj_new_int(vad_detect());
+}
+
+STATIC mp_obj_t mp_vad_process(mp_obj_t self_in, mp_obj_t data, mp_obj_t data_len)
+{
+ (void)self_in;
+ return vad_run_pcm(data, data_len);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_3(mp_vad_process_obj, mp_vad_process);
+
+STATIC mp_obj_t mp_custom_vad_process(mp_obj_t self_in, mp_obj_t data, mp_obj_t data_len)
+{
+ mp_obj_t st = vad_run_pcm(data, data_len);
+ int v = mp_obj_get_int(st);
+ (void)self_in;
+ if (v == 2) {
+ vad_clear();
+ return mp_obj_new_int(0);
+ }
+ return mp_obj_new_int(v == 1 ? 1 : 0);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_3(mp_custom_vad_process_obj, mp_custom_vad_process);
+
+STATIC mp_obj_t mp_vad_detect(mp_obj_t self_in)
+{
+ int st;
+ (void)self_in;
+ vad_ensure_init(NULL);
+ st = vad_detect();
+ if (st == 2) {
+ vad_clear();
+ }
+ return mp_obj_new_int(st);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_vad_detect_obj, mp_vad_detect);
+
+STATIC mp_obj_t mp_vad_silence_detect(mp_obj_t self_in)
+{
+ (void)self_in;
+ vad_ensure_init(NULL);
+ return mp_obj_new_int(vad_silence_detect());
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_vad_silence_detect_obj, mp_vad_silence_detect);
+
+STATIC mp_obj_t mp_vad_silence_clear(mp_obj_t self_in)
+{
+ (void)self_in;
+ vad_ensure_init(NULL);
+ vad_silence_clear();
+ return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_vad_silence_clear_obj, mp_vad_silence_clear);
+
+STATIC mp_obj_t mp_vad_clear(mp_obj_t self_in)
+{
+ (void)self_in;
+ vad_ensure_init(NULL);
+ vad_clear();
+ return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_vad_clear_obj, mp_vad_clear);
+
+STATIC mp_obj_t mp_custom_vad_reset(mp_obj_t self_in)
+{
+ (void)self_in;
+ vad_ensure_init(NULL);
+ vad_clear();
+ vad_silence_clear();
+ return mp_obj_new_int(1);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_custom_vad_reset_obj, mp_custom_vad_reset);
+
+STATIC mp_obj_t mp_vad_init_mode(mp_obj_t self_in)
+{
+ (void)self_in;
+ vad_ensure_init(NULL);
+ return mp_obj_new_int(s_vad_init_mode);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_vad_init_mode_obj, mp_vad_init_mode);
+
+STATIC mp_obj_t mp_vad_free(size_t n_args, const mp_obj_t *args)
+{
+ (void)n_args;
+ (void)args;
+ if (s_vad_ready) {
+ free_vad();
+ s_vad_ready = 0;
+ s_vad_init_mode = 0;
+ }
+ return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_vad_free_obj, 0, 0, mp_vad_free);
+
+STATIC const mp_rom_map_elem_t VAD_locals_dict_table[] = {
+ { MP_ROM_QSTR(MP_QSTR_process), MP_ROM_PTR(&mp_vad_process_obj) },
+ { MP_ROM_QSTR(MP_QSTR_detect), MP_ROM_PTR(&mp_vad_detect_obj) },
+ { MP_ROM_QSTR(MP_QSTR_silence_detect), MP_ROM_PTR(&mp_vad_silence_detect_obj) },
+ { 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_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) },
+ { MP_ROM_QSTR(MP_QSTR_MODE_FAIL), MP_ROM_INT(0) },
+ { MP_ROM_QSTR(MP_QSTR_MODE_TRIAL), MP_ROM_INT(1) },
+ { MP_ROM_QSTR(MP_QSTR_MODE_LICENSED), MP_ROM_INT(2) },
+ { MP_ROM_QSTR(MP_QSTR_SILENCE), MP_ROM_INT(0) },
+ { MP_ROM_QSTR(MP_QSTR_SPEECH), MP_ROM_INT(1) },
+ { MP_ROM_QSTR(MP_QSTR_SPEECH_END), MP_ROM_INT(2) },
+};
+STATIC MP_DEFINE_CONST_DICT(VAD_locals_dict, VAD_locals_dict_table);
+
+STATIC const mp_obj_type_t VAD_type = {
+ { &mp_type_type },
+ .name = MP_QSTR_VAD,
+ .make_new = VAD_make_new,
+ .locals_dict = (void *)&VAD_locals_dict,
+};
+
+STATIC const mp_rom_map_elem_t VAD_module_globals_table[] = {
+ { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_VAD) },
+ { MP_ROM_QSTR(MP_QSTR_VAD), MP_ROM_PTR(&VAD_type) },
+ { MP_ROM_QSTR(MP_QSTR_SILENCE), MP_ROM_INT(0) },
+ { MP_ROM_QSTR(MP_QSTR_SPEECH), MP_ROM_INT(1) },
+ { MP_ROM_QSTR(MP_QSTR_SPEECH_END), MP_ROM_INT(2) },
+ { MP_ROM_QSTR(MP_QSTR_MODE_FAIL), MP_ROM_INT(0) },
+ { MP_ROM_QSTR(MP_QSTR_MODE_TRIAL), MP_ROM_INT(1) },
+ { MP_ROM_QSTR(MP_QSTR_MODE_LICENSED), MP_ROM_INT(2) },
+};
+STATIC MP_DEFINE_CONST_DICT(VAD_module_globals, VAD_module_globals_table);
+
+const mp_obj_module_t mp_module_VAD = {
+ .base = { &mp_type_module },
+ .globals = (mp_obj_dict_t *)&VAD_module_globals,
+};
+
+#endif
-# -*- coding: utf-8 -*-\r
-"""设备鉴权与 token。"""\r
-from common import Abstract\r
-try:\r
- from qp_log import qp_print as print\r
-except Exception:\r
- pass\r
-import EventMesh\r
-import usys\r
-import utime\r
-import uhashlib\r
-import ubinascii\r
-import ujson\r
-import osTimer\r
-import modem\r
-import net\r
-import sim\r
-import machine\r
-import base64\r
-import constants\r
-import ucryptolib\r
-import urandom as random\r
-import request\r
-try:\r
- import vc_config\r
-except Exception:\r
- vc_config = None\r
-\r
-class device_res_author(Abstract):\r
- \r
- def __init__(self) :\r
- print("device_res_author __init__ start !!!!!!!!!!!!!!!!!")\r
- self.deviceId = modem.getDevImei()#"876226002022574"\r
- self.SHA1_BLOCK_SIZE = 64\r
- self.PAD_BLOCK_SIZE = 16\r
- self.SHA256 = uhashlib.sha256\r
- self.pad = lambda s: s + chr(self.PAD_BLOCK_SIZE - len(s) % self.PAD_BLOCK_SIZE) * (self.PAD_BLOCK_SIZE - len(s) % self.PAD_BLOCK_SIZE)\r
- # 除去补16字节的多余字符\r
- self.unpad = lambda s: s[:-s[-1]]\r
- # 设备鉴权:优先 default_config / usr/default_config 的 PRODUCT_PID、PRODUCT_KEY\r
- self.pid = "cqxJZi5CNgzjS3mX21Zw"\r
- self.key = b"uKLrChwrxA1LklgBc3VwawYjUkbT3BgX"\r
- try:\r
- if "vc_config" in globals() and vc_config:\r
- _pid = vc_config.get_attr("PRODUCT_PID", None)\r
- if _pid:\r
- self.pid = str(_pid)\r
- _key = vc_config.get_attr("PRODUCT_KEY", None)\r
- if _key is not None and _key != "":\r
- self.key = _key if isinstance(_key, bytes) else str(_key).encode()\r
- except Exception:\r
- pass\r
- self.dev_res_timer = osTimer()\r
- self.dev_res_timer.start(20000, 1, self.dev_timer_cb)\r
- self.dev_res_timerCount = 0\r
- self.ud_token_timer = osTimer()\r
- self.ud_token_timer.start(10000, 1, self.ud_token_timer_cb)\r
- self.ud_token_timer_Count = 0\r
- self.dev_token = None\r
- self.res_error_count = 0\r
- self.ntptime_flag = 0\r
- EventMesh.subscribe("get_dev_token", self.get_dev_token)\r
- EventMesh.subscribe("update_dev_token", self.update_dev_token)\r
- EventMesh.subscribe("dev_active", self.dev_active)\r
- EventMesh.subscribe("dev_sign_in", self.dev_sign_in)\r
- EventMesh.subscribe("dev_NTP", self.dev_NTP)\r
- EventMesh.subscribe("post_iccid_user", self.post_iccid_user)\r
- # self.post_iccidd_token_timer = osTimer()\r
- # self.post_iccidd_token/_timer.start(10000, 0, self.post_iccidd_token_timer_cb)\r
- self.connect_web_flag = 0\r
- #EventMesh.publish_async("dev_NTP",thread_size = 8192)\r
-\r
- # count = 0\r
- # while True:\r
- # if self.ntptime_flag == 1:\r
- # break\r
- # utime.sleep_ms(1)\r
- # count+=1\r
- # if count>600:\r
- # break\r
- # EventMesh.publish_async("dev_active",thread_size = 8192)\r
- # EventMesh.publish_async("dev_sign_in",thread_size = 8192)\r
-\r
- self.dev_NTP()#获取时间\r
- self.dev_active() #设备激活\r
- self.dev_sign_in() #设备登入\r
-\r
- \r
- print("device_res_author __init__ end !!!!!!!!!!!!!!!!!")\r
- def post_iccidd_token_timer_cb(self,*argc):\r
- EventMesh.publish("post_iccid_user")\r
-\r
- def get_dev_token(self, event, msg): \r
- return self.dev_token\r
- #网络校时\r
- def dev_NTP(self, event=None, msg=None):\r
- response = None\r
- try:\r
- print("dev_NTP1")\r
- url = constants.DMP_BASE + "/dev/time"\r
- print("dev_NTP:{}".format(url))\r
- response = request.get(url,timeout=5)\r
- data = response.json()\r
- print("dev_NTP:{}".format(data))\r
- if data:\r
- try:\r
- timeSecond = data["data"]["timestamp"]//1000\r
- \r
- next_alarm_time = utime.localtime(timeSecond)\r
- print("timeSecond {} next_alarm_time {}".format(timeSecond,next_alarm_time))\r
- machine.RTC().datetime((next_alarm_time[0],next_alarm_time[1],next_alarm_time[2],next_alarm_time[6],next_alarm_time[3],next_alarm_time[4],next_alarm_time[5],0))\r
- self.ntptime_flag = 1\r
- except Exception as e:\r
- usys.print_exception(e)\r
- except Exception as e:\r
- usys.print_exception(e)\r
- if response != None:\r
- response.close() \r
- print("dev_NTP end")\r
- def dev_timer_cb(self, *args): #设备资源管理鉴权平台定时器\r
- EventMesh.publish("publish_AI_btnInfo",{"func":self.dev_timer_cb_}) \r
-\r
- def dev_timer_cb_(self): \r
- #if EventMesh.DEV_RES_MANAGE_AUTHEN_PLATFORM == 1:\r
- try:\r
- if self.dev_token == None:\r
- if self.ntptime_flag == 0:\r
- self.ntptime_flag = 1\r
- EventMesh.publish_async("dev_NTP",thread_size = 8192)\r
- #EventMesh.publish("publish_AI_btnInfo",{"func":self.dev_NTP})\r
- print("timer:{}!!!!!!!!\r\n".format(utime.localtime()))\r
- EventMesh.publish_async("dev_active",thread_size = 8192)\r
- EventMesh.publish_async("dev_sign_in",thread_size = 8192)\r
- # self.dev_active() #设备激活\r
- # self.dev_sign_in() #设备登入\r
- self.dev_res_timerCount+=1\r
- if self.dev_res_timerCount > 3: #开机一分钟内没有获取到密码和token 等下一次更新令牌在走登入 激活流程\r
- self.dev_res_timerCount=0\r
- self.dev_res_timer.stop()\r
- except Exception as e:\r
- usys.print_exception(e)\r
- def ud_token_timer_cb(self, *args): \r
- EventMesh.publish("publish_AI_btnInfo",{"func":self.ud_token_timer_cb_}) \r
-\r
- def ud_token_timer_cb_(self): \r
- try:\r
- #print("ud_token_timer_!!!!")\r
- self.ud_token_timer_Count+=1\r
- if self.ud_token_timer_Count >= 720: #定时10*3000s时更新token\r
- self.ud_token_timer_Count = 0\r
- EventMesh.publish_async("dev_sign_in",thread_size = 8192)\r
- except Exception as e:\r
- usys.print_exception(e) \r
- def get_sim_Status(self):\r
- return sim.getStatus() \r
- def HMAC(self,k, m):\r
- \r
- KEY_BLOCK = k + (b'\0' * (self.SHA1_BLOCK_SIZE - len(k)))\r
- KEY_INNER = bytes((x ^ 0x36) for x in KEY_BLOCK)\r
- KEY_OUTER = bytes((x ^ 0x5C) for x in KEY_BLOCK)\r
- inner_message = KEY_INNER + m\r
- outer_message = KEY_OUTER + self.SHA256(inner_message).digest()\r
- return self.SHA256(outer_message)\r
- def get_hmac_sha256(self,k, m):\r
- data = self.HMAC(k, m).digest()\r
- # print("HMAC(k, m).digest():", data)\r
- # print("HMAC(k, m).digest():", ubinascii.hexlify(data))\r
- hex_data = ubinascii.hexlify(data)\r
- hex_data = hex_data.decode('ascii')\r
- return hex_data\r
- # 加密函数\r
- def aes_CBC_Encrypt(self,data, key, iv): # CBC模式的加密函数,data为明文,key为16字节密钥,iv为16字节的偏移量\r
- key = key.encode('utf-8')\r
- iv = iv.encode('utf-8') # CBC 模式下的偏移量\r
- data = self.pad(data) # 补位\r
- data = data.encode('utf-8')\r
- aes = ucryptolib.aes(key,ucryptolib.MODE_CBC,iv)\r
- result = base64.b64encode(aes.encrypt(data))\r
- return str(result, 'utf-8') # 以字符串的形式返回\r
-\r
- # 解密函数\r
- def aes_CBC_Decrypt(self,data, key, iv): # CBC模式的解密函数,data为密文,key为16字节密钥\r
- key = key.encode('utf-8')\r
- iv = iv.encode('utf-8')\r
- \r
- aes = ucryptolib.aes(key,ucryptolib.MODE_CBC,iv) #CBC模式\r
-\r
- # decrypt AES解密 B64decode为base64 转码\r
- result = aes.decrypt(base64.b64decode(data))\r
- result = self.unpad(result) # 除去补16字节的多余字符\r
- return str(result, 'utf-8') # 以字符串的形式返回\r
- #激活接口 没有密码走激活\r
- def dev_active(self, event=None, msg=None):\r
- signal = net.csqQueryPoll()\r
- if signal == -1 or self.get_sim_Status() != 1:#网络不正常\r
- print("dev_active 无 SIM卡!!!!!!!!\r\n")\r
- return\r
- print("dev_active 1\r\n")\r
- # 签名内容: = deviceId+pid+timeStamp\r
- dev_pass = ""\r
- dev_pass = EventMesh.publish("get_storage_config","dev_pass")\r
- print("dev_pass:{}\r\n".format(dev_pass))\r
- if dev_pass == None:\r
- dev_pass = ""\r
- if dev_pass == "" or dev_pass == None:\r
- try:\r
- date_tmp = utime.localtime() #获取当前时间\r
- print("date_tmp:{}\r\n".format(date_tmp)) #转换时间戳s\r
- timeStamp = (utime.mktime(date_tmp))*1000#获取时间戳ms\r
- deviceId = self.deviceId #"876226002022574" #以imei号\r
- pid = self.pid\r
- key = self.key\r
- sign_data = "{}{}{}".format(deviceId,pid,timeStamp) #签名内容\r
- print("sign_data:{}\r\n".format(sign_data))\r
- sha256_hex = self.get_hmac_sha256(key,sign_data)\r
- print("sha256_hex:{}\r\n".format(sha256_hex))\r
-\r
- data = {\r
- "deviceId":"{}".format(deviceId), #设备名\r
- "pid":pid, #产品PID\r
- "sign":"{}".format(sha256_hex), #HMACSHA256签名后的数据\r
- "timeStamp":timeStamp, #要以ms的形式\r
- "signMethod":"HMACSHA256" #签名方式 HMACSHA256\r
- }\r
- print(ujson.dumps(data))\r
- headers_T ={"Content-Type":"application/json"}\r
- url = constants.DMP_BASE + "/dev/auth/active"\r
- print("dev_active:{}".format(url))\r
- data =ujson.dumps(data)\r
- response = None\r
- response_result = 0\r
- try:\r
- response = request.put(url,data=data,headers = headers_T,timeout=5)\r
- response_result = 1\r
- except Exception as e:\r
- usys.print_exception(e) \r
- print("put error!!!!!\r\n")\r
- response_result = 0\r
- \r
- IV = "" #偏移量\r
- PASSWORD= "" #服务器返回后的加密内容 密码\r
- if response_result == 1: #访问成功ip\r
- if response.status_code == 200:\r
- print("headers:{}".format(response.headers))\r
- content = response.content\r
- c = next(content)\r
- # "api.xcloudtech.com"\r
- # d_server_port = 9000\r
- data = ujson.loads(c)\r
- # data = response.json()\r
- print("data-{}".format(data))\r
- if data != None:\r
- if "success" in data:\r
- if data['success'] == True:\r
- if "data" in data:\r
- data_tmp = data["data"]\r
- if "nonce" in data_tmp: #偏移量\r
- IV = data_tmp["nonce"]\r
- if "password" in data_tmp:\r
- PASSWORD = data_tmp["password"]\r
- # EventMesh.publish("set_storage_config",["dev_pass",PASS])\r
- if data["code"] == 20001:#鉴权成功\r
- pass\r
- elif data["code"] > 50000:#\r
- self.res_error_count+=1\r
- if self.res_error_count>=3:\r
- self.res_error_count = 0\r
- \r
- EventMesh.publish("paly_device_res_error")\r
- if data["code"] == 50003:#时间错误\r
- self.ntptime_flag = 0\r
- if PASSWORD != None and IV != None:\r
- if len(PASSWORD) != 0 and len(IV) != 0:\r
- password = PASSWORD\r
- iv = IV\r
- #解密 之后保存本地下一次登入做使用\r
- decrypt_data = self.aes_CBC_Decrypt(password, self.key, iv) #对服务器下发的密码进行解密\r
- print("decrypt_data {}".format(decrypt_data))\r
- EventMesh.publish("set_storage_config",["dev_pass",decrypt_data]) \r
- print("IV:{}\r\n PASS:{}".format(IV,PASSWORD))\r
- if response != None:\r
- response.close() \r
- except Exception as e:\r
- usys.print_exception(e) \r
- print("dev_active end\r\n")\r
- return [response_result,PASSWORD,IV]\r
- #随机生成16个字节的字符串作为加密的IV 偏移量\r
- def generate_random_string(self,length=16): \r
- random_str = ""\r
- chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'\r
- for i in range(length):\r
- random_str+=chars[random.randint(0,length)]\r
- return random_str\r
-\r
- #设备登入 没有Token 走登入获取token\r
- def dev_sign_in(self, event=None, msg=None):\r
- \r
-\r
- signal = net.csqQueryPoll()\r
- if signal == -1 or self.get_sim_Status() != 1:#网络不正常\r
- print("dev_sign_in 无 SIM卡!!!!!!!!\r\n")\r
- return\r
- print("dev_sign_in 1")\r
- token = ""\r
- try:\r
- token = self.dev_token\r
- dev_pass = EventMesh.publish("get_storage_config","dev_pass") \r
- #print("token:{}\r\n".format(token))\r
- if token == None:\r
- token = ""\r
- if dev_pass == None:\r
- dev_pass = ""\r
- if len(dev_pass) == 0:#没有密码\r
- return\r
- #if token == None or token == "":\r
- if 1: #返回结果成功\r
- #获取本地保存的密码\r
- decrypt_data=EventMesh.publish("get_storage_config","dev_pass")\r
- # decrypt_data = self.aes_CBC_Decrypt(password, self.key, iv) #对服务器下发的密码进行解密\r
- print("decrypt_data {}".format(decrypt_data))\r
- #随机生成16个字符串 设备生成做加密使用\r
- random_string = self.generate_random_string(16) #随机的16个字符串\r
- enc_iv = random_string #加密的IV偏移量\r
- #设备端进行密码加密\r
- encrypt_data = self.aes_CBC_Encrypt(decrypt_data, self.key, enc_iv)\r
- print("encrypt_data {}".format(encrypt_data))\r
-\r
- #登入数据\r
- deviceId = self.deviceId\r
- sign_in_data = {\r
- "deviceId":"{}".format(deviceId), #设备ID\r
- "password":"{}".format(encrypt_data), #加密的数据\r
- "nonce":"{}".format(random_string) #随机的16个字符串\r
- }\r
- print(ujson.dumps(sign_in_data))\r
- sign_url =None\r
- sign_url = constants.DMP_BASE + "/dev/auth/sign_in"\r
- #获取验证码\r
- #url = "http://dmp.qipai.com.cn:30461/dev/device/bind-code/860132066060377"\r
- # token = EventMesh.publish("get_dev_token")\r
- # headers_T = {"Content-Type":"application/x-www-form-urlencoded","Accept":"*/*","bz-dt":"{}".format(token)}\r
- # response = request.get(url,headers = headers_T,timeout=5)\r
- # data = response.json()\r
- print("dev_sign_in:{}".format(sign_url))\r
- headers_T ={"Content-Type":"application/json"}\r
- response_result = 0\r
- response = 0\r
- try:\r
- response = request.post(sign_url,data=ujson.dumps(sign_in_data),headers = headers_T,timeout=5)\r
- response_result = 1\r
- except Exception as e:\r
- usys.print_exception(e) \r
- print("post error!!!!!\r\n")\r
- response_result = 0\r
- # {'msg': '', 'code': 20001, 'success': True, \r
- # 'data': {'deviceId': '876226002022574', \r
- # 'token': '95436a9e09fd0ff89feb8825257dca982f'}\r
- # }\r
- \r
- #self.dev_token = ""\r
- if response_result == 1:\r
- if response.status_code == 200:\r
- content = response.content\r
- c = next(content)\r
- data = ujson.loads(c)\r
- print("data-{}".format(data))\r
- if data != None:\r
- if "success" in data:\r
- if data['success'] == True: #登入成功\r
- if "data" in data:\r
- data_tmp = data["data"]\r
- if "token" in data_tmp: #token\r
- self.dev_token = data_tmp["token"]\r
- else:#报错清空密钥\r
- print("登录失败,清空密钥")\r
- EventMesh.publish("set_storage_config",["dev_pass",""])\r
- if data["code"] == 50003:#时间错误\r
- self.ntptime_flag = 0\r
- \r
- print("token:{}\r\n".format(self.dev_token))\r
- if response != None:\r
- response.close()\r
- pass\r
- except Exception as e:\r
- print("post error!!!!!\r\n")\r
- response_result = 0\r
- if EventMesh.publish("get_dev_token") != None:\r
- if len(EventMesh.publish("get_dev_token")) != 0:\r
- if self.connect_web_flag == 0:\r
- EventMesh.publish("post_iccid_user")\r
- self.connect_web_flag = 1\r
- print("dev_sign_in end")\r
- #ICCID上传\r
- def post_iccid_user(self,event=None,msg=None):\r
- response = None\r
- try:\r
- iccid = sim.getIccid()\r
- if iccid != -1 and len(iccid) > 5:\r
- print("pots_ICCID:{}".format(iccid))\r
- #Headers = {'Transfer-Encodong':'chunked'}\r
- token = EventMesh.publish("get_dev_token")\r
- headers_T = None\r
- if token:\r
- headers_T = {"bz-dt":"{}".format(token)}\r
- #http://dmp.raisound.com/bz-api/dev/iccid?deviceId=866610001099679&iccid=89860002192307889057\r
- url =None\r
- url = (constants.DMP_BASE + "/dev/iccid?deviceId={}&iccid={}").format(modem.getDevImei(),iccid)\r
- print("{} H:{}".format(url,headers_T))\r
- response = request.post(url,headers = headers_T)\r
- if response.status_code == 200:\r
- data = response.json()\r
- print("pots_ICCID:{}".format(data))\r
- else:\r
- print("pots_ICCID error!!!!")\r
- for i in response.text:\r
- print(i)\r
- response.close()\r
- except Exception as e:\r
- usys.print_exception(e)\r
- if response != None:\r
- response.close()\r
- #获取新的令牌 更新token\r
- def update_dev_token(self, event=None, msg=None):\r
- print("update_dev_token")\r
- try:\r
- dev_pass = ""\r
- dev_pass = EventMesh.publish("get_storage_config","dev_pass")\r
- \r
- if dev_pass == None:\r
- dev_pass = ""\r
- if len(dev_pass) == 0: #没有密码走激活\r
- print("no dev_pass:{}\r\n".format(dev_pass))\r
- EventMesh.publish("dev_active")\r
- token = self.dev_token\r
- if token == None:\r
- token = ""\r
- if len(token) == 0: #没有token走登入\r
- print("no dev_token:{}\r\n".format(token))\r
- #self.dev_sign_in()\r
- EventMesh.publish("dev_sign_in")\r
- dev_tokenip =None\r
- dev_tokenip = constants.DMP_BASE + "/dev/auth/token"\r
- \r
- token = self.dev_token\r
- if token == None:\r
- token = ""\r
- if len(token) != 0:\r
- response_result=0\r
- response = None\r
- headers_T = {"bz-dt":"{}".format(token)}\r
- try:\r
- response = request.get(dev_tokenip,headers = headers_T,timeout=5)\r
- response_result = 1\r
- except Exception as e:\r
- print("get error!!!!!\r\n")\r
- response_result = 0\r
- if response_result == 1:\r
- if response.status_code == 200:\r
- try:\r
- headers_data = response.headers\r
- # print("headers_data!!!!! headers_data:{}\r\n".format(headers_data))\r
- if "bz-dt" in headers_data: #bz-dt字段是否在头部数据里面 如果有就需要更新\r
- bz_dt = headers_data["bz-dt"] \r
- self.dev_token = bz_dt.replace(" ", "") #去掉所有的空格符\r
- print("update_dev_token:{}".format(self.dev_token))\r
- except Exception as e:\r
- print("headers_data!!!!! error\r\n")\r
- if response != None:\r
- response.close()\r
- except Exception as e:\r
- usys.print_exception(e) \r
- print("update_dev_token end")\r
-\r
-\r
-\r
- \r
+# -*- coding: utf-8 -*-
+"""设备鉴权与 token。"""
+from common import Abstract
+try:
+ from qp_log import qp_print as print
+except Exception:
+ pass
+import EventMesh
+import usys
+import utime
+import uhashlib
+import ubinascii
+import ujson
+import osTimer
+import modem
+import net
+import sim
+import machine
+import base64
+import constants
+import ucryptolib
+import urandom as random
+import request
+from vc_utils import cfg_attr
+
+class device_res_author(Abstract):
+
+ def __init__(self) :
+ print("device_res_author __init__ start !!!!!!!!!!!!!!!!!")
+ self.deviceId = modem.getDevImei()#"876226002022574"
+ self.SHA1_BLOCK_SIZE = 64
+ self.PAD_BLOCK_SIZE = 16
+ self.SHA256 = uhashlib.sha256
+ self.pad = lambda s: s + chr(self.PAD_BLOCK_SIZE - len(s) % self.PAD_BLOCK_SIZE) * (self.PAD_BLOCK_SIZE - len(s) % self.PAD_BLOCK_SIZE)
+ # 除去补16字节的多余字符
+ self.unpad = lambda s: s[:-s[-1]]
+ # 设备鉴权:优先 default_config / usr/default_config 的 PRODUCT_PID、PRODUCT_KEY
+ self.pid = "cqxJZi5CNgzjS3mX21Zw"
+ self.key = b"uKLrChwrxA1LklgBc3VwawYjUkbT3BgX"
+ _pid = cfg_attr("PRODUCT_PID", None)
+ if _pid:
+ self.pid = str(_pid)
+ _key = cfg_attr("PRODUCT_KEY", None)
+ if _key is not None and _key != "":
+ self.key = _key if isinstance(_key, bytes) else str(_key).encode()
+ self.dev_res_timer = osTimer()
+ self.dev_res_timer.start(20000, 1, self.dev_timer_cb)
+ self.dev_res_timerCount = 0
+ self.ud_token_timer = osTimer()
+ self.ud_token_timer.start(10000, 1, self.ud_token_timer_cb)
+ self.ud_token_timer_Count = 0
+ self.dev_token = None
+ self.res_error_count = 0
+ self.ntptime_flag = 0
+ EventMesh.subscribe("get_dev_token", self.get_dev_token)
+ EventMesh.subscribe("update_dev_token", self.update_dev_token)
+ EventMesh.subscribe("dev_active", self.dev_active)
+ EventMesh.subscribe("dev_sign_in", self.dev_sign_in)
+ EventMesh.subscribe("dev_NTP", self.dev_NTP)
+ EventMesh.subscribe("post_iccid_user", self.post_iccid_user)
+ # self.post_iccidd_token_timer = osTimer()
+ # self.post_iccidd_token/_timer.start(10000, 0, self.post_iccidd_token_timer_cb)
+ self.connect_web_flag = 0
+ #EventMesh.publish_async("dev_NTP",thread_size = 8192)
+
+ # count = 0
+ # while True:
+ # if self.ntptime_flag == 1:
+ # break
+ # utime.sleep_ms(1)
+ # count+=1
+ # if count>600:
+ # break
+ # EventMesh.publish_async("dev_active",thread_size = 8192)
+ # EventMesh.publish_async("dev_sign_in",thread_size = 8192)
+
+ self.dev_NTP()#获取时间
+ self.dev_active() #设备激活
+ self.dev_sign_in() #设备登入
+
+
+ print("device_res_author __init__ end !!!!!!!!!!!!!!!!!")
+ def post_iccidd_token_timer_cb(self,*argc):
+ EventMesh.publish("post_iccid_user")
+
+ def get_dev_token(self, event, msg):
+ return self.dev_token
+ #网络校时
+ def dev_NTP(self, event=None, msg=None):
+ response = None
+ try:
+ print("dev_NTP1")
+ url = constants.DMP_BASE + "/dev/time"
+ print("dev_NTP:{}".format(url))
+ response = request.get(url,timeout=5)
+ data = response.json()
+ print("dev_NTP:{}".format(data))
+ if data:
+ try:
+ timeSecond = data["data"]["timestamp"]//1000
+
+ next_alarm_time = utime.localtime(timeSecond)
+ print("timeSecond {} next_alarm_time {}".format(timeSecond,next_alarm_time))
+ machine.RTC().datetime((next_alarm_time[0],next_alarm_time[1],next_alarm_time[2],next_alarm_time[6],next_alarm_time[3],next_alarm_time[4],next_alarm_time[5],0))
+ self.ntptime_flag = 1
+ except Exception as e:
+ usys.print_exception(e)
+ except Exception as e:
+ usys.print_exception(e)
+ if response != None:
+ response.close()
+ print("dev_NTP end")
+ def dev_timer_cb(self, *args): #设备资源管理鉴权平台定时器
+ EventMesh.publish("publish_AI_btnInfo",{"func":self.dev_timer_cb_})
+
+ def dev_timer_cb_(self):
+ #if EventMesh.DEV_RES_MANAGE_AUTHEN_PLATFORM == 1:
+ try:
+ if self.dev_token == None:
+ if self.ntptime_flag == 0:
+ self.ntptime_flag = 1
+ EventMesh.publish_async("dev_NTP",thread_size = 8192)
+ #EventMesh.publish("publish_AI_btnInfo",{"func":self.dev_NTP})
+ print("timer:{}!!!!!!!!\r\n".format(utime.localtime()))
+ EventMesh.publish_async("dev_active",thread_size = 8192)
+ EventMesh.publish_async("dev_sign_in",thread_size = 8192)
+ # self.dev_active() #设备激活
+ # self.dev_sign_in() #设备登入
+ self.dev_res_timerCount+=1
+ if self.dev_res_timerCount > 3: #开机一分钟内没有获取到密码和token 等下一次更新令牌在走登入 激活流程
+ self.dev_res_timerCount=0
+ self.dev_res_timer.stop()
+ except Exception as e:
+ usys.print_exception(e)
+ def ud_token_timer_cb(self, *args):
+ EventMesh.publish("publish_AI_btnInfo",{"func":self.ud_token_timer_cb_})
+
+ def ud_token_timer_cb_(self):
+ try:
+ #print("ud_token_timer_!!!!")
+ self.ud_token_timer_Count+=1
+ if self.ud_token_timer_Count >= 720: #定时10*3000s时更新token
+ self.ud_token_timer_Count = 0
+ EventMesh.publish_async("dev_sign_in",thread_size = 8192)
+ except Exception as e:
+ usys.print_exception(e)
+ def get_sim_Status(self):
+ return sim.getStatus()
+ def HMAC(self,k, m):
+
+ KEY_BLOCK = k + (b'\0' * (self.SHA1_BLOCK_SIZE - len(k)))
+ KEY_INNER = bytes((x ^ 0x36) for x in KEY_BLOCK)
+ KEY_OUTER = bytes((x ^ 0x5C) for x in KEY_BLOCK)
+ inner_message = KEY_INNER + m
+ outer_message = KEY_OUTER + self.SHA256(inner_message).digest()
+ return self.SHA256(outer_message)
+ def get_hmac_sha256(self,k, m):
+ data = self.HMAC(k, m).digest()
+ # print("HMAC(k, m).digest():", data)
+ # print("HMAC(k, m).digest():", ubinascii.hexlify(data))
+ hex_data = ubinascii.hexlify(data)
+ hex_data = hex_data.decode('ascii')
+ return hex_data
+ # 加密函数
+ def aes_CBC_Encrypt(self,data, key, iv): # CBC模式的加密函数,data为明文,key为16字节密钥,iv为16字节的偏移量
+ key = key.encode('utf-8')
+ iv = iv.encode('utf-8') # CBC 模式下的偏移量
+ data = self.pad(data) # 补位
+ data = data.encode('utf-8')
+ aes = ucryptolib.aes(key,ucryptolib.MODE_CBC,iv)
+ result = base64.b64encode(aes.encrypt(data))
+ return str(result, 'utf-8') # 以字符串的形式返回
+
+ # 解密函数
+ def aes_CBC_Decrypt(self,data, key, iv): # CBC模式的解密函数,data为密文,key为16字节密钥
+ key = key.encode('utf-8')
+ iv = iv.encode('utf-8')
+
+ aes = ucryptolib.aes(key,ucryptolib.MODE_CBC,iv) #CBC模式
+
+ # decrypt AES解密 B64decode为base64 转码
+ result = aes.decrypt(base64.b64decode(data))
+ result = self.unpad(result) # 除去补16字节的多余字符
+ return str(result, 'utf-8') # 以字符串的形式返回
+ #激活接口 没有密码走激活
+ def dev_active(self, event=None, msg=None):
+ signal = net.csqQueryPoll()
+ if signal == -1 or self.get_sim_Status() != 1:#网络不正常
+ print("dev_active 无 SIM卡!!!!!!!!\r\n")
+ return
+ print("dev_active 1\r\n")
+ # 签名内容: = deviceId+pid+timeStamp
+ dev_pass = ""
+ dev_pass = EventMesh.publish("get_storage_config","dev_pass")
+ print("dev_pass:{}\r\n".format(dev_pass))
+ if dev_pass == None:
+ dev_pass = ""
+ if dev_pass == "" or dev_pass == None:
+ try:
+ date_tmp = utime.localtime() #获取当前时间
+ print("date_tmp:{}\r\n".format(date_tmp)) #转换时间戳s
+ timeStamp = (utime.mktime(date_tmp))*1000#获取时间戳ms
+ deviceId = self.deviceId #"876226002022574" #以imei号
+ pid = self.pid
+ key = self.key
+ sign_data = "{}{}{}".format(deviceId,pid,timeStamp) #签名内容
+ print("sign_data:{}\r\n".format(sign_data))
+ sha256_hex = self.get_hmac_sha256(key,sign_data)
+ print("sha256_hex:{}\r\n".format(sha256_hex))
+
+ data = {
+ "deviceId":"{}".format(deviceId), #设备名
+ "pid":pid, #产品PID
+ "sign":"{}".format(sha256_hex), #HMACSHA256签名后的数据
+ "timeStamp":timeStamp, #要以ms的形式
+ "signMethod":"HMACSHA256" #签名方式 HMACSHA256
+ }
+ print(ujson.dumps(data))
+ headers_T ={"Content-Type":"application/json"}
+ url = constants.DMP_BASE + "/dev/auth/active"
+ print("dev_active:{}".format(url))
+ data =ujson.dumps(data)
+ response = None
+ response_result = 0
+ try:
+ response = request.put(url,data=data,headers = headers_T,timeout=5)
+ response_result = 1
+ except Exception as e:
+ usys.print_exception(e)
+ print("put error!!!!!\r\n")
+ response_result = 0
+
+ IV = "" #偏移量
+ PASSWORD= "" #服务器返回后的加密内容 密码
+ if response_result == 1: #访问成功ip
+ if response.status_code == 200:
+ print("headers:{}".format(response.headers))
+ content = response.content
+ c = next(content)
+ # "api.xcloudtech.com"
+ # d_server_port = 9000
+ data = ujson.loads(c)
+ # data = response.json()
+ print("data-{}".format(data))
+ if data != None:
+ if "success" in data:
+ if data['success'] == True:
+ if "data" in data:
+ data_tmp = data["data"]
+ if "nonce" in data_tmp: #偏移量
+ IV = data_tmp["nonce"]
+ if "password" in data_tmp:
+ PASSWORD = data_tmp["password"]
+ # EventMesh.publish("set_storage_config",["dev_pass",PASS])
+ if data["code"] == 20001:#鉴权成功
+ pass
+ elif data["code"] > 50000:#
+ self.res_error_count+=1
+ if self.res_error_count>=3:
+ self.res_error_count = 0
+
+ EventMesh.publish("paly_device_res_error")
+ if data["code"] == 50003:#时间错误
+ self.ntptime_flag = 0
+ if PASSWORD != None and IV != None:
+ if len(PASSWORD) != 0 and len(IV) != 0:
+ password = PASSWORD
+ iv = IV
+ #解密 之后保存本地下一次登入做使用
+ decrypt_data = self.aes_CBC_Decrypt(password, self.key, iv) #对服务器下发的密码进行解密
+ print("decrypt_data {}".format(decrypt_data))
+ EventMesh.publish("set_storage_config",["dev_pass",decrypt_data])
+ print("IV:{}\r\n PASS:{}".format(IV,PASSWORD))
+ if response != None:
+ response.close()
+ except Exception as e:
+ usys.print_exception(e)
+ print("dev_active end\r\n")
+ return [response_result,PASSWORD,IV]
+ #随机生成16个字节的字符串作为加密的IV 偏移量
+ def generate_random_string(self,length=16):
+ random_str = ""
+ chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
+ for i in range(length):
+ random_str+=chars[random.randint(0,length)]
+ return random_str
+
+ #设备登入 没有Token 走登入获取token
+ def dev_sign_in(self, event=None, msg=None):
+
+
+ signal = net.csqQueryPoll()
+ if signal == -1 or self.get_sim_Status() != 1:#网络不正常
+ print("dev_sign_in 无 SIM卡!!!!!!!!\r\n")
+ return
+ print("dev_sign_in 1")
+ token = ""
+ try:
+ token = self.dev_token
+ dev_pass = EventMesh.publish("get_storage_config","dev_pass")
+ #print("token:{}\r\n".format(token))
+ if token == None:
+ token = ""
+ if dev_pass == None:
+ dev_pass = ""
+ if len(dev_pass) == 0:#没有密码
+ return
+ #if token == None or token == "":
+ if 1: #返回结果成功
+ #获取本地保存的密码
+ decrypt_data=EventMesh.publish("get_storage_config","dev_pass")
+ # decrypt_data = self.aes_CBC_Decrypt(password, self.key, iv) #对服务器下发的密码进行解密
+ print("decrypt_data {}".format(decrypt_data))
+ #随机生成16个字符串 设备生成做加密使用
+ random_string = self.generate_random_string(16) #随机的16个字符串
+ enc_iv = random_string #加密的IV偏移量
+ #设备端进行密码加密
+ encrypt_data = self.aes_CBC_Encrypt(decrypt_data, self.key, enc_iv)
+ print("encrypt_data {}".format(encrypt_data))
+
+ #登入数据
+ deviceId = self.deviceId
+ sign_in_data = {
+ "deviceId":"{}".format(deviceId), #设备ID
+ "password":"{}".format(encrypt_data), #加密的数据
+ "nonce":"{}".format(random_string) #随机的16个字符串
+ }
+ print(ujson.dumps(sign_in_data))
+ sign_url =None
+ sign_url = constants.DMP_BASE + "/dev/auth/sign_in"
+ #获取验证码
+ #url = "http://dmp.qipai.com.cn:30461/dev/device/bind-code/860132066060377"
+ # token = EventMesh.publish("get_dev_token")
+ # headers_T = {"Content-Type":"application/x-www-form-urlencoded","Accept":"*/*","bz-dt":"{}".format(token)}
+ # response = request.get(url,headers = headers_T,timeout=5)
+ # data = response.json()
+ print("dev_sign_in:{}".format(sign_url))
+ headers_T ={"Content-Type":"application/json"}
+ response_result = 0
+ response = 0
+ try:
+ response = request.post(sign_url,data=ujson.dumps(sign_in_data),headers = headers_T,timeout=5)
+ response_result = 1
+ except Exception as e:
+ usys.print_exception(e)
+ print("post error!!!!!\r\n")
+ response_result = 0
+ # {'msg': '', 'code': 20001, 'success': True,
+ # 'data': {'deviceId': '876226002022574',
+ # 'token': '95436a9e09fd0ff89feb8825257dca982f'}
+ # }
+
+ #self.dev_token = ""
+ if response_result == 1:
+ if response.status_code == 200:
+ content = response.content
+ c = next(content)
+ data = ujson.loads(c)
+ print("data-{}".format(data))
+ if data != None:
+ if "success" in data:
+ if data['success'] == True: #登入成功
+ if "data" in data:
+ data_tmp = data["data"]
+ if "token" in data_tmp: #token
+ self.dev_token = data_tmp["token"]
+ else:#报错清空密钥
+ print("登录失败,清空密钥")
+ EventMesh.publish("set_storage_config",["dev_pass",""])
+ if data["code"] == 50003:#时间错误
+ self.ntptime_flag = 0
+
+ print("token:{}\r\n".format(self.dev_token))
+ if response != None:
+ response.close()
+ pass
+ except Exception as e:
+ print("post error!!!!!\r\n")
+ response_result = 0
+ if EventMesh.publish("get_dev_token") != None:
+ if len(EventMesh.publish("get_dev_token")) != 0:
+ if self.connect_web_flag == 0:
+ EventMesh.publish("post_iccid_user")
+ self.connect_web_flag = 1
+ print("dev_sign_in end")
+ #ICCID上传
+ def post_iccid_user(self,event=None,msg=None):
+ response = None
+ try:
+ iccid = sim.getIccid()
+ if iccid != -1 and len(iccid) > 5:
+ print("pots_ICCID:{}".format(iccid))
+ #Headers = {'Transfer-Encodong':'chunked'}
+ token = EventMesh.publish("get_dev_token")
+ headers_T = None
+ if token:
+ headers_T = {"bz-dt":"{}".format(token)}
+ #http://dmp.raisound.com/bz-api/dev/iccid?deviceId=866610001099679&iccid=89860002192307889057
+ url =None
+ url = (constants.DMP_BASE + "/dev/iccid?deviceId={}&iccid={}").format(modem.getDevImei(),iccid)
+ print("{} H:{}".format(url,headers_T))
+ response = request.post(url,headers = headers_T)
+ if response.status_code == 200:
+ data = response.json()
+ print("pots_ICCID:{}".format(data))
+ else:
+ print("pots_ICCID error!!!!")
+ for i in response.text:
+ print(i)
+ response.close()
+ except Exception as e:
+ usys.print_exception(e)
+ if response != None:
+ response.close()
+ #获取新的令牌 更新token
+ def update_dev_token(self, event=None, msg=None):
+ print("update_dev_token")
+ try:
+ dev_pass = ""
+ dev_pass = EventMesh.publish("get_storage_config","dev_pass")
+
+ if dev_pass == None:
+ dev_pass = ""
+ if len(dev_pass) == 0: #没有密码走激活
+ print("no dev_pass:{}\r\n".format(dev_pass))
+ EventMesh.publish("dev_active")
+ token = self.dev_token
+ if token == None:
+ token = ""
+ if len(token) == 0: #没有token走登入
+ print("no dev_token:{}\r\n".format(token))
+ #self.dev_sign_in()
+ EventMesh.publish("dev_sign_in")
+ dev_tokenip =None
+ dev_tokenip = constants.DMP_BASE + "/dev/auth/token"
+
+ token = self.dev_token
+ if token == None:
+ token = ""
+ if len(token) != 0:
+ response_result=0
+ response = None
+ headers_T = {"bz-dt":"{}".format(token)}
+ try:
+ response = request.get(dev_tokenip,headers = headers_T,timeout=5)
+ response_result = 1
+ except Exception as e:
+ print("get error!!!!!\r\n")
+ response_result = 0
+ if response_result == 1:
+ if response.status_code == 200:
+ try:
+ headers_data = response.headers
+ # print("headers_data!!!!! headers_data:{}\r\n".format(headers_data))
+ if "bz-dt" in headers_data: #bz-dt字段是否在头部数据里面 如果有就需要更新
+ bz_dt = headers_data["bz-dt"]
+ self.dev_token = bz_dt.replace(" ", "") #去掉所有的空格符
+ print("update_dev_token:{}".format(self.dev_token))
+ except Exception as e:
+ print("headers_data!!!!! error\r\n")
+ if response != None:
+ response.close()
+ except Exception as e:
+ usys.print_exception(e)
+ print("update_dev_token end")
+
+
+
+
from queue import Queue
from misc import Power, USB, PowerKey
import constants
-try:
- import vc_config
-except Exception:
- vc_config = None
-from vc_common import dev_type
+from vc_utils import cfg_bool, cfg_attr, cfg_int, cfg_uart_supported
from vc_hw import set_ipv4_datacall, _BatteryCfg
from vc_uart import AI_UART
# set_ipv4_datacall()
self.is_wdt = 0 #是否开启看门狗
#AT+QDAI=1,0,0,1,0,0,1,1PCM音频输出设置为主模式、短同步、16 kHz采样率和256 kHz时钟频率,采样位深为16bit,使用的时间间隙数量为1,并且使用第一个时间间隙。
- try:
- bt_pm_en = False
- pin_bt_on = None
- pin_mot = None
- qdai_cfg = None
- if "vc_config" in globals() and vc_config:
- bt_pm_en = bool(vc_config.get_attr("BT_POWER_MOTOR_ENABLED", False))
- pin_bt_on = vc_config.get_attr("PIN_BT_ON_GPIO", None)
- pin_mot = vc_config.get_attr("PIN_MOT_GPIO", None)
- qdai_cfg = vc_config.get_attr("AUDIO_QDAI_CFG", None)
- except Exception:
- bt_pm_en = False
- pin_bt_on = None
- pin_mot = None
- qdai_cfg = None
+ bt_pm_en = cfg_bool("BT_POWER_MOTOR_ENABLED", False)
+ pin_bt_on = cfg_attr("PIN_BT_ON_GPIO", None)
+ pin_mot = cfg_attr("PIN_MOT_GPIO", None)
+ qdai_cfg = cfg_attr("AUDIO_QDAI_CFG", None)
if bt_pm_en:
try:
self.KeySOS_timer_flag = 0
self._single_power_ai_merged = False
self._pwk_shutdown_ticks = 30 # 100ms 节拍,默认 3s
- try:
- ai_gpio = "GPIO22"
- pwk_gpio = "GPIO26"
- bt_wakeup_en = False
- wakeup_cta1_gpio = None
- wakeup_bt_gpio = None
- if "vc_config" in globals() and vc_config:
- raw_ai = vc_config.get_attr("EXTINT_AI_GPIO", "GPIO22")
- if raw_ai is None or raw_ai == "":
- ai_gpio = None
- else:
- ai_gpio = raw_ai
- pwk_gpio = vc_config.get_attr("PWK_KEY_GPIO", "GPIO26") or "GPIO26"
- bt_wakeup_en = bool(vc_config.get_attr("BT_WAKEUP_4G_ENABLED", False))
- wakeup_cta1_gpio = vc_config.get_attr("EXTINT_WAKEUP_CTA1_GPIO", None)
- wakeup_bt_gpio = vc_config.get_attr("PIN_WAKEUP_BT_GPIO", None)
- try:
- self._single_power_ai_merged = bool(
- vc_config.get_bool("SINGLE_POWER_KEY_AI_MERGED", False)
- ) or (ai_gpio is None)
- except Exception:
- self._single_power_ai_merged = ai_gpio is None
- try:
- _pwk_ms = int(vc_config.get_int("PWK_LONG_PRESS_SHUTDOWN_MS", 3000))
- except Exception:
- _pwk_ms = 3000
- self._pwk_shutdown_ticks = max(1, (_pwk_ms + 99) // 100)
- except Exception:
- ai_gpio = "GPIO22"
- pwk_gpio = "GPIO26"
- bt_wakeup_en = False
- wakeup_cta1_gpio = None
- wakeup_bt_gpio = None
+ raw_ai = cfg_attr("EXTINT_AI_GPIO", "GPIO22")
+ if raw_ai is None or raw_ai == "":
+ ai_gpio = None
+ else:
+ ai_gpio = raw_ai
+ pwk_gpio = cfg_attr("PWK_KEY_GPIO", "GPIO26") or "GPIO26"
+ bt_wakeup_en = cfg_bool("BT_WAKEUP_4G_ENABLED", False)
+ wakeup_cta1_gpio = cfg_attr("EXTINT_WAKEUP_CTA1_GPIO", None)
+ wakeup_bt_gpio = cfg_attr("PIN_WAKEUP_BT_GPIO", None)
+ self._single_power_ai_merged = cfg_bool("SINGLE_POWER_KEY_AI_MERGED", False) or (ai_gpio is None)
+ _pwk_ms = cfg_int("PWK_LONG_PRESS_SHUTDOWN_MS", 3000)
+ self._pwk_shutdown_ticks = max(1, (_pwk_ms + 99) // 100)
if ai_gpio:
self.extint_AI = ExtInt(
#EventMesh.publish("publish_AI_btnInfo",{"func":self.ntptime_cb})
self.check_rest_timer_count = 0
try:
- if "vc_config" in globals() and vc_config and vc_config.uart_supported():
+ if cfg_uart_supported():
self.ai_uart = AI_UART()
except Exception:
pass
#EventMesh.publish("flicker_led_red")#充电闪灯
#self.aud.play(1,1,'U:/static/R_CHARGE_IN.mp3')
try:
- if not ("vc_config" in globals() and vc_config and vc_config.get_bool("USE_MIN_HW_STATUS", True)):
+ if not cfg_bool("USE_MIN_HW_STATUS", True):
EventMesh.publish("set_led_state", {"charging": "charging"})
except Exception:
pass
if VC_satrt_flag == 0 and voice_record_satrt_flag == 0:
self.aud.stop()
try:
- if not ("vc_config" in globals() and vc_config and vc_config.get_bool("USE_MIN_HW_STATUS", True)):
+ if not cfg_bool("USE_MIN_HW_STATUS", True):
EventMesh.publish("set_led_state", {"charging": "none"})
except Exception:
pass
def sys_sleep_cb(self,event=None,msg=None):#休眠前回调
try:
- if not ("vc_config" in globals() and vc_config and vc_config.get_bool("BT_WAKEUP_4G_ENABLED", False)):
+ if not cfg_bool("BT_WAKEUP_4G_ENABLED", False):
return
except Exception:
return
self.PIN_wakeup_bt.write(0)
def sys_up_cb(self,event=None,msg=None):#唤醒前回调
try:
- if not ("vc_config" in globals() and vc_config and vc_config.get_bool("BT_WAKEUP_4G_ENABLED", False)):
+ if not cfg_bool("BT_WAKEUP_4G_ENABLED", False):
return
except Exception:
return
self.PIN_BT_ON.write(1)
def wakeup_BT(self,event=None,msg=None):#4G唤醒蓝牙
try:
- if not ("vc_config" in globals() and vc_config and vc_config.get_bool("BT_WAKEUP_4G_ENABLED", False)):
+ if not cfg_bool("BT_WAKEUP_4G_ENABLED", False):
return
except Exception:
return
def sleep_BT(self,event=None,msg=None):#使蓝牙休眠
try:
- if not ("vc_config" in globals() and vc_config and vc_config.get_bool("BT_WAKEUP_4G_ENABLED", False)):
+ if not cfg_bool("BT_WAKEUP_4G_ENABLED", False):
return
except Exception:
return
def wakeup_extint_cb(self,args):#蓝牙唤醒4g
try:
- if not ("vc_config" in globals() and vc_config and vc_config.get_bool("BT_WAKEUP_4G_ENABLED", False)):
+ if not cfg_bool("BT_WAKEUP_4G_ENABLED", False):
return
except Exception:
return
EventMesh.publish("publish_AI_btnInfo", {"func": self._shutdown_tone_play_and_powerdown})
if self.pwk_key_status == 1:#松开
#print("pwk_key_timer_cb:{}".format(self.pwk_key_timer_count))
- try:
- key_count = vc_config.get_int("KEY_RELEASE_DEBOUNCE_COUNT", 5)
- except Exception:
- key_count = 5
+ key_count = cfg_int("KEY_RELEASE_DEBOUNCE_COUNT", 5)
if self.pwk_key_timer_count >= key_count: #防抖200ms
#EventMesh.publish("AI_key_release")
EventMesh.publish("publish_AI_btnInfo",{"func":self.pwk_key_release})
self.KeyAI_long_press = 1
#EventMesh.publish("AI_key_long_press")
EventMesh.publish("publish_AI_btnInfo",{"func":self.AI_key_long_press})
- try:
- _sos_on = vc_config.get_bool("SOS_ENABLED", True)
- except Exception:
- _sos_on = True
+ _sos_on = cfg_bool("SOS_ENABLED", True)
if _sos_on and self.KeyAI_timer_count >= 10*3 : #长按3s 上一次是短按则拨打sos紧急联系人
print("long sos phone:{}".format(self.KeySOS_timer_flag))
pass
elif self.KeyAI_timer_count >= 10*8:#关机
- try:
- allow_power_off = vc_config.get_bool("AI_LONG_PRESS_POWER_OFF_ENABLED", False)
- except Exception:
- allow_power_off = False
+ allow_power_off = cfg_bool("AI_LONG_PRESS_POWER_OFF_ENABLED", False)
if allow_power_off:
EventMesh.publish("publish_AI_btnInfo", {"func": self._shutdown_tone_play_and_powerdown})
if self.KeyAI_status == 1:#松开
#print("KeyAI_timer_cb:{}".format(self.KeyAI_timer_count))
- try:
- key_count = vc_config.get_int("KEY_RELEASE_DEBOUNCE_COUNT", 5)
- except Exception:
- key_count = 5
+ key_count = cfg_int("KEY_RELEASE_DEBOUNCE_COUNT", 5)
if self.KeyAI_timer_count >= key_count: #防抖200ms
if self.KeySOS_timer_flag == 1:
self.KeySOS_timer_flag = 0
print("KeySOS_timer_flag!!!!!!!!!!!!!!!") #短按两次需要清除标识
if self.KeyAI_long_press == 0:
- try:
- _sos_on = vc_config.get_bool("SOS_ENABLED", True)
- except Exception:
- _sos_on = True
+ _sos_on = cfg_bool("SOS_ENABLED", True)
if _sos_on and self.KeySOS_timer_flag == 0:
self.KeySOS_timer_flag = 1
self.KeySos_long_press = 0
except Exception:
pass
try:
- n, ms = 3, 500
- if "vc_config" in globals() and vc_config:
- n = int(vc_config.get_int("BATTERY_EMPTY_FLASH_COUNT", 3))
- ms = int(vc_config.get_int("BATTERY_EMPTY_FLASH_PERIOD_MS", 500))
+ n = cfg_int("BATTERY_EMPTY_FLASH_COUNT", 3)
+ ms = cfg_int("BATTERY_EMPTY_FLASH_PERIOD_MS", 500)
EventMesh.publish("set_led_state", {"alert": "red_flash_3"})
utime.sleep_ms(n * ms * 2 + 200)
EventMesh.publish("set_led_state", {"ai_state": "idle", "battery": "normal", "charging": "none"})
Vbatt = _bcfg.get_vbatt_mv_charge() if self.usb_status == 1 else _bcfg.get_vbatt_mv()
if self.usb_status == 1 and VC_satrt_flag == 0 and voice_record_satrt_flag == 0:
try:
- if not ("vc_config" in globals() and vc_config and vc_config.get_bool("USE_MIN_HW_STATUS", True)):
+ if not cfg_bool("USE_MIN_HW_STATUS", True):
EventMesh.publish("set_led_state", {"charging": "charging"})#充电红灯常亮
except Exception:
pass
if self.usb_status == 1 and Vbatt >= _bcfg.charge_full_mv and VC_satrt_flag == 0 and voice_record_satrt_flag == 0:
try:
- if not ("vc_config" in globals() and vc_config and vc_config.get_bool("USE_MIN_HW_STATUS", True)):
+ if not cfg_bool("USE_MIN_HW_STATUS", True):
EventMesh.publish("set_led_state", {"charging": "full"})
except Exception:
pass
low_soc = int(_bcfg.low_soc)
except Exception:
low_soc = 25
- warn_interval_ms = 300000
- try:
- if "vc_config" in globals() and vc_config:
- warn_interval_ms = int(vc_config.get_int("BATTERY_LOW_WARN_INTERVAL_MS", 300000))
- except Exception:
- pass
+ warn_interval_ms = cfg_int("BATTERY_LOW_WARN_INTERVAL_MS", 300000)
soc = None
try:
soc = self.get_battery()
if _bcfg.should_shutdown_empty(Vbatt):
if getattr(self, "_empty_shutdown_done", 0) == 0:
self._empty_shutdown_done = 1
- try:
- print("[BAT] empty shutdown vbatt={} soc={} empty_mv={}".format(
- Vbatt, soc, _bcfg.empty_mv))
- except Exception:
- pass
+ print("[BAT] empty shutdown vbatt={} soc={} empty_mv={}".format(
+ Vbatt, soc, _bcfg.empty_mv))
EventMesh.publish("publish_AI_btnInfo", {"func": self._battery_empty_shutdown_seq})
elif soc is not None and soc < low_soc:
if voice_record_satrt_flag == 0:
last = getattr(self, "_low_warn_last_ms", 0)
if (not last) or utime.ticks_diff(now, last) >= warn_interval_ms:
self._low_warn_last_ms = now
- try:
- print("[BAT] low warn soc={} interval_ms={}".format(soc, warn_interval_ms))
- except Exception:
- pass
+ print("[BAT] low warn soc={} interval_ms={}".format(soc, warn_interval_ms))
EventMesh.publish("audio_montage_play", ["Low_power_warning.mp3"])
except Exception:
pass
pass
if VC_satrt_flag == 0 and Vbatt is not None and Vbatt >= int(_bcfg.low_mv):
try:
- if not ("vc_config" in globals() and vc_config and vc_config.get_bool("USE_MIN_HW_STATUS", True)):
+ if not cfg_bool("USE_MIN_HW_STATUS", True):
EventMesh.publish("set_led_state", {"charging": "none", "battery": "normal"})
except Exception:
pass
import versions
import version_util
from machine import UART
-try:
- import vc_config
-except Exception as e:
- usys.print_exception(e)
+from vc_utils import cfg_dev_type
try:
import vc_text_intent
except Exception:
#dev_type = 'csh'#慈善会
# 统一从配置加载 DEV_TYPE(usr 覆盖优先)
-try:
- if "vc_config" in globals() and vc_config:
- dev_type = vc_config.get_dev_type(dev_type)
-except Exception:
- pass
+dev_type = cfg_dev_type(dev_type)
# 1=打印 VC 周期性保活专用行「VC: ping ping」;默认 0(WS send 明细里已跳过 ping,无需再开此项)
VC_HEARTBEAT_LOG = 0
self.log("server.asr.started")
def _turn_name(self, t):
- try:
- return {
- VCTurnState.Idle: "Idle",
- VCTurnState.Listening: "Listening",
- VCTurnState.SpeechStreaming: "SpeechStreaming",
- VCTurnState.SpeechEnded: "SpeechEnded",
- VCTurnState.Thinking: "Thinking",
- VCTurnState.TtsReceiving: "TtsReceiving",
- VCTurnState.Playing: "Playing",
- VCTurnState.AwaitPlayedAck: "AwaitPlayedAck",
- }.get(t, str(t))
- except Exception:
- return str(t)
+ return {
+ VCTurnState.Idle: "Idle",
+ VCTurnState.Listening: "Listening",
+ VCTurnState.SpeechStreaming: "SpeechStreaming",
+ VCTurnState.SpeechEnded: "SpeechEnded",
+ VCTurnState.Thinking: "Thinking",
+ VCTurnState.TtsReceiving: "TtsReceiving",
+ VCTurnState.Playing: "Playing",
+ VCTurnState.AwaitPlayedAck: "AwaitPlayedAck",
+ }.get(t, str(t))
def _session_name(self, s):
- try:
- return {
- VCSessionState.Disconnected: "Disconnected",
- VCSessionState.Connecting: "Connecting",
- VCSessionState.Starting: "Starting",
- VCSessionState.Started: "Started",
- }.get(s, str(s))
- except Exception:
- return str(s)
+ return {
+ VCSessionState.Disconnected: "Disconnected",
+ VCSessionState.Connecting: "Connecting",
+ VCSessionState.Starting: "Starting",
+ VCSessionState.Started: "Started",
+ }.get(s, str(s))
def log(self, reason=""):
# 只用于关键节点的单行状态日志,便于串口快速定位状态漂移
pass
def mode(self):
- try:
- return VCMode.Realtime if self.vc.VC_mode == 0 else VCMode.PushToTalk
- except Exception:
- return VCMode.Realtime
+ return VCMode.Realtime if int(getattr(self.vc, "VC_mode", 0)) == 0 else VCMode.PushToTalk
def on_session_start_request(self):
self.session = VCSessionState.Starting
return actions
if event == "llm.completed":
# 若对端偶发跳过 llm.created,用 completed 把 turn 补到 Thinking,避免兜底全失效
- try:
- if self.session == VCSessionState.Started:
- if self.turn in (VCTurnState.SpeechEnded, VCTurnState.Listening):
- self.turn = VCTurnState.Thinking
- except Exception:
- pass
+ if self.session == VCSessionState.Started:
+ if self.turn in (VCTurnState.SpeechEnded, VCTurnState.Listening):
+ self.turn = VCTurnState.Thinking
return actions
if event == "started":
self.on_server_started()
if event == "canceled":
self.on_server_canceled()
# canceled:仅长对话允许“立刻回到聆听并尝试开麦”(由 _uplink_request_start 门控保证安全幂等)
- try:
- if self.mode() == VCMode.Realtime and getattr(self.vc, "Close_flag", 0) == 0:
- actions.append(("uplink_start", "canceled"))
- except Exception:
- pass
+ if self.mode() == VCMode.Realtime and getattr(self.vc, "Close_flag", 0) == 0:
+ actions.append(("uplink_start", "canceled"))
return actions
if event == "completed":
self.on_server_completed()
# completed:若不在等待 audio.played(说明本轮无 TTS),仅长对话可直接进入下一轮聆听
- try:
- if self.mode() == VCMode.Realtime and getattr(self.vc, "Close_flag", 0) == 0:
- if (not getattr(self, "await_played", False)) and self.turn != VCTurnState.AwaitPlayedAck:
- actions.append(("uplink_start", "completed"))
- except Exception:
- pass
+ if (
+ self.mode() == VCMode.Realtime
+ and getattr(self.vc, "Close_flag", 0) == 0
+ and (not getattr(self, "await_played", False))
+ and self.turn != VCTurnState.AwaitPlayedAck
+ ):
+ actions.append(("uplink_start", "completed"))
return actions
except Exception:
pass
if self.await_played:
actions.append(("send_audio_played", "local.play_end"))
# 长对话模式:对话过程中的 TTS 播完后,自动开麦继续当前对话。
- # 例外:
- # - 刚切到长对话模式的提示音(mode_switch_long)不应自动开麦
- # - 其它提示/提醒(prompt)不应自动开麦
- # - boot_prompt:播完仅 Close 回 idle,勿自动开麦(待机后等用户按键)
- # 实际开麦是否允许由 _uplink_request_start 的门控(FSM.turn / record_state 等)保证安全幂等。
- try:
- if self.mode() == VCMode.Realtime and getattr(self.vc, "Close_flag", 0) == 0:
- k = getattr(self.vc, "_last_tts_kind", "") or ""
- if k == "dialog":
- # 用户短按打断(RequestToSpeak):等 canceled 再开麦,勿 play_end 抢跑
- if getattr(self.vc, "_vc_pending_interrupt_uplink", 0) != 1:
- actions.append(("uplink_start", "local.play_end"))
- except Exception:
- pass
+ if (
+ self.mode() == VCMode.Realtime
+ and getattr(self.vc, "Close_flag", 0) == 0
+ ):
+ k = getattr(self.vc, "_last_tts_kind", "") or ""
+ if k == "dialog":
+ # 用户短按打断(RequestToSpeak):等 canceled 再开麦,勿 play_end 抢跑
+ if getattr(self.vc, "_vc_pending_interrupt_uplink", 0) != 1:
+ actions.append(("uplink_start", "local.play_end"))
self.on_local_audio_played()
except Exception:
pass
-# -*- coding: utf-8 -*-\r
-"""充电/电量/信号采集。"""\r
-from common import Abstract\r
-try:\r
- from qp_log import qp_print as print\r
-except Exception:\r
- pass\r
-import EventMesh\r
-import utime\r
-import osTimer\r
-import net\r
-import dataCall\r
-from misc import USB, Power\r
-try:\r
- import vc_config\r
-except Exception:\r
- vc_config = None\r
-from vc_common import dev_type\r
-\r
-def _default_battery_ocv_map():\r
- # 无 BATTERY_OCV_MAP 配置时的兜底(502631 ZCV;0% 锚定 3400mV,适配 4G 带载)\r
- return {\r
- 4322: 100, 4239: 95, 4177: 90, 4117: 85, 4059: 80, 4006: 75, 3942: 70, 3898: 65,\r
- 3853: 60, 3814: 55, 3781: 50, 3755: 45, 3738: 40, 3724: 35, 3706: 30, 3678: 25,\r
- 3634: 20, 3577: 15, 3522: 10, 3468: 5, 3400: 0,\r
- }\r
-\r
-\r
-def _parse_battery_ocv_map(raw):\r
- """解析 default_config.BATTERY_OCV_MAP:dict 或 [(mv, soc), ...]。"""\r
- if raw is None:\r
- return None\r
- out = {}\r
- try:\r
- if isinstance(raw, dict):\r
- pairs = raw.items()\r
- elif isinstance(raw, (tuple, list)):\r
- pairs = ((p[0], p[1]) for p in raw if isinstance(p, (tuple, list)) and len(p) >= 2)\r
- else:\r
- return None\r
- for k, v in pairs:\r
- out[int(k)] = int(v)\r
- return out if out else None\r
- except Exception:\r
- return None\r
-\r
-\r
-def _soc_from_vbatt_mv(volt_mv, ocv_map, ocv_volts, vbatt_simple=None):\r
- """由电压(mV) 算 SoC(0~100);配置来自 default_config / _BatteryCfg。"""\r
- try:\r
- v = int(volt_mv)\r
- except Exception:\r
- return None\r
- try:\r
- if vbatt_simple:\r
- _full, _v20, _v5 = vbatt_simple\r
- if v >= int(_full):\r
- return 100\r
- if v <= int(_v5):\r
- return 0\r
- if v <= int(_v20):\r
- return 10\r
- return 60\r
- except Exception:\r
- pass\r
- try:\r
- volts = ocv_volts\r
- if not volts:\r
- return None\r
- pre_volt = 0\r
- volt_not_under = 0\r
- soc1 = 0\r
- soc2 = 0\r
- for vv in volts:\r
- if v > vv:\r
- volt_not_under = 1\r
- soc1 = ocv_map.get(vv, 0)\r
- soc2 = ocv_map.get(pre_volt, 0)\r
- break\r
- else:\r
- pre_volt = vv\r
- if pre_volt == 0:\r
- return soc1\r
- if volt_not_under == 0:\r
- return 0\r
- return int(soc2 - (soc2 - soc1) * (pre_volt - v) // (pre_volt - vv))\r
- except Exception:\r
- return None\r
-\r
-\r
-class _BatteryCfg(object):\r
- """从 vc_config(default_config) 加载电池参数;全机唯一 Power.getVbatt 采样点 + 10 点滑动平均。"""\r
- _inst = None\r
-\r
- def __init__(self):\r
- self.ocv_map = _default_battery_ocv_map()\r
- self.ocv_volts = sorted(self.ocv_map.keys(), reverse=True)\r
- self.charge_full_mv = 4290\r
- self.low_mv = 3699\r
- self.empty_mv = 3629\r
- self.low_soc = 25\r
- self.empty_soc = 5\r
- self.vbatt_simple = None\r
- self._vbat_buf = []\r
- self._vbat_avg_mv = 0\r
- self._vbat_chg_last_mv = 0\r
- self._soc_frozen = None\r
- self._usb_chg = 0\r
- self._vbat_last_push_ms = 0\r
- self._vbat_avg_len = 10\r
- self._vbat_push_min_ms = 9000\r
- try:\r
- if "vc_config" in globals() and vc_config:\r
- self.charge_full_mv = int(vc_config.get_int("VBATT_CHARGE_FULL_MV", 4320))\r
- self.low_mv = int(vc_config.get_int("VBATT_LOW_MV", 3630))\r
- self.empty_mv = int(vc_config.get_int("VBATT_EMPTY_MV", 3400))\r
- self.low_soc = int(vc_config.get_int("BATTERY_LOW_SOC_PERCENT", 25))\r
- self.empty_soc = int(vc_config.get_int("BATTERY_EMPTY_SOC_PERCENT", 5))\r
- self._vbat_avg_len = int(vc_config.get_int("VBATT_AVG_LEN", 10)) or 10\r
- self._vbat_push_min_ms = int(vc_config.get_int("VBATT_PUSH_MIN_MS", 9000)) or 9000\r
- _ocv_cfg = _parse_battery_ocv_map(vc_config.get_attr("BATTERY_OCV_MAP", None))\r
- if _ocv_cfg:\r
- self.ocv_map = _ocv_cfg\r
- self.ocv_volts = sorted(self.ocv_map.keys(), reverse=True)\r
- if vc_config.get_bool("USE_SIMPLE_VBATT_THRESH", False):\r
- self.vbatt_simple = (self.charge_full_mv, self.low_mv, self.empty_mv)\r
- except Exception:\r
- pass\r
-\r
- @classmethod\r
- def instance(cls):\r
- if cls._inst is None:\r
- cls._inst = cls()\r
- return cls._inst\r
-\r
- def _push_vbatt_raw(self, raw_mv):\r
- """与 protocol.py 一致:滑动窗口求算术平均(mV)。"""\r
- try:\r
- v = int(raw_mv)\r
- except Exception:\r
- return self._vbat_avg_mv\r
- n = int(self._vbat_avg_len) or 10\r
- buf = self._vbat_buf\r
- if len(buf) < n:\r
- buf.append(v)\r
- else:\r
- for i in range(n - 1):\r
- buf[i] = buf[i + 1]\r
- buf[n - 1] = v\r
- total = 0\r
- for x in buf:\r
- total += x\r
- self._vbat_avg_mv = total // len(buf)\r
- return self._vbat_avg_mv\r
-\r
- def _usb_is_charging(self):\r
- try:\r
- if self._usb_chg:\r
- return 1\r
- st = EventMesh.publish("GET_USB_STATE")\r
- return 1 if st == 1 else 0\r
- except Exception:\r
- return 0\r
-\r
- def on_usb_change(self, plugged_in):\r
- """插拔 USB:充电电压偏高,与放电 OCV 不可混用;清空滑动窗并冻结/恢复 SoC。"""\r
- try:\r
- plug = 1 if plugged_in else 0\r
- self._usb_chg = plug\r
- if plug:\r
- if self._vbat_buf and self._vbat_avg_mv > 0:\r
- s = self.soc_from_vbatt(self._vbat_avg_mv)\r
- self._soc_frozen = max(0, min(100, int(s) if s is not None else 0))\r
- elif self._soc_frozen is None:\r
- self._soc_frozen = 0\r
- self._vbat_buf = []\r
- self._vbat_avg_mv = 0\r
- self._vbat_last_push_ms = 0\r
- else:\r
- self._vbat_buf = []\r
- self._vbat_avg_mv = 0\r
- self._vbat_chg_last_mv = 0\r
- self._vbat_last_push_ms = 0\r
- except Exception:\r
- pass\r
-\r
- def push_vbatt_sample(self, force=0, usb_status=None):\r
- """采样一次 getVbatt:充电只记瞬时电压(判满);放电才进滑动平均(算 SoC/关机)。"""\r
- try:\r
- now = utime.ticks_ms()\r
- chg = self._usb_chg if usb_status is None else (1 if usb_status == 1 else 0)\r
- if not force and self._vbat_last_push_ms:\r
- if utime.ticks_diff(now, self._vbat_last_push_ms) < int(self._vbat_push_min_ms):\r
- if chg:\r
- return self._vbat_chg_last_mv or self._vbat_avg_mv\r
- return self._vbat_avg_mv\r
- self._vbat_last_push_ms = now\r
- raw = Power.getVbatt()\r
- except Exception:\r
- if self._usb_is_charging():\r
- return self._vbat_chg_last_mv\r
- return self._vbat_avg_mv\r
- try:\r
- chg = self._usb_chg if usb_status is None else (1 if usb_status == 1 else 0)\r
- if chg:\r
- self._vbat_chg_last_mv = int(raw)\r
- return self._vbat_chg_last_mv\r
- except Exception:\r
- pass\r
- return self._push_vbatt_raw(raw)\r
-\r
- def get_vbatt_mv(self):\r
- """放电路径滑动平均电压(mV);充电时不混用充电偏高电压。"""\r
- if self._usb_is_charging():\r
- return self._vbat_avg_mv if self._vbat_avg_mv > 0 else 0\r
- if self._vbat_buf and self._vbat_avg_mv > 0:\r
- return self._vbat_avg_mv\r
- return self.push_vbatt_sample(force=1, usb_status=0)\r
-\r
- def get_vbatt_mv_charge(self):\r
- """充电时最近一次采样(判充满);未采样则触发一次。"""\r
- if self._vbat_chg_last_mv > 0:\r
- return self._vbat_chg_last_mv\r
- return self.push_vbatt_sample(force=1, usb_status=1)\r
-\r
- def soc_from_vbatt(self, volt_mv):\r
- return _soc_from_vbatt_mv(volt_mv, self.ocv_map, self.ocv_volts, self.vbatt_simple)\r
-\r
- def soc_now(self):\r
- """放电:OCV 表 + 滑动平均;充电:冻结插 USB 前的 SoC,避免充电电压算成 100%。"""\r
- if self._usb_is_charging():\r
- if self._soc_frozen is not None:\r
- return int(self._soc_frozen)\r
- return 100\r
- v = self.get_vbatt_mv()\r
- s = self.soc_from_vbatt(v)\r
- if s is None:\r
- return 0\r
- if s < 0:\r
- return 0\r
- if s > 100:\r
- return 100\r
- return int(s)\r
-\r
- def should_shutdown_empty(self, vbatt_mv=None):\r
- """产品定义:仅未充电且平均电压 < VBATT_EMPTY_MV 时低电关机。"""\r
- if self._usb_is_charging():\r
- return False\r
- try:\r
- v = int(vbatt_mv if vbatt_mv is not None else self.get_vbatt_mv())\r
- except Exception:\r
- return False\r
- return v > 0 and v < int(self.empty_mv)\r
-\r
- def led_battery_level(self, soc=None, vbatt_mv=None):\r
- """未充电时 LED 用电位/SoC;充电时由 charging 灯态接管,返回 normal。"""\r
- if self._usb_is_charging():\r
- return "normal"\r
- try:\r
- s = int(soc if soc is not None else self.soc_now())\r
- except Exception:\r
- s = -1\r
- try:\r
- v = int(vbatt_mv if vbatt_mv is not None else self.get_vbatt_mv())\r
- except Exception:\r
- v = 0\r
- if v > 0 and v < int(self.empty_mv):\r
- return "empty"\r
- if s >= 0 and s < int(self.empty_soc):\r
- return "empty"\r
- if s >= 0 and s < int(self.low_soc):\r
- return "low"\r
- if v > 0 and v < int(self.low_mv):\r
- return "low"\r
- return "normal"\r
-\r
-\r
-class AI_hw_status(Abstract):\r
- # 精简硬件状态采集:仅维护 LED 状态机所需的 charging/battery/signal\r
- def __init__(self):\r
- # 无条件首行:确认是否进入初始化(避免被异常/注册顺序误判)\r
- try:\r
- print("[HW] __init__ enter")\r
- except Exception:\r
- pass\r
- _bcfg = _BatteryCfg.instance()\r
- self._bcfg = _bcfg\r
- self._ocv_map = _bcfg.ocv_map\r
- self._ocv_volts = _bcfg.ocv_volts\r
- self._charge_full_mv = _bcfg.charge_full_mv\r
- self._low_soc = _bcfg.low_soc\r
- self._empty_soc = _bcfg.empty_soc\r
- self._vbatt_simple = _bcfg.vbatt_simple\r
- # cached state (avoid repeat publish)\r
- self._chg = None\r
- self._bat = None\r
- self._sig = None\r
- self._usb = None\r
- self._charge_full_latched = 0\r
- self._charge_full_streak = 0\r
- self._charge_full_streak_need = 2\r
- self._timer = osTimer()\r
- self._period_ms = 10000\r
- self._weak_csq = 10\r
- self._dbg = 0\r
- try:\r
- if "vc_config" in globals() and vc_config:\r
- self._period_ms = vc_config.get_int("HW_STATUS_PERIOD_MS", 10000) or 10000\r
- self._weak_csq = vc_config.get_int("SIGNAL_WEAK_CSQ", 10) or 10\r
- self._dbg = 1 if vc_config.get_bool("HW_STATUS_DEBUG", False) else 0\r
- except Exception:\r
- pass\r
- # 若开启了 LED/按键调试,也一并打开硬件监控打印,便于关联分析\r
- try:\r
- if "vc_config" in globals() and vc_config:\r
- if vc_config.get_bool("LED_DEBUG", False) or vc_config.get_bool("KEY_LED_DEBUG", False):\r
- self._dbg = 1\r
- except Exception:\r
- pass\r
-\r
- # 注意:AI_dev 也会注册 USB callback;USB 模块通常只支持一个 callback,后注册会覆盖先注册。\r
- # 为避免“刚开始有效,后面失效”,这里不直接 setCallback,改为订阅 AI_dev 转发的 USB 状态事件,\r
- # 并在 10 秒轮询中再读一次 GET_USB_STATE 作兜底。\r
- try:\r
- EventMesh.subscribe("hw_usb_state", self._on_usb_state)\r
- except Exception:\r
- pass\r
-\r
- # 初始化:先立即刷新一次,再开启周期轮询(避免 one-shot/覆盖差异导致只跑一次)\r
- try:\r
- self._update()\r
- except Exception:\r
- pass\r
- try:\r
- self._timer.start(self._period_ms, 1, self._tick_cb)\r
- except Exception:\r
- pass\r
- # 初始化打印(一次)\r
- try:\r
- print("[HW] init ok period_ms={} weak_csq={} usb_init={} algo={}".format(\r
- self._period_ms,\r
- self._weak_csq,\r
- self._usb,\r
- "simple" if getattr(self, "_vbatt_simple", None) else "ocv"))\r
- if self._dbg == 1:\r
- print("[HW] init detail vbatt_simple={}".format(getattr(self, "_vbatt_simple", None)))\r
- except Exception:\r
- pass\r
-\r
- def _on_usb_state(self, event=None, msg=None):\r
- try:\r
- state = msg\r
- prev = self._usb\r
- self._usb = 1 if state == 1 else 0\r
- if self._usb == 1 and prev != 1:\r
- self._charge_full_latched = 0\r
- self._charge_full_streak = 0\r
- if self._usb == 0:\r
- self._charge_full_latched = 0\r
- self._charge_full_streak = 0\r
- try:\r
- self._bcfg.on_usb_change(self._usb)\r
- except Exception:\r
- pass\r
- except Exception:\r
- pass\r
- try:\r
- if self._dbg == 1:\r
- print("[HW] usb_evt state={} usb={}".format(state, self._usb))\r
- except Exception:\r
- pass\r
- try:\r
- self._update()\r
- except Exception:\r
- pass\r
-\r
- def _tick_cb(self, *args, **kwargs):\r
- # 定时器回调直接刷新(不依赖 AI_dev 的事件线程)\r
- try:\r
- self._tick()\r
- except Exception:\r
- pass\r
-\r
- def _tick(self, *args, **kwargs):\r
- self._update()\r
-\r
- def _update(self):\r
- # 每次刷新都“同步推送一次”当前硬件基础态到 LED(不依赖变化检测)\r
- # 目的:保证 10 秒轮询和 USB callback 都能及时刷新充电/电量/信号的基础态显示\r
- # charging/battery(本周期唯一 getVbatt;充电/放电分流)\r
- try:\r
- usb_status = self._usb\r
- if usb_status is None:\r
- try:\r
- usb_status = EventMesh.publish("GET_USB_STATE")\r
- except Exception:\r
- usb_status = 0\r
- v = self._bcfg.push_vbatt_sample(usb_status=usb_status)\r
- except Exception:\r
- v = None\r
- soc = None\r
- csq = None\r
- rssi = None\r
- usb_status = None\r
- chg = "none"\r
- bat = "normal"\r
- sig = "normal"\r
- try:\r
- usb_status = self._usb\r
- if usb_status is None:\r
- try:\r
- usb_status = EventMesh.publish("GET_USB_STATE")\r
- if usb_status is None:\r
- usb_status = 0\r
- except Exception:\r
- usb_status = 0\r
- # charging:用充电通道电压判满(勿用放电 OCV 平均)\r
- if usb_status == 1:\r
- v_chg = v\r
- try:\r
- v_chg = self._bcfg.get_vbatt_mv_charge()\r
- except Exception:\r
- pass\r
- if getattr(self, "_charge_full_latched", 0) == 1:\r
- chg = "full"\r
- else:\r
- if v_chg is not None and v_chg >= int(self._charge_full_mv):\r
- self._charge_full_streak = int(getattr(self, "_charge_full_streak", 0)) + 1\r
- need = int(getattr(self, "_charge_full_streak_need", 2) or 2)\r
- if self._charge_full_streak >= need:\r
- self._charge_full_latched = 1\r
- chg = "full"\r
- else:\r
- chg = "charging"\r
- else:\r
- self._charge_full_streak = 0\r
- chg = "charging"\r
- soc = None\r
- try:\r
- soc = self._bcfg.soc_now()\r
- except Exception:\r
- pass\r
- bat = self._bcfg.led_battery_level(soc=soc, vbatt_mv=v if usb_status != 1 else None)\r
- self._chg = chg\r
- self._bat = bat\r
- except Exception:\r
- pass\r
-\r
- # signal\r
- try:\r
- csq = net.csqQueryPoll()\r
- # csqQueryPoll 返回 (rssi, ber) 或 int,按保守取 rssi\r
- try:\r
- if isinstance(csq, (tuple, list)) and len(csq) > 0:\r
- rssi = csq[0]\r
- else:\r
- rssi = csq\r
- except Exception:\r
- rssi = csq\r
- sig = "weak" if (rssi is not None and int(rssi) >= 0 and int(rssi) < int(self._weak_csq)) else "normal"\r
- self._sig = sig\r
- except Exception:\r
- pass\r
-\r
- # 统一推送一次当前基础态(一次调用带齐字段,减少来回切换)\r
- try:\r
- EventMesh.publish("set_led_state", {"charging": chg, "battery": bat, "signal": sig})\r
- except Exception:\r
- pass\r
-\r
- # 轮询调试打印(每次 10s tick 一次):硬件采样一行 + LED 聚合状态一行内打完\r
- try:\r
- if self._dbg == 1:\r
- led = None\r
- try:\r
- led = EventMesh.publish("get_led_debug_state")\r
- except Exception:\r
- pass\r
- print("[HW] usb={} vbatt_mv={} soc={} chg={} bat={} csq={} rssi={} sig={} period_ms={} led={}".format(\r
- usb_status, v, soc, self._chg, self._bat, csq, rssi, self._sig, self._period_ms, led))\r
- except Exception:\r
- pass\r
-\r
- def _soc_from_vbatt(self, volt_mv):\r
- return self._bcfg.soc_from_vbatt(volt_mv)\r
-\r
-\r
-def set_ipv4_datacall():\r
- # 获取第一路的APN,ipType 等信息\r
- pdpCtx = dataCall.getPDPContext(1)\r
- if pdpCtx != -1:\r
- if pdpCtx[0] != 0:\r
- # 如果不是用户需要的ipv4,使用如下方式配置,使用如下方式配置\r
- ret = dataCall.setPDPContext(1, 0,pdpCtx[1],pdpCtx[2],pdpCtx[3],pdpCtx[4])\r
- if ret == 0:\r
- print('配置成功。')\r
- # cfun0/1后按照配置的信息进行拨号\r
- net.setModemFun(0)\r
- net.setModemFun(1)\r
- else:\r
- print('配置失败。')\r
- else:\r
- print('已经配置为IPv4')\r
- else:\r
- print('获取PDP Context失败。')\r
-\r
+# -*- coding: utf-8 -*-
+"""充电/电量/信号采集。"""
+from common import Abstract
+try:
+ from qp_log import qp_print as print
+except Exception:
+ pass
+import EventMesh
+import utime
+import osTimer
+import net
+import dataCall
+from misc import USB, Power
+from vc_common import dev_type
+from vc_utils import cfg_bool, cfg_int, cfg_attr
+
+def _default_battery_ocv_map():
+ # 无 BATTERY_OCV_MAP 配置时的兜底(502631 ZCV;0% 锚定 3400mV,适配 4G 带载)
+ return {
+ 4322: 100, 4239: 95, 4177: 90, 4117: 85, 4059: 80, 4006: 75, 3942: 70, 3898: 65,
+ 3853: 60, 3814: 55, 3781: 50, 3755: 45, 3738: 40, 3724: 35, 3706: 30, 3678: 25,
+ 3634: 20, 3577: 15, 3522: 10, 3468: 5, 3400: 0,
+ }
+
+
+def _parse_battery_ocv_map(raw):
+ """解析 default_config.BATTERY_OCV_MAP:dict 或 [(mv, soc), ...]。"""
+ if raw is None:
+ return None
+ out = {}
+ try:
+ if isinstance(raw, dict):
+ pairs = raw.items()
+ elif isinstance(raw, (tuple, list)):
+ pairs = ((p[0], p[1]) for p in raw if isinstance(p, (tuple, list)) and len(p) >= 2)
+ else:
+ return None
+ for k, v in pairs:
+ out[int(k)] = int(v)
+ return out if out else None
+ except Exception:
+ return None
+
+
+def _soc_from_vbatt_mv(volt_mv, ocv_map, ocv_volts, vbatt_simple=None):
+ """由电压(mV) 算 SoC(0~100);配置来自 default_config / _BatteryCfg。"""
+ try:
+ v = int(volt_mv)
+ except Exception:
+ return None
+ try:
+ if vbatt_simple:
+ _full, _v20, _v5 = vbatt_simple
+ if v >= int(_full):
+ return 100
+ if v <= int(_v5):
+ return 0
+ if v <= int(_v20):
+ return 10
+ return 60
+ except Exception:
+ pass
+ try:
+ volts = ocv_volts
+ if not volts:
+ return None
+ pre_volt = 0
+ volt_not_under = 0
+ soc1 = 0
+ soc2 = 0
+ for vv in volts:
+ if v > vv:
+ volt_not_under = 1
+ soc1 = ocv_map.get(vv, 0)
+ soc2 = ocv_map.get(pre_volt, 0)
+ break
+ else:
+ pre_volt = vv
+ if pre_volt == 0:
+ return soc1
+ if volt_not_under == 0:
+ return 0
+ return int(soc2 - (soc2 - soc1) * (pre_volt - v) // (pre_volt - vv))
+ except Exception:
+ return None
+
+
+class _BatteryCfg(object):
+ """从 vc_config(default_config) 加载电池参数;全机唯一 Power.getVbatt 采样点 + 10 点滑动平均。"""
+ _inst = None
+
+ def __init__(self):
+ self.ocv_map = _default_battery_ocv_map()
+ self.ocv_volts = sorted(self.ocv_map.keys(), reverse=True)
+ self.charge_full_mv = 4290
+ self.low_mv = 3699
+ self.empty_mv = 3629
+ self.low_soc = 25
+ self.empty_soc = 5
+ self.vbatt_simple = None
+ self._vbat_buf = []
+ self._vbat_avg_mv = 0
+ self._vbat_chg_last_mv = 0
+ self._soc_frozen = None
+ self._usb_chg = 0
+ self._vbat_last_push_ms = 0
+ self._vbat_avg_len = 10
+ self._vbat_push_min_ms = 9000
+ self.charge_full_mv = cfg_int("VBATT_CHARGE_FULL_MV", 4320)
+ self.low_mv = cfg_int("VBATT_LOW_MV", 3630)
+ self.empty_mv = cfg_int("VBATT_EMPTY_MV", 3400)
+ self.low_soc = cfg_int("BATTERY_LOW_SOC_PERCENT", 25)
+ self.empty_soc = cfg_int("BATTERY_EMPTY_SOC_PERCENT", 5)
+ self._vbat_avg_len = cfg_int("VBATT_AVG_LEN", 10) or 10
+ self._vbat_push_min_ms = cfg_int("VBATT_PUSH_MIN_MS", 9000) or 9000
+ _ocv_cfg = _parse_battery_ocv_map(cfg_attr("BATTERY_OCV_MAP", None))
+ if _ocv_cfg:
+ self.ocv_map = _ocv_cfg
+ self.ocv_volts = sorted(self.ocv_map.keys(), reverse=True)
+ if cfg_bool("USE_SIMPLE_VBATT_THRESH", False):
+ self.vbatt_simple = (self.charge_full_mv, self.low_mv, self.empty_mv)
+
+ @classmethod
+ def instance(cls):
+ if cls._inst is None:
+ cls._inst = cls()
+ return cls._inst
+
+ def _push_vbatt_raw(self, raw_mv):
+ """与 protocol.py 一致:滑动窗口求算术平均(mV)。"""
+ try:
+ v = int(raw_mv)
+ except Exception:
+ return self._vbat_avg_mv
+ n = int(self._vbat_avg_len) or 10
+ buf = self._vbat_buf
+ if len(buf) < n:
+ buf.append(v)
+ else:
+ for i in range(n - 1):
+ buf[i] = buf[i + 1]
+ buf[n - 1] = v
+ total = 0
+ for x in buf:
+ total += x
+ self._vbat_avg_mv = total // len(buf)
+ return self._vbat_avg_mv
+
+ def _usb_is_charging(self):
+ try:
+ if self._usb_chg:
+ return 1
+ st = EventMesh.publish("GET_USB_STATE")
+ return 1 if st == 1 else 0
+ except Exception:
+ return 0
+
+ def on_usb_change(self, plugged_in):
+ """插拔 USB:充电电压偏高,与放电 OCV 不可混用;清空滑动窗并冻结/恢复 SoC。"""
+ try:
+ plug = 1 if plugged_in else 0
+ self._usb_chg = plug
+ if plug:
+ if self._vbat_buf and self._vbat_avg_mv > 0:
+ s = self.soc_from_vbatt(self._vbat_avg_mv)
+ self._soc_frozen = max(0, min(100, int(s) if s is not None else 0))
+ elif self._soc_frozen is None:
+ self._soc_frozen = 0
+ self._vbat_buf = []
+ self._vbat_avg_mv = 0
+ self._vbat_last_push_ms = 0
+ else:
+ self._vbat_buf = []
+ self._vbat_avg_mv = 0
+ self._vbat_chg_last_mv = 0
+ self._vbat_last_push_ms = 0
+ except Exception:
+ pass
+
+ def push_vbatt_sample(self, force=0, usb_status=None):
+ """采样一次 getVbatt:充电只记瞬时电压(判满);放电才进滑动平均(算 SoC/关机)。"""
+ try:
+ now = utime.ticks_ms()
+ chg = self._usb_chg if usb_status is None else (1 if usb_status == 1 else 0)
+ if not force and self._vbat_last_push_ms:
+ if utime.ticks_diff(now, self._vbat_last_push_ms) < int(self._vbat_push_min_ms):
+ if chg:
+ return self._vbat_chg_last_mv or self._vbat_avg_mv
+ return self._vbat_avg_mv
+ self._vbat_last_push_ms = now
+ raw = Power.getVbatt()
+ except Exception:
+ if self._usb_is_charging():
+ return self._vbat_chg_last_mv
+ return self._vbat_avg_mv
+ try:
+ chg = self._usb_chg if usb_status is None else (1 if usb_status == 1 else 0)
+ if chg:
+ self._vbat_chg_last_mv = int(raw)
+ return self._vbat_chg_last_mv
+ except Exception:
+ pass
+ return self._push_vbatt_raw(raw)
+
+ def get_vbatt_mv(self):
+ """放电路径滑动平均电压(mV);充电时不混用充电偏高电压。"""
+ if self._usb_is_charging():
+ return self._vbat_avg_mv if self._vbat_avg_mv > 0 else 0
+ if self._vbat_buf and self._vbat_avg_mv > 0:
+ return self._vbat_avg_mv
+ return self.push_vbatt_sample(force=1, usb_status=0)
+
+ def get_vbatt_mv_charge(self):
+ """充电时最近一次采样(判充满);未采样则触发一次。"""
+ if self._vbat_chg_last_mv > 0:
+ return self._vbat_chg_last_mv
+ return self.push_vbatt_sample(force=1, usb_status=1)
+
+ def soc_from_vbatt(self, volt_mv):
+ return _soc_from_vbatt_mv(volt_mv, self.ocv_map, self.ocv_volts, self.vbatt_simple)
+
+ def soc_now(self):
+ """放电:OCV 表 + 滑动平均;充电:冻结插 USB 前的 SoC,避免充电电压算成 100%。"""
+ if self._usb_is_charging():
+ if self._soc_frozen is not None:
+ return int(self._soc_frozen)
+ return 100
+ v = self.get_vbatt_mv()
+ s = self.soc_from_vbatt(v)
+ if s is None:
+ return 0
+ if s < 0:
+ return 0
+ if s > 100:
+ return 100
+ return int(s)
+
+ def should_shutdown_empty(self, vbatt_mv=None):
+ """产品定义:仅未充电且平均电压 < VBATT_EMPTY_MV 时低电关机。"""
+ if self._usb_is_charging():
+ return False
+ try:
+ v = int(vbatt_mv if vbatt_mv is not None else self.get_vbatt_mv())
+ except Exception:
+ return False
+ return v > 0 and v < int(self.empty_mv)
+
+ def led_battery_level(self, soc=None, vbatt_mv=None):
+ """未充电时 LED 用电位/SoC;充电时由 charging 灯态接管,返回 normal。"""
+ if self._usb_is_charging():
+ return "normal"
+ try:
+ s = int(soc if soc is not None else self.soc_now())
+ except Exception:
+ s = -1
+ try:
+ v = int(vbatt_mv if vbatt_mv is not None else self.get_vbatt_mv())
+ except Exception:
+ v = 0
+ if v > 0 and v < int(self.empty_mv):
+ return "empty"
+ if s >= 0 and s < int(self.empty_soc):
+ return "empty"
+ if s >= 0 and s < int(self.low_soc):
+ return "low"
+ if v > 0 and v < int(self.low_mv):
+ return "low"
+ return "normal"
+
+
+class AI_hw_status(Abstract):
+ # 精简硬件状态采集:仅维护 LED 状态机所需的 charging/battery/signal
+ def __init__(self):
+ # 无条件首行:确认是否进入初始化(避免被异常/注册顺序误判)
+ try:
+ print("[HW] __init__ enter")
+ except Exception:
+ pass
+ _bcfg = _BatteryCfg.instance()
+ self._bcfg = _bcfg
+ self._ocv_map = _bcfg.ocv_map
+ self._ocv_volts = _bcfg.ocv_volts
+ self._charge_full_mv = _bcfg.charge_full_mv
+ self._low_soc = _bcfg.low_soc
+ self._empty_soc = _bcfg.empty_soc
+ self._vbatt_simple = _bcfg.vbatt_simple
+ # cached state (avoid repeat publish)
+ self._chg = None
+ self._bat = None
+ self._sig = None
+ self._usb = None
+ self._charge_full_latched = 0
+ self._charge_full_streak = 0
+ self._charge_full_streak_need = 2
+ self._timer = osTimer()
+ self._period_ms = 10000
+ self._weak_csq = 10
+ self._dbg = 0
+ self._period_ms = cfg_int("HW_STATUS_PERIOD_MS", 10000) or 10000
+ self._weak_csq = cfg_int("SIGNAL_WEAK_CSQ", 10) or 10
+ self._dbg = 1 if cfg_bool("HW_STATUS_DEBUG", False) else 0
+ if cfg_bool("LED_DEBUG", False) or cfg_bool("KEY_LED_DEBUG", False):
+ self._dbg = 1
+
+ # 注意:AI_dev 也会注册 USB callback;USB 模块通常只支持一个 callback,后注册会覆盖先注册。
+ # 为避免“刚开始有效,后面失效”,这里不直接 setCallback,改为订阅 AI_dev 转发的 USB 状态事件,
+ # 并在 10 秒轮询中再读一次 GET_USB_STATE 作兜底。
+ try:
+ EventMesh.subscribe("hw_usb_state", self._on_usb_state)
+ except Exception:
+ pass
+
+ # 初始化:先立即刷新一次,再开启周期轮询(避免 one-shot/覆盖差异导致只跑一次)
+ try:
+ self._update()
+ except Exception:
+ pass
+ try:
+ self._timer.start(self._period_ms, 1, self._tick_cb)
+ except Exception:
+ pass
+ # 初始化打印(一次)
+ try:
+ print("[HW] init ok period_ms={} weak_csq={} usb_init={} algo={}".format(
+ self._period_ms,
+ self._weak_csq,
+ self._usb,
+ "simple" if getattr(self, "_vbatt_simple", None) else "ocv"))
+ if self._dbg == 1:
+ print("[HW] init detail vbatt_simple={}".format(getattr(self, "_vbatt_simple", None)))
+ except Exception:
+ pass
+
+ def _on_usb_state(self, event=None, msg=None):
+ try:
+ state = msg
+ prev = self._usb
+ self._usb = 1 if state == 1 else 0
+ if self._usb == 1 and prev != 1:
+ self._charge_full_latched = 0
+ self._charge_full_streak = 0
+ if self._usb == 0:
+ self._charge_full_latched = 0
+ self._charge_full_streak = 0
+ try:
+ self._bcfg.on_usb_change(self._usb)
+ except Exception:
+ pass
+ except Exception:
+ pass
+ try:
+ if self._dbg == 1:
+ print("[HW] usb_evt state={} usb={}".format(state, self._usb))
+ except Exception:
+ pass
+ try:
+ self._update()
+ except Exception:
+ pass
+
+ def _tick_cb(self, *args, **kwargs):
+ # 定时器回调直接刷新(不依赖 AI_dev 的事件线程)
+ try:
+ self._tick()
+ except Exception:
+ pass
+
+ def _tick(self, *args, **kwargs):
+ self._update()
+
+ def _update(self):
+ # 每次刷新都“同步推送一次”当前硬件基础态到 LED(不依赖变化检测)
+ # 目的:保证 10 秒轮询和 USB callback 都能及时刷新充电/电量/信号的基础态显示
+ # charging/battery(本周期唯一 getVbatt;充电/放电分流)
+ try:
+ usb_status = self._usb
+ if usb_status is None:
+ try:
+ usb_status = EventMesh.publish("GET_USB_STATE")
+ except Exception:
+ usb_status = 0
+ v = self._bcfg.push_vbatt_sample(usb_status=usb_status)
+ except Exception:
+ v = None
+ soc = None
+ csq = None
+ rssi = None
+ usb_status = None
+ chg = "none"
+ bat = "normal"
+ sig = "normal"
+ try:
+ usb_status = self._usb
+ if usb_status is None:
+ try:
+ usb_status = EventMesh.publish("GET_USB_STATE")
+ if usb_status is None:
+ usb_status = 0
+ except Exception:
+ usb_status = 0
+ # charging:用充电通道电压判满(勿用放电 OCV 平均)
+ if usb_status == 1:
+ v_chg = v
+ try:
+ v_chg = self._bcfg.get_vbatt_mv_charge()
+ except Exception:
+ pass
+ if getattr(self, "_charge_full_latched", 0) == 1:
+ chg = "full"
+ else:
+ if v_chg is not None and v_chg >= int(self._charge_full_mv):
+ self._charge_full_streak = int(getattr(self, "_charge_full_streak", 0)) + 1
+ need = int(getattr(self, "_charge_full_streak_need", 2) or 2)
+ if self._charge_full_streak >= need:
+ self._charge_full_latched = 1
+ chg = "full"
+ else:
+ chg = "charging"
+ else:
+ self._charge_full_streak = 0
+ chg = "charging"
+ soc = None
+ try:
+ soc = self._bcfg.soc_now()
+ except Exception:
+ pass
+ bat = self._bcfg.led_battery_level(soc=soc, vbatt_mv=v if usb_status != 1 else None)
+ self._chg = chg
+ self._bat = bat
+ except Exception:
+ pass
+
+ # signal
+ try:
+ csq = net.csqQueryPoll()
+ # csqQueryPoll 返回 (rssi, ber) 或 int,按保守取 rssi
+ try:
+ if isinstance(csq, (tuple, list)) and len(csq) > 0:
+ rssi = csq[0]
+ else:
+ rssi = csq
+ except Exception:
+ rssi = csq
+ sig = "weak" if (rssi is not None and int(rssi) >= 0 and int(rssi) < int(self._weak_csq)) else "normal"
+ self._sig = sig
+ except Exception:
+ pass
+
+ # 统一推送一次当前基础态(一次调用带齐字段,减少来回切换)
+ try:
+ EventMesh.publish("set_led_state", {"charging": chg, "battery": bat, "signal": sig})
+ except Exception:
+ pass
+
+ # 轮询调试打印(每次 10s tick 一次):硬件采样一行 + LED 聚合状态一行内打完
+ try:
+ if self._dbg == 1:
+ led = None
+ try:
+ led = EventMesh.publish("get_led_debug_state")
+ except Exception:
+ pass
+ print("[HW] usb={} vbatt_mv={} soc={} chg={} bat={} csq={} rssi={} sig={} period_ms={} led={}".format(
+ usb_status, v, soc, self._chg, self._bat, csq, rssi, self._sig, self._period_ms, led))
+ except Exception:
+ pass
+
+ def _soc_from_vbatt(self, volt_mv):
+ return self._bcfg.soc_from_vbatt(volt_mv)
+
+
+def set_ipv4_datacall():
+ # 获取第一路的APN,ipType 等信息
+ pdpCtx = dataCall.getPDPContext(1)
+ if pdpCtx != -1:
+ if pdpCtx[0] != 0:
+ # 如果不是用户需要的ipv4,使用如下方式配置,使用如下方式配置
+ ret = dataCall.setPDPContext(1, 0,pdpCtx[1],pdpCtx[2],pdpCtx[3],pdpCtx[4])
+ if ret == 0:
+ print('配置成功。')
+ # cfun0/1后按照配置的信息进行拨号
+ net.setModemFun(0)
+ net.setModemFun(1)
+ else:
+ print('配置失败。')
+ else:
+ print('已经配置为IPv4')
+ else:
+ print('获取PDP Context失败。')
+
self._sync_legacy(vc)\r
\r
def begin(self, vc, kind, pending_uplink=0, cancel_wait_ms=800):\r
- try:\r
- gen = int(getattr(vc, "_vc_turn_gen", 0))\r
- except Exception:\r
- gen = 0\r
+ self.gen = int(getattr(vc, "_vc_turn_gen", 0))\r
self.active = 1\r
self.kind = kind or self.KIND_NONE\r
- self.gen = gen\r
self.pending_uplink = 1 if pending_uplink else 0\r
self.drop_tts = 1\r
self.ruppt_tts = 1\r
self.settled_ms = 0\r
+ self.cancel_deadline_ms = 0\r
if utime and cancel_wait_ms:\r
try:\r
self.cancel_deadline_ms = utime.ticks_add(utime.ticks_ms(), int(cancel_wait_ms))\r
except Exception:\r
- self.cancel_deadline_ms = 0\r
- else:\r
- self.cancel_deadline_ms = 0\r
+ pass\r
self._sync_legacy(vc)\r
- return gen\r
+ return self.gen\r
\r
def settle(self, vc):\r
"""打断开麦完成:清 is_ruppt/drop 以允许新 TTS;保留 settled_ms 供迟到 canceled 判 stale。"""\r
self._sync_legacy(vc)\r
\r
def is_stale_gen(self, vc):\r
- try:\r
- return int(getattr(vc, "_vc_turn_gen", 0)) != int(self.gen)\r
- except Exception:\r
- return False\r
+ return int(getattr(vc, "_vc_turn_gen", 0)) != int(self.gen)\r
\r
def _sync_legacy(self, vc):\r
"""与 vc_session_io / media 中既有 getattr 兼容。"""\r
- try:\r
- vc._vc_pending_interrupt_uplink = 1 if self.pending_uplink else 0\r
- vc.is_ruppt_tts = 1 if self.ruppt_tts else 0\r
- vc._drop_tts_audio = 1 if self.drop_tts else 0\r
- vc._long_dialogue_interrupt_settled_ms = int(self.settled_ms or 0)\r
- vc._vc_cancel_deadline_ms = int(self.cancel_deadline_ms or 0)\r
- except Exception:\r
- pass\r
+ vc._vc_pending_interrupt_uplink = 1 if self.pending_uplink else 0\r
+ vc.is_ruppt_tts = 1 if self.ruppt_tts else 0\r
+ vc._drop_tts_audio = 1 if self.drop_tts else 0\r
+ vc._long_dialogue_interrupt_settled_ms = int(self.settled_ms or 0)\r
+ vc._vc_cancel_deadline_ms = int(self.cancel_deadline_ms or 0)\r
\r
def load_legacy(self, vc):\r
- try:\r
- self.pending_uplink = 1 if getattr(vc, "_vc_pending_interrupt_uplink", 0) else 0\r
- self.ruppt_tts = 1 if getattr(vc, "is_ruppt_tts", 0) else 0\r
- self.drop_tts = 1 if getattr(vc, "_drop_tts_audio", 0) else 0\r
- self.settled_ms = int(getattr(vc, "_long_dialogue_interrupt_settled_ms", 0) or 0)\r
- self.cancel_deadline_ms = int(getattr(vc, "_vc_cancel_deadline_ms", 0) or 0)\r
- self.active = 1 if (self.pending_uplink or self.ruppt_tts or self.drop_tts) else 0\r
- except Exception:\r
- pass\r
+ self.pending_uplink = 1 if getattr(vc, "_vc_pending_interrupt_uplink", 0) else 0\r
+ self.ruppt_tts = 1 if getattr(vc, "is_ruppt_tts", 0) else 0\r
+ self.drop_tts = 1 if getattr(vc, "_drop_tts_audio", 0) else 0\r
+ self.settled_ms = int(getattr(vc, "_long_dialogue_interrupt_settled_ms", 0) or 0)\r
+ self.cancel_deadline_ms = int(getattr(vc, "_vc_cancel_deadline_ms", 0) or 0)\r
+ self.active = 1 if (self.pending_uplink or self.ruppt_tts or self.drop_tts) else 0\r
utime = None
from vc_ux import derive_ux_state, UX_IDLE, UX_RECORDING, UX_THINKING, UX_TTS, ux_name
-
-try:
- import vc_config
-except Exception:
- vc_config = None
+from vc_utils import cfg_int, cfg_attr
class KeyRouter(object):
if getattr(vc, "AI_key_long_press_flag", 0) == 1:
return False
ux = derive_ux_state(vc)
- try:
- print("[KEY][router] ptt_release ux={}".format(ux_name(ux)))
- except Exception:
- pass
+ print("[KEY][router] ptt_release ux={}".format(ux_name(ux)))
if ux == UX_TTS:
- try:
- if vc._ptt_is_active_tts_playback():
- vc._ptt_stop_tts_on_short_press()
- return True
- except Exception:
- pass
- if ux == UX_THINKING:
- try:
- vc._ptt_stop_dialog_to_idle()
+ if vc._ptt_is_active_tts_playback():
+ vc._ptt_stop_tts_on_short_press()
return True
- except Exception:
- pass
+ if ux == UX_THINKING:
+ vc._ptt_stop_dialog_to_idle()
+ return True
if ux == UX_IDLE:
- try:
- if hasattr(vc, "_ptt_play_idle_hint"):
- vc._ptt_play_idle_hint()
- return True
- except Exception:
- pass
+ if hasattr(vc, "_ptt_play_idle_hint"):
+ vc._ptt_play_idle_hint()
+ return True
return False
@staticmethod
def handle_power_short(vc):
"""Power 短按:cancel → Close → 清 sid(设计稿幻灯片 6)。"""
ux = derive_ux_state(vc)
- try:
- print("[KEY][router] power_short ux={}".format(ux_name(ux)))
- except Exception:
- pass
+ print("[KEY][router] power_short ux={}".format(ux_name(ux)))
try:
vc._vc_send_protocol_cancel("power_short/ux={}".format(ux_name(ux)))
except Exception:
pass
- try:
- vc._vc_close_reason = "power_short"
- except Exception:
- pass
- try:
- if EventMesh:
- EventMesh.publish("publish_AI_btnInfo", {"func": vc.Close})
- except Exception:
- pass
- try:
- if EventMesh and constants:
- EventMesh.publish(constants.EVENT.SYSTEM_UP)
- except Exception:
- pass
+ vc._vc_close_reason = "power_short"
+ if EventMesh:
+ EventMesh.publish("publish_AI_btnInfo", {"func": vc.Close})
+ if EventMesh and constants:
+ EventMesh.publish(constants.EVENT.SYSTEM_UP)
return True
@staticmethod
def _long_ai_press(vc):
ux = derive_ux_state(vc)
- try:
- print("[KEY][router] ai_press ux={} {}".format(
- ux_name(ux), getattr(vc, "_vc_fsm_log_snip", lambda: "")()))
- except Exception:
- pass
+ print("[KEY][router] ai_press ux={} {}".format(
+ ux_name(ux), getattr(vc, "_vc_fsm_log_snip", lambda: "")()))
if ux == UX_RECORDING:
- try:
- return vc._vc_restart_record_same_dialog()
- except Exception:
- pass
+ return vc._vc_restart_record_same_dialog()
if ux in (UX_THINKING, UX_TTS):
- try:
- vc._long_dialogue_interrupt_on_short_press()
- return True
- except Exception:
- pass
+ vc._long_dialogue_interrupt_on_short_press()
+ return True
if vc._ai_key_press_long_dialogue_session():
return True
if vc._ai_key_press_long_dialogue_wake():
"""PTT 长按松手:录音过短 → notify TTS + idle。"""
if getattr(vc, "VC_record_state_flag", 0) == 0:
return False
- min_ms = 400
- tts = "录音时间太短,请按住圆形按钮说话"
- try:
- if vc_config:
- min_ms = int(vc_config.get_int("PTT_MIN_RECORD_MS", min_ms))
- tts = vc_config.get_attr("PTT_RECORD_TOO_SHORT_TTS", tts) or tts
- except Exception:
- pass
+ min_ms = cfg_int("PTT_MIN_RECORD_MS", 400)
+ tts = cfg_attr("PTT_RECORD_TOO_SHORT_TTS", "录音时间太短,请按住圆形按钮说话") or "录音时间太短,请按住圆形按钮说话"
t_open = int(getattr(vc, "_ptt_record_open_ms", 0) or 0)
if not t_open or utime is None:
return False
-# -*- coding: utf-8 -*-\r
-"""三色 LED 状态机。"""\r
-from common import Abstract\r
-try:\r
- from qp_log import qp_print as print\r
-except Exception:\r
- pass\r
-import EventMesh\r
-import utime\r
-import osTimer\r
-from machine import Pin\r
-try:\r
- import vc_config\r
-except Exception:\r
- vc_config = None\r
-from vc_common import dev_type\r
-\r
-class AI_led(Abstract):\r
- def __init__(self):\r
- try:\r
- if "vc_config" in globals() and vc_config:\r
- r_gpio, g_gpio, b_gpio = vc_config.led_gpio_tuple()\r
- else:\r
- r_gpio, g_gpio, b_gpio = Pin.GPIO36, Pin.GPIO21, Pin.GPIO19\r
- except Exception:\r
- r_gpio, g_gpio, b_gpio = Pin.GPIO36, Pin.GPIO21, Pin.GPIO19\r
- self._led_gpio_r = r_gpio\r
- self._led_gpio_g = g_gpio\r
- self._led_gpio_b = b_gpio\r
- self.led_red = Pin(r_gpio, Pin.OUT, Pin.PULL_PD, 0)\r
- self.led_green = Pin(g_gpio, Pin.OUT, Pin.PULL_PD, 1)\r
- self.led_blue = Pin(b_gpio, Pin.OUT, Pin.PULL_PD, 1)\r
- print("AI_led GPIO dev_type={} red={} green={} blue={}".format(\r
- dev_type, r_gpio, g_gpio, b_gpio))\r
-\r
- # 统一输入状态(充电/电量/信号/AI对话),按优先级表输出\r
- self._st_ai = "idle" # idle/listening/thinking/playing\r
- self._st_charging = "none" # none/charging/full\r
- self._st_battery = "normal" # normal/low/empty\r
- self._st_signal = "normal" # normal/weak\r
- self._st_alert = None # None / rb_flash_2(REQ-ERR-01/03)\r
-\r
- self._timer = osTimer()\r
- self._mode = "off" # off/red_on/green_on/green_blink/blue_blink/red_blink/bg_alt/alert_rb\r
- self._alert_steps_left = 0\r
- self._alert_rb_phase = 0\r
- self._alert_period_ms = 250\r
- self._blink_on = 0\r
- self._bg_phase = 0\r
- self._period_ms = 1000\r
- self._gb_on_ms = 1000\r
- self._gb_off_ms = 1000\r
- self._prefer_off = 0\r
-\r
- EventMesh.subscribe("set_led_state", self.set_led_state)\r
- EventMesh.subscribe("get_led_debug_state", self.get_led_debug_state)\r
- # LED 电平极性:有些板子是低电平点亮(active-low),也可能仅某一路反相\r
- self._inv_r = 0\r
- self._inv_g = 0\r
- self._inv_b = 0\r
- try:\r
- if "vc_config" in globals() and vc_config:\r
- inv = vc_config.get_attr("LED_ACTIVE_LOW_RGB", None)\r
- if isinstance(inv, (tuple, list)) and len(inv) == 3:\r
- self._inv_r = 1 if inv[0] else 0\r
- self._inv_g = 1 if inv[1] else 0\r
- self._inv_b = 1 if inv[2] else 0\r
- else:\r
- all_inv = 1 if vc_config.get_bool("LED_ACTIVE_LOW", False) else 0\r
- self._inv_r = all_inv\r
- self._inv_g = all_inv\r
- self._inv_b = all_inv\r
- except Exception:\r
- pass\r
- try:\r
- self._apply_by_table()\r
- except Exception:\r
- try:\r
- self._set_off()\r
- except Exception:\r
- pass\r
-\r
- def _timer_stop(self):\r
- try:\r
- self._timer.stop()\r
- except Exception:\r
- pass\r
-\r
- def _set_rgb(self, r, g, b):\r
- try:\r
- rr = 1 if r else 0\r
- gg = 1 if g else 0\r
- bb = 1 if b else 0\r
- if self._inv_r:\r
- rr = 0 if rr else 1\r
- if self._inv_g:\r
- gg = 0 if gg else 1\r
- if self._inv_b:\r
- bb = 0 if bb else 1\r
- self.led_red.write(rr)\r
- self.led_green.write(gg)\r
- self.led_blue.write(bb)\r
- except Exception:\r
- pass\r
-\r
- def _set_off(self):\r
- self._mode = "off"\r
- self._timer_stop()\r
- self._set_rgb(0, 0, 0)\r
-\r
- def _set_red_on(self):\r
- self._mode = "red_on"\r
- self._timer_stop()\r
- self._set_rgb(1, 0, 0)\r
-\r
- def _set_green_on(self):\r
- self._mode = "green_on"\r
- self._timer_stop()\r
- self._set_rgb(0, 1, 0)\r
-\r
- def _set_green_blink(self, on_ms=1000, off_ms=None):\r
- """待机/空闲:绿灯慢闪(替代呼吸灯,数字 GPIO 整颗亮灭)。off_ms 缺省则与 on_ms 对称。"""\r
- on_ms = int(on_ms or 1000)\r
- if off_ms is None:\r
- off_ms = on_ms\r
- else:\r
- off_ms = int(off_ms or on_ms)\r
- try:\r
- if (self._mode == "green_blink" and int(self._gb_on_ms) == int(on_ms)\r
- and int(self._gb_off_ms) == int(off_ms)):\r
- return\r
- except Exception:\r
- pass\r
- self._mode = "green_blink"\r
- self._gb_on_ms = on_ms\r
- self._gb_off_ms = off_ms\r
- self._period_ms = on_ms\r
- self._blink_on = 1\r
- self._timer_stop()\r
- self._set_rgb(0, 1, 0)\r
- self._timer.start(self._gb_on_ms, 0, self._timer_cb)\r
-\r
- def _listening_blink_period_ms(self):\r
- """单对话 PTT 250ms 快闪;长对话 1000ms 慢闪。优先运行时 VC_mode。"""\r
- try:\r
- if EventMesh.publish("get_vc_mode") == 1:\r
- return 250\r
- except Exception:\r
- pass\r
- try:\r
- if EventMesh.publish("get_storage_config", "VC_mode") == 1:\r
- return 250\r
- except Exception:\r
- pass\r
- return 1000\r
-\r
- def _set_blue_blink(self, period_ms=1000):\r
- period_ms = int(period_ms or 1000)\r
- try:\r
- if self._mode == "blue_blink" and int(self._period_ms) == period_ms:\r
- return\r
- except Exception:\r
- pass\r
- self._mode = "blue_blink"\r
- self._period_ms = period_ms\r
- self._blink_on = 1\r
- self._timer_stop()\r
- self._set_rgb(0, 0, 1)\r
- self._timer.start(self._period_ms, 1, self._timer_cb)\r
-\r
- def _set_red_blink(self, period_ms=1000):\r
- self._mode = "red_blink"\r
- self._period_ms = period_ms or 1000\r
- self._blink_on = 1\r
- self._timer_stop()\r
- self._set_rgb(1, 0, 0)\r
- self._timer.start(self._period_ms, 1, self._timer_cb)\r
-\r
- def _set_bg_alt(self, period_ms=1000):\r
- self._mode = "bg_alt"\r
- self._period_ms = period_ms or 1000\r
- self._bg_phase = 0\r
- self._timer_stop()\r
- self._set_rgb(0, 0, 1)\r
- self._timer.start(self._period_ms, 1, self._timer_cb)\r
-\r
- def _set_alert_rb_flash(self, cycles=2, period_ms=250):\r
- """REQ-ERR-01/03:红蓝快闪(约 2 次/秒),结束后回到 _apply_by_table。"""\r
- try:\r
- cycles = int(cycles or 2)\r
- except Exception:\r
- cycles = 2\r
- if cycles < 1:\r
- cycles = 1\r
- try:\r
- period_ms = int(period_ms or 250)\r
- except Exception:\r
- period_ms = 250\r
- if period_ms < 100:\r
- period_ms = 100\r
- self._mode = "alert_rb"\r
- self._st_alert = "rb_flash_2"\r
- self._alert_period_ms = period_ms\r
- self._alert_steps_left = cycles * 2\r
- self._alert_rb_phase = 0\r
- self._timer_stop()\r
- self._set_rgb(1, 0, 0)\r
- self._timer.start(self._alert_period_ms, 0, self._timer_cb)\r
-\r
- def _set_red_flash_limited(self, flashes=3, period_ms=500):\r
- """REQ-BAT-03:红快闪若干次后熄灭(约 2 次/秒)。"""\r
- try:\r
- flashes = int(flashes or 3)\r
- except Exception:\r
- flashes = 3\r
- if flashes < 1:\r
- flashes = 1\r
- try:\r
- period_ms = int(period_ms or 500)\r
- except Exception:\r
- period_ms = 500\r
- if period_ms < 100:\r
- period_ms = 100\r
- self._mode = "red_flash_n"\r
- self._red_flash_steps_left = flashes * 2\r
- self._alert_period_ms = period_ms\r
- self._blink_on = 1\r
- self._timer_stop()\r
- self._set_rgb(1, 0, 0)\r
- self._timer.start(self._alert_period_ms, 0, self._timer_cb)\r
-\r
- def _timer_cb(self, *args, **kwargs):\r
- EventMesh.publish("publish_AI_btnInfo", {"func": self._timer_cb_})\r
-\r
- def _timer_cb_(self):\r
- if self._mode == "green_blink":\r
- self._blink_on = 0 if self._blink_on else 1\r
- self._set_rgb(0, 1 if self._blink_on else 0, 0)\r
- next_ms = self._gb_on_ms if self._blink_on else self._gb_off_ms\r
- try:\r
- self._timer.start(next_ms, 0, self._timer_cb)\r
- except Exception:\r
- pass\r
- return\r
- if self._mode == "blue_blink":\r
- self._blink_on = 0 if self._blink_on else 1\r
- self._set_rgb(0, 0, 1 if self._blink_on else 0)\r
- try:\r
- self._timer.start(self._period_ms, 1, self._timer_cb)\r
- except Exception:\r
- pass\r
- return\r
- if self._mode == "red_blink":\r
- self._blink_on = 0 if self._blink_on else 1\r
- self._set_rgb(1 if self._blink_on else 0, 0, 0)\r
- return\r
- if self._mode == "red_flash_n":\r
- self._red_flash_steps_left -= 1\r
- if self._red_flash_steps_left <= 0:\r
- self._set_off()\r
- return\r
- self._blink_on = 0 if self._blink_on else 1\r
- self._set_rgb(1 if self._blink_on else 0, 0, 0)\r
- try:\r
- self._timer.start(self._alert_period_ms, 0, self._timer_cb)\r
- except Exception:\r
- pass\r
- return\r
- if self._mode == "bg_alt":\r
- if self._bg_phase == 0:\r
- self._set_rgb(0, 1, 0)\r
- self._bg_phase = 1\r
- else:\r
- self._set_rgb(0, 0, 1)\r
- self._bg_phase = 0\r
- return\r
- if self._mode == "alert_rb":\r
- self._alert_steps_left -= 1\r
- if self._alert_steps_left <= 0:\r
- self._st_alert = None\r
- try:\r
- self._apply_by_table()\r
- except Exception:\r
- self._set_off()\r
- return\r
- if self._alert_rb_phase == 0:\r
- self._set_rgb(0, 0, 1)\r
- self._alert_rb_phase = 1\r
- else:\r
- self._set_rgb(1, 0, 0)\r
- self._alert_rb_phase = 0\r
- try:\r
- self._timer.start(self._alert_period_ms, 0, self._timer_cb)\r
- except Exception:\r
- pass\r
- return\r
-\r
- def set_led_state(self, event=None, msg=None):\r
- # msg: dict {ai_state, charging, battery, signal, alert}\r
- try:\r
- if isinstance(msg, dict):\r
- if "alert" in msg:\r
- aval = msg.get("alert")\r
- if aval in ("rb_flash_2", "rb_flash", "rb_flash2"):\r
- self._set_alert_rb_flash(2, 250)\r
- return\r
- if aval in ("red_flash_3", "red_flash3"):\r
- try:\r
- n = 3\r
- ms = 500\r
- if "vc_config" in globals() and vc_config:\r
- n = int(vc_config.get_int("BATTERY_EMPTY_FLASH_COUNT", 3))\r
- ms = int(vc_config.get_int("BATTERY_EMPTY_FLASH_PERIOD_MS", 500))\r
- self._set_red_flash_limited(n, ms)\r
- except Exception:\r
- self._set_red_flash_limited(3, 500)\r
- return\r
- if aval in (None, "", "none", "clear"):\r
- self._st_alert = None\r
- if "ai_state" in msg:\r
- new_ai = msg.get("ai_state") or "idle"\r
- try:\r
- if EventMesh.publish("get_ptt_should_force_idle_led") == 1:\r
- if new_ai != "idle":\r
- if self._led_state_debug_enabled():\r
- print("[LED] coerce ai={} -> idle (ptt_stop_latch)".format(new_ai))\r
- new_ai = "idle"\r
- elif EventMesh.publish("get_vc_hold_listening_led") == 1:\r
- if new_ai != "listening":\r
- if self._led_state_debug_enabled():\r
- print("[LED] coerce ai={} -> listening (listen_hold)".format(new_ai))\r
- new_ai = "listening"\r
- except Exception:\r
- pass\r
- self._st_ai = new_ai\r
- if "charging" in msg:\r
- self._st_charging = msg.get("charging") or "none"\r
- if "battery" in msg:\r
- self._st_battery = msg.get("battery") or "normal"\r
- if "signal" in msg:\r
- self._st_signal = msg.get("signal") or "normal"\r
- if "prefer_off" in msg:\r
- self._prefer_off = 1 if msg.get("prefer_off") else 0\r
- except Exception:\r
- pass\r
- if self._mode in ("alert_rb", "red_flash_n"):\r
- return\r
- if self._led_state_debug_enabled() and isinstance(msg, dict):\r
- try:\r
- print("[LED] set_led_state in={}".format(msg))\r
- except Exception:\r
- pass\r
- self._apply_by_table(msg)\r
-\r
- def _led_state_debug_enabled(self):\r
- try:\r
- if "vc_config" in globals() and vc_config:\r
- return vc_config.get_bool("LED_STATE_DEBUG", True)\r
- except Exception:\r
- pass\r
- return True\r
-\r
- def _led_log(self, tag, extra=""):\r
- if not self._led_state_debug_enabled():\r
- return\r
- try:\r
- print("[LED] {} ai={} chg={} bat={} sig={} -> mode={} period_ms={} {}".format(\r
- tag, self._st_ai, self._st_charging, self._st_battery, self._st_signal,\r
- self._mode, self._period_ms, extra))\r
- except Exception:\r
- pass\r
-\r
- def _apply_by_table(self, _msg=None):\r
- if self._mode in ("alert_rb", "red_flash_n"):\r
- return\r
- _prev_mode = self._mode\r
- # P0:低电/空电(高于 AI 交互灯;充电中不显示,走充电灯态)\r
- try:\r
- if self._st_charging not in ("charging", "full"):\r
- if self._st_battery == "empty":\r
- try:\r
- ms = 500\r
- if "vc_config" in globals() and vc_config:\r
- ms = int(vc_config.get_int("BATTERY_EMPTY_FLASH_PERIOD_MS", 500))\r
- self._set_red_blink(ms)\r
- except Exception:\r
- self._set_red_blink(500)\r
- return\r
- if self._st_battery == "low":\r
- self._set_red_blink(1000)\r
- return\r
- except Exception:\r
- pass\r
- # P1~P3:AI 阶段(播放 > 思考 > 聆听)\r
- try:\r
- if self._st_ai == "playing":\r
- self._set_green_on()\r
- return\r
- if self._st_ai == "thinking":\r
- # 蓝绿「交替」:约 0.5 s 换一色(`period_ms` 为换色间隔)\r
- self._set_bg_alt(500)\r
- return\r
- if self._st_ai == "listening":\r
- # 长对话蓝慢闪(≈1s);单对话 PTT 蓝快闪(≈2次/s,REQ-AI-07)\r
- self._set_blue_blink(self._listening_blink_period_ms())\r
- return\r
- except Exception:\r
- pass\r
- # AI 交互中(聆听/思考/播放/流播)不让充电灯抢占;交互结束 idle 后恢复充电红/充满绿(REQ 冲突规避)\r
- _skip_charge_led = 0\r
- try:\r
- if self._st_ai in ("listening", "thinking", "playing"):\r
- _skip_charge_led = 1\r
- except Exception:\r
- pass\r
- if not _skip_charge_led:\r
- try:\r
- if EventMesh.publish("get_vc_stream_active") == 1:\r
- _skip_charge_led = 1\r
- except Exception:\r
- pass\r
- # 模式切换/提示音待机:ai=idle 时优先灭灯,勿被 charging=full 显示成「绿灯常亮」\r
- try:\r
- if self._st_ai == "idle" and getattr(self, "_prefer_off", 0):\r
- self._prefer_off = 0\r
- self._set_off()\r
- return\r
- except Exception:\r
- pass\r
- # 基础态:充电/电量/信号\r
- try:\r
- if not _skip_charge_led:\r
- if self._st_charging == "full":\r
- self._set_green_on()\r
- return\r
- if self._st_charging == "charging":\r
- self._set_red_on()\r
- return\r
- if self._st_signal == "weak":\r
- # 弱网:蓝绿「慢交替」,与 thinking 同节拍定义(约 1 s 换一色)\r
- self._set_bg_alt(1000)\r
- return\r
- except Exception:\r
- pass\r
- # 空闲待机:默认灭灯(REQ-BAT-01 / GAP-005 方案甲);LED_IDLE_MODE=green_blink 可恢复旧工程绿灯慢闪\r
- try:\r
- idle_mode = "off"\r
- if "vc_config" in globals() and vc_config:\r
- _im = vc_config.get_attr("LED_IDLE_MODE", None)\r
- if _im is not None:\r
- idle_mode = str(_im).strip().lower()\r
- if idle_mode in ("green_blink", "blink", "green"):\r
- idle_on = 1000\r
- if "vc_config" in globals() and vc_config:\r
- idle_on = int(vc_config.get_int("LED_IDLE_GREEN_BLINK_MS", 1000))\r
- idle_off = idle_on\r
- if "vc_config" in globals() and vc_config:\r
- _ioff = vc_config.get_attr("LED_IDLE_GREEN_BLINK_OFF_MS", None)\r
- if _ioff is not None:\r
- try:\r
- idle_off = int(_ioff)\r
- except Exception:\r
- idle_off = idle_on\r
- if idle_on < 400:\r
- idle_on = 400\r
- if idle_off < 400:\r
- idle_off = 400\r
- self._set_green_blink(idle_on, idle_off)\r
- else:\r
- self._set_off()\r
- except Exception:\r
- self._set_off()\r
- if self._mode != _prev_mode:\r
- self._led_log("apply_table", "in={}".format(_msg))\r
-\r
- def get_led_debug_state(self, event=None, msg=None):\r
- # 供按键/状态机打印当前 LED 聚合状态与最终模式\r
- try:\r
- return {\r
- "ai": self._st_ai,\r
- "charging": self._st_charging,\r
- "battery": self._st_battery,\r
- "signal": self._st_signal,\r
- "mode": self._mode,\r
- "period_ms": self._period_ms,\r
- }\r
- except Exception:\r
- return {"mode": getattr(self, "_mode", "?")}\r
-\r
+# -*- coding: utf-8 -*-
+"""三色 LED 状态机。"""
+from common import Abstract
+try:
+ from qp_log import qp_print as print
+except Exception:
+ pass
+import EventMesh
+import utime
+import osTimer
+from machine import Pin
+from vc_common import dev_type
+from vc_utils import cfg_bool, cfg_int, cfg_attr, cfg_led_gpio_tuple
+
+class AI_led(Abstract):
+ def __init__(self):
+ r_gpio, g_gpio, b_gpio = cfg_led_gpio_tuple((Pin.GPIO36, Pin.GPIO21, Pin.GPIO19))
+ self._led_gpio_r = r_gpio
+ self._led_gpio_g = g_gpio
+ self._led_gpio_b = b_gpio
+ self.led_red = Pin(r_gpio, Pin.OUT, Pin.PULL_PD, 0)
+ self.led_green = Pin(g_gpio, Pin.OUT, Pin.PULL_PD, 1)
+ self.led_blue = Pin(b_gpio, Pin.OUT, Pin.PULL_PD, 1)
+ print("AI_led GPIO dev_type={} red={} green={} blue={}".format(
+ dev_type, r_gpio, g_gpio, b_gpio))
+
+ # 统一输入状态(充电/电量/信号/AI对话),按优先级表输出
+ self._st_ai = "idle" # idle/listening/thinking/playing
+ self._st_charging = "none" # none/charging/full
+ self._st_battery = "normal" # normal/low/empty
+ self._st_signal = "normal" # normal/weak
+ self._st_alert = None # None / rb_flash_2(REQ-ERR-01/03)
+
+ self._timer = osTimer()
+ self._mode = "off" # off/red_on/green_on/green_blink/blue_blink/red_blink/bg_alt/alert_rb
+ self._alert_steps_left = 0
+ self._alert_rb_phase = 0
+ self._alert_period_ms = 250
+ self._blink_on = 0
+ self._bg_phase = 0
+ self._period_ms = 1000
+ self._gb_on_ms = 1000
+ self._gb_off_ms = 1000
+ self._prefer_off = 0
+
+ EventMesh.subscribe("set_led_state", self.set_led_state)
+ EventMesh.subscribe("get_led_debug_state", self.get_led_debug_state)
+ # LED 电平极性:有些板子是低电平点亮(active-low),也可能仅某一路反相
+ self._inv_r = 0
+ self._inv_g = 0
+ self._inv_b = 0
+ inv = cfg_attr("LED_ACTIVE_LOW_RGB", None)
+ if isinstance(inv, (tuple, list)) and len(inv) == 3:
+ self._inv_r = 1 if inv[0] else 0
+ self._inv_g = 1 if inv[1] else 0
+ self._inv_b = 1 if inv[2] else 0
+ else:
+ all_inv = 1 if cfg_bool("LED_ACTIVE_LOW", False) else 0
+ self._inv_r = all_inv
+ self._inv_g = all_inv
+ self._inv_b = all_inv
+ try:
+ self._apply_by_table()
+ except Exception:
+ self._set_off()
+
+ def _timer_stop(self):
+ try:
+ self._timer.stop()
+ except Exception:
+ pass
+
+ def _set_rgb(self, r, g, b):
+ try:
+ rr = 1 if r else 0
+ gg = 1 if g else 0
+ bb = 1 if b else 0
+ if self._inv_r:
+ rr = 0 if rr else 1
+ if self._inv_g:
+ gg = 0 if gg else 1
+ if self._inv_b:
+ bb = 0 if bb else 1
+ self.led_red.write(rr)
+ self.led_green.write(gg)
+ self.led_blue.write(bb)
+ except Exception:
+ pass
+
+ def _set_off(self):
+ self._mode = "off"
+ self._timer_stop()
+ self._set_rgb(0, 0, 0)
+
+ def _set_red_on(self):
+ self._mode = "red_on"
+ self._timer_stop()
+ self._set_rgb(1, 0, 0)
+
+ def _set_green_on(self):
+ self._mode = "green_on"
+ self._timer_stop()
+ self._set_rgb(0, 1, 0)
+
+ 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._gb_on_ms) == int(on_ms)
+ and int(self._gb_off_ms) == int(off_ms)):
+ return
+ except Exception:
+ pass
+ self._mode = "green_blink"
+ 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._gb_on_ms, 0, self._timer_cb)
+
+ def _listening_blink_period_ms(self):
+ """单对话 PTT 250ms 快闪;长对话 1000ms 慢闪。优先运行时 VC_mode。"""
+ try:
+ if EventMesh.publish("get_vc_mode") == 1:
+ return 250
+ except Exception:
+ pass
+ try:
+ if EventMesh.publish("get_storage_config", "VC_mode") == 1:
+ return 250
+ except Exception:
+ pass
+ return 1000
+
+ def _set_blue_blink(self, period_ms=1000):
+ period_ms = int(period_ms or 1000)
+ try:
+ if self._mode == "blue_blink" and int(self._period_ms) == period_ms:
+ return
+ except Exception:
+ pass
+ self._mode = "blue_blink"
+ self._period_ms = period_ms
+ self._blink_on = 1
+ self._timer_stop()
+ self._set_rgb(0, 0, 1)
+ self._timer.start(self._period_ms, 1, self._timer_cb)
+
+ def _set_red_blink(self, period_ms=1000):
+ self._mode = "red_blink"
+ self._period_ms = period_ms or 1000
+ self._blink_on = 1
+ self._timer_stop()
+ self._set_rgb(1, 0, 0)
+ self._timer.start(self._period_ms, 1, self._timer_cb)
+
+ def _set_bg_alt(self, period_ms=1000):
+ self._mode = "bg_alt"
+ self._period_ms = period_ms or 1000
+ self._bg_phase = 0
+ self._timer_stop()
+ self._set_rgb(0, 0, 1)
+ self._timer.start(self._period_ms, 1, self._timer_cb)
+
+ def _set_alert_rb_flash(self, cycles=2, period_ms=250):
+ """REQ-ERR-01/03:红蓝快闪(约 2 次/秒),结束后回到 _apply_by_table。"""
+ try:
+ cycles = int(cycles or 2)
+ except Exception:
+ cycles = 2
+ if cycles < 1:
+ cycles = 1
+ try:
+ period_ms = int(period_ms or 250)
+ except Exception:
+ period_ms = 250
+ if period_ms < 100:
+ period_ms = 100
+ self._mode = "alert_rb"
+ self._st_alert = "rb_flash_2"
+ self._alert_period_ms = period_ms
+ self._alert_steps_left = cycles * 2
+ self._alert_rb_phase = 0
+ self._timer_stop()
+ self._set_rgb(1, 0, 0)
+ self._timer.start(self._alert_period_ms, 0, self._timer_cb)
+
+ def _set_red_flash_limited(self, flashes=3, period_ms=500):
+ """REQ-BAT-03:红快闪若干次后熄灭(约 2 次/秒)。"""
+ try:
+ flashes = int(flashes or 3)
+ except Exception:
+ flashes = 3
+ if flashes < 1:
+ flashes = 1
+ try:
+ period_ms = int(period_ms or 500)
+ except Exception:
+ period_ms = 500
+ if period_ms < 100:
+ period_ms = 100
+ self._mode = "red_flash_n"
+ self._red_flash_steps_left = flashes * 2
+ self._alert_period_ms = period_ms
+ self._blink_on = 1
+ self._timer_stop()
+ self._set_rgb(1, 0, 0)
+ self._timer.start(self._alert_period_ms, 0, self._timer_cb)
+
+ def _timer_cb(self, *args, **kwargs):
+ EventMesh.publish("publish_AI_btnInfo", {"func": self._timer_cb_})
+
+ def _timer_cb_(self):
+ 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
+ self._set_rgb(0, 0, 1 if self._blink_on else 0)
+ try:
+ self._timer.start(self._period_ms, 1, self._timer_cb)
+ except Exception:
+ pass
+ return
+ if self._mode == "red_blink":
+ self._blink_on = 0 if self._blink_on else 1
+ self._set_rgb(1 if self._blink_on else 0, 0, 0)
+ return
+ if self._mode == "red_flash_n":
+ self._red_flash_steps_left -= 1
+ if self._red_flash_steps_left <= 0:
+ self._set_off()
+ return
+ self._blink_on = 0 if self._blink_on else 1
+ self._set_rgb(1 if self._blink_on else 0, 0, 0)
+ try:
+ self._timer.start(self._alert_period_ms, 0, self._timer_cb)
+ except Exception:
+ pass
+ return
+ if self._mode == "bg_alt":
+ if self._bg_phase == 0:
+ self._set_rgb(0, 1, 0)
+ self._bg_phase = 1
+ else:
+ self._set_rgb(0, 0, 1)
+ self._bg_phase = 0
+ return
+ if self._mode == "alert_rb":
+ self._alert_steps_left -= 1
+ if self._alert_steps_left <= 0:
+ self._st_alert = None
+ try:
+ self._apply_by_table()
+ except Exception:
+ self._set_off()
+ return
+ if self._alert_rb_phase == 0:
+ self._set_rgb(0, 0, 1)
+ self._alert_rb_phase = 1
+ else:
+ self._set_rgb(1, 0, 0)
+ self._alert_rb_phase = 0
+ try:
+ self._timer.start(self._alert_period_ms, 0, self._timer_cb)
+ except Exception:
+ pass
+ return
+
+ def set_led_state(self, event=None, msg=None):
+ # msg: dict {ai_state, charging, battery, signal, alert}
+ try:
+ if isinstance(msg, dict):
+ if "alert" in msg:
+ aval = msg.get("alert")
+ if aval in ("rb_flash_2", "rb_flash", "rb_flash2"):
+ self._set_alert_rb_flash(2, 250)
+ return
+ if aval in ("red_flash_3", "red_flash3"):
+ try:
+ n = cfg_int("BATTERY_EMPTY_FLASH_COUNT", 3)
+ ms = cfg_int("BATTERY_EMPTY_FLASH_PERIOD_MS", 500)
+ self._set_red_flash_limited(n, ms)
+ except Exception:
+ self._set_red_flash_limited(3, 500)
+ return
+ if aval in (None, "", "none", "clear"):
+ self._st_alert = None
+ if "ai_state" in msg:
+ new_ai = msg.get("ai_state") or "idle"
+ if EventMesh.publish("get_ptt_should_force_idle_led") == 1:
+ if new_ai != "idle":
+ if self._led_state_debug_enabled():
+ print("[LED] coerce ai={} -> idle (ptt_stop_latch)".format(new_ai))
+ new_ai = "idle"
+ elif EventMesh.publish("get_vc_hold_listening_led") == 1:
+ if new_ai != "listening":
+ if self._led_state_debug_enabled():
+ print("[LED] coerce ai={} -> listening (listen_hold)".format(new_ai))
+ new_ai = "listening"
+ self._st_ai = new_ai
+ if "charging" in msg:
+ self._st_charging = msg.get("charging") or "none"
+ if "battery" in msg:
+ self._st_battery = msg.get("battery") or "normal"
+ if "signal" in msg:
+ self._st_signal = msg.get("signal") or "normal"
+ if "prefer_off" in msg:
+ self._prefer_off = 1 if msg.get("prefer_off") else 0
+ except Exception:
+ pass
+ if self._mode in ("alert_rb", "red_flash_n"):
+ return
+ if self._led_state_debug_enabled() and isinstance(msg, dict):
+ print("[LED] set_led_state in={}".format(msg))
+ self._apply_by_table(msg)
+
+ def _led_state_debug_enabled(self):
+ return cfg_bool("LED_STATE_DEBUG", True)
+
+ def _led_log(self, tag, extra=""):
+ if not self._led_state_debug_enabled():
+ return
+ print("[LED] {} ai={} chg={} bat={} sig={} -> mode={} period_ms={} {}".format(
+ tag, self._st_ai, self._st_charging, self._st_battery, self._st_signal,
+ self._mode, self._period_ms, extra))
+
+ def _apply_by_table(self, _msg=None):
+ if self._mode in ("alert_rb", "red_flash_n"):
+ return
+ _prev_mode = self._mode
+ # P0:低电/空电(高于 AI 交互灯;充电中不显示,走充电灯态)
+ try:
+ if self._st_charging not in ("charging", "full"):
+ if self._st_battery == "empty":
+ ms = cfg_int("BATTERY_EMPTY_FLASH_PERIOD_MS", 500)
+ self._set_red_blink(ms)
+ return
+ if self._st_battery == "low":
+ self._set_red_blink(1000)
+ return
+ except Exception:
+ pass
+ # P1~P3:AI 阶段(播放 > 思考 > 聆听)
+ try:
+ if self._st_ai == "playing":
+ self._set_green_on()
+ return
+ if self._st_ai == "thinking":
+ # 蓝绿「交替」:约 0.5 s 换一色(`period_ms` 为换色间隔)
+ self._set_bg_alt(500)
+ return
+ if self._st_ai == "listening":
+ # 长对话蓝慢闪(≈1s);单对话 PTT 蓝快闪(≈2次/s,REQ-AI-07)
+ self._set_blue_blink(self._listening_blink_period_ms())
+ return
+ except Exception:
+ pass
+ # AI 交互中(聆听/思考/播放/流播)不让充电灯抢占;交互结束 idle 后恢复充电红/充满绿(REQ 冲突规避)
+ _skip_charge_led = 0
+ try:
+ if self._st_ai in ("listening", "thinking", "playing"):
+ _skip_charge_led = 1
+ except Exception:
+ pass
+ if not _skip_charge_led:
+ try:
+ if EventMesh.publish("get_vc_stream_active") == 1:
+ _skip_charge_led = 1
+ except Exception:
+ pass
+ # 模式切换/提示音待机:ai=idle 时优先灭灯,勿被 charging=full 显示成「绿灯常亮」
+ try:
+ if self._st_ai == "idle" and getattr(self, "_prefer_off", 0):
+ self._prefer_off = 0
+ self._set_off()
+ return
+ except Exception:
+ pass
+ # 基础态:充电/电量/信号
+ try:
+ if not _skip_charge_led:
+ if self._st_charging == "full":
+ self._set_green_on()
+ return
+ if self._st_charging == "charging":
+ self._set_red_on()
+ return
+ if self._st_signal == "weak":
+ # 弱网:蓝绿「慢交替」,与 thinking 同节拍定义(约 1 s 换一色)
+ self._set_bg_alt(1000)
+ return
+ except Exception:
+ pass
+ # 空闲待机:默认灭灯(REQ-BAT-01 / GAP-005 方案甲);LED_IDLE_MODE=green_blink 可恢复旧工程绿灯慢闪
+ try:
+ idle_mode = "off"
+ _im = cfg_attr("LED_IDLE_MODE", None)
+ if _im is not None:
+ idle_mode = str(_im).strip().lower()
+ if idle_mode in ("green_blink", "blink", "green"):
+ idle_on = cfg_int("LED_IDLE_GREEN_BLINK_MS", 1000)
+ idle_off = idle_on
+ _ioff = cfg_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)
+ else:
+ self._set_off()
+ except Exception:
+ self._set_off()
+ if self._mode != _prev_mode:
+ self._led_log("apply_table", "in={}".format(_msg))
+
+ def get_led_debug_state(self, event=None, msg=None):
+ # 供按键/状态机打印当前 LED 聚合状态与最终模式
+ try:
+ return {
+ "ai": self._st_ai,
+ "charging": self._st_charging,
+ "battery": self._st_battery,
+ "signal": self._st_signal,
+ "mode": self._mode,
+ "period_ms": self._period_ms,
+ }
+ except Exception:
+ return {"mode": getattr(self, "_mode", "?")}
+
class MediaArbiter(object):\r
@staticmethod\r
def llm_active(vc):\r
- try:\r
+ if hasattr(vc, "_vc_tts_playback_active"):\r
return vc._vc_tts_playback_active()\r
- except Exception:\r
- return False\r
+ return False\r
\r
@staticmethod\r
def before_local(vc):\r
"""local 播:仅打断 llm_pcm;不停录、不断 notify WS。"""\r
+ if not MediaArbiter.llm_active(vc):\r
+ return\r
try:\r
- if MediaArbiter.llm_active(vc):\r
- try:\r
- vc._ptt_hard_mute_local_playback()\r
- except Exception:\r
- pass\r
- try:\r
- vc.VC_Play_End()\r
- except Exception:\r
- pass\r
+ vc._ptt_hard_mute_local_playback()\r
+ vc.VC_Play_End()\r
except Exception:\r
pass\r
\r
@staticmethod\r
def before_notify(vc):\r
"""notify TTS:关 llm_pcm + local(设计稿;会话接管仍由 play_tts_cb 建链)。"""\r
- try:\r
- MediaArbiter.before_local(vc)\r
- if getattr(vc, "_vc_local_play_busy", None) and vc._vc_local_play_busy():\r
- try:\r
- vc.aud.stopAll()\r
- except Exception:\r
- pass\r
- if hasattr(vc, "_vc_stop_downlink_for_interrupt"):\r
- vc._vc_stop_downlink_for_interrupt("notify")\r
- except Exception:\r
- pass\r
+ MediaArbiter.before_local(vc)\r
+ if getattr(vc, "_vc_local_play_busy", None) and vc._vc_local_play_busy():\r
+ try:\r
+ vc.aud.stopAll()\r
+ except Exception:\r
+ pass\r
+ if hasattr(vc, "_vc_stop_downlink_for_interrupt"):\r
+ vc._vc_stop_downlink_for_interrupt("notify")\r
\r
@staticmethod\r
def before_llm_pcm(vc):\r
"""llm 下行:停 local 短音;notify 走 defer 队列。"""\r
- try:\r
- if getattr(vc, "_vc_local_play_busy", None) and vc._vc_local_play_busy():\r
- try:\r
- vc.aud.stopAll()\r
- except Exception:\r
- pass\r
- except Exception:\r
- pass\r
+ if getattr(vc, "_vc_local_play_busy", None) and vc._vc_local_play_busy():\r
+ try:\r
+ vc.aud.stopAll()\r
+ except Exception:\r
+ pass\r
\r
@staticmethod\r
def montage_allowed(vc):\r
"""llm 播时缓存/跳过 montage(vc_buttons 已有类似逻辑,集中判断)。"""\r
if MediaArbiter.llm_active(vc):\r
return False\r
- try:\r
- if EventMesh and EventMesh.publish("get_vc_tts_playback_active") == 1:\r
- return False\r
- except Exception:\r
- pass\r
+ if EventMesh and EventMesh.publish("get_vc_tts_playback_active") == 1:\r
+ return False\r
return True\r
vc.Close()\r
EventMesh.publish("start_voice_record", 4)\r
vc.AI_key_long_press_flag = 1\r
- try:\r
- vc._ptt_idle_latch = 0\r
- vc._ptt_short_press_stop = 0\r
- except Exception:\r
- pass\r
+ vc._ptt_idle_latch = 0\r
+ vc._ptt_short_press_stop = 0\r
vc._vc_enqueue_btn(vc.ptt_begin, priority=1)\r
return True\r
\r
\r
def strategy_for_mode(vc_mode):\r
- try:\r
- if int(vc_mode) == 1:\r
- return PTTStrategy()\r
- except Exception:\r
- pass\r
+ if int(vc_mode) == 1:\r
+ return PTTStrategy()\r
return LongDialogueStrategy()\r
from vc_fsm import VCTurnState\r
except Exception:\r
VCTurnState = None\r
-try:\r
- import vc_config\r
-except Exception:\r
- vc_config = None\r
+\r
+import EventMesh\r
+from vc_utils import cfg_bool\r
\r
# play_tts 通道\r
CHANNEL_TAKEOVER = "takeover" # 断连重连 WS synthesis(IoT 查找设备/模式切换/无对话)\r
\r
def dialog_session_active(vc):\r
"""对话占用中:通知类 play_tts 应 defer。"""\r
- try:\r
- if getattr(vc, "Close_flag", 0) == 1:\r
- return False\r
- if getattr(vc, "VC_satrt_flag", 0) != 1:\r
- return False\r
- if getattr(vc, "AI_client_VC_isconnect", 0) != 1:\r
- return False\r
- if getattr(vc, "VC_Play_flag", 0) == 1:\r
- return True\r
- if getattr(vc, "VC_record_state_flag", 0) != 0:\r
+ if getattr(vc, "Close_flag", 0) == 1:\r
+ return False\r
+ if getattr(vc, "VC_satrt_flag", 0) != 1:\r
+ return False\r
+ if getattr(vc, "AI_client_VC_isconnect", 0) != 1:\r
+ return False\r
+ if getattr(vc, "VC_Play_flag", 0) == 1:\r
+ return True\r
+ if getattr(vc, "VC_record_state_flag", 0) != 0:\r
+ return True\r
+ if getattr(vc, "music_play_flag", 0) == 1:\r
+ return True\r
+ if VCTurnState is not None and getattr(vc, "fsm", None) is not None:\r
+ t = getattr(vc.fsm, "turn", VCTurnState.Idle)\r
+ if t not in (VCTurnState.Idle, VCTurnState.Listening):\r
return True\r
- # 7PIN_1_5 无闹钟业务;alarm_play_flag 仅 legacy(如 play_single_voice)\r
- if getattr(vc, "music_play_flag", 0) == 1:\r
- return True\r
- if VCTurnState is not None and getattr(vc, "fsm", None) is not None:\r
- t = getattr(vc.fsm, "turn", VCTurnState.Idle)\r
- if t not in (VCTurnState.Idle, VCTurnState.Listening):\r
- return True\r
- except Exception:\r
- pass\r
return False\r
\r
\r
class NotifyScheduler(object):\r
@staticmethod\r
def classify_play_tts(vc, is_close_vc):\r
- try:\r
- if is_close_vc:\r
- return CHANNEL_TAKEOVER\r
- except Exception:\r
- pass\r
- try:\r
- k = getattr(vc, "_pending_tts_kind", "") or getattr(vc, "_last_tts_kind", "") or ""\r
- if k in _TAKEOVER_KINDS:\r
- return CHANNEL_TAKEOVER\r
- except Exception:\r
- pass\r
+ if is_close_vc:\r
+ return CHANNEL_TAKEOVER\r
+ k = getattr(vc, "_pending_tts_kind", "") or getattr(vc, "_last_tts_kind", "") or ""\r
+ if k in _TAKEOVER_KINDS:\r
+ return CHANNEL_TAKEOVER\r
if dialog_session_active(vc):\r
return CHANNEL_DEFER\r
return CHANNEL_TAKEOVER\r
def plan_on_started(vc, skip_long_uplink=0):\r
"""替代 vc_session_io started 内 if-elif 媒体分支。"""\r
plan = []\r
- try:\r
- import EventMesh\r
- except Exception:\r
- EventMesh = None\r
\r
- # 长对话:started 补开麦(原 597-623,与媒体队列正交)\r
- try:\r
- if (\r
- not skip_long_uplink\r
- and getattr(vc, "VC_mode", 0) == 0\r
- and getattr(vc, "Close_flag", 0) == 0\r
- and not getattr(vc, "_vc_boot_standby", 0)\r
- ):\r
- plan.append({"op": OP_LONG_UPLINK})\r
- except Exception:\r
- pass\r
+ if (\r
+ not skip_long_uplink\r
+ and getattr(vc, "VC_mode", 0) == 0\r
+ and getattr(vc, "Close_flag", 0) == 0\r
+ and not getattr(vc, "_vc_boot_standby", 0)\r
+ ):\r
+ plan.append({"op": OP_LONG_UPLINK})\r
\r
tts = getattr(vc, "AI_TTS_str", "") or ""\r
url = getattr(vc, "AI_new_voice_url", "") or ""\r
alarm = getattr(vc, "alarm_play_flag", 0) == 1\r
music = getattr(vc, "music_play_flag", 0) == 1\r
\r
- # 闹钟铃声(其它机型);7PIN_1_5 无闹钟,alarm_play_flag 通常为 0\r
if url and alarm:\r
plan.append({"op": OP_ALARM_VOICE})\r
elif not tts and url and not music:\r
elif tts and not url:\r
plan.append({"op": OP_SYNTHESIS})\r
elif tts and url and not music:\r
- try:\r
- his = EventMesh.publish("get_history_voice_flag") == 1 if EventMesh else False\r
- except Exception:\r
- his = False\r
+ his = EventMesh.publish("get_history_voice_flag") == 1\r
if his:\r
- try:\r
- wait = EventMesh.publish("get_wait_voice_flag") == 0 if EventMesh else True\r
- except Exception:\r
- wait = True\r
+ wait = EventMesh.publish("get_wait_voice_flag") == 0\r
if wait:\r
plan.append({"op": OP_SYNTHESIS_HIS_TIMER})\r
else:\r
- try:\r
- notice = getattr(vc, "pwk_notice_flag", 0) == 0\r
- except Exception:\r
- notice = True\r
+ notice = getattr(vc, "pwk_notice_flag", 0) == 0\r
if notice:\r
plan.append({"op": OP_SYNTHESIS_WAIT_TIMER})\r
else:\r
elif tts and url and music:\r
plan.append({"op": OP_SYNTHESIS_MUSIC_TIMER})\r
else:\r
- try:\r
- if "vc_config" in globals() and vc_config and vc_config.get_bool(\r
- "UPLOAD_START_TONE_ENABLED", False\r
- ):\r
- plan.append({"op": OP_UPLOAD_TONE})\r
- except Exception:\r
- pass\r
- try:\r
- if getattr(vc, "VC_mode", 0) == 0:\r
- plan.append({"op": OP_IDLE_UPLINK})\r
- else:\r
- plan.append({"op": OP_PTT_ROUND})\r
- except Exception:\r
+ if cfg_bool("UPLOAD_START_TONE_ENABLED", False):\r
+ plan.append({"op": OP_UPLOAD_TONE})\r
+ if getattr(vc, "VC_mode", 0) == 0:\r
plan.append({"op": OP_IDLE_UPLINK})\r
+ else:\r
+ plan.append({"op": OP_PTT_ROUND})\r
+\r
return plan\r
import constants\r
import version_util\r
from misc import Power\r
+import _thread\r
\r
def _build_ota_task_url(source_version):\r
"""OTA 检查任务 URL:default_srv.OTA_TASK_URL_FMT,否则 DMP_BASE + /ota/task。"""\r
print("OTA升级请求:{}".format(data))\r
\r
if data:\r
- try:\r
- if data["code"] == 20007:#有新版本\r
- if data["data"]["targetVersion"] != bt_versions and "fileList"in data["data"]:\r
- #if len(data["data"]["fileList"]) == 2:\r
- for fileList in data["data"]["fileList"]:\r
- \r
- if fileList["fileName"] == "update.ufw":\r
- self.BT_ota_size = fileList["size"]\r
- self.downloadFileVoURLBT = fileList["url"]\r
- if data["code"] == 20006:#已是最新版本\r
- ret_str = 0\r
- \r
- except Exception as e:\r
- usys.print_exception(e)\r
+ code = data.get("code")\r
+ if code == 20007:\r
+ file_list = (data.get("data") or {}).get("fileList")\r
+ if file_list and data.get("data", {}).get("targetVersion") != bt_versions:\r
+ for fileList in file_list:\r
+ if fileList.get("fileName") == "update.ufw":\r
+ self.BT_ota_size = fileList.get("size", 0)\r
+ self.downloadFileVoURLBT = fileList.get("url", "")\r
+ elif code == 20006:\r
+ ret_str = 0\r
else:\r
print("bt_ota get error")\r
response.close()\r
print("OTA升级请求:{}".format(data))\r
\r
if data:\r
- try:\r
- if data["code"] == 20007:#有新版本\r
- if "fileList"in data["data"]:\r
- #if len(data["data"]["fileList"]) == 2:\r
- for fileList in data["data"]["fileList"]:\r
- if fileList["fileName"] == "dfota_2.bin":\r
- self.downloadFileVoURL2 = fileList["url"]\r
- elif fileList["fileName"] == "dfota_1.bin":\r
- self.downloadFileVoURL1 = fileList["url"]\r
- elif fileList["fileName"] == "update.ufw":\r
- self.BT_ota_size = fileList["size"]\r
- self.downloadFileVoURLBT = fileList["url"]\r
- if data["code"] == 20006:#已是最新版本\r
- ret_str = 0\r
- \r
- except Exception as e:\r
- usys.print_exception(e)\r
+ code = data.get("code")\r
+ if code == 20007:\r
+ file_list = (data.get("data") or {}).get("fileList")\r
+ if file_list:\r
+ for fileList in file_list:\r
+ name = fileList.get("fileName")\r
+ url = fileList.get("url", "")\r
+ if name == "dfota_2.bin":\r
+ self.downloadFileVoURL2 = url\r
+ elif name == "dfota_1.bin":\r
+ self.downloadFileVoURL1 = url\r
+ elif name == "update.ufw":\r
+ self.BT_ota_size = fileList.get("size", 0)\r
+ self.downloadFileVoURLBT = url\r
+ elif code == 20006:\r
+ ret_str = 0\r
else:\r
print("min_sys_ota get error")\r
response.close()\r
# -*- coding: utf-8 -*-\r
"""VC 叠加态:模式切换等短时覆盖 FSM 的按键屏蔽(兼容 _vc_ms_phase)。"""\r
+import utime\r
\r
OVERLAY_IDLE = 0\r
OVERLAY_MODE_SWITCH_PREP = 1\r
\r
\r
def overlay_from_vc(vc):\r
- try:\r
- return int(getattr(vc, "_vc_overlay", getattr(vc, "_vc_ms_phase", 0)) or 0)\r
- except Exception:\r
- return OVERLAY_IDLE\r
+ return int(getattr(vc, "_vc_overlay", getattr(vc, "_vc_ms_phase", 0)) or 0)\r
\r
\r
def overlay_set(vc, state):\r
- try:\r
- vc._vc_overlay = int(state or 0)\r
- vc._vc_ms_phase = vc._vc_overlay\r
- except Exception:\r
- pass\r
+ vc._vc_overlay = int(state or 0)\r
+ vc._vc_ms_phase = vc._vc_overlay\r
\r
\r
def overlay_keys_blocked(vc, tag=""):\r
"""模式切换 PREP/PLAYING/CLOSE 期间屏蔽 AI/电源短按(单入口)。"""\r
- try:\r
- phase = overlay_from_vc(vc)\r
- if phase in (\r
- OVERLAY_MODE_SWITCH_PREP,\r
- OVERLAY_MODE_SWITCH_PLAYING,\r
- OVERLAY_MODE_SWITCH_CLOSING,\r
- ):\r
- try:\r
- print("[VC][overlay] key blocked phase={} tag={}".format(phase, tag))\r
- except Exception:\r
- pass\r
- return True\r
- if getattr(vc, "_vc_ms_close_pending", 0) == 1:\r
- try:\r
- print("[VC][overlay] key blocked close_pending tag={}".format(tag))\r
- except Exception:\r
- pass\r
- return True\r
- until = int(getattr(vc, "_vc_ms_key_block_until_ms", 0) or 0)\r
- if until:\r
- try:\r
- import utime\r
- if utime.ticks_diff(until, utime.ticks_ms()) > 0:\r
- try:\r
- print("[VC][overlay] key blocked cooldown tag={}".format(tag))\r
- except Exception:\r
- pass\r
- return True\r
- except Exception:\r
- pass\r
- except Exception:\r
- pass\r
+ phase = overlay_from_vc(vc)\r
+ if phase in (\r
+ OVERLAY_MODE_SWITCH_PREP,\r
+ OVERLAY_MODE_SWITCH_PLAYING,\r
+ OVERLAY_MODE_SWITCH_CLOSING,\r
+ ):\r
+ print("[VC][overlay] key blocked phase={} tag={}".format(phase, tag))\r
+ return True\r
+ if getattr(vc, "_vc_ms_close_pending", 0) == 1:\r
+ print("[VC][overlay] key blocked close_pending tag={}".format(tag))\r
+ return True\r
+ until = int(getattr(vc, "_vc_ms_key_block_until_ms", 0) or 0)\r
+ if until and utime.ticks_diff(until, utime.ticks_ms()) > 0:\r
+ print("[VC][overlay] key blocked cooldown tag={}".format(tag))\r
+ return True\r
return False\r
def build_present_state(vc):\r
"""只读聚合,不写 vc。"""\r
st = {\r
- "mode": 0,\r
- "turn": -1,\r
+ "mode": int(getattr(vc, "VC_mode", 0)),\r
+ "turn": int(getattr(getattr(vc, "fsm", None), "turn", -1)),\r
"force_idle": 0,\r
"hold_listening": 0,\r
"prefer_off": 0,\r
"override_ai": None,\r
"override_prefer_off": 0,\r
}\r
- try:\r
- st["mode"] = int(getattr(vc, "VC_mode", 0))\r
- except Exception:\r
- pass\r
- try:\r
- st["turn"] = int(getattr(getattr(vc, "fsm", None), "turn", -1))\r
- except Exception:\r
- pass\r
- try:\r
- ov = getattr(vc, "_led_override", None)\r
- if ov and isinstance(ov, (tuple, list)) and len(ov) >= 1:\r
- st["override_ai"] = ov[0]\r
- st["override_prefer_off"] = 1 if (len(ov) > 1 and ov[1]) else 0\r
- except Exception:\r
- pass\r
- try:\r
- if hasattr(vc, "_ptt_should_force_idle_led") and vc._ptt_should_force_idle_led():\r
- st["force_idle"] = 1\r
- except Exception:\r
- pass\r
- try:\r
- if hasattr(vc, "_vc_should_hold_listening_led") and vc._vc_should_hold_listening_led():\r
- st["hold_listening"] = 1\r
- except Exception:\r
- pass\r
- try:\r
- if hasattr(vc, "_vc_led_should_standby_idle") and vc._vc_led_should_standby_idle():\r
- st["force_idle"] = 1\r
- if hasattr(vc, "_vc_led_standby_prefer_off") and vc._vc_led_standby_prefer_off():\r
- st["prefer_off"] = 1\r
- except Exception:\r
- pass\r
- try:\r
- if hasattr(vc, "_vc_tts_playback_active") and vc._vc_tts_playback_active():\r
- st["stream_active"] = 1\r
- except Exception:\r
- pass\r
- try:\r
- st["ptt_await_server"] = 1 if getattr(vc, "_ptt_await_server", 0) else 0\r
- except Exception:\r
- pass\r
+ ov = getattr(vc, "_led_override", None)\r
+ if ov and isinstance(ov, (tuple, list)) and len(ov) >= 1:\r
+ st["override_ai"] = ov[0]\r
+ st["override_prefer_off"] = 1 if (len(ov) > 1 and ov[1]) else 0\r
+ if hasattr(vc, "_ptt_should_force_idle_led") and vc._ptt_should_force_idle_led():\r
+ st["force_idle"] = 1\r
+ if hasattr(vc, "_vc_should_hold_listening_led") and vc._vc_should_hold_listening_led():\r
+ st["hold_listening"] = 1\r
+ if hasattr(vc, "_vc_led_should_standby_idle") and vc._vc_led_should_standby_idle():\r
+ st["force_idle"] = 1\r
+ if hasattr(vc, "_vc_led_standby_prefer_off") and vc._vc_led_standby_prefer_off():\r
+ st["prefer_off"] = 1\r
+ if hasattr(vc, "_vc_tts_playback_active") and vc._vc_tts_playback_active():\r
+ st["stream_active"] = 1\r
+ st["ptt_await_server"] = 1 if getattr(vc, "_ptt_await_server", 0) else 0\r
return st\r
\r
\r
if present.get("stream_active"):\r
return {"ai_state": "playing"}\r
if derive_ux_state is not None:\r
- try:\r
- ux = derive_ux_state(vc)\r
- if ux == UX_RECORDING:\r
- return {"ai_state": "listening"}\r
- if ux == UX_TTS:\r
- return {"ai_state": "playing"}\r
- if ux == UX_THINKING:\r
- return {"ai_state": "thinking"}\r
- except Exception:\r
- pass\r
+ ux = derive_ux_state(vc)\r
+ if ux == UX_RECORDING:\r
+ return {"ai_state": "listening"}\r
+ if ux == UX_TTS:\r
+ return {"ai_state": "playing"}\r
+ if ux == UX_THINKING:\r
+ return {"ai_state": "thinking"}\r
msg = {"ai_state": "idle"}\r
if present.get("prefer_off"):\r
msg["prefer_off"] = 1\r
"""VC WebSocket 协议适配:V2.5(金三)与 V3(RVC)可配置切换。"""
import ujson
+from vc_utils import cfg_attr, cfg_int, cfg_bool
+
PROTO_V25 = "v2.5"
PROTO_V3 = "v3"
}
-def _cfg(name, default=None):
- try:
- import vc_config
- return vc_config.get_attr(name, default)
- except Exception:
- return default
-
-
def get_protocol_version():
- v = _cfg("VC_PROTOCOL_VERSION", PROTO_V25)
+ v = cfg_attr("VC_PROTOCOL_VERSION", PROTO_V25)
if v is None:
return PROTO_V25
- try:
- v = str(v).lower().strip()
- except Exception:
- return PROTO_V25
+ v = str(v).lower().strip()
if v in ("v3", "3", "rvc", "rvc_v3"):
return PROTO_V3
return PROTO_V25
"""V2.5:允许设备发 WebSocket 文本帧 \"ping\";V3:无自定义心跳。"""
if is_v3():
return False
- try:
- return int(_cfg("VC_WS_PING_INTERVAL_SEC", 55)) > 0
- except Exception:
- return True
+ return cfg_int("VC_WS_PING_INTERVAL_SEC", 55) > 0
def vc_proto_audio_played_enabled():
default = 0 if is_v3() else 1
- try:
- return bool(_cfg("VC_AUDIO_PLAYED_ACK", default))
- except Exception:
- return bool(default)
+ return cfg_bool("VC_AUDIO_PLAYED_ACK", default)
def vc_proto_build_ws_url(amp_server, path, is_auth, token=None, device_id=None):
"""拼 VC WebSocket URL(无 ws:// 前缀)。"""
path = path or "vc/chat"
- auth_mode = _cfg("VC_WS_AUTH_MODE", "dmp_dt")
- try:
- auth_mode = str(auth_mode or "dmp_dt").lower().strip()
- except Exception:
- auth_mode = "dmp_dt"
+ auth_mode = str(cfg_attr("VC_WS_AUTH_MODE", "dmp_dt") or "dmp_dt").lower().strip()
if is_v3():
if auth_mode == "api_key":
- key = token or _cfg("VC_API_KEY", "") or ""
+ key = token or cfg_attr("VC_API_KEY", "") or ""
did = device_id or ""
if key and did:
return "ws://{}/{}?api_key={}&device_id={}".format(
greeting = g
enabled = False
message = ""
- try:
- if greeting.get("enabled"):
- enabled = True
- message = greeting.get("content") or ""
- except Exception:
- pass
- cfg_val = _cfg("VC_WELCOME_SERVER_ENABLED", None)
+ if greeting.get("enabled"):
+ enabled = True
+ message = greeting.get("content") or ""
+ cfg_val = cfg_attr("VC_WELCOME_SERVER_ENABLED", None)
if cfg_val is not None:
try:
enabled = bool(int(cfg_val))
except Exception:
enabled = bool(cfg_val)
if enabled:
- message = _cfg("VC_WELCOME_SERVER_MESSAGE", message) or message
+ message = cfg_attr("VC_WELCOME_SERVER_MESSAGE", message) or message
en = bool(enabled)
msg = message if en else ""
# 同时带 enabled/message(与 audio_encryption.enabled 命名一致)及 started 回包字段名
},
}
- agent_id = _cfg("VC_AGENT_ID", None)
+ agent_id = cfg_attr("VC_AGENT_ID", None)
if agent_id is None or agent_id == "":
- agent_id = bot.get("bot_id") or _cfg("VC_BOT_ID", "")
+ agent_id = bot.get("bot_id") or cfg_attr("VC_BOT_ID", "")
if agent_id:
data["agent_id"] = agent_id
if meta:
data["metadata"] = meta
- enc = _cfg("VC_AUDIO_ENCRYPTION", 0)
+ enc = cfg_int("VC_AUDIO_ENCRYPTION", 0)
try:
if int(enc):
data["audio_encryption"] = {"enabled": True}
def _proto_tx_log_enabled():
- try:
- import vc_config
- if vc_config:
- v = vc_config.get_attr("VC_PROTO_TX_LOG", None)
- if v is not None:
- return bool(v)
- except Exception:
- pass
+ v = cfg_attr("VC_PROTO_TX_LOG", None)
+ if v is not None:
+ return bool(v)
try:
from vc_common import VC_PROTO_TX_LOG
return bool(VC_PROTO_TX_LOG)
def _text_preview(s, n=48):
- try:
- t = (s or "").strip().replace("\n", " ")
- except Exception:
- return ""
+ t = (s or "").strip().replace("\n", " ")
if len(t) <= n:
return t
return t[:n] + "..."
bot = (dlg.get("cfg") or {}).get("bot_option") or {}
disable_vad = inb.get("disable_vad", True)
sess = "push_to_talk" if disable_vad else "realtime"
- tid = ""
- try:
- tid = (json_data.get("header") or {}).get("trace_id") or ""
- except Exception:
- pass
+ tid = (json_data.get("header") or {}).get("trace_id") or ""
print("[VC][proto] start_tx ver={} trace={} vc_mode={} sess={} vad_silence={} "
"voice={} out_prov={} in_prov={} fmt={} sr={} speech_rate={} bot={} wf={}".format(
get_protocol_version(),
OP_PTT_ROUND, OP_UPLOAD_TONE,
)
from vc_mode_strategy import strategy_for_mode
+from vc_utils import cfg_bool, cfg_int, cfg_attr
class AI_VC(VCSessionIoMixin, VCSessionMediaMixin, Abstract):
def _vc_fsm_log_snip(self):
# 约定:带 _ptt_ 前缀的状态/逻辑仅单对话;带 _long_dialogue_ 仅长对话;公共路径须先判 VC_mode。
# -------------------------------------------------------------------------
def _vc_is_ptt_mode(self):
- try:
- return int(getattr(self, "VC_mode", -1)) == 1
- except Exception:
- return False
+ return int(getattr(self, "VC_mode", -1)) == 1
def _vc_is_long_dialogue_mode(self):
- try:
- return int(getattr(self, "VC_mode", -1)) == 0
- except Exception:
- return False
+ return int(getattr(self, "VC_mode", -1)) == 0
def _vc_reset_dialogue_mode_state(self):
"""Close/模式切换时清零双模式按键与灯锁,避免残留互相影响。"""
return False
def _vc_asr_continue_merge_ms(self):
- try:
- if "vc_config" in globals() and vc_config:
- return int(vc_config.get_int("LONG_DIALOGUE_ASR_CONTINUE_MS", 2000))
- except Exception:
- pass
- return 2000
+ return cfg_int("LONG_DIALOGUE_ASR_CONTINUE_MS", 2000)
def _vc_ld_cancel_storm_max(self):
- try:
- if "vc_config" in globals() and vc_config:
- return int(vc_config.get_int("LONG_DIALOGUE_LLM_CANCEL_MAX", 2))
- except Exception:
- pass
- return 2
+ return cfg_int("LONG_DIALOGUE_LLM_CANCEL_MAX", 2)
def _vc_ld_reset_merge_freeze(self):
try:
self._vc_ld_merge_frozen = 1
self._vc_asr_continue_merge = 0
self._vc_pending_asr_completed_stop = 0
- try:
- print("[VC][cancel_storm] n={} max={} -> force commit".format(n, mx))
- except Exception:
- pass
+ print("[VC][cancel_storm] n={} max={} -> force commit".format(n, mx))
return True
except Exception:
pass
if getattr(self, "record_data_save_flag", 0) == 0:
self._server_vad_silence = 0
self._vc_defer_vad_uplink_stop = 0
- try:
- print("[VC][ASR] continue after completed -> resume uplink gate")
- except Exception:
- pass
+ print("[VC][ASR] continue after completed -> resume uplink gate")
except Exception:
pass
if getattr(self, "record_data_save_flag", 0) != 0:
return
if getattr(self, "_vc_vad_had_active_after_silence", 0) == 1:
- try:
- print("[VC][VAD] asr.completed defer stop (vad pause merged)")
- except Exception:
- pass
+ print("[VC][VAD] asr.completed defer stop (vad pause merged)")
return
try:
self._vc_asr_completed_ms = utime.ticks_ms()
return
self._vc_pending_asr_completed_stop = 0
if getattr(self, "VC_record_state_flag", 0) != 0 and self._vc_vad_uplink_stop_eligible():
- try:
- print("[VC][ASR] merge window end -> stop uplink")
- except Exception:
- pass
+ print("[VC][ASR] merge window end -> stop uplink")
self.request_uplink_stop("asr.completed/merge_timeout")
except Exception:
pass
else:
self._server_vad_silence = 0
self._vc_pending_asr_completed_stop = 0
- try:
- print("[KEY] long_dialogue canceled -> keep/restore speech")
- except Exception:
- pass
+ print("[KEY] long_dialogue canceled -> keep/restore speech")
except Exception:
pass
def _vc_long_dialogue_max_turn_ms(self):
"""长对话单轮录音墙钟上限(ms);0=不限制。merge 续说期间累计,不因 silence_gate 清零。"""
- try:
- if "vc_config" in globals() and vc_config:
- return int(vc_config.get_int("LONG_DIALOGUE_MAX_TURN_MS", 25000))
- except Exception:
- pass
- return 25000
+ return cfg_int("LONG_DIALOGUE_MAX_TURN_MS", 25000)
def _vc_turn_wall_clear(self):
try:
self._vc_pending_asr_completed_stop = 0
self._vc_asr_continue_merge = 0
self._vc_ld_merge_frozen = 1
- try:
- print("[VC][turn_cap] force stop elapsed_ms>={} max_ms={}".format(
- utime.ticks_diff(utime.ticks_ms(), start), max_ms))
- except Exception:
- pass
+ print("[VC][turn_cap] force stop elapsed_ms>={} max_ms={}".format(
+ utime.ticks_diff(utime.ticks_ms(), start), max_ms))
self._vc_defer_vad_uplink_stop = 0
self._vc_vad_had_active_after_silence = 0
self._server_vad_silence = 1
pass
def _long_dialogue_drop_tts_window_ms(self):
- try:
- if "vc_config" in globals() and vc_config:
- return int(vc_config.get_int("LONG_DIALOGUE_DROP_TTS_MS", 8000))
- except Exception:
- pass
- return 8000
+ return cfg_int("LONG_DIALOGUE_DROP_TTS_MS", 8000)
def _vc_ignore_late_tts_completed_event(self):
"""打断后已停播/开麦:迟到的 tts.completed 不参与 await_played / play_end。"""
def _vc_long_dialogue_key_arm_session(self):
"""长对话按键唤醒/续聊:滴与蓝灯在 _vc_user_record_entry 统一处理。"""
- try:
- self._long_dialogue_key_arm = 1
- except Exception:
- pass
+ self._long_dialogue_key_arm = 1
def _vc_ptt_mark_record_after_started(self):
"""PTT 长按:等 started / asr.started 后开录,无开录提示音(REQ-AI-07)。"""
- try:
- self._ptt_force_record_on_started = 1
- except Exception:
- pass
+ self._ptt_force_record_on_started = 1
def _long_dialogue_key_down_arm(self, event=None, msg=None):
"""EXTI 仅投递;业务在编排线程 _long_dialogue_key_down_arm_impl。"""
if not self._long_dialogue_media_busy():
return
try:
- wait_ms = 800
- if "vc_config" in globals() and vc_config:
- wait_ms = int(vc_config.get_int("LONG_DIALOGUE_CANCEL_WAIT_MS", wait_ms))
+ wait_ms = cfg_int("LONG_DIALOGUE_CANCEL_WAIT_MS", 800)
if getattr(self, "_intr", None) is not None:
self._intr.begin(
self, InterruptContext.KIND_LONG_SHORT,
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
+ print("[VC][idle_L2] 调用 Close 断开会话/链路")
self.Close()
except Exception:
pass
pass
try:
if not self._vc_is_business_idle():
- try:
- print("[VC][idle_L2] 仍有后台活跃,推迟 SYSTEM_SLEEP")
- except Exception:
- pass
- try:
- self._vc_idle_deep_armed_suppress = 0
- except Exception:
- pass
+ print("[VC][idle_L2] 仍有后台活跃,推迟 SYSTEM_SLEEP")
+ self._vc_idle_deep_armed_suppress = 0
return
except Exception:
pass
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
+ print("[VC][idle_L2] 发布 Hsensor_set_sleep")
+ EventMesh.publish("Hsensor_set_sleep")
+ print("[VC][idle_L2] 发布 SYSTEM_SLEEP ({})".format(constants.EVENT.SYSTEM_SLEEP))
+ EventMesh.publish(constants.EVENT.SYSTEM_SLEEP)
def _vc_rx_resets_long_idle_timer(self, recv_data):
"""是否清零 close_timerout:仅 TTS 反馈;保活(文本 ping/pong、heartbeat)不计。"""
try:
except Exception:
pass
def _vc_ms_key_block_ms(self):
- try:
- if "vc_config" in globals() and vc_config:
- return int(vc_config.get_int("VC_MODE_SWITCH_KEY_BLOCK_MS", 500))
- except Exception:
- pass
- return 500
+ return cfg_int("VC_MODE_SWITCH_KEY_BLOCK_MS", 500)
def _vc_ms_keys_blocked(self, tag=""):
"""兼容旧名;统一走 vc_overlay.overlay_keys_blocked。"""
def _vc_handle_asr_empty(self, reason="asr.completed"):
"""ASR completed 无有效文本:清轮次态 + Notify 播报(与 _ptt_abort_short_record 同出口)。"""
hint = "我没有听清,请再说一遍"
- try:
- if "vc_config" in globals() and vc_config:
- cfg = vc_config.get_attr("ASR_EMPTY_HINT_TTS", None)
- if cfg is not None and str(cfg).strip():
- hint = str(cfg).strip()
- except Exception:
- pass
- try:
- print("[VC][ASR] completed empty -> clear + notify ({})".format(reason))
- except Exception:
- pass
+ cfg = cfg_attr("ASR_EMPTY_HINT_TTS", None)
+ if cfg is not None and str(cfg).strip():
+ hint = str(cfg).strip()
+ print("[VC][ASR] completed empty -> clear + notify ({})".format(reason))
try:
self.AI_ASR_str = ""
self.AI_ASR_str_tmp = ""
self._vc_turn_bump("long_interrupt")
self.Close_flag = 0
self.fsm.await_played = False
- wait_ms = 800
- if "vc_config" in globals() and vc_config:
- wait_ms = int(vc_config.get_int("LONG_DIALOGUE_CANCEL_WAIT_MS", wait_ms))
+ wait_ms = cfg_int("LONG_DIALOGUE_CANCEL_WAIT_MS", 800)
if getattr(self, "_intr", None) is not None:
self._intr.begin(
self, InterruptContext.KIND_LONG_SHORT,
pass
if getattr(self, "VC_record_state_flag", 0) != 0:
try:
- gap = 200
- if "vc_config" in globals() and vc_config:
- gap = int(vc_config.get_int("PTT_RELEASE_END_SPEECH_DELAY_MS", 200))
+ gap = cfg_int("PTT_RELEASE_END_SPEECH_DELAY_MS", 200)
if gap > 0:
utime.sleep_ms(gap)
except Exception:
except Exception:
pass
try:
- gap = 0
- if "vc_config" in globals() and vc_config:
- gap = int(vc_config.get_int("PTT_POST_MUTE_MS", 30))
+ gap = cfg_int("PTT_POST_MUTE_MS", 30)
if gap > 0:
utime.sleep_ms(gap)
except Exception:
except Exception:
pass
def _vc_ptt_cancel_wait_ms(self):
- try:
- if "vc_config" in globals() and vc_config:
- return int(vc_config.get_int("PTT_CANCEL_WAIT_MS", 2500))
- except Exception:
- pass
- return 2500
+ return cfg_int("PTT_CANCEL_WAIT_MS", 2500)
def _vc_ptt_need_interrupt_wait(self):
"""单对话:思考/TTS/播中/松手等服务器时,开录前须先 cancel 并等 canceled。"""
try:
self._ptt_arm_uplink(t0)
def _vc_led_state_debug_enabled(self):
- try:
- if "vc_config" in globals() and vc_config:
- return vc_config.get_bool("LED_STATE_DEBUG", True)
- except Exception:
- pass
- return True
+ return cfg_bool("LED_STATE_DEBUG", True)
def _vc_led_should_standby_idle(self):
"""未录音且非 TTS 播中:待机/提示音/模式切换/单对话轮间应灭灯(DES-L3 idle),勿被 FSM.turn=Listening 误导。"""
try:
self.is_auth = 1 #是否开启dmp鉴权
#self.VC_mode = 1 #0:短按连续问答模式 1:长按录音模式
self.VC_mode = EventMesh.publish("get_storage_config","VC_mode")#
- _vc_mode_default = 0
- try:
- if "vc_config" in globals() and vc_config:
- _vc_mode_default = int(vc_config.get_int("VC_MODE_DEFAULT", 0))
- except Exception:
- pass
+ _vc_mode_default = cfg_int("VC_MODE_DEFAULT", 0)
if self.VC_mode == None:
self.VC_mode = _vc_mode_default
try:
#开机提示音
self.power_on_tone = EventMesh.publish("get_storage_config","power_on_tone")#
- try:
- if "vc_config" in globals() and vc_config:
- if not vc_config.get_bool("POWER_ON_TONE_ENABLED", True):
- self.power_on_tone = None
- except Exception:
- pass
+ if not cfg_bool("POWER_ON_TONE_ENABLED", True):
+ self.power_on_tone = None
if self.power_on_tone == None:
- try:
- if "vc_config" in globals() and vc_config:
- self.power_on_tone = vc_config.get_attr("POWER_ON_TONE_DEFAULT", None)
- except Exception:
- pass
+ self.power_on_tone = cfg_attr("POWER_ON_TONE_DEFAULT", None)
self.VC_record_TYPE = VC_record_TYPE_PCM #0:PCM 1:AMR
self.VC_play_TYPE = VC_play_TYPE_PCM #0:PCM 1:mp3
self.VC_record_samplerate = 16000
self.VC_play_samplerate = 16000
- self.VAD_data_len = 640 #10ms数据
- self.is_VAD = 0#=1打开vad打断
+ self.VAD_data_len = 640 # 20ms @16kHz mono pcm16
+ self._local_vad_debug_only = cfg_bool("LOCAL_VAD_DEBUG_ONLY", True)
+ self.speech_rate = EventMesh.publish("get_storage_config","speech_rate")#语速配置
+ if self.speech_rate == None:
+ self.speech_rate = 0
+
+ self.vad_silence = EventMesh.publish("get_storage_config","vad_silence")
+ if self.vad_silence == None:
+ self.vad_silence = cfg_int("VAD_SILENCE_DEFAULT", 1000)
+ try:
+ self.vad_silence = int(self.vad_silence)
+ except Exception:
+ self.vad_silence = cfg_int("VAD_SILENCE_DEFAULT", 1000)
+ if self.vad_silence < 300:
+ self.vad_silence = 300
+ # 长对话(VC_mode=0)启用本地 imsl VAD;单对话不用
+ self.is_VAD = 1 if cfg_bool("LOCAL_VAD_ENABLE", True) and int(getattr(self, "VC_mode", 0)) == 0 else 0
# ARG_sample_rate, // 采样率
# ARG_channel, // 通道数
# ARG_frame_size, // 每帧字节数
# ARG_energy_threshold, // 能量阈值
# ARG_voice_time, // 语音持续时间阈值(ms)
- # ARG_silence_time, // 静音持续时间阈值(ms)
- # ARG_silence_start_threshold, // 静音开始阈值(ms)
+ # ARG_silence_time, // 静音持续时间阈值(ms) → imsl rule2/3
+ # ARG_silence_start_threshold, // 静音开始阈值(ms) → imsl rule1
self.vad = None
+ self._vc_vad_pcm_tail = bytearray()
if self.is_VAD == 1:
- self.vad = VAD.VAD(self.VC_record_samplerate ,1,self.VAD_data_len,600,100,300,100)
- self.speech_rate = EventMesh.publish("get_storage_config","speech_rate")#语速配置
- if self.speech_rate == None:
- self.speech_rate = 0
-
- self.vad_silence = EventMesh.publish("get_storage_config","vad_silence")#语速配置
- if self.vad_silence == None:
try:
- if "vc_config" in globals() and vc_config:
- self.vad_silence = vc_config.get_int("VAD_SILENCE_DEFAULT", 300)
- else:
- self.vad_silence = 300
- except Exception:
- self.vad_silence = 300
+ sil_ms = int(self.vad_silence)
+ self.vad = VAD.VAD(
+ self.VC_record_samplerate, 1, self.VAD_data_len,
+ 10000, 240, sil_ms, 480)
+ mode = self.vad.init_mode()
+ print("[VAD] init_mode=", mode, "trial=", VAD.MODE_TRIAL,
+ "sil_ms=", sil_ms, "debug_only=", self._local_vad_debug_only,
+ "endpoint=", not self._local_vad_debug_only)
+ except Exception as e:
+ print("[VAD] init fail:", e)
+ self.is_VAD = 0
+ self.vad = None
+ else:
+ print("[VAD] local vad disabled VC_mode=", getattr(self, "VC_mode", -1))
self.VC_TTS_voice_type = EventMesh.publish("get_storage_config","VC_TTS_voice_type")#音色配置
if self.VC_TTS_voice_type == None :
- try:
- if "vc_config" in globals() and vc_config:
- cfg = vc_config.get_attr("VC_TTS_VOICE_TYPE_DEFAULT", None)
- if isinstance(cfg, dict):
- self.VC_TTS_voice_type = cfg
- except Exception:
- pass
+ cfg = cfg_attr("VC_TTS_VOICE_TYPE_DEFAULT", None)
+ if isinstance(cfg, dict):
+ self.VC_TTS_voice_type = cfg
# 若配置未提供,沿用原逻辑内置兜底(保持兼容)
if self.VC_TTS_voice_type == None:
self.VC_TTS_voice_type = {
try:
self.VC_TTS_voice_key = EventMesh.publish("get_storage_config","VC_TTS_voice_key")#音色配置
if self.VC_TTS_voice_key == None :
- try:
- if "vc_config" in globals() and vc_config:
- self.VC_TTS_voice_key = vc_config.get_attr("VC_TTS_VOICE_KEY_DEFAULT", None)
- except Exception:
- pass
+ self.VC_TTS_voice_key = cfg_attr("VC_TTS_VOICE_KEY_DEFAULT", None)
if not self.VC_TTS_voice_key:
self.VC_TTS_voice_key = "男"
if self.VC_TTS_voice_key in self.VC_TTS_voice_type:
self.record = audio.Record()
#self.record.end_callback(self.record_callback)
try:
- _cg, _dg = 4, 10
- if "vc_config" in globals() and vc_config:
- _cg = int(vc_config.get_int("RECORD_CODEC_GAIN", 4))
- _dg = int(vc_config.get_int("RECORD_DSP_GAIN", 10))
+ _cg = cfg_int("RECORD_CODEC_GAIN", 4)
+ _dg = cfg_int("RECORD_DSP_GAIN", 10)
if _cg < 0:
_cg = 0
elif _cg > 4:
try:
bt_ota_flag=0
try:
- if "vc_config" in globals() and vc_config and vc_config.get_bool("BT_OTA_ENABLED", False):
+ if cfg_bool("BT_OTA_ENABLED", False):
bt_ota_flag = self.ai_OTA.bt_ota()#先检查蓝牙是否要升级
except Exception:
pass
return
# 按键时打印 LED 聚合状态/最终模式(用于定位“绿灯不灭/闪一下”)
try:
- if "vc_config" in globals() and vc_config and vc_config.get_bool("KEY_LED_DEBUG", False):
+ if cfg_bool("KEY_LED_DEBUG", False):
try:
led = EventMesh.publish("get_led_debug_state")
except Exception:
if self._vc_ms_keys_blocked("AI_release"):
return
try:
- if "vc_config" in globals() and vc_config and vc_config.get_bool("KEY_LED_DEBUG", False):
+ if cfg_bool("KEY_LED_DEBUG", False):
try:
led = EventMesh.publish("get_led_debug_state")
except Exception:
self._vc_enqueue_btn(self._vc_mode_switch_run, gen)
def AI_key_long_press(self, event, msg):#按键长按
try:
- if "vc_config" in globals() and vc_config and vc_config.get_bool("KEY_LED_DEBUG", False):
+ if cfg_bool("KEY_LED_DEBUG", False):
try:
led = EventMesh.publish("get_led_debug_state")
except Exception:
print("AI_key_long_press")
self._ai_key_long_press_route(event, msg)
def pwk_key_release(self, event, msg):#电源键短按,关闭
- try:
- if "vc_config" in globals() and vc_config:
- _m = bool(vc_config.get_bool("SINGLE_POWER_KEY_AI_MERGED", False))
- if not _m:
- _ai = vc_config.get_attr("EXTINT_AI_GPIO", "GPIO22")
- _m = _ai is None or _ai == ""
- else:
- _m = False
- except Exception:
- _m = False
+ _m = cfg_bool("SINGLE_POWER_KEY_AI_MERGED", False)
+ if not _m:
+ _ai = cfg_attr("EXTINT_AI_GPIO", "GPIO22")
+ _m = _ai is None or _ai == ""
if _m:
self._handle_pwk_short_release(event, msg, merged_ai_tail=True)
return
def _ptt_play_idle_hint(self):
"""PTT idle 短按:notify 话术提醒(对齐 k8 PTT_HINT,非 KEY_PRESS 本地音)。"""
try:
- tts_str = "请您按住圆形的按钮开始讲话,讲完松开即可 "
- if "vc_config" in globals() and vc_config:
- tts_str = (
- vc_config.get_attr("PTT_HINT", None)
- or vc_config.get_attr("KWS_PTT_HINT", None)
- or tts_str
- )
+ tts_str = (
+ cfg_attr("PTT_HINT", None)
+ or cfg_attr("KWS_PTT_HINT", None)
+ or "请您按住圆形的按钮开始讲话,讲完松开即可 "
+ )
tts_str = str(tts_str or "").strip()
if not tts_str:
return
EventMesh.publish("system_sleep_rest")
# --- Level 1:长对话轮次间隙 idle_sec 内无 TTS 下行 → Close(JSON ping/pong 不重置、不暂停累计)
# close_timerout:仅 tts.* / started / TTS 音频重置;听/想/播/录期 _vc_long_idle_timer_armed=False
- 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
+ idle_sec = cfg_int("VC_IDLE_AUTO_CLOSE_SEC", 20)
if idle_sec < 5:
idle_sec = 5
if self._vc_long_idle_timer_armed():
EventMesh.publish("publish_AI_btnInfo", {"func": self.Close})
# --- 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
+ deep_sec = cfg_int("VC_IDLE_DEEP_SLEEP_SEC", 60)
+ deep_en = cfg_int("VC_IDLE_DEEP_SLEEP_ENABLE", 1)
active_deep = bool(deep_en) and deep_sec > 0
if active_deep and deep_sec < 10:
deep_sec = 10
# V2.5 自定义文本 ping;V3 无自定义心跳(入站标准 PING 由 uwebsocket 回 PONG)
if vc_ws_custom_ping_enabled() and getattr(self, "AI_client_VC_isconnect", 0) == 1:
- try:
- _ping_iv = int(vc_config.get_int("VC_WS_PING_INTERVAL_SEC", 55))
- except Exception:
- _ping_iv = 55
+ _ping_iv = cfg_int("VC_WS_PING_INTERVAL_SEC", 55)
if _ping_iv > 0:
self.VC_pingping_timerout += 1
if self.VC_pingping_timerout >= _ping_iv:
return
print("kws_even_cb")
if self.VC_mode == 1:
- try:
- tts_str = vc_config.get_attr("KWS_PTT_HINT", "请您按住圆形的按钮开始讲话,讲完松开即可 ")
- except Exception:
- tts_str = "请您按住圆形的按钮开始讲话,讲完松开即可 "
+ tts_str = cfg_attr("KWS_PTT_HINT", "请您按住圆形的按钮开始讲话,讲完松开即可 ")
EventMesh.publish("play_tts",[tts_str,1])
return
if self.VC_mode == 0:
pass
# 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))
+ _dsec = cfg_int("VC_IDLE_DEEP_SLEEP_SEC", 60)
+ _den = cfg_int("VC_IDLE_DEEP_SLEEP_ENABLE", 1)
if _den and _dsec > 0:
self._1S_timer.start(1000, 1, self._1S_timer_cb)
except Exception:
-"""vc_session 子模块共享 import(io / media / core 显式引用,禁止 import * 扩散到业务外)。"""\r
# -*- coding: utf-8 -*-\r
"""vc_session 子模块共享 import(io / media / core 显式引用,禁止 import * 扩散到业务外)。"""\r
from common import Abstract\r
"""AI_VC mixin:VC WebSocket 建链、收发线程、协议 JSON 分发。"""
from vc_session_imports import * # noqa: F401,F403
from vc_notify import NotifyScheduler
+from vc_utils import cfg_bool, cfg_attr
# import * 不导入以下划线开头的符号;_thread 必须显式引入(否则 start_new_thread NameError)
import _thread
def _vc_server_event_drop_stale(self, ev, gen):
"""仅丢弃迟到下行/TTS 相关事件;canceled/asr/started 不因 turn_gen 误杀。"""
- try:
- if not self._vc_turn_stale(gen):
- return False
- if ev in self._VC_STALE_DROP_EVENTS:
- return True
- except Exception:
- pass
- return False
+ if not self._vc_turn_stale(gen):
+ return False
+ return ev in self._VC_STALE_DROP_EVENTS
def _vc_error_tts_enabled(self):
"""VC_ERROR_TTS_ENABLED=1:协议 failed 原文 synthesis 播报(联调用)。"""
- try:
- if "vc_config" in globals() and vc_config:
- return vc_config.get_bool("VC_ERROR_TTS_ENABLED", False)
- except Exception:
- pass
- return False
+ return cfg_bool("VC_ERROR_TTS_ENABLED", False)
def _vc_error_tts_speakable(self, msg):
"""协议 failed 是否走 synthesis;默认过滤技术错误,VC_ERROR_TTS_ENABLED=1 时全播。"""
- try:
- if msg is None:
- return None
- s = str(msg).strip()
- if not s:
- return None
- if self._vc_error_tts_enabled():
- return s
- low = s.lower()
- for pat in (
- "failed to parse",
- "parse message",
- "json decode",
- "invalid json",
- "internal server",
- "concurrency_limit",
- ):
- if pat in low:
- return None
- except Exception:
+ if msg is None:
return None
+ s = str(msg).strip()
+ if not s:
+ return None
+ if self._vc_error_tts_enabled():
+ return s
+ low = s.lower()
+ for pat in (
+ "failed to parse",
+ "parse message",
+ "json decode",
+ "invalid json",
+ "internal server",
+ "concurrency_limit",
+ ):
+ if pat in low:
+ return None
return s
def _vc_classify_llm_tts_kind(self, payload_dialog_id=""):
"""设计稿 llm tts:V3 下行常无 dialog_id,用轮次状态补判为 dialog。"""
- try:
- if payload_dialog_id:
- return "dialog"
- k = getattr(self, "_pending_tts_kind", "") or ""
- if k:
- return k
- cur = getattr(self, "_last_tts_kind", "") or ""
- if cur in ("mode_switch_long", "mode_switch_ptt", "boot_prompt"):
- return cur
- if getattr(self, "_vc_expect_dialog_tts", 0) == 1:
- return "dialog"
- if (
- getattr(self, "VC_mode", -1) == 0
- and getattr(self, "_turn_has_asr_completed", 0) == 1
- ):
- return "dialog"
- if not cur:
- return "prompt"
+ if payload_dialog_id:
+ return "dialog"
+ k = getattr(self, "_pending_tts_kind", "") or ""
+ if k:
+ return k
+ cur = getattr(self, "_last_tts_kind", "") or ""
+ if cur in ("mode_switch_long", "mode_switch_ptt", "boot_prompt"):
return cur
- except Exception:
+ if getattr(self, "_vc_expect_dialog_tts", 0) == 1:
+ return "dialog"
+ if (
+ getattr(self, "VC_mode", -1) == 0
+ and getattr(self, "_turn_has_asr_completed", 0) == 1
+ ):
+ return "dialog"
+ if not cur:
return "prompt"
+ return cur
def _vc_orchestrator_server_event_cb(self, data):
"""btn 编排线程:服务端协议事件唯一入口(长对话/PTT 统一)。"""
except Exception:
return
if self._vc_server_event_drop_stale(ev, gen):
- try:
- print("[ORCH] drop server ev={} gen={} cur={}".format(
- ev, gen, self._vc_turn_current()))
- except Exception:
- pass
+ print("[ORCH] drop server ev={} gen={} cur={}".format(
+ ev, gen, self._vc_turn_current()))
return
if ev == "tts.started":
- try:
- self._vc_tts_rx_counters_reset()
- except Exception:
- pass
+ self._vc_tts_rx_counters_reset()
if self._vc_is_long_dialogue_mode():
- try:
- if hasattr(self, "_vc_ld_on_tts_started"):
- self._vc_ld_on_tts_started()
- if hasattr(self, "_long_dialogue_on_server_tts_started"):
- self._long_dialogue_on_server_tts_started()
- except Exception:
- pass
+ if hasattr(self, "_vc_ld_on_tts_started"):
+ self._vc_ld_on_tts_started()
+ if hasattr(self, "_long_dialogue_on_server_tts_started"):
+ self._long_dialogue_on_server_tts_started()
if ev == "canceled":
try:
keep_speech = False
return
except Exception:
pass
- try:
- self._vc_stop_downlink_for_interrupt("canceled")
- except Exception:
- pass
+ self._vc_stop_downlink_for_interrupt("canceled")
if ev == "tts.completed" and self._vc_ignore_late_tts_completed_event():
print("[ORCH] ignore late tts.completed (interrupt/recording)")
return
def request_send_audio_played(self):
EventMesh.publish("publish_AI_btnInfo", {"func": self.AI_client_VC_audio_played})
def request_send_synthesis(self, text):
- try:
- self.AI_TTS_str = text
- except Exception:
- pass
+ self.AI_TTS_str = text
EventMesh.publish("publish_AI_btnInfo", {"func": self.AI_client_VC_synthesis})
def websocket_connect_VC(self):
print("websocket_connect_VC:{} e:{}!!!!!!!!!!!!!!!!!!!!!".format(self.AI_client_VC_isconnect,self.AI_client_VC_debug))
token = EventMesh.publish("get_dev_token")
print("token:{}".format(token))
- base = "vc/chat"
- try:
- if "vc_config" in globals() and vc_config:
- base = vc_config.get_attr("VC_WS_PATH", "vc/chat") or "vc/chat"
- except Exception:
- pass
+ base = cfg_attr("VC_WS_PATH", "vc/chat") or "vc/chat"
try:
did = modem.getDevImei()
except Exception:
except Exception as e: #网络连接异常(已通过 CSQ/SIM,多为 URL/握手/服务端问题,勿播「信号弱」)
usys.print_exception(e)
print("websocket_connect_VC error!!!\r\n")
- try:
- print("[VC] ws connect exc: {}".format(e))
- except Exception:
- pass
+ print("[VC] ws connect exc: {}".format(e))
str_error = str(e)
if str_error.find("[Errno 22] EINVAL")!= -1:
print("[VC] websocket EINVAL: {}".format(str_error))
print("websocket_connect_VC end")
except Exception as e:
usys.print_exception(e)
- try:
- print("[VC] ws thread start failed: {}".format(e))
- except Exception:
- pass
+ print("[VC] ws thread start failed: {}".format(e))
self.AI_client_VC_isconnect = 0
try:
self.websocket_deconnect_VC()
pass
def websocket_error(self, TTS_str=None, play_weak_signal_tone=False):
"""play_weak_signal_tone=True 时播 xinhaoruo1(弱网/无卡类);连接/协议失败请传 False,避免误报「信号弱」。"""
- try:
- if getattr(self, "VC_mode", 0) != 1:
- print("[VC][long_idle] websocket_error enter VC_mode={} TTS_str={} weak_hint={} -> Close then uplink_stop(async)".format(
- getattr(self, "VC_mode", -1), TTS_str, play_weak_signal_tone))
- except Exception:
- pass
+ if getattr(self, "VC_mode", 0) != 1:
+ print("[VC][long_idle] websocket_error enter VC_mode={} TTS_str={} weak_hint={} -> Close then uplink_stop(async)".format(
+ getattr(self, "VC_mode", -1), TTS_str, play_weak_signal_tone))
print("websocket_error1!!!!")
utime.sleep_ms(800)
self.Close()
self.AI_ASR_str_tmp = ""
self.AI_ASR_flag = 0
# 可能由收包线程/其它线程触发:统一切回主线程执行 stop,避免“异常→重试→再异常”的循环
- try:
- if getattr(self, "VC_mode", 0) != 1:
- print("[VC][long_idle] websocket_error schedule uplink_stop reason=websocket_error + set_led_idle")
- except Exception:
- pass
+ if getattr(self, "VC_mode", 0) != 1:
+ print("[VC][long_idle] websocket_error schedule uplink_stop reason=websocket_error + set_led_idle")
EventMesh.publish("publish_AI_btnInfo",{"func":self._uplink_request_stop, "data":"websocket_error"})
EventMesh.publish("vc_led_sync")
if TTS_str == None:
#print("websocket_deconnect_VC {}!!!!!!!".format(self.AI_client_VC_isconnect))
print("websocket_deconnect_VC!!!!!!!")
self._vc_session_started = 0
- # 断链/模式切换时必须重置“上行录音状态”,否则会被 _uplink_request_start 的幂等门控挡住,
- # 表现为:切回长对话后无法自动开麦,按键 cancel/canceled 也无法恢复。
- try:
- self.VC_record_state_flag = 0
- except Exception:
- pass
- try:
- self._server_vad_silence = 0
- except Exception:
- pass
+ self.VC_record_state_flag = 0
+ self._server_vad_silence = 0
+ self._ptt_audio_created = 0
try:
- self._ptt_audio_created = 0
- except Exception:
- pass
- try:
- # 若录音线程/录音设备仍在占用,先停掉
self.VC_Speech_End()
except Exception:
try:
self.VC_record_thread_close()
except Exception:
pass
- # 断链必须同步重置 FSM,否则 await_played/turn 残留会导致动态切换后“无法自动开麦/按键无效”
try:
self.fsm.session = VCSessionState.Disconnected
self.fsm.turn = VCTurnState.Idle
# if dev_type != "7PIN" :
#EventMesh.publish("publish_AI_btnInfo",{"func":self.send_tone})
elif jsload_data["event"] == "vad.active" :#VAD 检测到说话→聆听
- try:
+ if hasattr(self, "_vc_local_vad_endpoint") and self._vc_local_vad_endpoint():
+ print("[VC][VAD] ignore server vad.active (local endpoint)")
+ else:
self._vc_vad_had_active_after_silence = 1
self._vc_defer_vad_uplink_stop = 0
self._server_vad_silence = 0
- except Exception:
- pass
- try:
- if "vc_config" in globals() and vc_config and vc_config.get_bool("VAD_ACTIVE_BLUE_LED", True):
+ if cfg_bool("VAD_ACTIVE_BLUE_LED", True):
self._server_vad_silence = 0
- except Exception:
- pass
elif jsload_data["event"] == "vad.silence" :#VAD 终止的标识
- # 长对话:句中停顿仅标记,等 asr.completed 再停麦(配合服务端 vad_silence 加长)
- self._turn_has_vad_silence = 1
- try:
- if hasattr(self, "_vc_long_dialogue_defer_vad_stop") and self._vc_long_dialogue_defer_vad_stop():
- # defer 仅延后 VC_Speech_End;须立刻 silence_gate 止 PCM 上行
- self._vc_defer_vad_uplink_stop = 1
- self._server_vad_silence = 1
- try:
+ if hasattr(self, "_vc_local_vad_endpoint") and self._vc_local_vad_endpoint():
+ print("[VC][VAD] ignore server vad.silence (local endpoint)")
+ else:
+ # 长对话:句中停顿仅标记,等 asr.completed 再停麦(配合服务端 vad_silence 加长)
+ self._turn_has_vad_silence = 1
+ try:
+ if hasattr(self, "_vc_long_dialogue_defer_vad_stop") and self._vc_long_dialogue_defer_vad_stop():
+ # defer 仅延后 VC_Speech_End;须立刻 silence_gate 止 PCM 上行
+ self._vc_defer_vad_uplink_stop = 1
+ self._server_vad_silence = 1
self._uplink_mark_end("vad.silence/defer")
- except Exception:
- pass
- try:
print("[VC][VAD] silence defer stop_mic_only (silence_gate on)")
- except Exception:
- pass
- else:
+ else:
+ self._server_vad_silence = 1
+ self._uplink_mark_end("vad.silence")
+ if self.record_data_save_flag == 0:
+ if self.VC_record_state_flag != 0 and self._vc_vad_uplink_stop_eligible():
+ self.request_uplink_stop("vad.silence")
+ except Exception:
self._server_vad_silence = 1
self._uplink_mark_end("vad.silence")
- if self.record_data_save_flag == 0:
- if self.VC_record_state_flag != 0 and self._vc_vad_uplink_stop_eligible():
- self.request_uplink_stop("vad.silence")
- except Exception:
- self._server_vad_silence = 1
- self._uplink_mark_end("vad.silence")
elif jsload_data["event"] == "llm.created" :#思考(LLM)
- try:
- self._turn_has_llm_created = 1
- except Exception:
- pass
- try:
- if (
- self._vc_is_long_dialogue_mode()
- and getattr(self, "VC_record_state_flag", 0) != 0
- and getattr(self, "record_data_save_flag", 0) == 0
- ):
- self.request_uplink_stop("llm.created")
- except Exception:
- pass
- try:
- if hasattr(self, "_vc_reset_long_idle_timer"):
- self._vc_reset_long_idle_timer("llm.created")
- except Exception:
- pass
- try:
- self._ptt_await_server = 0
- except Exception:
- pass
- try:
- if not self._vc_tts_playback_active() and not getattr(
- self.fsm, "await_played", False
- ):
- EventMesh.publish("vc_led_sync")
- except Exception:
- pass
+ self._turn_has_llm_created = 1
+ if (
+ self._vc_is_long_dialogue_mode()
+ and getattr(self, "VC_record_state_flag", 0) != 0
+ and getattr(self, "record_data_save_flag", 0) == 0
+ ):
+ self.request_uplink_stop("llm.created")
+ if hasattr(self, "_vc_reset_long_idle_timer"):
+ self._vc_reset_long_idle_timer("llm.created")
+ self._ptt_await_server = 0
+ if not self._vc_tts_playback_active() and not getattr(
+ self.fsm, "await_played", False
+ ):
+ EventMesh.publish("vc_led_sync")
self._llm_completed_ms = 0
- try:
- if (
- getattr(self, "VC_mode", 0) == 0
- and getattr(self, "_turn_has_asr_completed", 0) == 1
- ):
- self._vc_expect_dialog_tts = 1
- except Exception:
- pass
- pass
+ if (
+ getattr(self, "VC_mode", 0) == 0
+ and getattr(self, "_turn_has_asr_completed", 0) == 1
+ ):
+ self._vc_expect_dialog_tts = 1
elif jsload_data["event"] == "llm.completed" :#llm完成(可能无 tts)
try:
self._llm_completed_ms = utime.ticks_ms()
except Exception:
- # 勿用 1:ticks_diff(now,1)≈开机至今,会瞬间满足 thinking 超时误以为该重启
self._llm_completed_ms = 0
- try:
- self._cur_dialog_id = jsload_data.get("payload", {}).get("dialog_id", "") or ""
- except Exception:
+ payload = jsload_data.get("payload", {})
+ if isinstance(payload, dict):
+ self._cur_dialog_id = payload.get("dialog_id", "") or ""
+ else:
self._cur_dialog_id = ""
- try:
+ if hasattr(self.fsm, "log"):
self.fsm.log("server.llm.completed")
- except Exception:
- pass
- pass
elif jsload_data["event"] == "llm.delta" :#llm返回数据
if self.is_VAD == 0 and self.record_data_save_flag == 0:
if self.VC_record_state_flag == 1:#llm返回数据还没停止,就先停止
self.request_uplink_stop("llm.delta")
elif jsload_data["event"] == "tts.started" :#tts开始
- try:
- self._ptt_await_server = 0
- except Exception:
- pass
+ self._ptt_await_server = 0
self._server_vad_silence = 1
self._turn_has_tts_started = 1
self._tts_pending = 0
self._tts_pending_ms = 0
self._uplink_mark_end("tts.started")
- # stop uplink + play_start 由 FSM action list 统一触发,避免多处重复调用
- # 标记本轮 TTS 来源:
- # - 有 payload.dialog_id:认为是“对话回复 TTS”
- # - 无 dialog_id:认为是“提示/提醒 TTS”(模式切换可通过 _pending_tts_kind 标记)
- try:
- did = jsload_data.get("payload", {}).get("dialog_id", "") or ""
- if not did:
- did = getattr(self, "_cur_dialog_id", "") or ""
- except Exception:
- did = ""
- try:
- self._last_tts_kind = self._vc_classify_llm_tts_kind(did)
- if self._last_tts_kind == "dialog":
- self._vc_expect_dialog_tts = 0
- except Exception:
- pass
- try:
- self._pending_tts_kind = ""
- except Exception:
- pass
- # 播放灯由阶段事件控制
- try:
- self._tts_completed_wall_ms = 0
- except Exception:
- pass
+ payload = jsload_data.get("payload", {})
+ did = payload.get("dialog_id", "") if isinstance(payload, dict) else ""
+ if not did:
+ did = getattr(self, "_cur_dialog_id", "") or ""
+ self._last_tts_kind = self._vc_classify_llm_tts_kind(did)
+ if self._last_tts_kind == "dialog":
+ self._vc_expect_dialog_tts = 0
+ self._pending_tts_kind = ""
+ self._tts_completed_wall_ms = 0
elif jsload_data["event"] == "tts.completed" :#tts结束
- # tts.completed 仅表示下发结束,本地可能仍在播放;绿灯关闭在本地播放结束时处理
- try:
- # server event 已在统一入口 on_server_event 触发 FSM,这里避免重复驱动
- pass
- except Exception:
- pass
- try:
- try:
- sid = getattr(self, "_cur_sid", "")
- did = getattr(self, "_cur_dialog_id", "")
- except Exception:
- sid, did = "", ""
- print("[TTS] completed in_len={} out_len={} q_empty={} play_pcm={} sid={} did={}".format(
- getattr(self, "tts_in_data_len", 0),
- getattr(self, "tts_out_data_len", 0),
- 1 if self.AI_audio_queue.empty() else 0,
- 1 if self.play_pcm != None else 0,
- sid,
- did,
- ))
- except Exception:
- pass
+ sid = getattr(self, "_cur_sid", "")
+ did = getattr(self, "_cur_dialog_id", "")
+ print("[TTS] completed in_len={} out_len={} q_empty={} play_pcm={} sid={} did={}".format(
+ getattr(self, "tts_in_data_len", 0),
+ getattr(self, "tts_out_data_len", 0),
+ 1 if self.AI_audio_queue.empty() else 0,
+ 1 if self.play_pcm != None else 0,
+ sid,
+ did,
+ ))
try:
self._tts_completed_wall_ms = utime.ticks_ms()
except Exception:
self._tts_completed_wall_ms = 0
- try:
- if getattr(self, "VC_mode", 0) == 0:
- EventMesh.publish(
- "publish_AI_btnInfo",
- {"func": self._vc_try_play_end_tick},
- )
- except Exception:
- pass
- # 播完上报完全由 FSM await_played + play_end 驱动,这里不再使用 LocalRespondingEnded_timerout/_need_audio_played_ack
- pass
+ if getattr(self, "VC_mode", 0) == 0:
+ EventMesh.publish(
+ "publish_AI_btnInfo",
+ {"func": self._vc_try_play_end_tick},
+ )
+ # 播完上报完全由 FSM await_played + play_end 驱动
elif jsload_data["event"] == "canceled" :#打断
# 长对话清 is_ruppt:仅在 btn 编排 _vc_orchestrator_server_event_cb 中处理,
self._need_audio_played_ack = 0
self._tts_pending = 0
self._tts_pending_ms = 0
- try:
- if (
- getattr(self, "VC_mode", 0) == 0
- and getattr(self, "_vc_pending_interrupt_uplink", 0) == 1
- ):
- self._long_dialogue_publish_listening("server.canceled/interrupt")
- except Exception:
- pass
+ if (
+ getattr(self, "VC_mode", 0) == 0
+ and getattr(self, "_vc_pending_interrupt_uplink", 0) == 1
+ ):
+ self._long_dialogue_publish_listening("server.canceled/interrupt")
# 开麦由 FSM action list 统一触发(uplink_start:canceled),避免重复调用
if self.AI_audio_queue_thread_id ==0:
_thread.stack_size(24*1024)
or self._vc_tts_pipeline_busy()
or self.VC_Play_flag == 1
):
- try:
- if (
- getattr(self, "VC_mode", 0) == 0
- and getattr(self.fsm, "await_played", False)
- and getattr(self, "VC_record_state_flag", 0) == 0
- ):
- EventMesh.publish(
- "publish_AI_btnInfo",
- {"func": self._vc_try_play_end_tick},
- )
- except Exception:
- pass
+ if (
+ getattr(self, "VC_mode", 0) == 0
+ and getattr(self.fsm, "await_played", False)
+ and getattr(self, "VC_record_state_flag", 0) == 0
+ ):
+ EventMesh.publish(
+ "publish_AI_btnInfo",
+ {"func": self._vc_try_play_end_tick},
+ )
else:
# 无 TTS 的 completed:清状态并按需进入下一轮(见下方条件)
self.LocalRespondingEnded_timerout = 0
self._need_audio_played_ack = 0
- try:
+ if hasattr(self.fsm, "reset_rx_phases"):
self.fsm.reset_rx_phases()
- except Exception:
- pass
# 连续对话:若本轮没有 TTS(或服务端直接 completed),需要立刻回到聆听状态
# 否则会出现“有时 1 轮/2 轮后就停住”的现象(服务端 completed 但端侧未重新开录音上行)。
if self.VC_mode == 0 and self.Close_flag == 0:
if vc_text_intent is None:
return None
try:
- try:
- _btv = bool("vc_config" in globals() and vc_config and vc_config.get_bool("BT_VOICE_FEATURES_ENABLED", False))
- except Exception:
- _btv = False
- r = vc_text_intent.match_vc_command(text, {"bt_voice": _btv})
+ r = vc_text_intent.match_vc_command(
+ text, {"bt_voice": cfg_bool("BT_VOICE_FEATURES_ENABLED", False)}
+ )
except Exception as e:
usys.print_exception(e)
return None
EventMesh.publish("publish_AI_btnInfo", {"func": self.Close})
EventMesh.publish("Power_off")
return 1
- try:
- close_only = ("vc_config" in globals() and vc_config and vc_config.get_bool("POWEROFF_CMD_CLOSE_ONLY", True))
- except Exception:
- close_only = True
- if close_only:
+ if cfg_bool("POWEROFF_CMD_CLOSE_ONLY", True):
EventMesh.publish("publish_AI_btnInfo", {"func": self.Close})
return 1
EventMesh.publish("publish_AI_btnInfo", {"func": self.Close})
if llm_style_tts:
self.AI_TTS_str = "了解,已切换到单对话模式"
else:
- try:
- self.AI_TTS_str = vc_config.get_attr("CMD_TOGGLE_MODE_TO_PTT_TTS", "已切换到单对话模式")
- except Exception:
- self.AI_TTS_str = "已切换到单对话模式"
+ self.AI_TTS_str = cfg_attr("CMD_TOGGLE_MODE_TO_PTT_TTS", "已切换到单对话模式")
else:
self.VC_mode = 0
if llm_style_tts:
self.AI_TTS_str = "了解,已切换到长对话模式"
else:
- try:
- self.AI_TTS_str = vc_config.get_attr("CMD_TOGGLE_MODE_TO_LONG_TTS", "已切换到长对话模式")
- except Exception:
- self.AI_TTS_str = "已切换到长对话模式"
+ self.AI_TTS_str = cfg_attr("CMD_TOGGLE_MODE_TO_LONG_TTS", "已切换到长对话模式")
self._vc_persist_vc_mode()
return 0
if it == "volume_set":
return 0
if it == "volume_up":
if llm_style_tts:
- try:
- print("self.VC_TTS_volume add:{}".format(self.VC_TTS_volume))
- except Exception:
- pass
+ print("self.VC_TTS_volume add:{}".format(self.VC_TTS_volume))
self.VC_TTS_volume += 10
if self.VC_TTS_volume > 100:
self.AI_TTS_str = "音量已经是最大啦" if llm_style_tts else "音量已最大"
return 0
if it == "volume_down":
if llm_style_tts:
- try:
- print("self.VC_TTS_volume end:{}".format(self.VC_TTS_volume))
- except Exception:
- pass
+ print("self.VC_TTS_volume end:{}".format(self.VC_TTS_volume))
self.VC_TTS_volume -= 10
if self.VC_TTS_volume < 0:
self.VC_TTS_volume = 0
return 0
if it == "query_battery":
battery = EventMesh.publish("get_battery")
- try:
- print("电量查询:{}".format(battery))
- except Exception:
- pass
+ print("电量查询:{}".format(battery))
self.AI_TTS_str = "电量剩余百分之{}".format(battery)
return 0
if it == "query_voltage":
if it == "query_iccid":
iccid = sim.getIccid()
if iccid != -1 and len(iccid) > 5:
- try:
- print("iccid{}".format(iccid))
- except Exception:
- pass
+ print("iccid{}".format(iccid))
self.AI_TTS_str = "当前卡号为:{}".format(iccid)
else:
self.AI_TTS_str = "卡号查询失败"
if it == "query_imei":
imei = modem.getDevImei()
if imei != -1 and len(imei) > 5:
- try:
- print("IMEI:{}".format(imei))
- except Exception:
- pass
+ print("IMEI:{}".format(imei))
self.AI_TTS_str = "当前设备号为:{}".format(imei)
else:
self.AI_TTS_str = "设备号查询失败"
if it == "alarm_set":
try:
alarm = ujson.loads(cmd["command"]["params_json"])
- try:
- print("params_json:{}".format(cmd["command"]["params_json"]))
- except Exception:
- pass
+ print("params_json:{}".format(cmd["command"]["params_json"]))
add_alarm_tmp = EventMesh.publish("AI_add_alarm", alarm["alarm"])
if add_alarm_tmp[0] > 0:
self.AI_TTS_str = add_alarm_tmp[1]
return 1
except Exception as e:
usys.print_exception(e)
- try:
- self.AI_TTS_str = cmd["command"]["fail_prompt"]
- except Exception:
- self.AI_TTS_str = ""
+ self.AI_TTS_str = cmd.get("command", {}).get("fail_prompt", "")
return -1
if it == "alarm_clear":
try:
self.Close_flag = 1
self.stop_voice_timer.stop()
self.stop_voice_timer.start(30 * 1000, 0, self.exit_voice_message_timer)
- try:
- print("语音留言!!!!!!!!!!")
- except Exception:
- pass
+ print("语音留言!!!!!!!!!!")
return 0
if it == "bt_ble_adv_on":
self.AI_TTS_str = "正在开蓝牙广播"
EventMesh.publish("AI_send_bt_ble_switch_toble", 1)
- try:
- print("正在开蓝牙广播")
- except Exception:
- pass
+ print("正在开蓝牙广播")
return 0
if it == "bt_ble_adv_off":
self.AI_TTS_str = "正在关蓝牙广播"
EventMesh.publish("AI_send_bt_ble_switch_toble", 2)
- try:
- print("正在关蓝牙广播")
- except Exception:
- pass
+ print("正在关蓝牙广播")
return 0
if it == "bt_classic_on":
self.AI_TTS_str = "正在开经典蓝牙"
EventMesh.publish("AI_send_bt_ble_switch_toble", 3)
- try:
- print("正在开经典蓝牙")
- except Exception:
- pass
+ print("正在开经典蓝牙")
return 0
if it == "bt_classic_off":
self.AI_TTS_str = "正在关经典蓝牙"
EventMesh.publish("AI_send_bt_ble_switch_toble", 4)
- try:
- print("正在关经典蓝牙")
- except Exception:
- pass
+ print("正在关经典蓝牙")
return 0
if it == "unbind_confirm":
self.AI_TTS_str = "设备解绑中...."
self.Close_flag = 1
EventMesh.publish("send_unbind_dev_to_iot")
- try:
- print("解绑设备!!!!!!!!!!!!!!")
- except Exception:
- pass
+ print("解绑设备!!!!!!!!!!!!!!")
return 0
if it == "clear_earphone":
self.AI_TTS_str = "正在删除"
EventMesh.publish("clear_earphone_record")
- try:
- print("正在删除")
- except Exception:
- pass
+ print("正在删除")
return 0
return None
def check_text_llm(self,cmd):
# bot_option:优先从 default_config(usr 可覆盖)读取 VC_BOT_ID / VC_WORKFLOW_ID,允许空字符串
_def_bot_id = "7462617881076351002"
_def_workflow_id = "7462621757327196187"
- try:
- if "vc_config" in globals() and vc_config:
- _vc_bot_id = vc_config.get_attr("VC_BOT_ID", _def_bot_id)
- _vc_workflow_id = vc_config.get_attr("VC_WORKFLOW_ID", _def_workflow_id)
- if _vc_bot_id is None:
- _vc_bot_id = ""
- if _vc_workflow_id is None:
- _vc_workflow_id = ""
- else:
- _vc_bot_id, _vc_workflow_id = _def_bot_id, _def_workflow_id
- except Exception:
- _vc_bot_id, _vc_workflow_id = _def_bot_id, _def_workflow_id
+ _vc_bot_id = cfg_attr("VC_BOT_ID", _def_bot_id) or ""
+ _vc_workflow_id = cfg_attr("VC_WORKFLOW_ID", _def_workflow_id) or ""
json_data = \
{
"header": {
print("outbound_attributess_provider是VC_TTS_voice_type里的:{}".format(self.VC_TTS_voice_type[self.VC_TTS_voice_key]["outbound_attributess_provider"]))
# 根据配置设置默认 bot/workflow,并允许 VC_TTS_voice_type 覆盖
- try:
- if "vc_config" in globals() and vc_config:
- opt = vc_config.get_attr("DIALOG_BOT_OPTION", None)
- if isinstance(opt, dict):
- if "bot_id" in opt:
- json_data["payload"]["dialog_attributes"]["cfg"]["bot_option"]["bot_id"] = opt.get("bot_id") or ""
- if "workflow_id" in opt:
- json_data["payload"]["dialog_attributes"]["cfg"]["bot_option"]["workflow_id"] = opt.get("workflow_id") or ""
- if "use_workflow" in opt:
- json_data["payload"]["dialog_attributes"]["cfg"]["bot_option"]["use_workflow"] = bool(opt.get("use_workflow"))
- except Exception:
- pass
-
- try:
- # voice 配置可覆盖 bot_id/workflow_id/openai_option
- cur = self.VC_TTS_voice_type[self.VC_TTS_voice_key]
- if isinstance(cur, dict):
- if cur.get("bot_id"):
- json_data["payload"]["dialog_attributes"]["cfg"]["bot_option"]["bot_id"] = cur.get("bot_id")
- if "workflow_id" in cur:
- json_data["payload"]["dialog_attributes"]["cfg"]["bot_option"]["workflow_id"] = cur.get("workflow_id") or ""
- if cur.get("openai_option"):
- json_data["payload"]["dialog_attributes"]["cfg"]["openai_option"] = cur.get("openai_option")
- except Exception:
- pass
+ opt = cfg_attr("DIALOG_BOT_OPTION", None)
+ if isinstance(opt, dict):
+ _bo = json_data["payload"]["dialog_attributes"]["cfg"]["bot_option"]
+ if "bot_id" in opt:
+ _bo["bot_id"] = opt.get("bot_id") or ""
+ if "workflow_id" in opt:
+ _bo["workflow_id"] = opt.get("workflow_id") or ""
+ if "use_workflow" in opt:
+ _bo["use_workflow"] = bool(opt.get("use_workflow"))
- try:
+ cur = self.VC_TTS_voice_type.get(self.VC_TTS_voice_key)
+ if isinstance(cur, dict):
_bo = json_data["payload"]["dialog_attributes"]["cfg"]["bot_option"]
- if not _bo.get("bot_id", "") or not _bo.get("workflow_id", ""):
- _bo["use_workflow"] = False
- except Exception:
- pass
- try:
- if "vc_config" in globals() and vc_config:
- p = vc_config.get_attr("DIALOG_PROVIDER_DEFAULT", None)
- if p:
- json_data["payload"]["dialog_attributes"]["provider"] = p
- except Exception:
- pass
+ if cur.get("bot_id"):
+ _bo["bot_id"] = cur.get("bot_id")
+ if "workflow_id" in cur:
+ _bo["workflow_id"] = cur.get("workflow_id") or ""
+ if cur.get("openai_option"):
+ json_data["payload"]["dialog_attributes"]["cfg"]["openai_option"] = cur.get("openai_option")
- try:
- if "vc_config" in globals() and vc_config and vc_config.get_bool("KEYWORDS_FROM_VOICE_TYPE", False):
- keywords = []
- for key in self.VC_TTS_voice_type:
- keywords.append(key)
- json_data["payload"]["inbound_attributes"]["cfg"]["keywords"] = keywords
- except Exception:
- pass
+ _bo = json_data["payload"]["dialog_attributes"]["cfg"]["bot_option"]
+ if not _bo.get("bot_id", "") or not _bo.get("workflow_id", ""):
+ _bo["use_workflow"] = False
+
+ p = cfg_attr("DIALOG_PROVIDER_DEFAULT", None)
+ if p:
+ json_data["payload"]["dialog_attributes"]["provider"] = p
+
+ if cfg_bool("KEYWORDS_FROM_VOICE_TYPE", False):
+ json_data["payload"]["inbound_attributes"]["cfg"]["keywords"] = list(self.VC_TTS_voice_type.keys())
if self.dialog_attributes_provider != None:
json_data["payload"]["dialog_attributes"]["provider"] = self.dialog_attributes_provider
if self.commands_mode !=0 :
json_data["payload"]["commands"] = []
- if self.VC_mode == 0 :#and dev_type != "7PIN_BK_coze":#长对话模式打开vad
+ # 长对话:本地 imsl 断句时保持 disable_vad=true;否则走云端 VAD(realtime)
+ if self.VC_mode == 0 and not (
+ hasattr(self, "_vc_local_vad_endpoint") and self._vc_local_vad_endpoint()
+ ):
json_data["payload"]["inbound_attributes"]["disable_vad"] = False
# 新会话开始:在收到服务端 started 前,禁止发送音频帧(避免 session not initialized)
self._vc_session_started = 0
- try:
+ if hasattr(self.fsm, "on_session_start_request"):
self.fsm.on_session_start_request()
- except Exception:
- pass
try:
vc_proto_log_start_from_v25(json_data, getattr(self, "VC_mode", -1))
except Exception:
# -*- coding: utf-8 -*-
"""AI_VC mixin:ASR 上行/录音、TTS 下行、播放队列与本地采播。"""
from vc_session_imports import * # noqa: F401,F403
+from vc_utils import cfg_bool, cfg_int, cfg_attr
import _thread
class VCSessionMediaMixin:
return False
def _vc_arm_record_start_tone(self):
"""AI 键开录意图:待服务端允许上行后再播 start.mp3。"""
- try:
- self._vc_pending_record_start_tone = 1
- except Exception:
- pass
+ self._vc_pending_record_start_tone = 1
def _vc_record_start_tone_debug(self):
- try:
- if "vc_config" in globals() and vc_config and (
- vc_config.get_bool("KEY_LED_DEBUG", False)
- or vc_config.get_bool("LED_STATE_DEBUG", False)
- ):
- return True
- except Exception:
- pass
- return False
+ return cfg_bool("KEY_LED_DEBUG", False) or cfg_bool("LED_STATE_DEBUG", False)
def _vc_try_play_record_start_tone_when_ready(self, via=""):
"""收到 server.started / asr.started(PTT)或会话已 started 的按键续聊后再滴。"""
"""开录提示音;RECORD_START_TONE_FILE=None 时不播(REQ-AI-07)。"""
try:
path = None
- hold_ms = 180
- if "vc_config" in globals() and vc_config:
- cfg = vc_config.get_attr("RECORD_START_TONE_FILE", None)
- if cfg is not None and str(cfg).strip():
- path = str(cfg).strip()
- hold_ms = int(vc_config.get_int("RECORD_START_TONE_GAP_MS", hold_ms))
+ hold_ms = cfg_int("RECORD_START_TONE_GAP_MS", 180)
+ cfg = cfg_attr("RECORD_START_TONE_FILE", None)
+ if cfg is not None and str(cfg).strip():
+ path = str(cfg).strip()
if not path:
return False
print("[VC] record_start_tone ready via={} path={}".format(via or "-", path))
"""已废弃:K8 无按键确认音;仅 RECORD_START_TONE(start.mp3)。配置缺省则不播。"""
try:
path = None
- hold_ms = 300
- if "vc_config" in globals() and vc_config:
- cfg = vc_config.get_attr("KEY_PRESS_TONE_FILE", None)
- if cfg is not None and str(cfg).strip():
- path = str(cfg).strip()
- hold_ms = int(vc_config.get_int("KEY_PRESS_TONE_DELAY_MS", hold_ms))
+ hold_ms = cfg_int("KEY_PRESS_TONE_DELAY_MS", 300)
+ cfg = cfg_attr("KEY_PRESS_TONE_FILE", None)
+ if cfg is not None and str(cfg).strip():
+ path = str(cfg).strip()
if not path:
return False
print("[VC] key_press_tone via={} path={}".format(via or "-", path))
return False
def _vc_arm_key_press_tone(self):
- try:
- self._vc_pending_key_press_tone = 1
- except Exception:
- pass
+ self._vc_pending_key_press_tone = 1
def _vc_try_play_key_press_tone_when_ready(self, via=""):
try:
pass
try:
if getattr(self, "VC_record_state_flag", 0) == 1:
+ self._vc_local_vad_send_audio_create()
self.VC_Speech_Start_now()
elif getattr(self, "VC_record_state_flag", 0) == 0:
self.VC_Speech_Start()
if getattr(self, "VC_record_state_flag", 0) == 1:
+ self._vc_local_vad_send_audio_create()
self.VC_Speech_Start_now()
except Exception as e:
usys.print_exception(e)
self._ptt_end_led_suppress()
except Exception:
pass
- try:
- print("[VC][user_record] uplink_open reason={} rec={}".format(
- reason, getattr(self, "VC_record_state_flag", -1)))
- except Exception:
- pass
+ print("[VC][user_record] uplink_open reason={} rec={}".format(
+ reason, getattr(self, "VC_record_state_flag", -1)))
def _vc_user_record_entry(self, reason=""):
"""开录统一入口;start.mp3 仅按键/PTT 开录时播。"""
pass
except Exception as e:
usys.print_exception(e)
- hold_ms = 180
- try:
- if "vc_config" in globals() and vc_config:
- hold_ms = int(vc_config.get_int("RECORD_START_TONE_GAP_MS", hold_ms))
- except Exception:
- pass
+ hold_ms = cfg_int("RECORD_START_TONE_GAP_MS", 180)
played = False
try:
if self._vc_should_play_record_start_tone(reason):
return t not in (VCTurnState.Idle, VCTurnState.Listening)
except Exception:
return False
+
+ def _vc_vad_ready(self):
+ return getattr(self, "is_VAD", 0) == 1 and getattr(self, "vad", None) is not None
+
+ def _vc_local_vad_debug_only(self):
+ return bool(getattr(self, "_local_vad_debug_only", True))
+
+ def _vc_local_vad_endpoint(self):
+ """长对话以本地 imsl 断句,关闭云端 VAD(disable_vad=true + audio.create/completed)。"""
+ return self._vc_vad_ready() and not self._vc_local_vad_debug_only()
+
+ def _vc_vad_feed_record_pcm(self, record_buf, record_len):
+ """录音 PCM 按 VAD_data_len 切块送 imsl process,返回 0/1/2(2=句末)。"""
+ if not self._vc_vad_ready() or record_len <= 0:
+ return 0
+ frame_len = int(getattr(self, "VAD_data_len", 640))
+ if frame_len <= 0:
+ return 0
+ tail = getattr(self, "_vc_vad_pcm_tail", None)
+ if tail is None:
+ tail = bytearray()
+ self._vc_vad_pcm_tail = tail
+ try:
+ tail.extend(record_buf[:record_len])
+ except Exception:
+ return 0
+ vad_state = 0
+ while len(tail) >= frame_len:
+ chunk = bytes(tail[:frame_len])
+ tail = tail[frame_len:]
+ self._vc_vad_pcm_tail = tail
+ st = int(self.vad.process(chunk, frame_len))
+ if st == 2:
+ try:
+ self.vad.clear()
+ except Exception:
+ pass
+ vad_state = 2
+ elif st == 1:
+ vad_state = 1
+ elif vad_state != 2:
+ vad_state = 0
+ return vad_state
+
+ def _vc_local_vad_send_audio_create(self):
+ if not self._vc_local_vad_endpoint():
+ return
+ if getattr(self, "_ptt_audio_created", 0) == 1:
+ return
+ try:
+ self.AI_client_VC_send_speech()
+ except Exception as e:
+ usys.print_exception(e)
+
+ def _vc_local_vad_send_audio_completed(self, defer_stop=True):
+ """本地断句:通知服务端本轮 PCM 结束;defer_stop 时长对话 merge 窗内仅止上行。"""
+ if not self._vc_local_vad_endpoint():
+ return
+ try:
+ json_data = {"header": {"event": "audio.completed"}}
+ self.AI_client_VC_send(ujson.dumps(json_data))
+ self._ptt_audio_created = 0
+ print("[VC][proto] audio.completed send local_vad defer={}".format(defer_stop))
+ except Exception as e:
+ usys.print_exception(e)
+ if not defer_stop:
+ self.request_uplink_stop("local.vad.end/audio.completed")
+
+ def _vc_local_vad_on_endpoint(self):
+ """本地 VAD 句末:silence_gate + merge 窗 + audio.completed。"""
+ if not self._vc_local_vad_endpoint():
+ return
+ if getattr(self, "record_data_save_flag", 0) != 0:
+ return
+ if not self._vc_is_long_dialogue_mode():
+ return
+ print("[VAD][local] endpoint -> silence_gate")
+ self._turn_has_vad_silence = 1
+ try:
+ self._vc_asr_completed_ms = utime.ticks_ms()
+ except Exception:
+ pass
+ if self._vc_long_dialogue_defer_vad_stop():
+ self._vc_defer_vad_uplink_stop = 1
+ self._server_vad_silence = 1
+ self._uplink_mark_end("local.vad.end/defer")
+ self._vc_pending_asr_completed_stop = 1
+ print("[VC][VAD] local endpoint defer (merge window)")
+ self._vc_local_vad_send_audio_completed(defer_stop=True)
+ return
+ self._server_vad_silence = 1
+ self._uplink_mark_end("local.vad.end")
+ self._vc_local_vad_send_audio_completed(defer_stop=False)
+
+ def _vc_vad_on_record_pcm(self, record_buf, record_len):
+ """录音线程喂本地 imsl VAD;endpoint 模式驱动断句,debug_only 仅打日志。"""
+ vad_state = self._vc_vad_feed_record_pcm(record_buf, record_len)
+ if vad_state == 1:
+ prev = int(getattr(self, "_vc_local_vad_last_state", 0))
+ if prev != 1:
+ print("[VAD][local] speech start")
+ self._vc_local_vad_last_state = 1
+ if self._vc_local_vad_endpoint() and self._vc_asr_continue_merge_active():
+ self._server_vad_silence = 0
+ self._vc_defer_vad_uplink_stop = 0
+ self._vc_pending_asr_completed_stop = 0
+ self._vc_local_vad_send_audio_create()
+ print("[VAD][local] continue merge -> resume uplink")
+ self.VAD_count = int(getattr(self, "VAD_count", 0)) + 1
+ if self.VAD_count >= 20 and self._vc_tts_pipeline_busy():
+ print("[VAD][local] speech hold {} frames (~400ms) interrupt".format(
+ self.VAD_count))
+ if not self._vc_local_vad_debug_only():
+ EventMesh.publish("publish_AI_btnInfo", {"func": self.AI_client_VC_RequestToSpeak})
+ return 1
+ if vad_state == 2:
+ frames = int(getattr(self, "VAD_count", 0))
+ print("[VAD][local] speech end frames={}".format(frames))
+ self._vc_local_vad_last_state = 0
+ self.VAD_count = 0
+ if not self._vc_local_vad_debug_only():
+ self._vc_local_vad_on_endpoint()
+ return 0
+ return 0
+
+ def _vc_vad_reset_feed(self):
+ self._vc_vad_pcm_tail = bytearray()
+ self._vc_local_vad_last_state = 0
+ if self._vc_vad_ready():
+ self.vad.custom_vad_reset()
+
def _vc_clear_stale_record_state(self, reason=""):
"""record_state_flag 非 0 但可能无真实录音时先停录复位,避免 uplink 门控拒开麦。"""
try:
return False
debounce_ms = 450 if user_intr else 1200
last_attr = "_vc_last_interrupt_uplink_ms" if user_intr else "_vc_last_auto_uplink_ms"
- if "vc_config" in globals() and vc_config:
- key = "VC_INTERRUPT_UPLINK_DEBOUNCE_MS" if user_intr else "VC_AUTO_UPLINK_DEBOUNCE_MS"
- debounce_ms = int(vc_config.get_int(key, debounce_ms))
+ key = "VC_INTERRUPT_UPLINK_DEBOUNCE_MS" if user_intr else "VC_AUTO_UPLINK_DEBOUNCE_MS"
+ debounce_ms = cfg_int(key, debounce_ms)
now = utime.ticks_ms()
last = getattr(self, last_attr, 0)
if last and utime.ticks_diff(now, last) < debounce_ms:
try:
if not self._vc_capture_allowed(reason):
- try:
- print("[VC][uplink_ctrl] Deny START by {} cause=playback_busy".format(reason))
- except Exception:
- pass
+ print("[VC][uplink_ctrl] Deny START by {} cause=playback_busy".format(reason))
return
except Exception:
return
# ===== 业务门控(收敛到 FSM turn/session)=====
try:
if getattr(self.fsm, "session", VCSessionState.Disconnected) != VCSessionState.Started:
- try:
- if reason in _key_reasons:
- print("[VC][uplink_ctrl] Defer START by {} (wait server.started)".format(reason))
- elif reason in ("canceled", "local.play_end", "audio.played"):
- print("[VC][uplink_ctrl] Deny START by {} cause=fsm.session".format(reason))
- except Exception:
- pass
+ if reason in _key_reasons:
+ print("[VC][uplink_ctrl] Defer START by {} (wait server.started)".format(reason))
+ elif reason in ("canceled", "local.play_end", "audio.played"):
+ print("[VC][uplink_ctrl] Deny START by {} cause=fsm.session".format(reason))
return
turn = getattr(self.fsm, "turn", VCTurnState.Idle)
# 仅 Listening/SpeechEnded 允许开麦;其它阶段拒绝(I0:禁止在门控里篡改 turn)
if turn not in (VCTurnState.Listening, VCTurnState.SpeechEnded):
- try:
- if reason in _key_reasons or reason in ("canceled", "local.play_end", "audio.played"):
- print("[VC][uplink_ctrl] Deny START by {} cause=fsm.turn({})".format(reason, turn))
- except Exception:
- pass
+ if reason in _key_reasons or reason in ("canceled", "local.play_end", "audio.played"):
+ print("[VC][uplink_ctrl] Deny START by {} cause=fsm.turn({})".format(reason, turn))
return
except Exception:
return
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
+ 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)))
return
# 新一轮开始录音:允许上行(上一轮可能已置 silence 闸门)
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
+ 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))
# 聆听灯与上行一并开启(见 _vc_user_record_uplink_open)
try:
if getattr(self, "_vc_defer_listening_led", 0) != 1:
# h_data_b = bytes(h_data)
# self.AI_client_VC_send(h_data_b)
AI_record_tmp_queue_len = 0
- vad_buf = bytearray()
- VAD_data_count = 0
vad_state = 0
self.VAD_count = 0
+ self._vc_vad_reset_feed()
while True:
try:
if self.VC_record_thread_lock == 2:
# if count >150*1024:
# self.record_fd.close()
#self.record_fd = None
- #VAD检测
- if self.is_VAD == 1:
+ # VAD 检测:录音 PCM → imsl run_vad/vad_detect(custom_vad_process 封装)
+ if self._vc_vad_ready():
+ vad_state = self._vc_vad_on_record_pcm(Record_read_buf, Record_len)
+ else:
vad_state = 0
- tmp_c = 1000
- while True:
- tmp_c -=1
- if tmp_c <=0:
- break
- #vad_buf_len = len(vad_buf)
- if VAD_data_count == 0:#没数据的时候
- vad_buf = Record_read_buf[:self.VAD_data_len]
- VAD_data_count = self.VAD_data_len
- self.vad.custom_vad_reset()#重置vad
- else:#有数据的时候
- if Record_len - VAD_data_count < self.VAD_data_len :#剩余长度不够一次填充,先保留,但不填算法
- vad_buf = Record_read_buf[VAD_data_count:Record_len]
- VAD_data_count = 0
- break
- else:#剩余长度够填一次数据
- vad_buf = Record_read_buf[VAD_data_count:VAD_data_count+self.VAD_data_len]
- VAD_data_count += len(vad_buf)
- #print("vad_buf_len:{},{}".format(len(vad_buf),VAD_data_count))
-
- if len(vad_buf) >= self.VAD_data_len:
- vad_state = self.vad.custom_vad_process(vad_buf,len(vad_buf))#给vad数据
- #print("vad_state:{}".format(vad_state))
-
- if VAD_data_count >= Record_len:
- VAD_data_count = 0
- break
- if vad_state == 1:
- print("检测到VAD=1!!!!!!!!!!!!!")
-
- # EventMesh.publish("publish_AI_btnInfo",{"func":self.AI_client_VC_RequestToSpeak})#打断
- # RequestToSpeak_flag = 1
-
- self.VAD_count+=1
- if self.VAD_count >= 20:
- EventMesh.publish("publish_AI_btnInfo",{"func":self.AI_client_VC_RequestToSpeak})#打断
-
- else:
- if self.VAD_count != 0:
- EventMesh.publish("publish_AI_btnInfo",{"func":self.VC_Play_Pause,"data":0})#恢复音频播放
- self.VAD_count = 0
if self._vc_tts_pipeline_busy():
pass
- if vad_state == 1:
+ if vad_state == 1 and not self._vc_local_vad_debug_only():
self.AI_record_tmp_queue.put(read_buf)#入缓存队列
AI_record_tmp_queue_len += len(read_buf)
self._vc_asr_completed_stop_tick()
except Exception:
pass
- VAD_data_count = 0
+ if not self._vc_vad_ready():
+ self._vc_vad_pcm_tail = bytearray()
if self.VC_record_state_flag <=1 :#没发送前先存起来
self.AI_record_tmp_queue.put(read_buf)
AI_record_tmp_queue_len += len(read_buf)
# - Push-To-Talk 在 audio.create 前禁止发帧
if VC_PROTO_GUARDS and (
(self._vc_session_started != 1 and self.record_data_save_flag == 0) or
- (self.VC_mode == 1 and self._ptt_audio_created != 1 and self.record_data_save_flag == 0)
+ (
+ (self.VC_mode == 1 or self._vc_local_vad_endpoint())
+ and self._ptt_audio_created != 1
+ and self.record_data_save_flag == 0
+ )
):
# 未 ready:转入缓存,等待 started 再发(并做容量控制)
try:
except Exception:
pass
# 关键日志:定位“tts 结束绿灯仍不灭”究竟是 base 态(如 charging/full)还是 playing 未退出
- try:
- if "vc_config" in globals() and vc_config and (
- vc_config.get_bool("LED_DEBUG", False) or vc_config.get_bool("KEY_LED_DEBUG", False) or vc_config.get_bool("HW_STATUS_DEBUG", False)
- ):
- try:
- led = EventMesh.publish("get_led_debug_state")
- except Exception:
- led = None
- print("[VC] VC_Play_End led={}".format(led))
- except Exception:
- pass
+ if (
+ cfg_bool("LED_DEBUG", False)
+ or cfg_bool("KEY_LED_DEBUG", False)
+ or cfg_bool("HW_STATUS_DEBUG", False)
+ ):
+ try:
+ led = EventMesh.publish("get_led_debug_state")
+ except Exception:
+ led = None
+ print("[VC] VC_Play_End led={}".format(led))
def _vc_tts_bytes_per_sec(self):
try:
return int(self.VC_play_samplerate) * 2
},
}
- if self.VC_mode == 1:#单对话模式
+ if self.VC_mode == 1 or self._vc_local_vad_endpoint():
# 协议门控(可用 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
+ tag = "ptt" if self.VC_mode == 1 else "local_vad"
+ print("[VC][proto] audio.create send mode={} session_started={} proto_guards={}".format(
+ tag, self._vc_session_started, VC_PROTO_GUARDS))
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
+ print("[VC][proto] audio.create SKIP session_started={} VC_PROTO_GUARDS={} "
+ "(等对端 started 后再开麦)".format(self._vc_session_started, VC_PROTO_GUARDS))
def AI_client_VC_end_speech(self):
json_data = \
{
-# -*- coding: utf-8 -*-\r
-"""UART 与蓝牙侧通道。"""\r
-try:\r
- from qp_log import qp_print as print\r
-except Exception:\r
- pass\r
-import usys\r
-import ujson\r
-import utime\r
-import osTimer\r
-import _thread\r
-import base64\r
-import modem\r
-import request\r
-import constants\r
-import EventMesh\r
-from queue import Queue\r
-from machine import UART\r
-try:\r
- import vc_config\r
-except Exception:\r
- vc_config = None\r
-\r
-#HEARDER+TOTALLEN+DATELEN+DATA\r
-HEARDER = "FFFE"\r
-TOTALLEN = "00000000"\r
-DATELEN = "0000"\r
-DATA = {}\r
-class AI_UART():\r
- #串口命令通道\r
- def __init__(self):\r
- self.send_count=0\r
- self.AI_uart = UART(UART.UART4, 230400, 8, 0, 1, 0)\r
- self.AI_uart.set_callback(self.uart_call)\r
- \r
- EventMesh.subscribe("bt_ota_run",self.bt_ota_run)#\r
- EventMesh.subscribe("start_ota",self.start_ota)\r
- EventMesh.subscribe("end_ota",self.end_ota)\r
- EventMesh.subscribe("send_bt_switch_toble",self.send_bt_switch_toble)\r
- EventMesh.subscribe("send_ble_switch_toble",self.send_ble_switch_toble)\r
- EventMesh.subscribe("send_ble_scan",self.send_ble_scan)\r
- EventMesh.subscribe("send_connect_bt_mac",self.send_connect_bt_mac)\r
- EventMesh.subscribe("send_disconnect_bt_mac",self.send_disconnect_bt_mac)\r
- EventMesh.subscribe("send_imei_to_ble",self.send_imei_to_ble)\r
- EventMesh.subscribe("send_get_connect_bt_state",self.send_get_connect_bt_state)\r
- EventMesh.subscribe("recv_bt_connect_rest",self.recv_bt_connect_rest)\r
- EventMesh.subscribe("AI_send_bt_ble_switch_toble",self.AI_send_bt_ble_switch_toble)\r
- EventMesh.subscribe("get_bt_versions",self.get_bt_versions)\r
- EventMesh.subscribe("adjust_volume_toBle",self.adjust_volume_toBle)\r
- EventMesh.subscribe("clear_earphone_record",self.clear_earphone_record)\r
- self.bt_switch = 0\r
- self.ble_switch = 0\r
- self.uart_timer = osTimer()\r
- self.get_bt_connect_timer = osTimer()\r
- self.get_bt_connect_flag = 0\r
- self.uart_timer_count = 0\r
- self.bt_ota_flag = 0\r
- self.read_ack_flag = 0\r
- self.ping_json_str = {}\r
- self.ping_json_str_tmp =""\r
- self.read_uart_data = ""\r
- self.bt_versions=""\r
- try:\r
- uart_ok = False\r
- if "vc_config" in globals() and vc_config:\r
- uart_ok = vc_config.uart_supported()\r
- except Exception:\r
- uart_ok = False\r
- if uart_ok:\r
- self.uart_send_queue = Queue(100)\r
- self.uart_send_queue_thread_id = _thread.start_new_thread(self.uart_send_queue_thread, ())\r
-\r
- self.uart_recv_queue = Queue(100)\r
- self.uart_recv_queue_thread_id = _thread.start_new_thread(self.uart_recv_queue_thread, ())\r
- self.send_get_versions()#获取蓝牙版本\r
- \r
- def uart_send_queue_thread(self):\r
- while True:\r
- data = self.uart_send_queue.get()\r
- \r
- #EventMesh.debug_log("Info_queue:data = {}".format(data))\r
- if data != None:\r
- try:\r
- if len(data) != 0:\r
- print("send_queu_uart_data2:{} data:{}".format(data,data["data"]))\r
- # json_str =ujson.dumps(data)\r
- if data["event"] == "uart_send_data":\r
- print("send_queu_uart_data sucess data:{} {}".format(data["data"],type(data["data"])))\r
- self.uart_queue_send_data(data["data"])\r
- if "resend_flag" in data:\r
- print("send_reset_cb:{} {}".format(data["resend_flag"],data["ACK_time"]))\r
- if data["resend_flag"] == 1:\r
- self.send_count = 5#重试5次\r
- ack_timer = 0 #单次最大等待时间\r
- count = 0\r
- if "ACK_time" in data:\r
- if data["ACK_time"] == None:\r
- ack_timer = 100#最大重发5次,没ack或者返回error重发\r
- else:\r
- ack_timer = data["ACK_time"]\r
- if ack_timer > 0:\r
- while self.send_count:\r
- \r
- if self.send_count <=0 or self.read_ack_flag == 1:\r
- print("4G串口重发机制退出:{} self.read_ack_flag:{} json_str:{}".format(self.send_count,self.read_ack_flag,data["data"]))\r
- break\r
- if count >= ack_timer:\r
- count = 0\r
- print("串口异常,重发:")\r
- self.uart_queue_send_data(data["data"])\r
- self.send_count-=1\r
- count += 1\r
- utime.sleep_ms(1)\r
-\r
- except Exception as e:\r
- usys.print_exception(e)\r
- utime.sleep_ms(10)\r
- \r
- def uart_recv_queue_thread(self):\r
- while True:\r
- data = self.uart_recv_queue.get()\r
- \r
- #EventMesh.debug_log("Info_queue:data = {}".format(data))\r
- if data != None:\r
- try:\r
- if len(data) != 0:\r
- print("recv_queu_uart_data2:{}".format(data))\r
- # json_str =ujson.dumps(data)\r
- # queue_data={"event":"uart_recv_data"}\r
- if data["event"] == "uart_recv_data":\r
- print("recv_queu_uart_data sucess data:{}".format(type(data["event"])))\r
- self.pares_uart_data()\r
- except Exception as e:\r
- usys.print_exception(e)\r
-\r
- def send_imei_to_ble(self,event,msg):\r
- EventMesh.publish("publish_AI_btnInfo",{"func":self.send_imei_to_ble_cb})\r
-\r
- def send_imei_to_ble_cb(self):\r
- self.read_ack_flag=0\r
- imei = modem.getDevImei()\r
- json_data = \\r
- {\r
- \r
- "event": "imei",\r
- "data":str(imei)\r
- \r
- }\r
- json_str =ujson.dumps(json_data)\r
- print("send imei:{}".format(json_str))\r
- self.send_data(json_str)\r
- pass\r
- def send_connect_bt_mac(self,event,msg):\r
- self.read_ack_flag=0\r
- json_data = \\r
- {\r
- "event": "connect_bt",\r
- "data":msg\r
- }\r
- json_str =ujson.dumps(json_data)\r
- self.send_data(json_str,1,2000)\r
- # self.send_reset_cb(json_str,0,2000) #每2s发送一次 10ms为单位\r
- pass\r
- def send_disconnect_bt_mac(self,event,msg):\r
- self.read_ack_flag=0\r
- json_data = \\r
- {\r
- "event": "disconnect_bt",\r
- "data":msg\r
- }\r
- json_str =ujson.dumps(json_data)\r
- self.send_data(json_str,1)\r
- # self.send_reset_cb(json_str)\r
-\r
- pass\r
- def uart_timer_cb(self, *args, **kwargs):\r
- self.uart_timer_count+=1\r
- if self.uart_timer_count >40:\r
- self.read_uart_data = ""\r
- if self.uart_timer_count >200:\r
- self.read_uart_data = ""\r
- self.uart_timer.stop()\r
- def split_combined_json(self,combined_str):\r
- # 将连续的JSON字符串分割为多个独立的JSON字符串列表\r
- #\r
- # 参数:\r
- # combined_str: 多个JSON拼接的字符串\r
- # 返回:\r
- # 分割后的\r
- json_list = []\r
- start_index = 0\r
- brace_count = 0 # 用于匹配{}括号\r
- print("combined_str:{}".format(combined_str))\r
- for i, char in enumerate(combined_str):\r
- if char == '{':\r
- brace_count += 1\r
- elif char == '}':\r
- brace_count -= 1\r
- \r
- # 当括号完全匹配(count=0)时,说明一个完整的JSON对象结束\r
- if brace_count == 0:\r
- # 提取从start_index到当前位置的子串(包含当前})\r
- json_str = combined_str[start_index:i+1].strip()\r
- if json_str: # 避免空字符串\r
- json_list.append(json_str)\r
- start_index = i + 1 # 下一个JSON的起始位置\r
- print("json_list{}".format(json_list))\r
- \r
- return json_list\r
- \r
- def uart_call(self,para):\r
- queue_data={"event":"uart_recv_data"}\r
-\r
- self.uart_recv_queue.put(queue_data)\r
- # print("uart_call start")\r
- # EventMesh.publish("publish_AI_btnInfo",{"func":self.pares_uart_data})\r
- # print("uart_call end")\r
- #print("ai_uart:{}".format(para)) \r
- #[{"event":""},{},{}]\r
- def pares_uart_data(self): \r
- uart_data = self.AI_uart.read()\r
- self.uart_timer.start(10, 1, self.uart_timer_cb)\r
- self.uart_timer_count = 0\r
- ack_flag = 0#是否要返回ack\r
- print("uart_data:{}",uart_data)\r
- uart_data_str = uart_data.decode('utf-8')\r
- \r
- self.read_uart_data = self.read_uart_data +uart_data_str\r
- try:\r
- ujson.loads(self.read_uart_data)\r
- except Exception as e:\r
- print("json数据不完整:self.read_uart_data{}".format(self.read_uart_data))\r
- usys.print_exception(e)\r
- return\r
- self.uart_timer.stop()\r
- self.uart_timer_count = 0\r
- self.playload_data(self.read_uart_data)\r
-\r
- # 分割JSON\r
- # json_strings = self.split_combined_json(uart_data_str)\r
- \r
- # # 逐个解析并处理\r
- # for i, json_str in enumerate(json_strings, 1):\r
- # print("第{}个JSON{}".format(i,json_str))\r
- # try:\r
- # data = ujson.loads(json_str)\r
- \r
- # # 在这里添加你的业务逻辑,比如根据event处理不同事件\r
- # self.uart_timer.stop()\r
- # self.uart_timer_count = 0\r
- # self.playload_data(self.read_uart_data)\r
- # # if data.get("event") == "bt_connect_single":\r
- \r
- # # elif data.get("event") == "bt_scan_rest":\r
- \r
- # except Exception as e:\r
- # print("JSON解析错误:原始字符串:")\r
- # print("-" * 50)\r
-\r
- \r
- \r
- # print("uart_data_str:{}",uart_data_str)\r
- # if len(uart_data_str) < (HEARDER+1+1):\r
- # return\r
- # head = uart_data_str[0:4]\r
- # pack_flag = uart_data_str[4:5]\r
- # recvflag = uart_data_str[5:6]\r
- \r
- \r
- # if head == HEARDER:\r
- # if pack_flag == "1": #分包数据\r
- # if recvflag == "1": #未发送完成\r
- # self.ping_json_str_tmp+=uart_data_str[6:]\r
- # pass\r
- # else:\r
- # self.playload_data(self.ping_json_str_tmp)\r
- # pass\r
- # else:\r
- # self.playload_data(uart_data_str[6:])\r
- \r
- # else:\r
- # print("uart is not FFFE:") \r
-\r
- def playload_data(self,msg):\r
- ack_flag=0\r
- try:\r
- print("playload_data:{}".format(msg))\r
- jsload_data = ujson.loads(msg)\r
- #print("AI_client_VC_recv jsload_data = {}".format(jsload_data))\r
- \r
- if jsload_data["event"] == "AI_KEY_PRESS" :#AI按键按下\r
- EventMesh.publish("publish_AI_btnInfo",{"func":self.AI_key_press}) \r
- ack_flag = 1\r
- elif jsload_data["event"] == "BT_AI_KEY_PRESS" :#蓝牙耳机key ai对话模式不支持长按对话模式 只支持短按按键对话模式 重新定义按键\r
- EventMesh.publish("publish_AI_btnInfo",{"func":self.BT_AI_key_press}) \r
- ack_flag = 1\r
- elif jsload_data["event"] == "AI_PWR_PRESS" :#电源按键按下\r
- EventMesh.publish("publish_AI_btnInfo",{"func":self.pwk_key_release}) \r
- ack_flag = 1\r
- elif jsload_data["event"] == "bt_scan_rest":#扫描列表 #蓝牙停止扫描后主动向4g发送扫描列表需要发送ack\r
- EventMesh.publish("send_bt_scan_list",jsload_data)\r
- ack_flag=1\r
- elif jsload_data["event"]=="bt_connect_single": #收到蓝牙主动发送过来的单个连接蓝牙耳机的连接状态 需要发送ack\r
- EventMesh.publish("save_bt_connect_list",jsload_data)\r
- ack_flag=1\r
- \r
- elif jsload_data["event"]=="need_send_bt_connect_list": #发送连接蓝牙连接记录列表 不需要发送ack\r
- self.get_bt_connect_timer.stop()\r
- self.get_bt_connect_flag = 0\r
- EventMesh.publish("save_bt_connect_list",jsload_data) #先保存连接记录再发送连接耳机列表to IOT\r
- EventMesh.publish("send_bt_connect_list")\r
- \r
- elif jsload_data["event"]=="get_ble_switch":\r
- ble_switch_flag = EventMesh.publish("get_storage_config","switch_ble_state")#ble开关 不需要发送ack\r
- if ble_switch_flag == None:\r
- ble_switch_flag = "1"\r
- EventMesh.publish("send_ble_switch_toble",str(ble_switch_flag))\r
- \r
- pass\r
- elif jsload_data["event"]=="get_bt_switch":\r
- bt_switch_flag = EventMesh.publish("get_storage_config","switch_bt_state")#bt开关 不需要发送ack\r
- if bt_switch_flag == None:\r
- bt_switch_flag = "1"\r
- EventMesh.publish("send_bt_switch_toble",bt_switch_flag)\r
- \r
- pass\r
- elif jsload_data["event"]=="get_cat1_imei": #蓝牙主动向4G获取imei 4g不需要发送ack 蓝牙收到imei需要回ack给4改\r
- EventMesh.publish("send_imei_to_ble")\r
- ack_flag=1\r
- pass\r
- elif jsload_data["event"] == "post_bt_connect_rest": #蓝牙主动蓝牙耳机连接状态 需要发送ack给蓝牙\r
- EventMesh.publish("recv_bt_connect_rest",jsload_data)\r
- ack_flag=1\r
-\r
- elif jsload_data["event"] == "clear_earphone_record_ok":#清除蓝牙耳机连接记录\r
- tts_play_str = "删除成功"\r
- EventMesh.publish("play_tts",[tts_play_str,1])\r
- self.read_ack_flag = 1\r
- \r
- elif jsload_data["event"] == "versions":\r
- self.bt_versions = jsload_data["data"]\r
- print("当前蓝牙版本是:{}".format(self.bt_versions))\r
- self.read_ack_flag = 1\r
-\r
- # elif jsload_data["event"] == "kws" :#\r
- # EventMesh.publish("kws_even")\r
- elif jsload_data["event"] == "ack" :#\r
- self.read_ack_flag = 1\r
- if ack_flag == 1:\r
- self.send_ack()\r
- self.read_uart_data = ""\r
- except Exception as e:\r
- usys.print_exception(e)\r
- self.read_uart_data = ""\r
- def recv_bt_connect_rest(self,event,msg):\r
- date_tmp = utime.localtime()\r
- time_tmp = utime.mktime(date_tmp)\r
- if "data" in msg:\r
- EventMesh.publish("send_bt_connect_state_to_iot",msg)\r
- pass\r
- def get_bt_versions(self,event=None,msg=None):\r
- return self.bt_versions\r
- def clear_earphone_record(self,event,msg): #清楚所有耳机记录\r
-\r
- json_data = \\r
- {\r
- "event": "clear_earphone_record",\r
- }\r
- json_str =ujson.dumps(json_data)\r
- print("clear_earphone_record{}".format(json_str))\r
- self.send_data(json_str,1)\r
- def adjust_volume_toBle(self,event,msg): #\r
- self.read_ack_flag=0\r
- volume = int(msg)\r
- if volume <= 10:\r
- volume = 10\r
- json_data = \\r
- {\r
- "event": "adjust_volume",\r
- "data":str(volume)\r
- }\r
- json_str =ujson.dumps(json_data)\r
- print("adjust_volume_toBle{}".format(json_str))\r
- self.send_data(json_str,1)\r
-\r
- def AI_send_bt_ble_switch_toble(self,event,msg):\r
- # // {\r
- # // "event":"switch_bt_state",\r
- # // "data":{\r
- # // "switch_bt_state":"0"\r
- # // }\r
- # // } #格式\r
- \r
- self.read_ack_flag=0\r
- if msg == 1: #AI对话开启蓝牙\r
- json_data = \\r
- {\r
- \r
- "event": "switch_ble_state",\r
- "data":{\r
- "switch_ble_state":"1"\r
- } \r
- \r
- }\r
- json_str =ujson.dumps(json_data)\r
- print("switch_ble_state{}".format(json_str))\r
- self.send_data(json_str,1)\r
-\r
- elif msg == 2: #AI对话开启蓝牙\r
- json_data = \\r
- {\r
- \r
- "event": "switch_ble_state",\r
- "data":{\r
- "switch_ble_state":"0"\r
- } \r
- \r
- }\r
- json_str =ujson.dumps(json_data)\r
- print("switch_ble_state{}".format(json_str))\r
- self.send_data(json_str,1)\r
- elif msg == 3: #AI对话开启蓝牙\r
- json_data = \\r
- {\r
- \r
- "event": "switch_bt_state",\r
- "data":{\r
- "switch_bt_state":"1"\r
- } \r
- }\r
- json_str =ujson.dumps(json_data)\r
- print("switch_bt_state{}".format(json_str))\r
- self.send_data(json_str,1)\r
-\r
- elif msg == 4: #AI对话开启蓝牙\r
- json_data = \\r
- {\r
- \r
- "event": "switch_bt_state",\r
- "data":{\r
- "switch_bt_state":"0"\r
- } \r
- \r
- }\r
- json_str =ujson.dumps(json_data)\r
- print("switch_bt_state{}".format(json_str))\r
- self.send_data(json_str,1)\r
-\r
- def send_bt_switch_toble(self,event,msg):\r
- EventMesh.publish("publish_AI_btnInfo",{"func":self.send_bt_switch_toble_cb,"data":msg})\r
- def send_bt_switch_toble_cb(self,data):\r
- # // {\r
- # // "event":"switch_bt_state",\r
- # // "data":{\r
- # // "switch_bt_state":"0"\r
- # // }\r
- # // } #格式\r
- self.read_ack_flag=0\r
- json_data = \\r
- {\r
- \r
- "event": "switch_bt_state",\r
- "data":{\r
- "switch_bt_state":str(data)\r
- } \r
- \r
- }\r
- json_str =ujson.dumps(json_data)\r
- print("send_bt_switch_toble{}".format(json_str))\r
- self.send_data(json_str,1)\r
-\r
- def send_ble_switch_toble(self,event,msg):\r
- EventMesh.publish("publish_AI_btnInfo",{"func":self.send_ble_switch_toble_cb,"data":msg})\r
- def send_ble_switch_toble_cb(self,data):\r
- # // {\r
- # // "event":"switch_ble_state",\r
- # // "data":{\r
- # // "switch_ble_state":"0"\r
- # // }\r
- # // } #格式\r
- \r
- self.read_ack_flag=0\r
- json_data = \\r
- {\r
- "event": "switch_ble_state",\r
- "data":{\r
- "switch_ble_state":str(data)\r
- } \r
- }\r
- json_str =ujson.dumps(json_data)\r
- print("send_ble_switch_toble{}".format(json_str))\r
- self.send_data(json_str,1) \r
-\r
- # 重发机制\r
- def send_reset_cb(self,json_str,need_resend = None,timeOut=None):\r
- print("send_reset_cb:{} {} {}".format(json_str,need_resend,timeOut))\r
- if timeOut == None:\r
- self.send_count = 100#最大重发5次,没ack或者返回error重发\r
- else:\r
- self.send_count = timeOut\r
-\r
- while self.send_count:\r
- self.send_count-=1\r
- utime.sleep_ms(10)\r
- if self.send_count <=0 or self.read_ack_flag == 1:\r
- print("4G串口重发机制退出:{} self.read_ack_flag:{} json_str:{}".format(self.send_count,self.read_ack_flag,json_str))\r
- break\r
- if self.send_count%(self.send_count//10) == 0:\r
- print("串口异常,重发:")\r
- self.send_data(json_str)\r
-\r
- pass\r
- def send_get_connect_bt_state(self,event,msg):\r
- json_data = \\r
- {\r
- \r
- "event": "get_connect_bt_state"\r
- }\r
- json_str =ujson.dumps(json_data)\r
- print("send_get_connect_bt_state{}".format(json_str))\r
- self.send_data(json_str)\r
- self.get_bt_connect_flag = 1\r
- self.get_bt_connect_timer.start(2000,0,self.get_bt_connect_timer_cb)\r
- def get_bt_connect_timer_cb(self,*agrc):\r
- if self.get_bt_connect_flag == 1:\r
- EventMesh.publish("send_bt_connect_list")\r
- pass\r
- self.get_bt_connect_flag = 0\r
- pass\r
- def send_ble_scan(self,event,msg):\r
- self.read_ack_flag=0\r
- # // {\r
- # // "event":"send_ble_scan",\r
- # // "data":{\r
- # // "send_ble_scan":"0"\r
- # // }\r
- # // } #格式\r
- json_data = \\r
- {\r
- \r
- "event": "bt_scan",\r
- "data":msg \r
- \r
- }\r
- json_str =ujson.dumps(json_data)\r
- print("send_ble_scan{}".format(json_str))\r
- self.send_data(json_str,1)\r
- # self.send_reset_cb(json_str)\r
-\r
- print("bt_send_end")\r
- def send_data(self,str_data,need_resend = None,ACK_time =None):\r
- try:\r
- if not ("vc_config" in globals() and vc_config and vc_config.uart_supported()):\r
- return\r
- except Exception:\r
- return\r
- if self.bt_ota_flag == 1:\r
- print("ota 中不需要上传")\r
- return\r
- print("send_data{} {} {}".format(str_data,need_resend,ACK_time))\r
- queue_data={"event":"uart_send_data","data":str_data}\r
- if need_resend != None:\r
- queue_data={"event":"uart_send_data","data":str_data,"resend_flag":1,"ACK_time":ACK_time}\r
-\r
- self.uart_send_queue.put(queue_data)\r
- def uart_queue_send_data(self,str_data):\r
- if self.bt_ota_flag == 1:\r
- return\r
- #EventMesh.publish("wakeup_BT")\r
- print("bt_seuart_queue_send_data start {}".format(str_data))\r
- EventMesh.publish(constants.EVENT.SYSTEM_UP)#唤醒休眠\r
- self.AI_uart.write(str_data)\r
- print("bt_seuart_queue_send_data end {}".format(str_data))\r
- def led_r_open(self,event=None,msg=None):\r
- json_data = \\r
- {\r
- \r
- "event": "led_r_open",\r
- \r
- \r
- }\r
- json_str =ujson.dumps(json_data)\r
- print("led_r_open{}".format(json_str))\r
- self.send_data(json_str)\r
- def led_g_open(self,event=None,msg=None):\r
- json_data = \\r
- {\r
-\r
- "event": "led_g_open",\r
-\r
- }\r
- json_str =ujson.dumps(json_data)\r
- print("led_g_open{}".format(json_str))\r
- self.send_data(json_str)\r
- def led_b_open(self,event=None,msg=None):\r
- json_data = \\r
- {\r
-\r
- "event": "led_b_open",\r
- \r
- }\r
- json_str =ujson.dumps(json_data)\r
- print("led_b_open{}".format(json_str))\r
- self.send_data(json_str)\r
- def led_rgb_open(self,event=None,msg=None):\r
- json_data = \\r
- {\r
-\r
- "event": "led_rgb_open",\r
-\r
- }\r
- json_str =ujson.dumps(json_data)\r
- print("led_rgb_open{}".format(json_str))\r
- self.send_data(json_str)\r
- def led_close(self,event=None,msg=None):\r
- json_data = \\r
- {\r
-\r
- "event": "led_close",\r
-\r
- }\r
- json_str =ujson.dumps(json_data)\r
- print("led_close{}".format(json_str))\r
- self.send_data(json_str)\r
- \r
- def send_ack(self):\r
- json_data = \\r
- {\r
-\r
- "event": "ack",\r
-\r
- }\r
- json_str =ujson.dumps(json_data)\r
- print("send_ack{}".format(json_str))\r
- self.send_data(json_str)\r
- def AI_key_press(self):\r
- self.check_rest_timer_count = 0\r
- print("AI_key_press")\r
- EventMesh.publish("AI_key_press")\r
- def BT_AI_key_press(self):\r
- self.check_rest_timer_count = 0\r
- print("BT_AI_key_press")\r
- EventMesh.publish("BT_AI_key_press")\r
-\r
- def pwk_key_release(self):\r
- self.check_rest_timer_count = 0\r
- #print("pwk_key_release")\r
- EventMesh.publish("pwk_key_release")\r
- def send_get_versions(self,event=None,msg=None):\r
- EventMesh.publish(constants.EVENT.SYSTEM_UP)#唤醒休眠\r
- #self.read_ack_flag = 0\r
- json_data = \\r
- {\r
- \r
- "event": "get_versions",\r
- }\r
- json_str =ujson.dumps(json_data)\r
- print("send_get_versions {}".format(json_str))\r
- self.send_data(json_str,1)\r
- #self.AI_uart.write(json_str)\r
- count =1000\r
- while True:\r
- count -=1\r
- if count <=0 or self.read_ack_flag == 1:\r
- break\r
- utime.sleep_ms(1)\r
-\r
- pass\r
- def start_ota(self,event=None,msg=None):#通过串口给蓝牙升级\r
- #EventMesh.publish("wakeup_BT") \r
- EventMesh.publish(constants.EVENT.SYSTEM_UP)#唤醒休眠\r
- print("start_ota!!!")\r
- print("start_ota!!!")\r
- json_data = \\r
- {\r
- "event": "ota_start",\r
- }\r
- json_str =ujson.dumps(json_data)\r
- self.AI_uart.write(json_str)\r
- print(json_str)\r
- count =100\r
- while True:\r
- count -=1\r
- if count <=0 or self.read_ack_flag == 1:\r
- break\r
- utime.sleep_ms(1)\r
- print("start_ota count:{}!!!".format(count))\r
-\r
- def end_ota(self,event=None,msg=None):#通过串口给蓝牙升级\r
- #EventMesh.publish("wakeup_BT") \r
- EventMesh.publish(constants.EVENT.SYSTEM_UP)#唤醒休眠\r
- print("end_ota!!!")\r
- print("end_ota!!!")\r
- json_data = \\r
- {\r
- "event": "ota_end",\r
- }\r
- json_str =ujson.dumps(json_data)\r
- self.AI_uart.write(json_str)\r
- print(json_str)\r
- count =100\r
- while True:\r
- count -=1\r
- if count <=0 or self.read_ack_flag == 1:\r
- break\r
- utime.sleep_ms(1)\r
- print("end_ota count:{}!!!".format(count))\r
-\r
- def bt_ota_run(self,event=None,msg=None):#通过串口给蓝牙升级\r
- # EventMesh.publish("wakeup_BT") \r
- EventMesh.publish(constants.EVENT.SYSTEM_UP)#唤醒休眠\r
- print("bt_ota_run!!!:{}".format(msg))\r
- print("bt_ota_run!!!")\r
- print("bt_ota_run!!!")\r
- self.bt_ota_flag = 1\r
- self.read_ack_flag = 0\r
- \r
- json_data = \\r
- {\r
- "event": "ota_start",\r
- }\r
- json_str =ujson.dumps(json_data)\r
- self.AI_uart.write(json_str)\r
- print(json_str)\r
- count =2000#等20秒,擦除flash\r
- while True:\r
- count -=1\r
- if count <=0 or self.read_ack_flag == 1:\r
- break\r
- utime.sleep_ms(10)\r
- EventMesh.publish(constants.EVENT.SYSTEM_UP)#唤醒休眠\r
- print("ota_start:count:{}".format(count))\r
- url = msg[0]\r
- bt_size = msg[1]\r
- headers_T = {"Content-Type":"application/octet-stream"}\r
- response = request.get(url = url,headers=headers_T,timeout = 120,decode = False)\r
- offset = 0\r
- checksum = 0\r
- for i in response.content:\r
- EventMesh.publish(constants.EVENT.SYSTEM_UP)#唤醒休眠\r
- \r
- \r
- data = base64.b64encode(i)\r
- send_count = 5#最大重发5次,没ack或者返回error重发\r
- while 1:\r
- send_count-=1\r
- self.read_ack_flag = 0\r
- checksum = 0\r
- # 对每个字节进行异或运算\r
- for byte in i:\r
- checksum ^= byte # 等价于 checksum = checksum ^ byte\r
- json_data = \\r
- {\r
- "event": "ota_data",\r
- "update":data,\r
- "offset":offset,\r
- "checksum":checksum \r
- }\r
- print("offset:{},checksum:{}".format(offset,checksum))\r
- json_str =ujson.dumps(json_data)\r
- self.AI_uart.write(json_str)\r
- #utime.sleep_ms(100)\r
- count =300\r
- while True:\r
- count -=1\r
- if count <=0 or self.read_ack_flag != 0 :\r
- break\r
- utime.sleep_ms(10)\r
- print("ota_data:{} count:{}".format(len(json_str),count))\r
- if self.read_ack_flag == 1:\r
- break\r
- if send_count <=0 :\r
- return -1\r
- offset+=len(i)\r
- if offset < bt_size:\r
- return -1\r
- self.read_ack_flag = 0\r
- json_data = \\r
- {\r
- "event": "ota_end",\r
- }\r
- json_str =ujson.dumps(json_data)\r
- self.AI_uart.write(json_str)\r
- \r
- count =100\r
- while True:\r
- count -=1\r
- if count <=0 or self.read_ack_flag == 1:\r
- break\r
- utime.sleep_ms(1)\r
- self.bt_ota_flag = 0\r
- return 0\r
+# -*- coding: utf-8 -*-
+"""UART 与蓝牙侧通道。"""
+try:
+ from qp_log import qp_print as print
+except Exception:
+ pass
+import usys
+import ujson
+import utime
+import osTimer
+import _thread
+import base64
+import modem
+import request
+import constants
+import EventMesh
+from queue import Queue
+from machine import UART
+from vc_utils import cfg_uart_supported, cfg_attr
+
+#HEARDER+TOTALLEN+DATELEN+DATA
+HEARDER = "FFFE"
+TOTALLEN = "00000000"
+DATELEN = "0000"
+DATA = {}
+class AI_UART():
+ #串口命令通道
+ def __init__(self):
+ self.send_count=0
+ self.AI_uart = UART(UART.UART4, 230400, 8, 0, 1, 0)
+ self.AI_uart.set_callback(self.uart_call)
+
+ EventMesh.subscribe("bt_ota_run",self.bt_ota_run)#
+ EventMesh.subscribe("start_ota",self.start_ota)
+ EventMesh.subscribe("end_ota",self.end_ota)
+ EventMesh.subscribe("send_bt_switch_toble",self.send_bt_switch_toble)
+ EventMesh.subscribe("send_ble_switch_toble",self.send_ble_switch_toble)
+ EventMesh.subscribe("send_ble_scan",self.send_ble_scan)
+ EventMesh.subscribe("send_connect_bt_mac",self.send_connect_bt_mac)
+ EventMesh.subscribe("send_disconnect_bt_mac",self.send_disconnect_bt_mac)
+ EventMesh.subscribe("send_imei_to_ble",self.send_imei_to_ble)
+ EventMesh.subscribe("send_get_connect_bt_state",self.send_get_connect_bt_state)
+ EventMesh.subscribe("recv_bt_connect_rest",self.recv_bt_connect_rest)
+ EventMesh.subscribe("AI_send_bt_ble_switch_toble",self.AI_send_bt_ble_switch_toble)
+ EventMesh.subscribe("get_bt_versions",self.get_bt_versions)
+ EventMesh.subscribe("adjust_volume_toBle",self.adjust_volume_toBle)
+ EventMesh.subscribe("clear_earphone_record",self.clear_earphone_record)
+ self.bt_switch = 0
+ self.ble_switch = 0
+ self.uart_timer = osTimer()
+ self.get_bt_connect_timer = osTimer()
+ self.get_bt_connect_flag = 0
+ self.uart_timer_count = 0
+ self.bt_ota_flag = 0
+ self.read_ack_flag = 0
+ self.ping_json_str = {}
+ self.ping_json_str_tmp =""
+ self.read_uart_data = ""
+ self.bt_versions=""
+ if cfg_uart_supported():
+ self.uart_send_queue = Queue(100)
+ self.uart_send_queue_thread_id = _thread.start_new_thread(self.uart_send_queue_thread, ())
+
+ self.uart_recv_queue = Queue(100)
+ self.uart_recv_queue_thread_id = _thread.start_new_thread(self.uart_recv_queue_thread, ())
+ self.send_get_versions()#获取蓝牙版本
+
+ def uart_send_queue_thread(self):
+ while True:
+ data = self.uart_send_queue.get()
+
+ #EventMesh.debug_log("Info_queue:data = {}".format(data))
+ if data != None:
+ try:
+ if len(data) != 0:
+ print("send_queu_uart_data2:{} data:{}".format(data,data["data"]))
+ # json_str =ujson.dumps(data)
+ if data["event"] == "uart_send_data":
+ print("send_queu_uart_data sucess data:{} {}".format(data["data"],type(data["data"])))
+ self.uart_queue_send_data(data["data"])
+ if "resend_flag" in data:
+ print("send_reset_cb:{} {}".format(data["resend_flag"],data["ACK_time"]))
+ if data["resend_flag"] == 1:
+ self.send_count = 5#重试5次
+ ack_timer = 0 #单次最大等待时间
+ count = 0
+ if "ACK_time" in data:
+ if data["ACK_time"] == None:
+ ack_timer = 100#最大重发5次,没ack或者返回error重发
+ else:
+ ack_timer = data["ACK_time"]
+ if ack_timer > 0:
+ while self.send_count:
+
+ if self.send_count <=0 or self.read_ack_flag == 1:
+ print("4G串口重发机制退出:{} self.read_ack_flag:{} json_str:{}".format(self.send_count,self.read_ack_flag,data["data"]))
+ break
+ if count >= ack_timer:
+ count = 0
+ print("串口异常,重发:")
+ self.uart_queue_send_data(data["data"])
+ self.send_count-=1
+ count += 1
+ utime.sleep_ms(1)
+
+ except Exception as e:
+ usys.print_exception(e)
+ utime.sleep_ms(10)
+
+ def uart_recv_queue_thread(self):
+ while True:
+ data = self.uart_recv_queue.get()
+
+ #EventMesh.debug_log("Info_queue:data = {}".format(data))
+ if data != None:
+ try:
+ if len(data) != 0:
+ print("recv_queu_uart_data2:{}".format(data))
+ # json_str =ujson.dumps(data)
+ # queue_data={"event":"uart_recv_data"}
+ if data["event"] == "uart_recv_data":
+ print("recv_queu_uart_data sucess data:{}".format(type(data["event"])))
+ self.pares_uart_data()
+ except Exception as e:
+ usys.print_exception(e)
+
+ def send_imei_to_ble(self,event,msg):
+ EventMesh.publish("publish_AI_btnInfo",{"func":self.send_imei_to_ble_cb})
+
+ def send_imei_to_ble_cb(self):
+ self.read_ack_flag=0
+ imei = modem.getDevImei()
+ json_data = \
+ {
+
+ "event": "imei",
+ "data":str(imei)
+
+ }
+ json_str =ujson.dumps(json_data)
+ print("send imei:{}".format(json_str))
+ self.send_data(json_str)
+ pass
+ def send_connect_bt_mac(self,event,msg):
+ self.read_ack_flag=0
+ json_data = \
+ {
+ "event": "connect_bt",
+ "data":msg
+ }
+ json_str =ujson.dumps(json_data)
+ self.send_data(json_str,1,2000)
+ # self.send_reset_cb(json_str,0,2000) #每2s发送一次 10ms为单位
+ pass
+ def send_disconnect_bt_mac(self,event,msg):
+ self.read_ack_flag=0
+ json_data = \
+ {
+ "event": "disconnect_bt",
+ "data":msg
+ }
+ json_str =ujson.dumps(json_data)
+ self.send_data(json_str,1)
+ # self.send_reset_cb(json_str)
+
+ pass
+ def uart_timer_cb(self, *args, **kwargs):
+ self.uart_timer_count+=1
+ if self.uart_timer_count >40:
+ self.read_uart_data = ""
+ if self.uart_timer_count >200:
+ self.read_uart_data = ""
+ self.uart_timer.stop()
+ def split_combined_json(self,combined_str):
+ # 将连续的JSON字符串分割为多个独立的JSON字符串列表
+ #
+ # 参数:
+ # combined_str: 多个JSON拼接的字符串
+ # 返回:
+ # 分割后的
+ json_list = []
+ start_index = 0
+ brace_count = 0 # 用于匹配{}括号
+ print("combined_str:{}".format(combined_str))
+ for i, char in enumerate(combined_str):
+ if char == '{':
+ brace_count += 1
+ elif char == '}':
+ brace_count -= 1
+
+ # 当括号完全匹配(count=0)时,说明一个完整的JSON对象结束
+ if brace_count == 0:
+ # 提取从start_index到当前位置的子串(包含当前})
+ json_str = combined_str[start_index:i+1].strip()
+ if json_str: # 避免空字符串
+ json_list.append(json_str)
+ start_index = i + 1 # 下一个JSON的起始位置
+ print("json_list{}".format(json_list))
+
+ return json_list
+
+ def uart_call(self,para):
+ queue_data={"event":"uart_recv_data"}
+
+ self.uart_recv_queue.put(queue_data)
+ # print("uart_call start")
+ # EventMesh.publish("publish_AI_btnInfo",{"func":self.pares_uart_data})
+ # print("uart_call end")
+ #print("ai_uart:{}".format(para))
+ #[{"event":""},{},{}]
+ def pares_uart_data(self):
+ uart_data = self.AI_uart.read()
+ self.uart_timer.start(10, 1, self.uart_timer_cb)
+ self.uart_timer_count = 0
+ ack_flag = 0#是否要返回ack
+ print("uart_data:{}",uart_data)
+ uart_data_str = uart_data.decode('utf-8')
+
+ self.read_uart_data = self.read_uart_data +uart_data_str
+ try:
+ ujson.loads(self.read_uart_data)
+ except Exception as e:
+ print("json数据不完整:self.read_uart_data{}".format(self.read_uart_data))
+ usys.print_exception(e)
+ return
+ self.uart_timer.stop()
+ self.uart_timer_count = 0
+ self.playload_data(self.read_uart_data)
+
+ # 分割JSON
+ # json_strings = self.split_combined_json(uart_data_str)
+
+ # # 逐个解析并处理
+ # for i, json_str in enumerate(json_strings, 1):
+ # print("第{}个JSON{}".format(i,json_str))
+ # try:
+ # data = ujson.loads(json_str)
+
+ # # 在这里添加你的业务逻辑,比如根据event处理不同事件
+ # self.uart_timer.stop()
+ # self.uart_timer_count = 0
+ # self.playload_data(self.read_uart_data)
+ # # if data.get("event") == "bt_connect_single":
+
+ # # elif data.get("event") == "bt_scan_rest":
+
+ # except Exception as e:
+ # print("JSON解析错误:原始字符串:")
+ # print("-" * 50)
+
+
+
+ # print("uart_data_str:{}",uart_data_str)
+ # if len(uart_data_str) < (HEARDER+1+1):
+ # return
+ # head = uart_data_str[0:4]
+ # pack_flag = uart_data_str[4:5]
+ # recvflag = uart_data_str[5:6]
+
+
+ # if head == HEARDER:
+ # if pack_flag == "1": #分包数据
+ # if recvflag == "1": #未发送完成
+ # self.ping_json_str_tmp+=uart_data_str[6:]
+ # pass
+ # else:
+ # self.playload_data(self.ping_json_str_tmp)
+ # pass
+ # else:
+ # self.playload_data(uart_data_str[6:])
+
+ # else:
+ # print("uart is not FFFE:")
+
+ def playload_data(self,msg):
+ ack_flag=0
+ try:
+ print("playload_data:{}".format(msg))
+ jsload_data = ujson.loads(msg)
+ #print("AI_client_VC_recv jsload_data = {}".format(jsload_data))
+
+ if jsload_data["event"] == "AI_KEY_PRESS" :#AI按键按下
+ EventMesh.publish("publish_AI_btnInfo",{"func":self.AI_key_press})
+ ack_flag = 1
+ elif jsload_data["event"] == "BT_AI_KEY_PRESS" :#蓝牙耳机key ai对话模式不支持长按对话模式 只支持短按按键对话模式 重新定义按键
+ EventMesh.publish("publish_AI_btnInfo",{"func":self.BT_AI_key_press})
+ ack_flag = 1
+ elif jsload_data["event"] == "AI_PWR_PRESS" :#电源按键按下
+ EventMesh.publish("publish_AI_btnInfo",{"func":self.pwk_key_release})
+ ack_flag = 1
+ elif jsload_data["event"] == "bt_scan_rest":#扫描列表 #蓝牙停止扫描后主动向4g发送扫描列表需要发送ack
+ EventMesh.publish("send_bt_scan_list",jsload_data)
+ ack_flag=1
+ elif jsload_data["event"]=="bt_connect_single": #收到蓝牙主动发送过来的单个连接蓝牙耳机的连接状态 需要发送ack
+ EventMesh.publish("save_bt_connect_list",jsload_data)
+ ack_flag=1
+
+ elif jsload_data["event"]=="need_send_bt_connect_list": #发送连接蓝牙连接记录列表 不需要发送ack
+ self.get_bt_connect_timer.stop()
+ self.get_bt_connect_flag = 0
+ EventMesh.publish("save_bt_connect_list",jsload_data) #先保存连接记录再发送连接耳机列表to IOT
+ EventMesh.publish("send_bt_connect_list")
+
+ elif jsload_data["event"]=="get_ble_switch":
+ ble_switch_flag = EventMesh.publish("get_storage_config","switch_ble_state")#ble开关 不需要发送ack
+ if ble_switch_flag == None:
+ ble_switch_flag = "1"
+ EventMesh.publish("send_ble_switch_toble",str(ble_switch_flag))
+
+ pass
+ elif jsload_data["event"]=="get_bt_switch":
+ bt_switch_flag = EventMesh.publish("get_storage_config","switch_bt_state")#bt开关 不需要发送ack
+ if bt_switch_flag == None:
+ bt_switch_flag = "1"
+ EventMesh.publish("send_bt_switch_toble",bt_switch_flag)
+
+ pass
+ elif jsload_data["event"]=="get_cat1_imei": #蓝牙主动向4G获取imei 4g不需要发送ack 蓝牙收到imei需要回ack给4改
+ EventMesh.publish("send_imei_to_ble")
+ ack_flag=1
+ pass
+ elif jsload_data["event"] == "post_bt_connect_rest": #蓝牙主动蓝牙耳机连接状态 需要发送ack给蓝牙
+ EventMesh.publish("recv_bt_connect_rest",jsload_data)
+ ack_flag=1
+
+ elif jsload_data["event"] == "clear_earphone_record_ok":#清除蓝牙耳机连接记录
+ tts_play_str = "删除成功"
+ EventMesh.publish("play_tts",[tts_play_str,1])
+ self.read_ack_flag = 1
+
+ elif jsload_data["event"] == "versions":
+ self.bt_versions = jsload_data["data"]
+ print("当前蓝牙版本是:{}".format(self.bt_versions))
+ self.read_ack_flag = 1
+
+ # elif jsload_data["event"] == "kws" :#
+ # EventMesh.publish("kws_even")
+ elif jsload_data["event"] == "ack" :#
+ self.read_ack_flag = 1
+ if ack_flag == 1:
+ self.send_ack()
+ self.read_uart_data = ""
+ except Exception as e:
+ usys.print_exception(e)
+ self.read_uart_data = ""
+ def recv_bt_connect_rest(self,event,msg):
+ date_tmp = utime.localtime()
+ time_tmp = utime.mktime(date_tmp)
+ if "data" in msg:
+ EventMesh.publish("send_bt_connect_state_to_iot",msg)
+ pass
+ def get_bt_versions(self,event=None,msg=None):
+ return self.bt_versions
+ def clear_earphone_record(self,event,msg): #清楚所有耳机记录
+
+ json_data = \
+ {
+ "event": "clear_earphone_record",
+ }
+ json_str =ujson.dumps(json_data)
+ print("clear_earphone_record{}".format(json_str))
+ self.send_data(json_str,1)
+ def adjust_volume_toBle(self,event,msg): #
+ self.read_ack_flag=0
+ volume = int(msg)
+ if volume <= 10:
+ volume = 10
+ json_data = \
+ {
+ "event": "adjust_volume",
+ "data":str(volume)
+ }
+ json_str =ujson.dumps(json_data)
+ print("adjust_volume_toBle{}".format(json_str))
+ self.send_data(json_str,1)
+
+ def AI_send_bt_ble_switch_toble(self,event,msg):
+ # // {
+ # // "event":"switch_bt_state",
+ # // "data":{
+ # // "switch_bt_state":"0"
+ # // }
+ # // } #格式
+
+ self.read_ack_flag=0
+ if msg == 1: #AI对话开启蓝牙
+ json_data = \
+ {
+
+ "event": "switch_ble_state",
+ "data":{
+ "switch_ble_state":"1"
+ }
+
+ }
+ json_str =ujson.dumps(json_data)
+ print("switch_ble_state{}".format(json_str))
+ self.send_data(json_str,1)
+
+ elif msg == 2: #AI对话开启蓝牙
+ json_data = \
+ {
+
+ "event": "switch_ble_state",
+ "data":{
+ "switch_ble_state":"0"
+ }
+
+ }
+ json_str =ujson.dumps(json_data)
+ print("switch_ble_state{}".format(json_str))
+ self.send_data(json_str,1)
+ elif msg == 3: #AI对话开启蓝牙
+ json_data = \
+ {
+
+ "event": "switch_bt_state",
+ "data":{
+ "switch_bt_state":"1"
+ }
+ }
+ json_str =ujson.dumps(json_data)
+ print("switch_bt_state{}".format(json_str))
+ self.send_data(json_str,1)
+
+ elif msg == 4: #AI对话开启蓝牙
+ json_data = \
+ {
+
+ "event": "switch_bt_state",
+ "data":{
+ "switch_bt_state":"0"
+ }
+
+ }
+ json_str =ujson.dumps(json_data)
+ print("switch_bt_state{}".format(json_str))
+ self.send_data(json_str,1)
+
+ def send_bt_switch_toble(self,event,msg):
+ EventMesh.publish("publish_AI_btnInfo",{"func":self.send_bt_switch_toble_cb,"data":msg})
+ def send_bt_switch_toble_cb(self,data):
+ # // {
+ # // "event":"switch_bt_state",
+ # // "data":{
+ # // "switch_bt_state":"0"
+ # // }
+ # // } #格式
+ self.read_ack_flag=0
+ json_data = \
+ {
+
+ "event": "switch_bt_state",
+ "data":{
+ "switch_bt_state":str(data)
+ }
+
+ }
+ json_str =ujson.dumps(json_data)
+ print("send_bt_switch_toble{}".format(json_str))
+ self.send_data(json_str,1)
+
+ def send_ble_switch_toble(self,event,msg):
+ EventMesh.publish("publish_AI_btnInfo",{"func":self.send_ble_switch_toble_cb,"data":msg})
+ def send_ble_switch_toble_cb(self,data):
+ # // {
+ # // "event":"switch_ble_state",
+ # // "data":{
+ # // "switch_ble_state":"0"
+ # // }
+ # // } #格式
+
+ self.read_ack_flag=0
+ json_data = \
+ {
+ "event": "switch_ble_state",
+ "data":{
+ "switch_ble_state":str(data)
+ }
+ }
+ json_str =ujson.dumps(json_data)
+ print("send_ble_switch_toble{}".format(json_str))
+ self.send_data(json_str,1)
+
+ # 重发机制
+ def send_reset_cb(self,json_str,need_resend = None,timeOut=None):
+ print("send_reset_cb:{} {} {}".format(json_str,need_resend,timeOut))
+ if timeOut == None:
+ self.send_count = 100#最大重发5次,没ack或者返回error重发
+ else:
+ self.send_count = timeOut
+
+ while self.send_count:
+ self.send_count-=1
+ utime.sleep_ms(10)
+ if self.send_count <=0 or self.read_ack_flag == 1:
+ print("4G串口重发机制退出:{} self.read_ack_flag:{} json_str:{}".format(self.send_count,self.read_ack_flag,json_str))
+ break
+ if self.send_count%(self.send_count//10) == 0:
+ print("串口异常,重发:")
+ self.send_data(json_str)
+
+ pass
+ def send_get_connect_bt_state(self,event,msg):
+ json_data = \
+ {
+
+ "event": "get_connect_bt_state"
+ }
+ json_str =ujson.dumps(json_data)
+ print("send_get_connect_bt_state{}".format(json_str))
+ self.send_data(json_str)
+ self.get_bt_connect_flag = 1
+ self.get_bt_connect_timer.start(2000,0,self.get_bt_connect_timer_cb)
+ def get_bt_connect_timer_cb(self,*agrc):
+ if self.get_bt_connect_flag == 1:
+ EventMesh.publish("send_bt_connect_list")
+ pass
+ self.get_bt_connect_flag = 0
+ pass
+ def send_ble_scan(self,event,msg):
+ self.read_ack_flag=0
+ # // {
+ # // "event":"send_ble_scan",
+ # // "data":{
+ # // "send_ble_scan":"0"
+ # // }
+ # // } #格式
+ json_data = \
+ {
+
+ "event": "bt_scan",
+ "data":msg
+
+ }
+ json_str =ujson.dumps(json_data)
+ print("send_ble_scan{}".format(json_str))
+ self.send_data(json_str,1)
+ # self.send_reset_cb(json_str)
+
+ print("bt_send_end")
+ def send_data(self,str_data,need_resend = None,ACK_time =None):
+ try:
+ if not cfg_uart_supported():
+ return
+ except Exception:
+ return
+ if self.bt_ota_flag == 1:
+ print("ota 中不需要上传")
+ return
+ print("send_data{} {} {}".format(str_data,need_resend,ACK_time))
+ queue_data={"event":"uart_send_data","data":str_data}
+ if need_resend != None:
+ queue_data={"event":"uart_send_data","data":str_data,"resend_flag":1,"ACK_time":ACK_time}
+
+ self.uart_send_queue.put(queue_data)
+ def uart_queue_send_data(self,str_data):
+ if self.bt_ota_flag == 1:
+ return
+ #EventMesh.publish("wakeup_BT")
+ print("bt_seuart_queue_send_data start {}".format(str_data))
+ EventMesh.publish(constants.EVENT.SYSTEM_UP)#唤醒休眠
+ self.AI_uart.write(str_data)
+ print("bt_seuart_queue_send_data end {}".format(str_data))
+ def led_r_open(self,event=None,msg=None):
+ json_data = \
+ {
+
+ "event": "led_r_open",
+
+
+ }
+ json_str =ujson.dumps(json_data)
+ print("led_r_open{}".format(json_str))
+ self.send_data(json_str)
+ def led_g_open(self,event=None,msg=None):
+ json_data = \
+ {
+
+ "event": "led_g_open",
+
+ }
+ json_str =ujson.dumps(json_data)
+ print("led_g_open{}".format(json_str))
+ self.send_data(json_str)
+ def led_b_open(self,event=None,msg=None):
+ json_data = \
+ {
+
+ "event": "led_b_open",
+
+ }
+ json_str =ujson.dumps(json_data)
+ print("led_b_open{}".format(json_str))
+ self.send_data(json_str)
+ def led_rgb_open(self,event=None,msg=None):
+ json_data = \
+ {
+
+ "event": "led_rgb_open",
+
+ }
+ json_str =ujson.dumps(json_data)
+ print("led_rgb_open{}".format(json_str))
+ self.send_data(json_str)
+ def led_close(self,event=None,msg=None):
+ json_data = \
+ {
+
+ "event": "led_close",
+
+ }
+ json_str =ujson.dumps(json_data)
+ print("led_close{}".format(json_str))
+ self.send_data(json_str)
+
+ def send_ack(self):
+ json_data = \
+ {
+
+ "event": "ack",
+
+ }
+ json_str =ujson.dumps(json_data)
+ print("send_ack{}".format(json_str))
+ self.send_data(json_str)
+ def AI_key_press(self):
+ self.check_rest_timer_count = 0
+ print("AI_key_press")
+ EventMesh.publish("AI_key_press")
+ def BT_AI_key_press(self):
+ self.check_rest_timer_count = 0
+ print("BT_AI_key_press")
+ EventMesh.publish("BT_AI_key_press")
+
+ def pwk_key_release(self):
+ self.check_rest_timer_count = 0
+ #print("pwk_key_release")
+ EventMesh.publish("pwk_key_release")
+ def send_get_versions(self,event=None,msg=None):
+ EventMesh.publish(constants.EVENT.SYSTEM_UP)#唤醒休眠
+ #self.read_ack_flag = 0
+ json_data = \
+ {
+
+ "event": "get_versions",
+ }
+ json_str =ujson.dumps(json_data)
+ print("send_get_versions {}".format(json_str))
+ self.send_data(json_str,1)
+ #self.AI_uart.write(json_str)
+ count =1000
+ while True:
+ count -=1
+ if count <=0 or self.read_ack_flag == 1:
+ break
+ utime.sleep_ms(1)
+
+ pass
+ def start_ota(self,event=None,msg=None):#通过串口给蓝牙升级
+ #EventMesh.publish("wakeup_BT")
+ EventMesh.publish(constants.EVENT.SYSTEM_UP)#唤醒休眠
+ print("start_ota!!!")
+ print("start_ota!!!")
+ json_data = \
+ {
+ "event": "ota_start",
+ }
+ json_str =ujson.dumps(json_data)
+ self.AI_uart.write(json_str)
+ print(json_str)
+ count =100
+ while True:
+ count -=1
+ if count <=0 or self.read_ack_flag == 1:
+ break
+ utime.sleep_ms(1)
+ print("start_ota count:{}!!!".format(count))
+
+ def end_ota(self,event=None,msg=None):#通过串口给蓝牙升级
+ #EventMesh.publish("wakeup_BT")
+ EventMesh.publish(constants.EVENT.SYSTEM_UP)#唤醒休眠
+ print("end_ota!!!")
+ print("end_ota!!!")
+ json_data = \
+ {
+ "event": "ota_end",
+ }
+ json_str =ujson.dumps(json_data)
+ self.AI_uart.write(json_str)
+ print(json_str)
+ count =100
+ while True:
+ count -=1
+ if count <=0 or self.read_ack_flag == 1:
+ break
+ utime.sleep_ms(1)
+ print("end_ota count:{}!!!".format(count))
+
+ def bt_ota_run(self,event=None,msg=None):#通过串口给蓝牙升级
+ # EventMesh.publish("wakeup_BT")
+ EventMesh.publish(constants.EVENT.SYSTEM_UP)#唤醒休眠
+ print("bt_ota_run!!!:{}".format(msg))
+ print("bt_ota_run!!!")
+ print("bt_ota_run!!!")
+ self.bt_ota_flag = 1
+ self.read_ack_flag = 0
+
+ json_data = \
+ {
+ "event": "ota_start",
+ }
+ json_str =ujson.dumps(json_data)
+ self.AI_uart.write(json_str)
+ print(json_str)
+ count =2000#等20秒,擦除flash
+ while True:
+ count -=1
+ if count <=0 or self.read_ack_flag == 1:
+ break
+ utime.sleep_ms(10)
+ EventMesh.publish(constants.EVENT.SYSTEM_UP)#唤醒休眠
+ print("ota_start:count:{}".format(count))
+ url = msg[0]
+ bt_size = msg[1]
+ headers_T = {"Content-Type":"application/octet-stream"}
+ response = request.get(url = url,headers=headers_T,timeout = 120,decode = False)
+ offset = 0
+ checksum = 0
+ for i in response.content:
+ EventMesh.publish(constants.EVENT.SYSTEM_UP)#唤醒休眠
+
+
+ data = base64.b64encode(i)
+ send_count = 5#最大重发5次,没ack或者返回error重发
+ while 1:
+ send_count-=1
+ self.read_ack_flag = 0
+ checksum = 0
+ # 对每个字节进行异或运算
+ for byte in i:
+ checksum ^= byte # 等价于 checksum = checksum ^ byte
+ json_data = \
+ {
+ "event": "ota_data",
+ "update":data,
+ "offset":offset,
+ "checksum":checksum
+ }
+ print("offset:{},checksum:{}".format(offset,checksum))
+ json_str =ujson.dumps(json_data)
+ self.AI_uart.write(json_str)
+ #utime.sleep_ms(100)
+ count =300
+ while True:
+ count -=1
+ if count <=0 or self.read_ack_flag != 0 :
+ break
+ utime.sleep_ms(10)
+ print("ota_data:{} count:{}".format(len(json_str),count))
+ if self.read_ack_flag == 1:
+ break
+ if send_count <=0 :
+ return -1
+ offset+=len(i)
+ if offset < bt_size:
+ return -1
+ self.read_ack_flag = 0
+ json_data = \
+ {
+ "event": "ota_end",
+ }
+ json_str =ujson.dumps(json_data)
+ self.AI_uart.write(json_str)
+
+ count =100
+ while True:
+ count -=1
+ if count <=0 or self.read_ack_flag == 1:
+ break
+ utime.sleep_ms(1)
+ self.bt_ota_flag = 0
+ return 0
# -*- coding: utf-8 -*-\r
"""VC 杂项工具函数。"""\r
+try:\r
+ import vc_config as _vc_config\r
+except Exception:\r
+ _vc_config = None\r
+\r
+\r
+def cfg_bool(name, default=False):\r
+ if _vc_config:\r
+ return _vc_config.get_bool(name, default)\r
+ return bool(default)\r
+\r
+\r
+def cfg_int(name, default=0):\r
+ if _vc_config:\r
+ return _vc_config.get_int(name, default)\r
+ return int(default)\r
+\r
+\r
+def cfg_attr(name, default=None):\r
+ if _vc_config:\r
+ return _vc_config.get_attr(name, default)\r
+ return default\r
+\r
+\r
+def cfg_uart_supported():\r
+ if _vc_config:\r
+ return _vc_config.uart_supported()\r
+ return False\r
+\r
+\r
+def cfg_dev_type(default="7PIN"):\r
+ if _vc_config:\r
+ return _vc_config.get_dev_type(default)\r
+ return default\r
+\r
+\r
+def cfg_led_gpio_tuple(default):\r
+ """default: (r, g, b) GPIO 常量元组。"""\r
+ if _vc_config:\r
+ return _vc_config.led_gpio_tuple()\r
+ return default\r
+\r
\r
def num_str_to_chinese(num_str):\r
- # 数字与中文映射(含零)\r
num_map = {\r
'0': '零', '1': '一', '2': '二', '3': '三', '4': '四',\r
'5': '五', '6': '六', '7': '七', '8': '八', '9': '九'\r
}\r
chinese = ''\r
- # 逐位转换,拼接单位\r
for char in num_str:\r
if char in num_map:\r
- digit = num_map[char]\r
- chinese += digit\r
+ chinese += num_map[char]\r
else:\r
chinese += char\r
- \r
return chinese\r
-\r
\r
\r
def ux_name(ux):\r
- try:\r
- return _UX_NAMES[int(ux)]\r
- except Exception:\r
- return "idle"\r
+ i = int(ux)\r
+ if 0 <= i < len(_UX_NAMES):\r
+ return _UX_NAMES[i]\r
+ return "idle"\r
\r
\r
def derive_ux_state(vc):\r
"""对齐 录音上传与播放-演示文稿:按键表与 LED 均基于此四态。"""\r
- try:\r
- if vc._vc_tts_playback_active():\r
- return UX_TTS\r
- except Exception:\r
- pass\r
- try:\r
- if getattr(vc, "VC_record_state_flag", 0) != 0:\r
- return UX_RECORDING\r
- except Exception:\r
- pass\r
- try:\r
- if int(getattr(vc, "_ptt_await_server", 0)) == 1:\r
- return UX_THINKING\r
- except Exception:\r
- pass\r
+ if hasattr(vc, "_vc_tts_playback_active") and vc._vc_tts_playback_active():\r
+ return UX_TTS\r
+ if getattr(vc, "VC_record_state_flag", 0) != 0:\r
+ return UX_RECORDING\r
+ if int(getattr(vc, "_ptt_await_server", 0)) == 1:\r
+ return UX_THINKING\r
if VCTurnState is not None:\r
- try:\r
- t = getattr(getattr(vc, "fsm", None), "turn", VCTurnState.Idle)\r
- # PTT 轮间:FSM 仍 Playing 但本地已停播 → 设计 idle\r
- if int(getattr(vc, "VC_mode", 0)) == 1 and t in (\r
- VCTurnState.Playing,\r
- VCTurnState.AwaitPlayedAck,\r
- ):\r
- return UX_IDLE\r
- if t == VCTurnState.Thinking:\r
- return UX_THINKING\r
- if t in (\r
- VCTurnState.TtsReceiving,\r
- VCTurnState.Playing,\r
- VCTurnState.AwaitPlayedAck,\r
- ):\r
- return UX_TTS\r
- except Exception:\r
- pass\r
+ t = getattr(getattr(vc, "fsm", None), "turn", VCTurnState.Idle)\r
+ # PTT 轮间:FSM 仍 Playing 但本地已停播 → 设计 idle\r
+ if int(getattr(vc, "VC_mode", 0)) == 1 and t in (\r
+ VCTurnState.Playing,\r
+ VCTurnState.AwaitPlayedAck,\r
+ ):\r
+ return UX_IDLE\r
+ if t == VCTurnState.Thinking:\r
+ return UX_THINKING\r
+ if t in (\r
+ VCTurnState.TtsReceiving,\r
+ VCTurnState.Playing,\r
+ VCTurnState.AwaitPlayedAck,\r
+ ):\r
+ return UX_TTS\r
return UX_IDLE\r