think播报加速
authorsnickersun <snickersun@163.com>
Sun, 28 Jun 2026 03:51:30 +0000 (11:51 +0800)
committersnickersun <snickersun@163.com>
Sun, 28 Jun 2026 03:51:30 +0000 (11:51 +0800)
12 files changed:
2.sdk/project/7PIN_1_5/sdk/services/microPython/microPython.mk
2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/Makefile
2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/default_config.py
2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/products/configs/g3p/default_config.py
2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/products/configs/k8v3/default_config.py
2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/source/audio_audio.c [new file with mode: 0644]
2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/source/modopus.c
2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/source/modws_dispatcher.c [new file with mode: 0644]
2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/source/mpconfigport.h
2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/uwebsocket.py
2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/vc_session_io.py
2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/vc_session_media.py

index 7fdb716..577e06f 100644 (file)
@@ -295,6 +295,7 @@ QPY_SRCS = \
         ports/quectel/core/source/code128_p.c \\r
         ports/quectel/core/source/modmask.c \\r
         ports/quectel/core/source/modcws_frame.c \\r
+        ports/quectel/core/source/modws_dispatcher.c \\r
         ports/quectel/core/source/modVad.c \\r
         ports/quectel/core/source/machine_one_wire.c\\r
        ports/quectel/core/source/modalipay_collection.c \\r
index 8246a3e..66521c9 100644 (file)
@@ -381,6 +381,7 @@ SRC_QSTR += \
                        source/modwlan.c \
                        source/modmask.c \
                        source/modcws_frame.c \
+                       source/modws_dispatcher.c \
                        source/modVad.c \
                        source/machine_one_wire.c
 
index 156ee43..7ccbacc 100644 (file)
@@ -220,7 +220,7 @@ VAD_RULE2_SILENCE = 500
 # rule3 尾部静音(ms):10s 以上最短连续静音判定语音结束(之前跟随 VAD_SILENCE_DEFAULT,现已独立)
 VAD_RULE3_SILENCE = 960
 # 本地 VAD 判句末后追加采集的尾音(ms),到点再发 audio.completed;防句尾渐弱音被关闸截断。0=立即收尾
-LOCAL_VAD_ENDPOINT_HANGOVER_MS = 200
+LOCAL_VAD_ENDPOINT_HANGOVER_MS = 0
 # 本地 imsl VAD 能量阈值:越低越灵敏(易触发说话),越高越钝;modVad.c 默认 15000
 VAD_ENERGY_THRESHOLD = 15000
 # imsl auth_vad:DMP 区域 0=海外 dmp-global.raisound.com 1=国内正式服务器 dmp.raisound.com  2=国内测试服务器 dmp-dev.raisound.com 3=测试服2 dmp-intl.raisound.com(与 imsl_vad.h AuthInfo.server_addr 一致)
index 156ee43..7ccbacc 100644 (file)
@@ -220,7 +220,7 @@ VAD_RULE2_SILENCE = 500
 # rule3 尾部静音(ms):10s 以上最短连续静音判定语音结束(之前跟随 VAD_SILENCE_DEFAULT,现已独立)
 VAD_RULE3_SILENCE = 960
 # 本地 VAD 判句末后追加采集的尾音(ms),到点再发 audio.completed;防句尾渐弱音被关闸截断。0=立即收尾
-LOCAL_VAD_ENDPOINT_HANGOVER_MS = 200
+LOCAL_VAD_ENDPOINT_HANGOVER_MS = 0
 # 本地 imsl VAD 能量阈值:越低越灵敏(易触发说话),越高越钝;modVad.c 默认 15000
 VAD_ENERGY_THRESHOLD = 15000
 # imsl auth_vad:DMP 区域 0=海外 dmp-global.raisound.com 1=国内正式服务器 dmp.raisound.com  2=国内测试服务器 dmp-dev.raisound.com 3=测试服2 dmp-intl.raisound.com(与 imsl_vad.h AuthInfo.server_addr 一致)
index 50f0d98..60e4bd8 100644 (file)
@@ -227,7 +227,7 @@ VAD_RULE2_SILENCE = 500
 # rule3 尾部静音(ms):10s 以上最短连续静音判定语音结束(之前跟随 VAD_SILENCE_DEFAULT,现已独立)
 VAD_RULE3_SILENCE = 960
 # 本地 VAD 判句末后追加采集的尾音(ms),到点再发 audio.completed;防句尾渐弱音被关闸截断。0=立即收尾
-LOCAL_VAD_ENDPOINT_HANGOVER_MS = 200
+LOCAL_VAD_ENDPOINT_HANGOVER_MS = 0
 # 本地 imsl VAD 能量阈值:越低越灵敏(易触发说话),越高越钝;modVad.c 默认 15000
 VAD_ENERGY_THRESHOLD = 15000
 # imsl auth_vad:DMP 区域 0=海外 dmp-global.raisound.com 1=国内正式服务器 dmp.raisound.com  2=国内测试服务器 dmp-dev.raisound.com 3=测试服2 dmp-intl.raisound.com(与 imsl_vad.h AuthInfo.server_addr 一致)
diff --git a/2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/source/audio_audio.c b/2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/source/audio_audio.c
new file mode 100644 (file)
index 0000000..99d0f97
--- /dev/null
@@ -0,0 +1,3095 @@
+/*
+ * Copyright (c) Quectel Wireless Solution, Co., Ltd.All Rights Reserved.
+ *  
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *  
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *  
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <stdio.h>
+#include "runtime.h"
+#include "extmod/vfs.h"
+#ifndef MICROPY_QPY_AUDIO_AUDIO
+#define MICROPY_QPY_AUDIO_AUDIO 1
+#define PLAT_ASR_1606 1
+#endif
+
+
+#if MICROPY_QPY_AUDIO_AUDIO
+
+
+#include "runtime.h"
+#include "stream.h"
+#include "mperrno.h"
+
+
+#include "audio_queue.h"
+#include "helios_audio.h"
+#include "helios_debug.h"
+#include "helios_gpio.h"
+#include "audio_handle.h"
+#include "helios_fs.h"
+
+
+#if defined(BOARD_EC600MCN_LA) || defined(BOARD_EC600MCN_LA_POC_XBND)|| defined(BOARD_EC600MCN_LA_POC_QS) \
+    || defined(BOARD_EC600MCN_LA_VOLTE) || defined(BOARD_EC600MCN_LA_HJT) \
+    || defined(BOARD_EC600MCN_LE) || defined(BOARD_EC600MCN_LE_POC_XBND) || defined(BOARD_EC600MCN_LE_ALIPAY) \
+       || defined(BOARD_EC600MCN_LA_POC_ZZD) || defined(BOARD_EC600MCN_LE_POC_ZZD) \
+       || defined(BOARD_EC600MCN_LE_POC_QS)  || defined(BOARD_EC600MCN_LE_VOLTE) || defined(BOARD_EC600MCN_LE_BTZ)\
+       || defined(BOARD_EC600MCN_MC) || defined(BOARD_EC600MEU_LA) || defined(BOARD_EC600MEU_LA_POC_XBND) \
+       || defined(BOARD_EC800MCN_GA) || defined(BOARD_EC800MCN_GA_VOLTE) || defined(BOARD_EC600MLA_LA_POC_XBND)\
+       || defined(BOARD_EC800MCN_GA_ALIPAY) || defined(BOARD_EG810MCN_GA_ALIPAY) \
+       || defined(BOARD_EC800MCN_GA_SPISD) || defined(BOARD_EC800MCN_GA_MS) || defined(BOARD_EC800MCN_GA_VOEXT)\
+       || defined(BOARD_EC800MCN_LE) || defined(BOARD_EC800MCN_LE_VOLTE) || defined(BOARD_EC800MCN_LE_VOLVGL)\
+       || defined(BOARD_EC800MCN_LA_POC_XBND) || defined(BOARD_EC800MCN_LE_POC_XBND) \
+       || defined(BOARD_EG810MCN_GA) || defined(BOARD_EG810MCN_GA_VOEXT) || defined(BOARD_EG810MCN_GA_VOLTE) \
+       || defined(BOARD_EG810MCN_GB) || defined(BOARD_EG810MCN_GB_VOEXT) \
+       || defined(BOARD_EG810MCN_LA) || defined(BOARD_EG810MCN_LA_VOLTE) \
+       || defined(BOARD_EG810MEU_LA) || defined(BOARD_EG810MEU_LA_VOEXT) \
+       || defined(PLAT_ASR_1803s) || defined(PLAT_ASR_1803sc) || defined(BOARD_EC800MCN_LE_CPE) || defined(BOARD_EC800MCN_GB_VOEXT) \
+       || defined(BOARD_EG810MEU_LA_VOLVGL) || defined(BOARD_EC800MCN_LE_VOEXT)
+       
+
+       
+
+#define AUDIO_DTMF_TONE_NEW_SUPPORT 1
+
+#endif
+
+
+
+#if CONFIG_AUDIO
+
+typedef void HeliosMPFILE;
+extern HeliosMPFILE* Helios_MP_fopen(const char* path_in, const char* mode_in);
+extern int Helios_MP_fread(void *buffer, size_t size, size_t num, HeliosMPFILE *file);
+extern int Helios_MP_fwrite(void *buffer, size_t size, size_t num, HeliosMPFILE *file);
+extern int Helios_MP_fclose(HeliosMPFILE *file);
+extern int Helios_MP_fseek(HeliosMPFILE *file, long offset, int origin);
+
+#undef HeliosFILE
+#undef Helios_fopen
+#undef Helios_fread
+#undef Helios_fwrite
+#undef Helios_fclose
+#undef Helios_fseek
+
+#define HeliosFILE HeliosMPFILE
+#define Helios_fopen Helios_MP_fopen
+#define Helios_fread Helios_MP_fread 
+#define Helios_fwrite Helios_MP_fwrite
+#define Helios_fclose Helios_MP_fclose
+#define Helios_fseek Helios_MP_fseek
+#endif
+
+
+
+typedef struct _audio_obj_t {
+    mp_obj_base_t base;
+       int device;
+       //int  inited;
+} audio_obj_t;
+
+#define HELIOS_AUDIO_LOG(fmt, ...) custom_log(audio_audio, fmt, ##__VA_ARGS__)
+
+#define AUDIO_CHANNEL_MAX 3
+extern const mp_obj_type_t audio_audio_type;
+
+extern c_callback_t *g_audio_callback;
+static c_callback_t *g_audio_speakerpa_callback;
+static int g_gpio_pa = -1;
+static int g_pa_class = 2;
+static audio_obj_t *audio_obj[AUDIO_CHANNEL_MAX] = {NULL};
+char audio_playing_file_name[256] = {0};
+
+
+extern int audio_err_handle(void);
+extern int audio_play_callback(char *ptr, size_t lens, Helios_EnumAudPlayerState state);
+
+#define FREE_BUFF(X) do \
+{                       \
+    if(X) {             \
+        free(X);        \
+        X = NULL;       \
+    }                   \
+} while (0);   
+
+
+#define CALLOC_BUFF_SET(X,Y) do     \
+{                                   \
+    X = calloc(1, strlen(Y)+16);       \
+    memset(X, 0, strlen(Y)+16);      \
+    if(X) {                         \
+        strncpy(X, Y, strlen(Y));   \
+    }                               \
+} while (0);
+
+#if defined(CONFIG_AUDIO) && !defined(PLAT_Unisoc_8850) && !defined(PLAT_Unisoc_8850_R02)
+#define GET_FILE_VFS_PATH(x, y) \
+       do                                                                                  \
+       {                                                                                   \
+               sprintf(y, "%s", x);                                                     \
+               HELIOS_AUDIO_LOG("vfs_path:%s\n", y);                                           \
+       } while (0)
+#else
+
+#if defined(PLAT_ASR) || defined(PLAT_Unisoc) || defined(PLAT_ASR_1606) || defined(PLAT_ASR_1609) || defined(PLAT_Unisoc_8850) \
+    || defined(PLAT_Unisoc_8910_R05)|| defined(PLAT_Unisoc_8910_R06) || defined(PLAT_ASR_1602) || defined(PLAT_Unisoc_8850_R02)
+#define GET_FILE_VFS_PATH(x, y) get_vfs_path(x,y)
+#else
+#define GET_FILE_VFS_PATH(x, y)                                                         \
+       do                                                                                  \
+       {                                                                                   \
+               char *p_out = NULL;                                                             \
+               if (0 == strncmp(x, "U:", 2) || 0 == strncmp(x, "B:", 2)                        \
+               || 0 == strncmp(x, "mp3files=U:", 11) || 0 == strncmp(x, "mp3files=B:", 11))    \
+               {                                                                               \
+                       sprintf(y, "%s", x);                                                        \
+                       break;                                                                      \
+               }                                                                               \
+               mp_vfs_mount_t *vfs = mp_vfs_lookup_path(x, (const char **)&p_out);             \
+               if (vfs != MP_VFS_NONE && vfs != MP_VFS_ROOT)                                   \
+               {                                                                               \
+                   if(0 == strncmp(vfs->str, "/bak", strlen("/bak"))) {                        \
+                           sprintf(y, "B:%s", p_out);                                              \
+                       } else {                                                                    \
+                           sprintf(y, "U:%s", p_out);                                              \
+                       }                                                                           \
+               }                                                                               \
+               else if(0 == strncmp(x, "mp3files=", 9) || 0 == strncmp(x, "amrfiles=", 9))     \
+               {                                                                               \
+                   vfs = mp_vfs_lookup_path(x + 9, (const char **)&p_out);                     \
+                   if (vfs != MP_VFS_NONE && vfs != MP_VFS_ROOT)                               \
+                   {                                                                           \
+                       memcpy(y, x, 9);                                                        \
+                   if(0 == strncmp(vfs->str, "/bak", strlen("/bak"))) {                    \
+                           sprintf(y + 9, "B:%s", p_out);                                      \
+                       } else {                                                                \
+                           sprintf(y + 9, "U:%s", p_out);                                      \
+                       }                                                                       \
+                   }                                                                           \
+                   else                                                                        \
+                   {                                                                           \
+                sprintf(y, "%s", x);                                                    \
+                   }                                                                           \
+               }                                                                               \
+               else                                                                            \
+               {                                                                               \
+                       sprintf(y, "U:/%s", x);                                                     \
+               }                                                                               \
+               HELIOS_AUDIO_LOG("vfs_path:%s\n", y);                                           \
+       } while (0)
+#endif
+
+#endif
+
+
+//虚函数,用来解决ASR160X R07在关闭MP3解码库宏控时造成的编译问�?
+#if defined (PLAT_ASR) || defined(PLAT_ASR_1606) || defined(PLAT_ASR_1609) || defined (PLAT_Unisoc) || defined(PLAT_Unisoc_8910_R05) \
+    || defined(PLAT_ASR_1602) || defined(PLAT_Unisoc_8910_R06)
+
+#if (!CONFIG_AUDIO_MP3) || (!defined(CONFIG_AUDIO_MP3))
+__attribute__((weak)) void Helios_mp3_stream_close_flag(unsigned char value) 
+{
+       (void) value;
+       return;
+}
+#endif
+
+#endif
+//end
+
+STATIC void delay_us(unsigned int us)
+{
+       int cnt = 26;
+       volatile int i = 0;
+       while(us--){
+               i = cnt;
+               while(i--);
+       }
+}
+
+STATIC void set_clk_high(void)
+{
+       Helios_GPIO_SetLevel(g_gpio_pa, HELIOS_LVL_HIGH);
+}
+
+STATIC void set_clk_low(void)
+{
+       Helios_GPIO_SetLevel(g_gpio_pa, HELIOS_LVL_LOW);
+}
+STATIC void set_pa_flag(uint8_t flag)
+{
+       Helios_Mutex_Lock(audio_pa.pa_mutex, HELIOS_WAIT_FOREVER);
+       if(flag > 0)
+       {
+               audio_pa.open_flag++;
+       }
+       else
+       {
+               if(audio_pa.open_flag > 0){
+                       audio_pa.open_flag--;
+               }
+       }
+       Helios_Mutex_Unlock(audio_pa.pa_mutex);
+}
+
+STATIC uint8_t get_pa_flag(void)
+{
+       uint8_t flag = 0;
+       flag = audio_pa.open_flag;
+       return flag;
+}
+
+STATIC void set_PA_pulse(int num)
+{
+    int i = 0;
+    if(num < 0) return;
+    for (i = 0; i < num; i++) 
+    {
+        set_clk_low();
+        delay_us(3);
+        set_clk_high();
+        delay_us(3);
+    }
+}
+
+STATIC void audio_open_power_amplifier(void)
+{
+       if(get_pa_flag() <= 0)
+       {
+               return;
+       }
+    set_PA_pulse(g_pa_class);
+}
+
+STATIC void audio_close_power_amplifier(void)
+{
+       if(get_pa_flag() > 0)
+       {
+               return;
+       }
+    set_clk_low();
+}
+
+enum {
+    PA_AUDIO_PLAY,
+    PA_AUDIO_STOP,
+};
+static uint8_t play_state = PA_AUDIO_STOP;
+
+static Helios_MsgQ_t open_pa_q = 0;
+static Helios_Thread_t open_pa_task_id = 0;
+
+
+
+// 延时打开PA
+void helios_open_pa(void * argv) {
+       uint8_t pa_ctrl = 0;
+       int ret = -1;
+
+       while (1) {
+               ret = Helios_MsgQ_Get(open_pa_q, (void *)&pa_ctrl, sizeof(uint8_t), HELIOS_WAIT_FOREVER);
+               if (ret != 0)
+               {
+                       HELIOS_AUDIO_LOG("helios_open_pa thread failed to get queue\n");
+                       continue;
+               }
+               if (pa_ctrl == 1) {
+                       Helios_msleep(audio_pa.open_pa_delay);
+                       audio_open_power_amplifier();
+                       play_state = PA_AUDIO_PLAY;
+                       HELIOS_AUDIO_LOG("audio set high, event 1.\r\n");
+               }
+               else {
+                       if(audio_pa.close_pa_delay > 0)
+                       {
+                               Helios_msleep(audio_pa.close_pa_delay);
+                       }
+                       audio_close_power_amplifier();
+                       play_state = PA_AUDIO_STOP;
+                       HELIOS_AUDIO_LOG("audio set low, event 0.\r\n");
+               }
+       }
+       
+}
+
+int asynch_open_pa_init(void) {
+       int ret = 0;
+       Helios_ThreadAttr attr = {0};
+
+       if (open_pa_q == 0) {
+               open_pa_q = Helios_MsgQ_Create(1, sizeof(uint8_t));
+       }
+
+       if(audio_pa.pa_mutex == 0)
+       {
+               audio_pa.pa_mutex = Helios_Mutex_Create();
+               if(audio_pa.pa_mutex == 0)
+               {
+            HELIOS_AUDIO_LOG("create open pa mutex failed\n");
+                       return -1;
+               }
+       }
+
+       if(open_pa_task_id == 0)
+       {
+           attr.name = "open_pa";
+        attr.stack_size = 1024*2;
+        attr.priority = 90;
+        attr.entry = helios_open_pa;
+
+        open_pa_task_id = Helios_Thread_Create(&attr);
+        if (0 == open_pa_task_id)
+        {
+            HELIOS_AUDIO_LOG("create open pa task failed\n");
+                       return -1;
+        }
+       }
+       return ret;
+}
+
+void user_audio_speakerpa_callback(unsigned int event)
+{
+       uint8_t pa_ctrl;
+       unsigned int on_off = 0;
+       if(g_gpio_pa != -1)
+       {
+#if !defined(BOARD_EC600MCN_LF_SLPOC)
+               if(audio_pa.pa_is_delay_close && (event == AUDIO_PA_CLOSE_NOW))
+               {
+                       event = AUDIO_PA_CLOSE_DELAY;
+               }
+               if(audio_pa.pa_is_delay_open && (event == AUDIO_PA_OPEN_NOW))
+               {
+                       event = AUDIO_PA_OPEN_DELAY;
+               }
+#endif
+
+#if defined(BOARD_EC600MCN_LE_POC_QS)
+               extern unsigned char ptt_tone_play_end_skip_pa;
+               if(ptt_tone_play_end_skip_pa)
+               {
+                       ptt_tone_play_end_skip_pa--;
+                       return;
+               }
+#endif
+
+               switch(event)
+               {
+                       case AUDIO_PA_CLOSE_NOW:
+                          set_pa_flag(0);
+                          audio_close_power_amplifier();
+                  play_state = PA_AUDIO_STOP;
+                          on_off = 0;
+                          HELIOS_AUDIO_LOG("audio set low, event 0.\r\n");
+                          break;
+                       case AUDIO_PA_OPEN_DELAY:
+                               set_pa_flag(1);
+                               if (audio_pa.open_pa_delay == 0) {
+                                       audio_open_power_amplifier();
+                                       play_state = PA_AUDIO_PLAY;
+                                       HELIOS_AUDIO_LOG("audio set high, event 1.\r\n");
+                               }
+                               else {
+                                       pa_ctrl = 1;
+                                       Helios_MsgQ_Put(open_pa_q, (const void *)&pa_ctrl, sizeof(uint8_t), HELIOS_NO_WAIT);
+                               }
+                               on_off = 1;
+                               HELIOS_AUDIO_LOG("asynch_open_pa start.\r\n");
+                               break;
+                       case AUDIO_PA_OPEN_NOW:
+                               set_pa_flag(1);
+                               audio_open_power_amplifier();
+                               play_state = PA_AUDIO_PLAY;
+                               on_off = 1;
+                               HELIOS_AUDIO_LOG("audio set high, event 1.\r\n");
+                               break;
+                       case AUDIO_PA_CLOSE_DELAY:
+                               set_pa_flag(0);
+                               pa_ctrl = 0;
+                               Helios_MsgQ_Put(open_pa_q, (const void *)&pa_ctrl, sizeof(uint8_t), HELIOS_NO_WAIT);
+                               on_off = 0;
+                               break;
+                       default:
+                               HELIOS_AUDIO_LOG("audio pa error event:%d\r\n",event);
+                               return;
+               }
+       }
+       if (g_audio_speakerpa_callback)
+       {
+           GC_STACKTOP_SET();
+               mp_sched_schedule_ex(g_audio_speakerpa_callback, mp_obj_new_int(on_off));
+               GC_STACKTOP_CLEAR();
+       }
+}
+
+#if defined(BOARD_EC600MCN_LE_POC_QS) || defined(BOARD_EC600MCN_LA_POC_QS)
+STATIC mp_obj_t mpy_set_audio_read_delay(mp_obj_t self_in, mp_obj_t delay) {
+       Helios_set_audio_read_delay(mp_obj_get_int(delay));
+       return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(mpy_set_audio_read_delay_obj, mpy_set_audio_read_delay);
+#endif
+
+#if defined (PLAT_ASR) || defined(PLAT_Unisoc) || defined(PLAT_ASR_1606) || defined(PLAT_ASR_1609) || defined(PLAT_Unisoc_8850) \
+    || defined(PLAT_EIGEN)|| defined(PLAT_EIGEN_718)  || defined(PLAT_Unisoc_8910_R05) || defined(PLAT_Unisoc_8910_R06) \
+       || defined(PLAT_ASR_1602) || defined(PLAT_Unisoc_8850_R02) || defined(PLAT_ASR_1803s) || defined(PLAT_ASR_1803sc)
+STATIC mp_obj_t helios_set_pa(size_t n_args, const mp_obj_t *args)
+{
+       int ret = 0;
+       Helios_GPIOInitStruct gpio_struct = {0};
+       gpio_struct.dir = HELIOS_GPIO_OUTPUT;
+       gpio_struct.pull = HELIOS_PULL_NONE;
+       gpio_struct.value = HELIOS_LVL_LOW;
+       
+       if(mp_obj_get_int(args[1]) == 0 || mp_obj_get_int(args[1]) > PLAT_GPIO_NUM) {
+               mp_raise_ValueError(MP_ERROR_TEXT("invalid pin"));
+       }
+       g_gpio_pa = mp_obj_get_int(args[1]);
+       if (n_args == 3)
+       {
+               if(mp_obj_get_int(args[2]) > 10 || mp_obj_get_int(args[2]) < 0) {
+                       mp_raise_ValueError(MP_ERROR_TEXT("Too many PA pulses, limited to 10. [0,10]"));
+               }
+        if(g_pa_class == 0 && 0 != mp_obj_get_int(args[2]) && play_state == PA_AUDIO_PLAY) {
+            g_pa_class = mp_obj_get_int(args[2]);
+            Helios_GPIO_Init(g_gpio_pa, &gpio_struct);
+            audio_open_power_amplifier();
+            return mp_obj_new_int(1); 
+        }
+               g_pa_class = mp_obj_get_int(args[2]);
+       }
+       
+       ret = Helios_GPIO_Init(g_gpio_pa, &gpio_struct);//Helios_Audio_SetPa(g_gpio_pa);
+       if (ret != 0)
+       {
+               return mp_obj_new_int(0);
+       }
+       return mp_obj_new_int(1);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(helios_set_pa_obj, 2, 3, helios_set_pa);
+
+STATIC mp_obj_t helios_set_open_pa_delay(mp_obj_t self_in, mp_obj_t delay) {
+       audio_pa.open_pa_delay = mp_obj_get_int(delay);
+       if(audio_pa.open_pa_delay > 0)
+       {
+               audio_pa.pa_is_delay_open = 1;
+       }
+       else
+       {
+               audio_pa.pa_is_delay_open = 0;
+       }
+       return mp_obj_new_int(1);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(helios_set_open_pa_delay_obj, helios_set_open_pa_delay);
+
+STATIC mp_obj_t helios_set_close_pa_delay(mp_obj_t self_in, mp_obj_t delay) {
+       audio_pa.close_pa_delay = mp_obj_get_int(delay);
+       if(audio_pa.close_pa_delay > 0)
+       {
+               audio_pa.pa_is_delay_close = 1;
+       }
+       else
+       {
+               audio_pa.pa_is_delay_close = 0;
+       }
+       return mp_obj_new_int(1);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(helios_set_close_pa_delay_obj, helios_set_close_pa_delay);
+
+STATIC mp_obj_t helios_set_speakerpa_callback(mp_obj_t self_in, mp_obj_t callback)
+{
+    static c_callback_t cb = {0};
+    memset(&cb, 0, sizeof(c_callback_t));
+       g_audio_speakerpa_callback = &cb;
+       mp_sched_schedule_callback_register(g_audio_speakerpa_callback, callback);
+       return mp_obj_new_int(0);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(helios_set_speakerpa_callback_obj, helios_set_speakerpa_callback);
+
+STATIC mp_obj_t helios_user_speakerpa_switch(mp_obj_t self_in, mp_obj_t pa_com)
+{
+       unsigned int event = 0;
+       if(mp_obj_get_int(pa_com) < 0 || mp_obj_get_int(pa_com) > 1) {
+               mp_raise_ValueError(MP_ERROR_TEXT("invalid parameter"));
+       } 
+       event = mp_obj_get_int(pa_com);
+       user_audio_speakerpa_callback(event);
+
+       return mp_obj_new_int(0);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(helios_user_speakerpa_switch_obj, helios_user_speakerpa_switch);
+
+#if defined(PLAT_Unisoc_8850_R02) && defined(CONFIG_POC)
+STATIC mp_obj_t helios_set_audio_data_dump_log(mp_obj_t self_in, mp_obj_t set)
+{
+       unsigned char enable = 0;
+       int ret = -1;
+       if(mp_obj_get_int(enable) < 0 || mp_obj_get_int(enable) > 1) {
+               mp_raise_ValueError(MP_ERROR_TEXT("invalid parameter"));
+       } 
+       enable = mp_obj_get_int(set);
+       ret = Helios_Debug_PCM_Data_Dump_Log_Set(enable);
+       return mp_obj_new_int(ret);
+}
+
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(helios_set_audio_data_dump_log_obj, helios_set_audio_data_dump_log);
+#endif
+
+#if defined(PLAT_Unisoc)
+
+STATIC mp_obj_t helios_internal_pa_type(mp_uint_t n_args, const mp_obj_t *args) {
+       int pa_type = 0;
+       if(n_args == 1)
+    {
+               pa_type = Helios_Get_Audio_Pa_Type();
+               if(pa_type >= HELIOS_AUD_SPKPA_TYPE_MAX || pa_type < HELIOS_AUD_SPKPA_TYPE_CLASSAB)
+               {
+                       return mp_obj_new_int(-1);
+               }
+               return mp_obj_new_int(pa_type);
+       }
+       else if(n_args == 2)
+       {
+               pa_type = mp_obj_get_int(args[1]);
+               if(pa_type >= HELIOS_AUD_SPKPA_TYPE_MAX || pa_type < HELIOS_AUD_SPKPA_TYPE_CLASSAB)
+               {
+                       return mp_obj_new_int(-1);
+               }
+               int ret = Helios_Set_Audio_Pa_Type(pa_type);
+               return mp_obj_new_int(ret);
+       }
+       return mp_obj_new_int(0);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(helios_internal_pa_type_obj, 1, 2, (mp_obj_t)helios_internal_pa_type);
+
+#endif
+
+#endif
+
+/*=============================================================================*/
+/* FUNCTION: helios_set_audio_callback                                             */
+/*=============================================================================*/
+/*!@brief              : user callback function for audio playing.
+ * @param[in]  : callback - user's callback
+ * @param[out]         : 
+ * @return             :
+ */
+/*=============================================================================*/
+STATIC mp_obj_t helios_set_audio_callback(mp_obj_t self_in, mp_obj_t callback)
+{
+    static c_callback_t cb = {0};
+    memset(&cb, 0, sizeof(c_callback_t));
+       g_audio_callback = &cb;
+       mp_sched_schedule_callback_register(g_audio_callback, callback);
+
+       return mp_obj_new_int(0);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(helios_set_audio_callback_obj, helios_set_audio_callback);
+
+#if !CONFIG_AUDIO_PWM
+#if defined (PLAT_ASR) || defined (PLAT_Unisoc) || defined(PLAT_ASR_1606) || defined(PLAT_ASR_1609) || defined (PLAT_Unisoc_8850) \
+    || defined(PLAT_Unisoc_8910_R05) || defined(PLAT_ASR_1602) || defined(PLAT_Unisoc_8850_R02) || defined(PLAT_Unisoc_8910_R06) \
+       || defined(PLAT_ASR_1803s) || defined(PLAT_ASR_1803sc)
+STATIC mp_obj_t helios_audio_set_channel(mp_obj_t self_in, mp_obj_t dev)
+{
+    audio_obj_t *self = MP_OBJ_TO_PTR(self_in);
+       
+       int device = HELIOS_OUTPUT_RECEIVER;
+    device = mp_obj_get_int(dev);
+
+       if(self->device != device)
+       {
+
+               if (!audio_channel_check(device))
+               {
+                       mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("The current platform does not support device %d."), device);
+               }
+               
+               if(device == HELIOS_OUTPUT_RECEIVER||device == HELIOS_OUTPUT_SPEAKER||device == HELIOS_OUTPUT_HEADPHONE){
+                       Helios_Audio_SetAudioChannle(device);
+               }
+               else{
+                       device = HELIOS_OUTPUT_RECEIVER;                        //default replay path
+                       Helios_Audio_SetAudioChannle(device);
+               }
+               self->device = device;
+               
+       }
+       return mp_obj_new_int(0);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(helios_set_channel_obj, helios_audio_set_channel);
+#endif
+#endif
+
+STATIC void helios_codec_callback(Helios_pcm_codec_event event)
+{
+
+       switch(event)
+       {
+               case Helios_PCM_CODEC_AboutToOpen:
+                       if(audio.play_start_mode == HELIOS_AUD_START_FIRST_PA_THEN_DEC)
+                       {
+                               user_audio_speakerpa_callback(2);
+                               Helios_msleep(audio.interval_of_start_dec_pa);
+                       }
+                       break;
+               case Helios_PCM_CODEC_Opened:
+                       if(audio.play_start_mode == HELIOS_AUD_START_FIRST_DEC_THEN_PA)
+                       {
+                               audio_pa.open_pa_delay = audio.interval_of_start_dec_pa;
+                               user_audio_speakerpa_callback(1);
+                       }
+                       break;
+               case Helios_PCM_CODEC_AboutToClose:
+                       if(audio.play_end_mode == HELIOS_AUD_END_FIRST_PA_THEN_DEC)
+                       {
+                               user_audio_speakerpa_callback(0);
+                               Helios_msleep(audio.interval_of_close_dec_pa);
+                       }                       
+                       break;
+               case Helios_PCM_CODEC_Closed:
+                       if(audio.play_end_mode == HELIOS_AUD_END_FIRST_DEC_THEN_PA)
+                       {
+                               audio_pa.close_pa_delay = audio.interval_of_close_dec_pa;
+                               user_audio_speakerpa_callback(3);
+                       }
+                       break;
+               default:
+                       break;
+       }
+}
+
+
+STATIC mp_obj_t audio_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) 
+{
+    mp_arg_check_num(n_args, n_kw, 1, MP_OBJ_FUN_ARGS_MAX, true);
+       int device = HELIOS_OUTPUT_RECEIVER;
+    device = mp_obj_get_int(args[0]);
+       
+       if (device < 0 || device > 2) {
+               mp_raise_ValueError(MP_ERROR_TEXT("invalid device index, the value of device should be in[0,2]"));
+       }
+       asynch_open_pa_init();
+#if !CONFIG_AUDIO_PWM
+#if !defined(PLAT_EIGEN) && !defined(PLAT_EIGEN_718)
+       if (!audio_channel_check(device))
+       {
+               mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("The current platform does not support device %d."), device);
+       }
+#endif
+#endif
+       if(audio_obj[device] == NULL)
+       {
+        audio_obj[device] = m_new_obj_with_finaliser(audio_obj_t);
+    }
+    audio_obj_t *self = audio_obj[device];
+    self->base.type = &audio_audio_type;
+       self->device = device;
+       //self->inited = 0;
+
+       Helios_Audio_Init();
+#if defined(BOARD_EC600MCN_LF_SLPOC)
+       Helios_PCM_Codec_Event_Callback_Register(helios_codec_callback);
+#endif
+
+#if defined(PLAT_ASR) || defined(PLAT_Unisoc) || defined(PLAT_ASR_1606) || defined(PLAT_ASR_1609) || defined(PLAT_EIGEN) \
+       || defined(PLAT_Unisoc_8850) || defined(PLAT_Unisoc_8910_R05) || defined(PLAT_ASR_1602) || defined(PLAT_Unisoc_8850_R02) || defined(PLAT_Unisoc_8910_R06)\
+       || defined(PLAT_EIGEN_718) || defined(PLAT_ASR_1803s) || defined(PLAT_ASR_1803sc)
+
+#if defined(PLAT_EIGEN) || defined(PLAT_EIGEN_718)
+       extern int Helios_Audio_SetPaCallback_py(Helios_AudOutputType type, helios_audio_pa_cb_t cb);
+       Helios_Audio_SetPaCallback_py((Helios_AudOutputType)device, user_audio_speakerpa_callback);
+#else 
+       Helios_Audio_SetPaCallback((Helios_AudOutputType)device, user_audio_speakerpa_callback);
+#endif
+#endif
+
+#if !CONFIG_AUDIO_PWM
+#if !defined(PLAT_EIGEN) && !defined(PLAT_EIGEN_718)
+       if(device == HELIOS_OUTPUT_RECEIVER||device == HELIOS_OUTPUT_SPEAKER||device == HELIOS_OUTPUT_HEADPHONE){
+               Helios_Audio_SetAudioChannle(device);
+       }
+       else{
+               device = HELIOS_OUTPUT_RECEIVER;                        //default replay path
+               Helios_Audio_SetAudioChannle(device);
+       }
+#endif
+#endif
+       if (audio.inited == 0)
+       {
+               uint8_t i = 0;
+               for (i=0; i<QUEUE_NUMS; i++)
+               {
+                       audio_queue_init(&audio.audio_queue[i]);
+               }
+               audio.cur_priority = 0;
+               audio.cur_breakin  = 0;
+               audio.audio_state = AUDIO_IDLE;
+               audio.inited = 1;
+               audio.total_nums = 0;
+               audio.queue_mutex  = 0;
+               audio.queue_msg = 0;
+               audio.montage_mutex = 0;
+               audio.queue_mutex = Helios_Mutex_Create();
+               audio.montage_mutex = Helios_Mutex_Create();
+               audio.queue_msg = Helios_MsgQ_Create(10, sizeof(uint8_t));
+               audio.play_start_mode = 0;
+               audio.play_end_mode = 0;
+               audio.interval_of_start_dec_pa = 0;
+               audio.interval_of_close_dec_pa = 0;
+               if (!audio.queue_msg)
+               {
+                       Helios_Mutex_Delete(audio.queue_mutex);
+                       Helios_Mutex_Delete(audio.montage_mutex);
+                       mp_raise_ValueError(MP_ERROR_TEXT("create audio object failed, can not create msgQ."));
+               }
+               
+               Helios_ThreadAttr attr = {0};
+               attr.name = "audio_queue_play";
+               attr.stack_size = 4096;
+               attr.priority = 95;
+               attr.entry = helios_audio_queue_play_task;
+               
+               Helios_Thread_t id = Helios_Thread_Create(&attr);
+               if (id == 0)
+               {
+                       Helios_MsgQ_Delete(audio.queue_msg);
+                       Helios_Mutex_Delete(audio.queue_mutex);
+                       Helios_Mutex_Delete(audio.montage_mutex);
+                       mp_raise_ValueError(MP_ERROR_TEXT("create audio object failed, can not create queue play task."));
+               }
+       }
+       else
+       {
+               if((audio.montage_mutex == 0) && (audio.queue_msg != 0))
+               {
+                       audio.montage_mutex = Helios_Mutex_Create();
+               }
+       }
+       
+    return MP_OBJ_FROM_PTR(self);
+}
+
+
+
+/*=============================================================================*/
+/* FUNCTION: helios_play_file_start                                               */
+/*=============================================================================*/
+/*!@brief              : play the audio file(mp3,amr)
+ * @param[in]  : filename
+ * @param[out]         : 
+ * @return             :
+ *        -  0--success
+ *        - -1--error
+ * @modify      : 
+                               ----------  ---------   ---------------------------------------------------
+                               2020/10/16  Jayceon.Fu  add queue, priority, breakin.
+ */
+/*=============================================================================*/
+STATIC mp_obj_t helios_play_file_start(size_t n_args, const mp_obj_t *args, mp_map_t *kw_args)
+{
+       enum { ARG_priority, ARG_breakin, ARG_data, ARG_frameJump};
+    static const mp_arg_t allowed_args[] = 
+    {
+       { MP_QSTR_priority, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0} },
+       { MP_QSTR_breakin,  MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0} },
+        { MP_QSTR_data,     MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
+               { MP_QSTR_frameJump,    MP_ARG_OBJ, {.u_int = 0} },
+    };
+    mp_arg_val_t vals[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args - 1, args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, vals);
+
+#if CONFIG_AUDIO
+       extern void Helios_file_jump_frame(Helios_AudStreamFormat format, uint32_t cnt);
+       Helios_file_jump_frame(HELIOS_AUDIO_FORMAT_MP3, vals[ARG_frameJump].u_int);
+#endif
+   
+       int new_priority = vals[ARG_priority].u_int;
+       int new_breakin  = vals[ARG_breakin].u_int;
+       char vfs_name[256] = {0};
+       char *new_data = NULL;
+       if (mp_obj_is_str(vals[ARG_data].u_obj)) 
+       {
+               new_data = (char *)mp_obj_str_get_str(vals[ARG_data].u_obj);
+       } 
+       else 
+       {
+               mp_raise_ValueError(MP_ERROR_TEXT("invalid data"));
+       }
+       GET_FILE_VFS_PATH(new_data, vfs_name);
+
+       Helios_Mutex_Lock(audio.queue_mutex, HELIOS_WAIT_FOREVER);
+       if (audio.audio_state == AUDIO_IDLE)
+       {
+               //HELIOS_AUDIO_LOG("----- audio 1-----\r\n");
+               audio.cur_priority = new_priority;
+               audio.cur_breakin  = new_breakin;
+               audio.cur_type     = AUDIO_FILE;
+               audio.audio_state = AUDIO_PLAYING;
+               Helios_Mutex_Unlock(audio.queue_mutex);
+       }
+       else if (audio.audio_state == AUDIO_PLAYING)
+       {
+               if (new_priority >= audio.cur_priority)
+           {
+                       if (audio.cur_breakin == 1)
+                       {
+                               audio.audio_state = AUDIO_PLAYING;
+
+                               if (!audio_queue_is_full(&audio.audio_queue[new_priority]))
+                               {
+                                       //Helios_Mutex_Lock(audio.queue_mutex, HELIOS_WAIT_FOREVER);
+                                       HELIOS_AUDIO_LOG("----- audio 2[%d,%d]-----\r\n", new_priority, audio.cur_priority);
+                                       uint8_t rear = audio.audio_queue[new_priority].rear;
+                                       uint8_t front = audio.audio_queue[new_priority].front;
+                                       
+                                       if (audio.audio_queue[new_priority].audio_data[rear].breakin == 0)
+                                       {
+                                               rear = (rear + 1) % QUEUE_SIZE;
+                                               audio.total_nums++;
+                                       }
+                                       else if (audio.audio_queue[new_priority].audio_data[rear].breakin == 1)
+                                       {
+                                               if (front == rear)
+                                               {
+                                                       if (front == 0)
+                                                       {
+                                                               front = QUEUE_SIZE - 1;
+                                                       }
+                                                       else
+                                                       {
+                                                               front = (front - 1) % QUEUE_SIZE;
+                                                       }
+                                                       audio.total_nums++;
+                                               }
+                                       }
+                               
+                                       audio.audio_queue[new_priority].audio_data[rear].audio_type = AUDIO_FILE;
+                                       audio.audio_queue[new_priority].audio_data[rear].priority = new_priority;
+                                       audio.audio_queue[new_priority].audio_data[rear].breakin  = new_breakin;
+                                       audio.audio_queue[new_priority].audio_data[rear].mode     = 0;
+                    FREE_BUFF(audio.audio_queue[new_priority].audio_data[rear].data);
+                    CALLOC_BUFF_SET(audio.audio_queue[new_priority].audio_data[rear].data, vfs_name);
+
+                                       audio.audio_queue[new_priority].rear = rear;
+                                       audio.audio_queue[new_priority].front = front;
+                                       
+                                       Helios_Mutex_Unlock(audio.queue_mutex);
+                               }
+                               else
+                               {
+                                       Helios_Mutex_Unlock(audio.queue_mutex);
+                                       return mp_obj_new_int(-2);
+                               }
+                               switch (audio.cur_type)
+                               {
+                               #if MICROPY_QPY_AUDIO_TTS
+                                       case AUDIO_TTS:
+                                       {
+                                               HELIOS_AUDIO_LOG("---- stop tts play. ----\r\n");
+                                               Helios_TTS_Stop();
+                                               break;
+                                       }
+                               #endif
+                                       case AUDIO_FILE:
+                                       {
+                                               HELIOS_AUDIO_LOG("---- stop audio file play. ----\r\n");
+                                               Helios_Audio_FilePlayStop();
+                                               break;
+                                       }
+                                       case AUDIO_MONTAGE:
+                                       {
+                                               Helios_Mutex_Lock(audio.montage_mutex, HELIOS_WAIT_FOREVER);
+                                               HELIOS_AUDIO_LOG("---- stop audio montage play. ----\r\n");
+                                               audio.montage_is_stopping = 1;
+                                               helios_set_montage_break_flag(1);
+                                               #if !defined(PLAT_EIGEN) && !defined(PLAT_EIGEN_718)
+                           audio_err_handle();
+                                               #endif
+                           Helios_msleep(200);
+                           
+                           Helios_Audio_StreamPlayStop();
+                                               audio.montage_is_stopping = 0;
+                                               Helios_Mutex_Unlock(audio.montage_mutex);
+                                               Helios_msleep(200);
+                                               uint8_t audio_msg = AUDIO_FINISH_EVENT;
+                                               if (Helios_MsgQ_Put(audio.queue_msg, (const void *)&audio_msg, sizeof(uint8_t), HELIOS_NO_WAIT) == -1)
+                                               {
+                                                       HELIOS_AUDIO_LOG("send audio msg failed[%u].\r\n", audio_msg);
+                                                       return mp_obj_new_int(-1);
+                                               }
+                                               break;
+                                       }
+                                       default:
+                                       {
+                                               HELIOS_AUDIO_LOG("Unknown audio type.\r\n");
+                                               return mp_obj_new_int(-1);
+                                       }
+                               }
+                               
+                               return mp_obj_new_int(0);
+                       }
+                       else if (audio.cur_breakin == 0)
+                       {
+                               if (!audio_queue_is_full(&audio.audio_queue[new_priority]))
+                               {
+                                       //Helios_Mutex_Lock(audio.queue_mutex, HELIOS_WAIT_FOREVER);
+                                       uint8_t rear = audio.audio_queue[new_priority].rear;
+                                       uint8_t front = audio.audio_queue[new_priority].front;
+                                       
+                                       if (audio.audio_queue[new_priority].audio_data[rear].breakin == 0)
+                                       {
+                                               rear = (rear + 1) % QUEUE_SIZE;
+                                               audio.total_nums++;
+                                       }
+                                       else if (audio.audio_queue[new_priority].audio_data[rear].breakin == 1)
+                                       {
+                                               if (front == rear)
+                                               {
+                                                       if (front == 0)
+                                                       {
+                                                               front = QUEUE_SIZE - 1;
+                                                       }
+                                                       else
+                                                       {
+                                                               front = (front - 1) % QUEUE_SIZE;
+                                                       }
+                                                       audio.total_nums++;
+                                               }
+                                       }
+                               
+                                       audio.audio_queue[new_priority].audio_data[rear].audio_type = AUDIO_FILE;
+                                       audio.audio_queue[new_priority].audio_data[rear].priority = new_priority;
+                                       audio.audio_queue[new_priority].audio_data[rear].breakin  = new_breakin;
+                                       audio.audio_queue[new_priority].audio_data[rear].mode     = 0;
+                    FREE_BUFF(audio.audio_queue[new_priority].audio_data[rear].data);
+                    CALLOC_BUFF_SET(audio.audio_queue[new_priority].audio_data[rear].data, vfs_name);
+                                       audio.audio_queue[new_priority].rear = rear;
+                                       Helios_Mutex_Unlock(audio.queue_mutex);
+                               }
+                               else
+                               {
+                                       Helios_Mutex_Unlock(audio.queue_mutex);
+                                       return mp_obj_new_int(-2);
+                               }
+                               
+                               return mp_obj_new_int(1);
+                       }
+           }
+           else
+           {
+                       if (!audio_queue_is_full(&audio.audio_queue[new_priority]))
+                       {
+                               //Helios_Mutex_Lock(audio.queue_mutex, HELIOS_WAIT_FOREVER);
+                               uint8_t rear = audio.audio_queue[new_priority].rear;
+                               uint8_t front = audio.audio_queue[new_priority].front;
+                               
+                               if (audio.audio_queue[new_priority].audio_data[rear].breakin == 0)
+                               {
+                                       rear = (rear + 1) % QUEUE_SIZE;
+                                       audio.total_nums++;
+                               }
+                               else if (audio.audio_queue[new_priority].audio_data[rear].breakin == 1)
+                               {
+                                       if (front == rear)
+                                       {
+                                               if (front == 0)
+                                               {
+                                                       front = QUEUE_SIZE - 1;
+                                               }
+                                               else
+                                               {
+                                                       front = (front - 1) % QUEUE_SIZE;
+                                               }
+                                               audio.total_nums++;
+                                       }
+                               }
+
+                               audio.audio_queue[new_priority].audio_data[rear].audio_type = AUDIO_FILE;
+                               audio.audio_queue[new_priority].audio_data[rear].priority = new_priority;
+                               audio.audio_queue[new_priority].audio_data[rear].breakin  = new_breakin;
+                               audio.audio_queue[new_priority].audio_data[rear].mode     = 0;
+                FREE_BUFF(audio.audio_queue[new_priority].audio_data[rear].data);
+                CALLOC_BUFF_SET(audio.audio_queue[new_priority].audio_data[rear].data, vfs_name);
+                               audio.audio_queue[new_priority].rear = rear;
+                               audio.audio_queue[new_priority].front = front;
+                               
+                               Helios_Mutex_Unlock(audio.queue_mutex);
+                       }
+                       else
+                       {
+                               Helios_Mutex_Unlock(audio.queue_mutex);
+                               return mp_obj_new_int(-2);
+                       }
+                       
+                       return mp_obj_new_int(1);
+           }
+       }
+       int ret = Helios_Audio_FilePlayStart(vfs_name, HELIOS_AUDIO_PLAY_TYPE_LOCAL, audio_play_callback);
+       if (ret == -1)
+       {
+               Helios_Mutex_Lock(audio.queue_mutex, HELIOS_WAIT_FOREVER);
+               audio.audio_state = AUDIO_IDLE;
+               Helios_Mutex_Unlock(audio.queue_mutex);
+       }
+       else
+       {
+               memcpy(audio_playing_file_name, vfs_name, sizeof(vfs_name));
+       }
+       return mp_obj_new_int(ret);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(helios_play_file_start_obj, 1, helios_play_file_start);
+
+#if defined(BOARD_EC600MCN_LF_SLPOC)
+STATIC mp_obj_t helios_set_audio_play_mode(size_t n_args, const mp_obj_t *args)
+       {               
+               if (n_args == 5)
+               {
+                       if(mp_obj_get_int(args[1]) < 0 || mp_obj_get_int(args[1]) > HELIOS_AUD_START_MODE_MAX) {
+                       mp_raise_ValueError(MP_ERROR_TEXT("parameter error!"));
+                       }
+                       if(mp_obj_get_int(args[2]) > 5000 || mp_obj_get_int(args[2]) < 0) {
+                               mp_raise_ValueError(MP_ERROR_TEXT("Too many time"));
+                       }
+
+                       
+                       
+                       audio.play_start_mode              = mp_obj_get_int(args[1]);
+                       audio.interval_of_start_dec_pa = mp_obj_get_int(args[2]);
+                       audio.play_end_mode                = mp_obj_get_int(args[3]);
+                       audio.interval_of_close_dec_pa = mp_obj_get_int(args[4]);
+                       return mp_obj_new_int(0);
+               }
+               else if (n_args == 1)
+               {
+                       mp_obj_t tuple[4] = 
+                               {
+                                       mp_obj_new_int(audio.play_start_mode),
+                                       mp_obj_new_int(audio.interval_of_start_dec_pa),
+                                       mp_obj_new_int(audio.play_end_mode),
+                                       mp_obj_new_int(audio.interval_of_close_dec_pa),
+                               };
+                       return mp_obj_new_tuple(4, tuple);
+               }
+               return mp_obj_new_int(-1);
+}
+
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(helios_set_audio_play_mode_obj, 1, 5, helios_set_audio_play_mode);
+#endif
+
+STATIC mp_obj_t helios_get_audio_play_state(mp_obj_t self_in)
+{
+       int state = 0;
+       if (audio.audio_state == AUDIO_PLAYING)
+       {
+               state = 1;
+       }
+       else
+       {
+               state = 0;
+       }
+       return mp_obj_new_int(state);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(helios_get_audio_play_state_obj, helios_get_audio_play_state);
+
+STATIC mp_obj_t helios_get_audio_playing_file_name(mp_obj_t self_in)
+{
+       int i = 0;
+       int wait_file = 0;
+       int count = 0;
+       mp_obj_t wait_list = mp_obj_new_list(0, NULL);
+       if (audio.audio_state == AUDIO_IDLE)
+       {
+               return mp_obj_new_int(-1);
+       }
+       for (i=QUEUE_NUMS-1; i>=0; i--)
+       {
+               uint8_t front = audio.audio_queue[i].front;
+               uint8_t rear = audio.audio_queue[i].rear;
+               uint8_t cur = front;
+               if (!audio_queue_is_empty(&audio.audio_queue[i]))
+               {
+                       while(cur != rear)
+                       {
+                               cur = (cur + 1) % QUEUE_SIZE;
+                               mp_obj_list_append(wait_list, mp_obj_new_str(audio.audio_queue[i].audio_data[cur].data, strlen(audio.audio_queue[i].audio_data[cur].data)));    
+                               if(cur == rear)
+                               {
+                                       break;
+                               }
+                       }
+
+               }
+       }
+       mp_obj_t tuple[3] = 
+               {
+                       mp_obj_new_int(audio.total_nums),
+                       mp_obj_new_str(audio_playing_file_name,strlen(audio_playing_file_name)),
+                       wait_list,
+               };
+       return mp_obj_new_tuple(3, tuple);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(helios_get_audio_playing_file_name_obj, helios_get_audio_playing_file_name);
+
+
+
+/*=============================================================================*/
+/* FUNCTION: helios_play_file_stop                                                */
+/*=============================================================================*/
+/*!@brief              : stop playing the audio file(mp3,amr)
+ * @param[in]  : 
+ * @param[out]         : 
+ * @return             :
+ *        -  0--success
+ */
+/*=============================================================================*/
+STATIC mp_obj_t helios_play_file_stop(mp_obj_t self_in)
+{
+       int ret = Helios_Audio_FilePlayStop();
+       return mp_obj_new_int(ret);
+}
+
+STATIC mp_obj_t helios_play_stream_stop(mp_obj_t self_in);
+
+STATIC mp_obj_t helios_play_file_stop_all(mp_obj_t self_in)
+{
+       uint8_t i = 0;
+       int ret = 0;
+
+       helios_set_montage_break_flag(1);
+    #if defined (PLAT_Unisoc) || defined(PLAT_Unisoc_8910_R05) || defined(PLAT_Unisoc_8910_R06)
+    audio_err_handle();
+    #endif
+
+       Helios_Mutex_Lock(audio.queue_mutex, HELIOS_WAIT_FOREVER);
+       for (i=0; i<QUEUE_NUMS; i++)
+       {
+               audio_queue_init(&audio.audio_queue[i]);
+       }
+       audio.cur_priority = 0;
+       audio.cur_breakin  = 0;
+       audio.total_nums = 0;
+       
+       Helios_Mutex_Unlock(audio.queue_mutex);
+       if(audio.cur_type == AUDIO_MONTAGE || audio.cur_type == AUDIO_STREAM)
+       {
+               ret = mp_obj_get_int(helios_play_stream_stop(self_in));
+       }
+       else
+       {
+               ret = Helios_Audio_FilePlayStop();
+       }
+       audio.audio_state = AUDIO_IDLE;
+       return mp_obj_new_int(ret);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(helios_play_file_stop_all_obj, helios_play_file_stop_all);
+
+
+/*=============================================================================*/
+/* FUNCTION: helios_play_stream_start                                               */
+/*=============================================================================*/
+/*!@brief              : play the audio file(mp3,amr)
+ * @param[in]  : filename
+ * @param[out]         : 
+ * @return             :
+ *        -  0--success
+ *        - -1--error
+ * @modify      : 
+                               ----------  ---------   ---------------------------------------------------
+                               2020/10/16  Jayceon.Fu  add queue, priority, breakin.
+ */
+/*=============================================================================*/
+STATIC mp_obj_t helios_play_stream_start(size_t n_args, const mp_obj_t *args, mp_map_t *kw_args)
+{
+       enum { ARG_format, ARG_audiobuf, ARG_mode, ARG_len };
+    static const mp_arg_t allowed_args[] = 
+    {
+       { MP_QSTR_format, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0} },
+        { MP_QSTR_audiobuf,     MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL} },
+        { MP_QSTR_mode,     MP_ARG_INT, {.u_int = 0} },
+               { MP_QSTR_len,     MP_ARG_INT, {.u_int = 0} },
+    };
+    mp_arg_val_t vals[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args - 1, args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, vals);
+   
+       int format = 1;
+       format = vals[ARG_format].u_int;
+       int play_len = vals[ARG_len].u_int;
+#if defined (PLAT_Unisoc) || defined(PLAT_Unisoc_8910_R05) || defined(PLAT_Unisoc_8910_R06)
+       if(format <= HELIOS_AUDIO_FORMAT_UNKNOWN || format >= HELIOS_AUDIO_FORMAT_MAX)
+       {
+               mp_raise_ValueError(MP_ERROR_TEXT("Unsupport format!"));
+               return mp_obj_new_int(-1);
+       }
+#endif
+
+#if defined (PLAT_ASR)
+       if(format != HELIOS_AUDIO_FORMAT_WAVPCM && format != HELIOS_AUDIO_FORMAT_MP3 && format != HELIOS_AUDIO_FORMAT_AMRNB
+        && format != HELIOS_AUDIO_FORMAT_AMRWB)
+       {
+               mp_raise_ValueError(MP_ERROR_TEXT("Unsupport format!"));
+               return mp_obj_new_int(-1);
+       }
+#endif
+
+       audio_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+       mp_buffer_info_t buff_a;
+       if(vals[ARG_audiobuf].u_obj != mp_const_none) {
+               mp_get_buffer_raise(vals[ARG_audiobuf].u_obj, &buff_a, MP_BUFFER_READ);
+               if(buff_a.len <= 0 || buff_a.buf == NULL) {
+                       mp_raise_ValueError(MP_ERROR_TEXT("invalid audio_buff data"));
+               }
+       }
+#if defined (PLAT_ASR) || defined(PLAT_ASR_1606) || defined(PLAT_ASR_1609) || defined (PLAT_Unisoc) || defined(PLAT_Unisoc_8910_R05) \
+    || defined(PLAT_ASR_1602) || defined(PLAT_Unisoc_8910_R06)
+       Helios_mp3_stream_close_flag(vals[ARG_mode].u_int);
+#endif
+       MP_THREAD_GIL_EXIT();
+       int ret = 0;
+       audio.cur_type = AUDIO_STREAM;
+       if(play_len == 0) {
+               ret = Helios_Audio_StreamPlayStart(format, buff_a.buf, buff_a.len, HELIOS_AUDIO_PLAY_TYPE_LOCAL, self->device, audio_play_callback);
+       }  else {
+               ret = Helios_Audio_StreamPlayStart(format, buff_a.buf, play_len, HELIOS_AUDIO_PLAY_TYPE_LOCAL, self->device, audio_play_callback);
+       }
+       MP_THREAD_GIL_ENTER();
+       return mp_obj_new_int(ret);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(helios_play_stream_start_obj, 1, helios_play_stream_start);
+
+#if defined (PLAT_Unisoc) || defined(PLAT_Unisoc_8910_R05) || defined(PLAT_Unisoc_8910_R06)
+STATIC mp_obj_t helios_pcm_para_set(size_t n_args, const mp_obj_t *args, mp_map_t *kw_args)
+{
+       enum { ARG_samplerate, ARG_channels };
+    static const mp_arg_t allowed_args[] = 
+    {
+       { MP_QSTR_samplerate, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 44100} },
+        { MP_QSTR_channels, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 2} },
+    };
+    mp_arg_val_t vals[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args - 1, args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, vals);
+   
+       int samplerate = 0;
+       samplerate = vals[ARG_samplerate].u_int;
+       if(samplerate != 96000 && samplerate != 88200 && samplerate != 64000&& samplerate != 48000 && samplerate != 44100 
+               && samplerate != 32000 && samplerate != 22050 && samplerate != 16000 && samplerate != 11025 && samplerate != 8000 && samplerate!=6000)
+       {
+               mp_raise_ValueError(MP_ERROR_TEXT("Unsupport samplerate!"));
+               return mp_obj_new_int(-1);
+       }
+
+       int channels = vals[ARG_channels].u_int;
+       if(channels != 2 && channels != 1)
+       {
+               mp_raise_ValueError(MP_ERROR_TEXT("Unsupport channels!"));
+               return mp_obj_new_int(-1);
+       }
+       
+       Helios_Audio_PCM_para_set(samplerate, channels);
+       return mp_obj_new_int(0);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(helios_pcm_para_obj, 1, helios_pcm_para_set);
+#endif
+
+
+/*=============================================================================*/
+/* FUNCTION: helios_play_stream_stop                                                */
+/*=============================================================================*/
+/*!@brief              : stop playing the audio file(mp3,amr)
+ * @param[in]  : 
+ * @param[out]         : 
+ * @return             :
+ *        -  0--success
+ */
+/*=============================================================================*/
+STATIC mp_obj_t helios_play_stream_stop(mp_obj_t self_in)
+{
+       if(0 != audio.montage_mutex)
+               Helios_Mutex_Lock(audio.montage_mutex, HELIOS_WAIT_FOREVER);
+
+       helios_set_montage_break_flag(1);
+    #if defined (PLAT_Unisoc) || defined(PLAT_Unisoc_8910_R05) || defined(PLAT_Unisoc_8910_R06)
+    audio_err_handle();
+    #endif
+
+       int ret = Helios_Audio_StreamPlayStop();
+       if(0 != audio.montage_mutex)
+               Helios_Mutex_Unlock(audio.montage_mutex);
+       return mp_obj_new_int(ret);
+       
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(helios_play_stream_stop_obj, helios_play_stream_stop);
+
+
+STATIC mp_obj_t helios_audio_play_stop(mp_obj_t self_in)
+{
+       int ret = 0;
+       if(audio.cur_type == AUDIO_MONTAGE || audio.cur_type == AUDIO_STREAM)
+       {
+               ret = mp_obj_get_int(helios_play_stream_stop(self_in));
+       }
+       else if(audio.cur_type == AUDIO_FILE)
+       {
+               ret = mp_obj_get_int(helios_play_file_stop(self_in));
+       }
+       if(1 == ret)
+       {
+               ret = 0;
+       }
+       return mp_obj_new_int(ret);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(helios_audio_play_stop_obj, helios_audio_play_stop);
+
+
+/*=============================================================================*/
+/* FUNCTION: helios_get_audio_state                                               */
+/*=============================================================================*/
+/*!@brief              : get the initialization state of audio.
+ * @param[in]  : 
+ * @param[out]         : 
+ * @return             :
+ *        - -1 -- False
+ *        - 0 -- True
+ */
+/*=============================================================================*/
+STATIC mp_obj_t helios_get_audio_state(mp_obj_t self_in)
+{
+    #if defined (PLAT_ASR) || defined (PLAT_Unisoc) || defined(PLAT_Unisoc_8910_R05) || defined(PLAT_Unisoc_8910_R06)
+       int ret = helios_audio_getInitState();
+    #else
+       int ret = 0;
+    #endif
+       return mp_obj_new_int(ret);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(helios_get_audio_state_obj, helios_get_audio_state);
+
+
+/*=============================================================================*/
+/* FUNCTION: helios_set_volume                                                    */
+/*=============================================================================*/
+/*!@brief              : set volume.
+ * @param[in]  : 
+ * @param[out]         : 
+ * @return             : 
+ */
+/*=============================================================================*/
+STATIC mp_obj_t helios_set_volume(mp_obj_t self_in, mp_obj_t volume)
+{
+       int vol = mp_obj_get_int(volume);
+       if (vol < 0 || vol > 11)
+       {
+               mp_raise_ValueError(MP_ERROR_TEXT("invalid value,TTS volume should be array between [0,11]"));
+               return mp_obj_new_int(-1);
+       }
+       
+       Helios_AudPlayerType type = 1;
+#ifdef CONFIG_AUDIO_PWM
+    int ret = Helios_Aud_PWM_Set_Volume(vol);
+#else
+       int ret = Helios_Audio_SetVolume(type, vol);
+#endif
+       return mp_obj_new_int(ret);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(helios_set_volume_obj, helios_set_volume);
+
+
+/*=============================================================================*/
+/* FUNCTION: helios_get_volume                                                    */
+/*=============================================================================*/
+/*!@brief              : get volume.
+ * @param[in]  : 
+ * @param[out]         : 
+ * @return             : current volume
+ */
+/*=============================================================================*/
+STATIC mp_obj_t helios_get_volume(mp_obj_t self_in)
+{
+       Helios_AudPlayerType type = 1;
+#ifdef CONFIG_AUDIO_PWM
+       int vol = Helios_Aud_PWM_Get_Volume();
+#else
+    int vol = Helios_Audio_GetVolume(type);
+#endif
+       return mp_obj_new_int(vol);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(helios_get_volume_obj, helios_get_volume);
+
+#ifdef CONFIG_AUDIO_PWM
+STATIC mp_obj_t helios_set_pwm_gain(mp_obj_t self_in, mp_obj_t gain_min, mp_obj_t gain_max)
+{
+       float gainMin = mp_obj_get_float(gain_min);
+       float gainMax = mp_obj_get_float(gain_max);
+       
+    int ret = Helios_Aud_PWM_Set_Gain_Value(gainMin, gainMax);
+       return mp_obj_new_int(ret);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_3(helios_set_pwm_gain_obj, helios_set_pwm_gain);
+#endif
+
+#ifdef AUDIO_DTMF_TONE_NEW_SUPPORT
+STATIC mp_obj_t helios_set_ToneVolume(mp_obj_t self_in, mp_obj_t volume)
+{
+       int vol = mp_obj_get_int(volume);
+       if (vol < 0 || vol > 11)
+       {
+               mp_raise_ValueError(MP_ERROR_TEXT("invalid value,Tone volume should be array between [0,10]"));
+               return mp_obj_new_int(-1);
+       }
+       
+       int ret = Helios_Audio_SetToneVolume(vol);
+       return mp_obj_new_int(ret);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(helios_set_ToneVolume_obj, helios_set_ToneVolume);
+#endif
+
+#if defined (PLAT_Unisoc) || defined(PLAT_Unisoc_8910_R05) || defined(PLAT_Unisoc_8910_R06)
+STATIC mp_obj_t helios_play_stream_jump(size_t n_args, const mp_obj_t *args, mp_map_t *kw_args)
+{
+       enum { ARG_second, ARG_drection };
+    static const mp_arg_t allowed_args[] = 
+    {
+       { MP_QSTR_second, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0} },
+       { MP_QSTR_drection, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0} },
+    };
+    mp_arg_val_t vals[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args - 1, args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, vals);
+   
+       int second = 0;
+       second = vals[ARG_second].u_int;
+
+       int drection = 0;
+       drection = vals[ARG_drection].u_int;
+       Helios_JumpInfoStruct info = {0,0};
+       info = Helios_Audio_Stream_Jump(second,drection);       
+       if(info.ofs == 0&&info.bytenow == 0)
+               return mp_obj_new_int(-1);
+       else
+               return mp_obj_new_int(0);
+       
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(helios_play_stream_jump_obj, 1, helios_play_stream_jump);
+
+STATIC mp_obj_t helios_play_stream_pause(mp_obj_t self_in)
+{
+       int s = Helios_Audio_Stream_Pause();
+       return mp_obj_new_int(s);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(helios_play_stream_pause_obj, helios_play_stream_pause);
+
+STATIC mp_obj_t helios_play_stream_continue(mp_obj_t self_in)
+{
+       int s = Helios_Audio_Stream_Continue();
+       return mp_obj_new_int(s);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(helios_play_stream_continue_obj, helios_play_stream_continue);
+
+STATIC mp_obj_t helios_play_stream_seek(size_t n_args, const mp_obj_t *args, mp_map_t *kw_args)
+{
+       enum { ARG_second };
+    static const mp_arg_t allowed_args[] = 
+    {
+       { MP_QSTR_second, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0} },
+    };
+    mp_arg_val_t vals[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args - 1, args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, vals);
+   
+       uint32_t second = 0;
+       second = vals[ARG_second].u_int;
+
+       long unsigned int bytepos = Helios_Audio_Stream_Seek(second);   
+
+       return mp_obj_new_int(bytepos);
+       
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(helios_play_stream_seek_obj, 1, helios_play_stream_seek);
+#endif
+
+#if CONFIG_AUDIO
+STATIC mp_obj_t helios_play_frame_jump(size_t n_args, const mp_obj_t *args, mp_map_t *kw_args)
+{
+       enum { ARG_number };
+    static const mp_arg_t allowed_args[] = 
+    {
+       { MP_QSTR_num, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0} },
+    };
+    mp_arg_val_t vals[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args - 1, args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, vals);
+   
+       extern void Helios_file_jump_frame(Helios_AudStreamFormat format, uint32_t cnt);
+       Helios_file_jump_frame(HELIOS_AUDIO_FORMAT_MP3, vals[ARG_number].u_int);
+       
+       return mp_obj_new_int(0);
+       
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(helios_play_jump_frame_obj, 1, helios_play_frame_jump);
+#endif
+
+#if defined (PLAT_ASR) || defined (PLAT_Unisoc) || defined(PLAT_ASR_1606) || defined(PLAT_ASR_1609) \
+               || defined(PLAT_Unisoc_8910_R05) || defined(PLAT_ASR_1602) || defined(PLAT_ASR_1803s) || defined(PLAT_ASR_1803sc) || defined(PLAT_Unisoc_8850_R02) || defined(PLAT_Unisoc_8910_R06)
+#ifndef AUDIO_DTMF_TONE_NEW_SUPPORT
+STATIC const mp_arg_t tone_allowed_args[] = {
+    { MP_QSTR_tone,            MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0} },
+    { MP_QSTR_time,            MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 500} },
+};
+#endif
+static Helios_OSTimer_t aud_tone_timer = 0;
+static Helios_Thread_t aud_tone_thread_id = 0;
+static Helios_MsgQ_t aud_tone_queue_msg = 0;
+static uint8_t aud_tone_flag = 0;
+
+
+static void helios_aud_tone_play_cb(void *argv) {
+       uint8_t audio_msg = 1;
+       Helios_MsgQ_Put(aud_tone_queue_msg, (const void *)&audio_msg, sizeof(uint8_t), HELIOS_NO_WAIT);
+}
+
+static void helios_aud_tone_stop_task(void *argv)
+{
+       HELIOS_AUDIO_LOG("helios_aud_tone_dtmf_stop_task start...\r\n");
+       uint8_t audio_msg = 0;
+       int ret = 0;
+       while (1)
+       {
+               ret = Helios_MsgQ_Get(aud_tone_queue_msg, (void *)&audio_msg, sizeof(uint8_t), HELIOS_WAIT_FOREVER);
+               if (ret == 0)
+               {
+                       switch (audio_msg)
+                       {
+                               case 1:
+                    while(aud_tone_flag == 0){
+                        Helios_msleep(20);
+                    }
+                    aud_tone_flag = 0;
+                    HELIOS_AUDIO_LOG("----Aud Tone Stop---\r\n");
+                                       Helios_Audio_Stop_Tone();
+#ifdef AUDIO_DTMF_TONE_NEW_SUPPORT
+                                       Helios_Audio_Stop_DTMF();
+#endif
+                                       break;
+                               default:
+                                       break;
+                       }
+               }
+       }
+}
+
+
+//dial tone,ring back tone
+#ifdef AUDIO_DTMF_TONE_NEW_SUPPORT
+//dial tone,ring back tone
+STATIC mp_obj_t helios_aud_tone_play(size_t n_args, const mp_obj_t *args)
+{
+
+       unsigned int time = 0;
+       int ret = 0;
+       int tone = 0;
+    int f1 = 0, f2 = 0;
+    unsigned char tone_flag = 0; //0: tone 1:dtmf
+    
+       
+       audio_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+
+    if(n_args == 3) {
+        tone = mp_obj_get_int(args[1]);
+        time = mp_obj_get_int(args[2]);
+
+    } else if(n_args == 4) {
+        f1 = mp_obj_get_int(args[1]);
+        f2 = mp_obj_get_int(args[2]);
+        time = mp_obj_get_int(args[3]);
+        tone_flag = 1;
+    }
+       
+       if(aud_tone_timer == 0)
+       {
+               aud_tone_timer = Helios_OSTimer_Create();
+       }
+       
+       if(aud_tone_timer == 0)
+       {
+               return mp_obj_new_int(-1);
+       } else {
+        Helios_OSTimer_Stop(aud_tone_timer);
+        Helios_Audio_Stop_Tone();
+        Helios_Audio_Stop_DTMF();
+        aud_tone_flag = 0;
+    }
+
+       if(0 != time)
+       {
+           Helios_OSTimerAttr OSTimerAttr = {
+               .ms = (uint32_t)time,
+               .cycle_enable = 0,
+               .cb = helios_aud_tone_play_cb,
+               .argv = (void *)self
+           };
+               ret = Helios_OSTimer_Start(aud_tone_timer, &OSTimerAttr);
+       }
+
+       if(ret)
+       {
+               HELIOS_AUDIO_LOG("Timer starte failed\r\n");
+       }
+       HELIOS_AUDIO_LOG("Timer started\r\n");
+
+       if(ret != 0) 
+       {
+               Helios_Audio_Stop_Tone();
+        Helios_Audio_Stop_DTMF();
+               if(aud_tone_timer != 0) 
+               {
+                       ret = Helios_OSTimer_Stop(aud_tone_timer);
+               }
+               return mp_obj_new_int(-1);
+       }
+
+       if(0 != time && 0 == aud_tone_thread_id)
+       {
+               Helios_ThreadAttr attr = {0};
+               attr.name = "aud_tone_stop";
+               attr.stack_size = 4096;
+               attr.priority = 95;
+               attr.entry = helios_aud_tone_stop_task;
+
+               aud_tone_queue_msg = Helios_MsgQ_Create(10, sizeof(uint8_t));
+               if (!aud_tone_queue_msg)
+               {
+                       return mp_obj_new_int(-1);
+               }
+               
+               aud_tone_thread_id = Helios_Thread_Create(&attr);
+               if (aud_tone_thread_id == 0)
+               {
+                       Helios_MsgQ_Delete(aud_tone_queue_msg);
+                       return mp_obj_new_int(-1);
+               }
+       }
+
+    while(aud_tone_flag == 1){
+        Helios_msleep(20);
+    }
+       MP_THREAD_GIL_EXIT();
+    if(tone_flag == 0) {
+        ret = Helios_Audio_Play_DTMF(tone, (uint32_t)time);
+    } else {
+        ret = Helios_Audio_Play_Tone(f1, f2);
+    }
+       MP_THREAD_GIL_ENTER();
+       if(ret != 0)
+       {
+        Helios_OSTimer_Stop(aud_tone_timer);
+        Helios_Audio_Stop_Tone();
+        Helios_Audio_Stop_DTMF();
+        aud_tone_flag = 0;
+               return mp_obj_new_int(-1);
+       }
+       aud_tone_flag = 1;
+    return mp_obj_new_int(0);
+}
+
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_helios_aud_tone_play_obj, 3, 4, helios_aud_tone_play);
+
+#else
+STATIC mp_obj_t helios_aud_tone_play(size_t n_args, const mp_obj_t *p_args, mp_map_t *kw_args)
+{
+       enum { ARG_tone, ARG_time};
+       
+    mp_arg_val_t args[MP_ARRAY_SIZE(tone_allowed_args)];
+    mp_arg_parse_all(n_args - 1, p_args + 1, kw_args,
+        MP_ARRAY_SIZE(tone_allowed_args), tone_allowed_args, args);
+
+       unsigned int time = 0;
+       int ret = 0;
+       int tone = 0;
+       
+       audio_obj_t *self = MP_OBJ_TO_PTR(p_args[0]);
+       
+       tone = args[ARG_tone].u_int;
+       time = args[ARG_time].u_int;
+
+       if(tone > 22 || tone < 0) 
+       {
+               mp_raise_ValueError(MP_ERROR_TEXT("Parameter error\n"));
+               return mp_obj_new_int(-1);
+       }
+       
+       if(aud_tone_timer == 0)
+       {
+               aud_tone_timer = Helios_OSTimer_Create();
+       }
+       
+       if(aud_tone_timer == 0)
+       {
+               return mp_obj_new_int(-1);
+       } else {
+        Helios_OSTimer_Stop(aud_tone_timer);
+        Helios_Audio_Stop_Tone();
+        aud_tone_flag = 0;
+    }
+
+       if(0 != time && 0 == aud_tone_thread_id)
+       {
+               Helios_ThreadAttr attr = {0};
+               attr.name = "aud_tone_stop";
+               attr.stack_size = 4096;
+               attr.priority = 95;
+               attr.entry = helios_aud_tone_stop_task;
+
+               aud_tone_queue_msg = Helios_MsgQ_Create(10, sizeof(uint8_t));
+               if (!aud_tone_queue_msg)
+               {
+                       return mp_obj_new_int(-1);
+               }
+               
+               aud_tone_thread_id = Helios_Thread_Create(&attr);
+               if (aud_tone_thread_id == 0)
+               {
+                       Helios_MsgQ_Delete(aud_tone_queue_msg);
+                       return mp_obj_new_int(-1);
+               }
+       }
+
+    while(aud_tone_flag == 1){
+        Helios_msleep(20);
+    } 
+
+       if(0 != time)
+       {
+           Helios_OSTimerAttr OSTimerAttr = {
+               .ms = (uint32_t)time,
+               .cycle_enable = 0,
+               .cb = helios_aud_tone_play_cb,
+               .argv = (void *)self
+           };
+               ret = Helios_OSTimer_Start(aud_tone_timer, &OSTimerAttr);
+       }
+       if(ret)
+       {
+               HELIOS_AUDIO_LOG("Timer starte failed\r\n");
+       }
+
+       if(ret != 0) 
+       {
+               Helios_Audio_Stop_Tone();
+               if(aud_tone_timer != 0) 
+               {
+                       ret = Helios_OSTimer_Stop(aud_tone_timer);
+               }
+               return mp_obj_new_int(-1);
+       }
+
+       MP_THREAD_GIL_EXIT();
+       aud_tone_flag = 1;
+       ret = Helios_Audio_Play_Tone(tone, (uint32_t)time);
+       MP_THREAD_GIL_ENTER();
+       if(ret != 0)
+       {
+        Helios_OSTimer_Stop(aud_tone_timer);
+        Helios_Audio_Stop_Tone();
+        aud_tone_flag = 0;
+               return mp_obj_new_int(-1);
+       }
+    return mp_obj_new_int(0);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(mp_helios_aud_tone_play_obj, 1, helios_aud_tone_play);
+#endif
+
+STATIC mp_obj_t helios_aud_tone_play_stop(mp_obj_t self_in)
+{
+       int ret = 0;
+       Helios_Audio_Stop_Tone();
+#ifdef AUDIO_DTMF_TONE_NEW_SUPPORT
+       Helios_Audio_Stop_DTMF();
+
+#endif
+       if(aud_tone_timer != 0) {
+               ret = Helios_OSTimer_Stop(aud_tone_timer);
+               }
+       return mp_obj_new_int(ret);
+}
+
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(helios_aud_tone_play_stop_obj, helios_aud_tone_play_stop);
+
+#if defined(BOARD_EC800GCN_LD_XBND)
+STATIC mp_obj_t helios_aud_set_tone_gain(mp_obj_t self_in, mp_obj_t gain) {
+       int tone_gain = mp_obj_get_int(gain);
+       if (tone_gain < 0 || tone_gain > 0x4000)
+       {
+               mp_raise_ValueError(MP_ERROR_TEXT("invalid value,tone gain should be array between [0x0, 0x4000]"));
+               return mp_obj_new_int(-1);
+       }
+       int ret = 0;
+       ret = Helios_Audio_Set_Tone_Gain(tone_gain);
+       return mp_obj_new_int(ret);
+}
+
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(helios_aud_set_tone_gain_obj, helios_aud_set_tone_gain);
+#endif
+
+#endif
+
+
+#if defined (PLAT_Unisoc) || defined(PLAT_Unisoc_8910_R05) || defined(PLAT_Unisoc_8910_R06)
+STATIC mp_obj_t helios_setGainTabel(size_t n_args, const mp_obj_t *args, mp_map_t *kw_args)
+{
+
+       int i = 0,ret = -1;
+       int16_t gain[12] = {0xff};
+       
+       HELIOS_AUDIO_LOG("gain para count = %d\n",n_args);
+       if(n_args != 14) {
+               mp_raise_ValueError(MP_ERROR_TEXT("Please enter complete parameters, including the gain corresponding to ID and volume (0-11)"));
+       }
+
+       HELIOS_AUDIO_LOG("gain id[%d]\n",mp_obj_get_int(args[1]));
+
+       for (i = 0; i < 12; i++) {
+               gain[i] = mp_obj_get_int(args[i+2]);
+               HELIOS_AUDIO_LOG("gain para[%d]:%d\n",i,gain[i]);
+               if (gain[i] < -26 || gain[i] > 23) {
+                       mp_raise_ValueError(MP_ERROR_TEXT("gain error, gain is out (-26db-23db)"));
+                       return mp_obj_new_int(-1);
+               }
+       }
+
+       if( 0 != Helios_Audio_SetDSPGainTable(mp_obj_get_int(args[1]), gain)) {
+               return mp_obj_new_int(-1);
+       }
+       return mp_obj_new_int(0);
+   
+       
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(helios_setgaintabel_obj, 1, helios_setGainTabel);
+#endif
+
+#if defined (PLAT_EIGEN) || defined(PLAT_EIGEN_718)
+STATIC mp_obj_t helios_setGainTabel(size_t n_args, const mp_obj_t *args, mp_map_t *kw_args)
+{
+
+       int i = 0,ret = -1;
+       int16_t gain[12] = {0xff};
+       
+       HELIOS_AUDIO_LOG("gain para count = %d\n",n_args);
+       if(n_args != 13) {
+               mp_raise_ValueError(MP_ERROR_TEXT("Please enter complete parameters, including the gain corresponding to ID and volume (0-11)"));
+       }
+
+       HELIOS_AUDIO_LOG("gain id[%d]\n",mp_obj_get_int(args[1]));
+
+       for (i = 0; i < 11; i++) {
+               gain[i] = mp_obj_get_int(args[i+2]);
+               HELIOS_AUDIO_LOG("gain para[%d]:%d\n",i,gain[i]);
+               if (gain[i] < -36 || gain[i] > 36) {
+                       mp_raise_ValueError(MP_ERROR_TEXT("gain error, gain is out (-36db-36db)"));
+                       return mp_obj_new_int(-1);
+               }
+       }
+
+       if( 0 != Helios_Audio_SetDigGainTable(mp_obj_get_int(args[1]), gain)) {
+               return mp_obj_new_int(-1);
+       }
+       return mp_obj_new_int(0);
+   
+       
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_KW(helios_setgaintabel_obj, 1, helios_setGainTabel);
+
+#endif
+
+STATIC mp_obj_t helios_audio___del__(mp_obj_t self_in)
+{
+       uint8_t i = 0;
+       audio_obj_t *self = MP_OBJ_TO_PTR(self_in);
+       Helios_Mutex_Lock(audio.queue_mutex, HELIOS_WAIT_FOREVER);
+       for (i=0; i<QUEUE_NUMS; i++)
+       {
+               audio_queue_init(&audio.audio_queue[i]);
+       }
+       audio.cur_priority = 0;
+       audio.cur_breakin  = 0;
+       audio.total_nums = 0;
+       //audio.audio_state = AUDIO_IDLE;
+       Helios_Mutex_Unlock(audio.queue_mutex);
+    g_audio_callback = NULL;
+    g_audio_speakerpa_callback = NULL;
+    audio_obj[self->device] = NULL;
+
+       int ret = Helios_Audio_FilePlayStop();
+       return mp_obj_new_int(ret);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(helios_audio___del___obj, helios_audio___del__);
+
+//================================montage Handel start=====================================================
+#if defined (PLAT_Unisoc) || defined (PLAT_ASR)  || defined(PLAT_ASR_1606) || defined(PLAT_ASR_1609) || defined(PLAT_EIGEN) \
+|| defined(PLAT_Unisoc_8910_R05) || defined(PLAT_ASR_1602) || defined(PLAT_EIGEN_718) || defined(PLAT_Unisoc_8910_R06)
+
+extern int Helios_Audio_MontageFilePlayStart(char *montage_name, char *file_name, Helios_AudPlayerType type, helios_cb_on_player usr_cb, int device);
+static mp_obj_t helios_play_montage_file_start(size_t n_args, const mp_obj_t *args, mp_map_t *kw_args)
+{
+    enum
+    {
+        ARF_montage_file,
+        ARG_priority,
+        ARG_breakin,
+        ARG_data
+    };
+    static const mp_arg_t allowed_args[] =
+        {
+            {MP_QSTR_montageFile, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL}},
+            {MP_QSTR_priority, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0}},
+            {MP_QSTR_breakin, MP_ARG_REQUIRED | MP_ARG_INT, {.u_int = 0}},
+            {MP_QSTR_data, MP_ARG_REQUIRED | MP_ARG_OBJ, {.u_obj = MP_OBJ_NULL}},
+        };
+    mp_arg_val_t vals[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args - 1, args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, vals);
+
+       if(vals[ARG_priority].u_int > 4)
+       {
+               mp_raise_ValueError(MP_ERROR_TEXT("invalid priority,must be in 0~4"));
+       }
+       if(vals[ARG_breakin].u_int > 1)
+       {
+               mp_raise_ValueError(MP_ERROR_TEXT("invalid breakin,must be in 0~1"));
+       }
+       audio_obj_t *self = MP_OBJ_TO_PTR(args[0]);
+    int new_priority = vals[ARG_priority].u_int;
+    int new_breakin = vals[ARG_breakin].u_int;
+    char vfs_name[256] = {0};
+    char *new_data = NULL;
+    char *new_monFile = NULL;
+    char vfs_monFile[256] = {0};
+    if (mp_obj_is_str(vals[ARG_data].u_obj))
+    {
+        new_data = (char *)mp_obj_str_get_str(vals[ARG_data].u_obj);
+    }
+    else
+    {
+        mp_raise_ValueError(MP_ERROR_TEXT("invalid data"));
+    }
+    // GET_FILE_VFS_PATH(new_data, vfs_name);
+    memcpy(vfs_name, new_data, strlen(new_data));
+       
+    if (mp_obj_is_str(vals[ARF_montage_file].u_obj))
+    {
+        new_monFile = (char *)mp_obj_str_get_str(vals[ARF_montage_file].u_obj);
+    }
+    else
+    {
+        mp_raise_ValueError(MP_ERROR_TEXT("invalid montage fail"));
+    }
+    GET_FILE_VFS_PATH(new_monFile, vfs_monFile);
+
+    HeliosFILE *fp = Helios_fopen(vfs_monFile, "rb");
+    if (NULL == fp)
+    {
+        HELIOS_AUDIO_LOG("montage(%s) does not exist\n", vfs_monFile);
+        mp_raise_ValueError(MP_ERROR_TEXT("monatage file does not exist"));
+    } else {
+        Helios_fclose(fp);
+    }
+
+       
+    Helios_Mutex_Lock(audio.queue_mutex, HELIOS_WAIT_FOREVER);
+       mp_printf(&mp_plat_print, "audio.audio_state :%d\n",audio.audio_state );
+    if (audio.audio_state == AUDIO_IDLE)
+    {
+        // HELIOS_AUDIO_LOG("----- audio 1-----\r\n");
+        audio.cur_priority = new_priority;
+        audio.cur_breakin = new_breakin;
+        audio.cur_type = AUDIO_MONTAGE;
+        audio.audio_state = AUDIO_PLAYING;
+        Helios_Mutex_Unlock(audio.queue_mutex);
+    }
+    else if (audio.audio_state == AUDIO_PLAYING)
+    {
+        if (new_priority >= audio.cur_priority)
+        {
+            if (audio.cur_breakin == 1)
+            {
+                audio.audio_state = AUDIO_PLAYING;
+
+                if (!audio_queue_is_full(&audio.audio_queue[new_priority]))
+                {
+                    // Helios_Mutex_Lock(audio.queue_mutex, HELIOS_WAIT_FOREVER);
+                    HELIOS_AUDIO_LOG("----- audio 2[%d,%d]-----\r\n", new_priority, audio.cur_priority);
+                    uint8_t rear = audio.audio_queue[new_priority].rear;
+                    uint8_t front = audio.audio_queue[new_priority].front;
+
+                    if (audio.audio_queue[new_priority].audio_data[rear].breakin == 0)
+                    {
+                        rear = (rear + 1) % QUEUE_SIZE;
+                        audio.total_nums++;
+                    }
+                    else if (audio.audio_queue[new_priority].audio_data[rear].breakin == 1)
+                    {
+                        if (front == rear)
+                        {
+                            if (front == 0)
+                            {
+                                front = QUEUE_SIZE - 1;
+                            }
+                            else
+                            {
+                                front = (front - 1) % QUEUE_SIZE;
+                            }
+                            audio.total_nums++;
+                        }
+                    }
+
+                    audio.audio_queue[new_priority].audio_data[rear].audio_type = AUDIO_MONTAGE;
+                    audio.audio_queue[new_priority].audio_data[rear].priority = new_priority;
+                    audio.audio_queue[new_priority].audio_data[rear].breakin = new_breakin;
+                    audio.audio_queue[new_priority].audio_data[rear].mode = 0;
+
+                    FREE_BUFF(audio.audio_queue[new_priority].audio_data[rear].data);
+                    FREE_BUFF(audio.audio_queue[new_priority].audio_data[rear].montage);
+
+                    CALLOC_BUFF_SET(audio.audio_queue[new_priority].audio_data[rear].data, new_data);
+                    CALLOC_BUFF_SET(audio.audio_queue[new_priority].audio_data[rear].montage, new_monFile);
+
+                                       audio.audio_queue[new_priority].audio_data[rear].device = self->device;
+                    audio.audio_queue[new_priority].rear = rear;
+                    audio.audio_queue[new_priority].front = front;
+
+                    Helios_Mutex_Unlock(audio.queue_mutex);
+                }
+                else
+                {
+                    Helios_Mutex_Unlock(audio.queue_mutex);
+                    return mp_obj_new_int(-2);
+                }
+                               
+                               switch (audio.cur_type)
+                               {
+                               #if MICROPY_QPY_AUDIO_TTS
+                                       case AUDIO_TTS:
+                                       {
+                                               HELIOS_AUDIO_LOG("---- stop tts play. ----\r\n");
+                                               Helios_TTS_Stop();
+                                               break;
+                                       }
+                               #endif
+                                       case AUDIO_FILE:
+                                       {
+                                               HELIOS_AUDIO_LOG("---- stop audio file play. ----\r\n");
+                                               Helios_Audio_FilePlayStop();
+                                               break;
+                                       }
+                                       case AUDIO_MONTAGE:
+                                       {
+                                               Helios_Mutex_Lock(audio.montage_mutex, HELIOS_WAIT_FOREVER);
+                                               HELIOS_AUDIO_LOG("---- stop audio montage play. ----\r\n");
+                                               audio.montage_is_stopping = 1;
+                                               helios_set_montage_break_flag(1);
+                                               #if !defined(PLAT_EIGEN) && !defined(PLAT_EIGEN_718)
+                           audio_err_handle();
+                                               #endif
+                           Helios_msleep(200);
+                           
+                           Helios_Audio_StreamPlayStop();
+                                               audio.montage_is_stopping = 0;
+                                               Helios_Mutex_Unlock(audio.montage_mutex);
+                                               Helios_msleep(200);
+                                               uint8_t audio_msg = AUDIO_FINISH_EVENT;
+                                               if (Helios_MsgQ_Put(audio.queue_msg, (const void *)&audio_msg, sizeof(uint8_t), HELIOS_NO_WAIT) == -1)
+                                               {
+                                                       HELIOS_AUDIO_LOG("send audio msg failed[%u].\r\n", audio_msg);
+                                                       return mp_obj_new_int(-1);
+                                               }
+                                               break;
+                                       }
+                                       default:
+                                       {
+                                               HELIOS_AUDIO_LOG("Unknown audio type.\r\n");
+                                               return mp_obj_new_int(-1);
+                                       }
+                               }
+
+                return mp_obj_new_int(0);
+            }
+            else if (audio.cur_breakin == 0)
+            {
+                if (!audio_queue_is_full(&audio.audio_queue[new_priority]))
+                {
+                    // Helios_Mutex_Lock(audio.queue_mutex, HELIOS_WAIT_FOREVER);
+                    uint8_t rear = audio.audio_queue[new_priority].rear;
+                    uint8_t front = audio.audio_queue[new_priority].front;
+
+                    if (audio.audio_queue[new_priority].audio_data[rear].breakin == 0)
+                    {
+                        rear = (rear + 1) % QUEUE_SIZE;
+                        audio.total_nums++;
+                    }
+                    else if (audio.audio_queue[new_priority].audio_data[rear].breakin == 1)
+                    {
+                        if (front == rear)
+                        {
+                            if (front == 0)
+                            {
+                                front = QUEUE_SIZE - 1;
+                            }
+                            else
+                            {
+                                front = (front - 1) % QUEUE_SIZE;
+                            }
+                            audio.total_nums++;
+                        }
+                    }
+
+                    audio.audio_queue[new_priority].audio_data[rear].audio_type = AUDIO_MONTAGE;
+                    audio.audio_queue[new_priority].audio_data[rear].priority = new_priority;
+                    audio.audio_queue[new_priority].audio_data[rear].breakin = new_breakin;
+                    audio.audio_queue[new_priority].audio_data[rear].mode = 0;
+                    FREE_BUFF(audio.audio_queue[new_priority].audio_data[rear].data);
+                    FREE_BUFF(audio.audio_queue[new_priority].audio_data[rear].montage);
+
+                    CALLOC_BUFF_SET(audio.audio_queue[new_priority].audio_data[rear].data, new_data);
+                    CALLOC_BUFF_SET(audio.audio_queue[new_priority].audio_data[rear].montage, new_monFile);
+                    audio.audio_queue[new_priority].rear = rear;
+                                       audio.audio_queue[new_priority].audio_data[rear].device = self->device;
+
+                    Helios_Mutex_Unlock(audio.queue_mutex);
+                }
+                else
+                {
+                    Helios_Mutex_Unlock(audio.queue_mutex);
+                    return mp_obj_new_int(-2);
+                }
+
+                return mp_obj_new_int(1);
+            }
+        }
+        else
+        {
+            if (!audio_queue_is_full(&audio.audio_queue[new_priority]))
+            {
+                // Helios_Mutex_Lock(audio.queue_mutex, HELIOS_WAIT_FOREVER);
+                uint8_t rear = audio.audio_queue[new_priority].rear;
+                uint8_t front = audio.audio_queue[new_priority].front;
+
+                if (audio.audio_queue[new_priority].audio_data[rear].breakin == 0)
+                {
+                    rear = (rear + 1) % QUEUE_SIZE;
+                    audio.total_nums++;
+                }
+                else if (audio.audio_queue[new_priority].audio_data[rear].breakin == 1)
+                {
+                    if (front == rear)
+                    {
+                        if (front == 0)
+                        {
+                            front = QUEUE_SIZE - 1;
+                        }
+                        else
+                        {
+                            front = (front - 1) % QUEUE_SIZE;
+                        }
+                        audio.total_nums++;
+                    }
+                }
+
+                audio.audio_queue[new_priority].audio_data[rear].audio_type = AUDIO_MONTAGE;
+                audio.audio_queue[new_priority].audio_data[rear].priority = new_priority;
+                audio.audio_queue[new_priority].audio_data[rear].breakin = new_breakin;
+                audio.audio_queue[new_priority].audio_data[rear].mode = 0;
+                FREE_BUFF(audio.audio_queue[new_priority].audio_data[rear].data);
+                FREE_BUFF(audio.audio_queue[new_priority].audio_data[rear].montage);
+
+                CALLOC_BUFF_SET(audio.audio_queue[new_priority].audio_data[rear].data, new_data);
+                CALLOC_BUFF_SET(audio.audio_queue[new_priority].audio_data[rear].montage, new_monFile);
+                audio.audio_queue[new_priority].rear = rear;
+                audio.audio_queue[new_priority].front = front;
+                               audio.audio_queue[new_priority].audio_data[rear].device = self->device;
+
+                Helios_Mutex_Unlock(audio.queue_mutex);
+            }
+            else
+            {
+                Helios_Mutex_Unlock(audio.queue_mutex);
+                return mp_obj_new_int(-2);
+            }
+
+            return mp_obj_new_int(1);
+        }
+    }
+       
+    HELIOS_AUDIO_LOG("Helios_Audio_MontageFilePlayStart start %s # %s\r\n", vfs_monFile, new_data);
+    int ret = Helios_Audio_MontageFilePlayStart(vfs_monFile, new_data, HELIOS_AUDIO_PLAY_TYPE_LOCAL, audio_play_callback, self->device);
+    HELIOS_AUDIO_LOG("Helios_Audio_MontageFilePlayStart ret = %d\r\n", ret);
+    if (ret == -1)
+    {
+        Helios_Mutex_Lock(audio.queue_mutex, HELIOS_WAIT_FOREVER);
+        audio.audio_state = AUDIO_IDLE;
+        Helios_Mutex_Unlock(audio.queue_mutex);
+    }
+       else
+       {
+               memcpy(audio_playing_file_name, vfs_monFile ,strlen(vfs_monFile));
+       }
+
+    return mp_obj_new_int(ret);
+}
+static MP_DEFINE_CONST_FUN_OBJ_KW(helios_play_montage_file_start_obj, 1, helios_play_montage_file_start);
+#endif
+
+//================================montage Handel end=====================================================
+
+#if defined (PLAT_ASR) || defined(PLAT_ASR_1606) || defined(PLAT_ASR_1609) || defined(PLAT_ASR_1602)
+#if CONFIG_AUDIO_MP3
+STATIC mp_obj_t helios_aud_mp3_clear_cache(mp_obj_t self_in)
+{
+       int ret = Helios_mp3_Clear_Cache();
+       return mp_obj_new_int(ret);
+}
+
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(helios_aud_clear_cache_obj, helios_aud_mp3_clear_cache);
+
+STATIC mp_obj_t helios_aud_mp3_cache_size(mp_obj_t self_in)
+{
+       int ret = Helios_mp3_get_cache_size();
+       return mp_obj_new_int(ret);
+}
+
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(helios_aud_cache_size_obj, helios_aud_mp3_cache_size);
+#endif
+#endif
+
+#if defined (PLAT_Unisoc) || defined(PLAT_Unisoc_8910_R05) || defined(PLAT_Unisoc_8850_R02) || defined(PLAT_ASR_1606) || defined(PLAT_Unisoc_8910_R06)
+STATIC mp_obj_t mpy_get_audio_file_time_lenth(mp_obj_t self_in, mp_obj_t filename) {
+       char vfs_name[256] = {0};
+       char *new_data = NULL;
+
+       if (mp_obj_is_str(filename)) 
+       {
+               new_data = (char *)mp_obj_str_get_str(filename);
+       } 
+       else 
+       {
+               mp_raise_ValueError(MP_ERROR_TEXT("invalid data"));
+       }
+       GET_FILE_VFS_PATH(new_data, vfs_name);
+
+       int ret = Helios_get_audio_file_time_lenth(vfs_name);
+       return mp_obj_new_int(ret);
+}
+
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(mpy_get_audio_file_time_lenth_obj, mpy_get_audio_file_time_lenth);
+#endif
+
+#if defined (PLAT_Unisoc) || defined(PLAT_Unisoc_8910_R05) || defined(PLAT_Unisoc_8850_R02) || defined(PLAT_Unisoc_8910_R06)
+STATIC mp_obj_t mpy_audio_pause(mp_obj_t self_in, mp_obj_t enable_obj) {
+       int enable = mp_obj_get_int(enable_obj);
+       if (enable == 1) {
+               return mp_obj_new_int(Helios_Audio_Stream_Pause());
+       } else {
+               return mp_obj_new_int(Helios_Audio_Stream_Continue());
+       }
+       
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_2(mpy_audio_pause_obj, mpy_audio_pause);
+#endif
+
+#if defined(PLAT_ASR_1606) && (defined(BOARD_EC600MCN_LE_POC_QS)|| defined(BOARD_EC600MCN_LA_POC_XBND))
+STATIC mp_obj_t helios_audio_denoise_config(mp_uint_t n_args, const mp_obj_t *args) {
+       unsigned char cfg = 0;
+       int ret =-1;
+       if(n_args == 1)
+    {
+               ret = Helios_Audio_Get_Denoise(&cfg);
+               if(0 != ret)
+               {
+                       return mp_obj_new_int(-1);
+               }
+               return mp_obj_new_int(cfg);
+       }
+       else if(n_args == 2)
+       {
+               unsigned char check_flag = 0;
+               Helios_Audio_Check_Denoise_Licenses_Verify(&check_flag); 
+               if(0 == check_flag)
+               {
+                       return mp_obj_new_int(-2);
+               }
+               cfg = mp_obj_get_int(args[1]);
+               ret = Helios_Audio_Set_Denoise(cfg);
+               return mp_obj_new_int(ret);
+       }
+       return mp_obj_new_int(-1);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(helios_audio_denoise_config_obj, 1, 2, (mp_obj_t)helios_audio_denoise_config);
+
+STATIC mp_obj_t helios_audio_denoise_check_verify(mp_obj_t self_in)
+{
+       unsigned char check_flag = 0;
+       Helios_Audio_Check_Denoise_Licenses_Verify(&check_flag);  
+       return mp_obj_new_int(check_flag);        //0-unauthorized 1-authorized
+}
+
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(helios_audio_denoise_check_verify_obj, helios_audio_denoise_check_verify);
+
+STATIC mp_obj_t helios_audio_get_denoise_libary_version(mp_obj_t self_in)
+{
+       char version[64] = {0};
+       char data_len = 0;
+       Helios_Audio_Get_Denoise_Lib_Version(&version);  
+       for(int i=0; i<64; i++)
+       {
+               if(version[i]==0)
+               {
+                       data_len = i;
+                       break;
+               }
+       }
+       return mp_obj_new_str(version, data_len);         
+}
+
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(helios_audio_get_denoise_libary_version_obj, helios_audio_get_denoise_libary_version);
+
+
+#endif
+const mp_obj_type_t audio_audio_pcm;
+
+STATIC const mp_rom_map_elem_t audio_locals_dict_table[] = {
+    { MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&helios_audio___del___obj) },
+    { MP_ROM_QSTR(MP_QSTR_play), MP_ROM_PTR(&helios_play_file_start_obj) },
+    { MP_ROM_QSTR(MP_QSTR_stop), MP_ROM_PTR(&helios_audio_play_stop_obj) },
+       { MP_ROM_QSTR(MP_QSTR_stopAll), MP_ROM_PTR(&helios_play_file_stop_all_obj) },
+    { MP_ROM_QSTR(MP_QSTR_getState), MP_ROM_PTR(&helios_get_audio_state_obj) },
+    { MP_ROM_QSTR(MP_QSTR_getPlayState), MP_ROM_PTR(&helios_get_audio_play_state_obj) },
+    { MP_ROM_QSTR(MP_QSTR_getPlayFile), MP_ROM_PTR(&helios_get_audio_playing_file_name_obj) },
+#if defined(PLAT_Unisoc_8850_R02) && defined(CONFIG_POC)
+       { MP_ROM_QSTR(MP_QSTR_setDataDumpLog), MP_ROM_PTR(&helios_set_audio_data_dump_log_obj) },
+#endif
+#if defined(PLAT_ASR_1606) && (defined(BOARD_EC600MCN_LE_POC_QS)|| defined(BOARD_EC600MCN_LA_POC_XBND))
+       { MP_ROM_QSTR(MP_QSTR_audDenoiseConfig), MP_ROM_PTR(&helios_audio_denoise_config_obj) },
+       { MP_ROM_QSTR(MP_QSTR_audDenoiseCheckVerify), MP_ROM_PTR(&helios_audio_denoise_check_verify_obj) },
+       { MP_ROM_QSTR(MP_QSTR_audDenoiseVersion), MP_ROM_PTR(&helios_audio_get_denoise_libary_version_obj) },
+#endif
+    #ifdef AUDIO_DTMF_TONE_NEW_SUPPORT
+       { MP_ROM_QSTR(MP_QSTR_setToneVolume), MP_ROM_PTR(&helios_set_ToneVolume_obj) },
+       #endif
+    { MP_ROM_QSTR(MP_QSTR_setVolume), MP_ROM_PTR(&helios_set_volume_obj) },
+    { MP_ROM_QSTR(MP_QSTR_getVolume), MP_ROM_PTR(&helios_get_volume_obj) },
+#ifdef CONFIG_AUDIO_PWM
+    { MP_ROM_QSTR(MP_QSTR_setPwmGain), MP_ROM_PTR(&helios_set_pwm_gain_obj) },
+#endif
+    { MP_ROM_QSTR(MP_QSTR_setCallback), MP_ROM_PTR(&helios_set_audio_callback_obj) },
+       { MP_ROM_QSTR(MP_QSTR_playStream), MP_ROM_PTR(&helios_play_stream_start_obj) },
+    { MP_ROM_QSTR(MP_QSTR_stopPlayStream), MP_ROM_PTR(&helios_play_stream_stop_obj) },
+#if defined (PLAT_ASR) || defined (PLAT_Unisoc) || defined(PLAT_ASR_1606) || defined(PLAT_ASR_1609) || defined (PLAT_Unisoc_8850) \
+    || defined(PLAT_EIGEN) || defined(PLAT_Unisoc_8910_R05) || defined(PLAT_ASR_1602) || defined(PLAT_Unisoc_8850_R02) \
+       || defined(PLAT_EIGEN_718) || defined(PLAT_Unisoc_8910_R06) || defined(PLAT_ASR_1803s) || defined(PLAT_ASR_1803sc)
+#if !CONFIG_AUDIO_PWM
+#if !defined(PLAT_EIGEN) && !defined(PLAT_EIGEN_718)
+       { MP_ROM_QSTR(MP_QSTR_set_channel), MP_ROM_PTR(&helios_set_channel_obj) },
+#endif
+#endif
+       { MP_ROM_QSTR(MP_QSTR_set_pa), MP_ROM_PTR(&helios_set_pa_obj) },
+       { MP_ROM_QSTR(MP_QSTR_set_open_pa_delay), MP_ROM_PTR(&helios_set_open_pa_delay_obj) },
+       { MP_ROM_QSTR(MP_QSTR_set_close_pa_delay), MP_ROM_PTR(&helios_set_close_pa_delay_obj) },
+       { MP_ROM_QSTR(MP_QSTR_setSpeakerpaCallback), MP_ROM_PTR(&helios_set_speakerpa_callback_obj) },
+       { MP_ROM_QSTR(MP_QSTR_setSpeakerpaSwitch), MP_ROM_PTR(&helios_user_speakerpa_switch_obj) },
+#if defined (PLAT_Unisoc) 
+       { MP_ROM_QSTR(MP_QSTR_internal_pa_type), MP_ROM_PTR(&helios_internal_pa_type_obj) },
+#endif
+
+#endif
+#if defined (PLAT_ASR) || defined (PLAT_Unisoc) || defined(PLAT_ASR_1606) || defined(PLAT_ASR_1609) || defined(PLAT_Unisoc_8910_R05) || defined(PLAT_Unisoc_8910_R06) \
+    || defined(PLAT_ASR_1602) || defined(PLAT_ASR_1803s) || defined(PLAT_ASR_1803sc) || defined(PLAT_Unisoc_8850_R02)
+       { MP_ROM_QSTR(MP_QSTR_aud_tone_play), MP_ROM_PTR(&mp_helios_aud_tone_play_obj) },
+       { MP_ROM_QSTR(MP_QSTR_aud_tone_play_stop), MP_ROM_PTR(&helios_aud_tone_play_stop_obj) },
+#if defined(BOARD_EC800GCN_LD_XBND)
+       { MP_ROM_QSTR(MP_QSTR_aud_set_tone_gain), MP_ROM_PTR(&helios_aud_set_tone_gain_obj) },
+#endif
+#if defined (PLAT_ASR) || defined(PLAT_ASR_1606) || defined(PLAT_ASR_1609) || defined(PLAT_ASR_1602)
+       #if CONFIG_AUDIO_MP3
+       { MP_ROM_QSTR(MP_QSTR_aud_cache_clear), MP_ROM_PTR(&helios_aud_clear_cache_obj) },
+       { MP_ROM_QSTR(MP_QSTR_aud_cache_size), MP_ROM_PTR(&helios_aud_cache_size_obj) },
+       #endif
+#endif
+#endif
+#if defined (PLAT_ASR) || defined (PLAT_Unisoc) || defined(PLAT_ASR_1606) || defined(PLAT_ASR_1609) || defined(PLAT_EIGEN) \
+    || defined(PLAT_Unisoc_8910_R05) || defined(PLAT_ASR_1602) || defined(PLAT_EIGEN_718) || defined(PLAT_Unisoc_8910_R06)
+       { MP_ROM_QSTR(MP_QSTR_montage_play), MP_ROM_PTR(&helios_play_montage_file_start_obj) },
+#endif
+#if CONFIG_AUDIO
+       { MP_ROM_QSTR(MP_QSTR_FrameJumpNum), MP_ROM_PTR(&helios_play_jump_frame_obj) },
+#endif
+#if defined (PLAT_Unisoc) || defined(PLAT_Unisoc_8910_R05) || defined(PLAT_Unisoc_8910_R06)
+       { MP_ROM_QSTR(MP_QSTR_pcmParaSet), MP_ROM_PTR(&helios_pcm_para_obj) },
+       { MP_ROM_QSTR(MP_QSTR_StreamJump), MP_ROM_PTR(&helios_play_stream_jump_obj) },
+       { MP_ROM_QSTR(MP_QSTR_StreamPause), MP_ROM_PTR(&helios_play_stream_pause_obj) },
+       { MP_ROM_QSTR(MP_QSTR_StreamContinue), MP_ROM_PTR(&helios_play_stream_continue_obj) },
+       { MP_ROM_QSTR(MP_QSTR_StreamSeek), MP_ROM_PTR(&helios_play_stream_seek_obj) },
+#endif
+#if defined (PLAT_Unisoc) || defined (PLAT_EIGEN) || defined(PLAT_Unisoc_8910_R05) || defined(PLAT_EIGEN_718) || defined(PLAT_Unisoc_8910_R06)
+       { MP_ROM_QSTR(MP_QSTR_setGainTabel), MP_ROM_PTR(&helios_setgaintabel_obj) },
+#endif
+#if defined (PLAT_ASR) || defined(PLAT_ASR_1606) || defined(PLAT_ASR_1609) || defined(PLAT_ASR_1803s) || defined(PLAT_ASR_1803sc) || defined(PLAT_ASR_1602) \
+       || defined(PLAT_Unisoc) || defined(PLAT_Unisoc_8910_R05) || defined(PLAT_Unisoc_8910_R06)
+       { MP_ROM_QSTR(MP_QSTR_PCM), MP_ROM_PTR(&audio_audio_pcm) },
+#endif
+
+#if defined(BOARD_EC600MCN_LE_POC_QS) || defined(BOARD_EC600MCN_LA_POC_QS)
+       { MP_ROM_QSTR(MP_QSTR_set_audio_read_delay), MP_ROM_PTR(&mpy_set_audio_read_delay_obj) },
+#endif
+#if defined(BOARD_EC600MCN_LF_SLPOC)
+       { MP_ROM_QSTR(MP_QSTR_playModeConfig), MP_ROM_PTR(&helios_set_audio_play_mode_obj) },
+       { MP_ROM_QSTR(MP_QSTR_OPEN_CODEC_THEN_PA), MP_ROM_INT(0) },
+       { MP_ROM_QSTR(MP_QSTR_OPEN_PA_THEN_CODEC), MP_ROM_INT(1) },
+       { MP_ROM_QSTR(MP_QSTR_CLOSE_CODEC_THEN_PA), MP_ROM_INT(0) },
+       { MP_ROM_QSTR(MP_QSTR_CLOSE_PA_THEN_CODEC), MP_ROM_INT(1) },
+
+#endif
+
+#if defined (PLAT_Unisoc) || defined(PLAT_Unisoc_8910_R05) || defined(PLAT_Unisoc_8850_R02) || defined(PLAT_Unisoc_8910_R06)
+       { MP_ROM_QSTR(MP_QSTR_pause), MP_ROM_PTR(&mpy_audio_pause_obj) },
+#endif
+#if defined (PLAT_Unisoc) || defined(PLAT_Unisoc_8910_R05) || defined(PLAT_Unisoc_8850_R02) || defined(PLAT_ASR_1606) || defined(PLAT_Unisoc_8910_R06)
+       { MP_ROM_QSTR(MP_QSTR_getFileTimeLenth), MP_ROM_PTR(&mpy_get_audio_file_time_lenth_obj) },
+#endif
+};
+STATIC MP_DEFINE_CONST_DICT(audio_locals_dict, audio_locals_dict_table);
+
+const mp_obj_type_t audio_audio_type = {
+    { &mp_type_type },
+    .name = MP_QSTR_Audio,
+    .make_new = audio_make_new,
+    .locals_dict = (mp_obj_dict_t *)&audio_locals_dict,
+};
+
+#if defined (PLAT_ASR) || defined(PLAT_ASR_1606) || defined(PLAT_ASR_1609) || defined(PLAT_ASR_1803s) || defined(PLAT_ASR_1803sc) || defined(PLAT_ASR_1602) || defined(PLAT_Unisoc) || defined(PLAT_Unisoc_8910_R05) || defined(PLAT_Unisoc_8910_R06)
+
+#define QL_PCM_BLOCK_FLAG              (0x01)
+#define QL_PCM_NONBLOCK_FLAG   (0x02)
+#define QL_PCM_READ_FLAG       (0x04)
+#define QL_PCM_WRITE_FLAG              (0x08)
+
+
+
+enum {
+       MIC_CHANNEL_RECEIVER,
+       MIC_CHANNEL_HEADSET,
+       MIC_CHANNEL_AUTO,
+       MIC_CHANNEL_MAX,
+};
+
+
+
+typedef struct _machine_pcm_obj_t {
+    mp_obj_base_t base;
+       void* handle_read;
+       void* handle_write;
+       int mic_channel;
+    unsigned int channels;
+    unsigned int samplerate;
+       unsigned int flags;
+       unsigned int mode;
+       void* PCM_stream_ring_buf;
+       char PCM_stream_RW_flag;
+       char pause_flag ;
+} machine_pcm_obj_t;
+
+const mp_obj_type_t audio_audio_pcm;
+
+static bool is_support_samplerate(unsigned int rate)
+{
+       switch(rate) {
+       case 8000:
+       case 11025:
+       case 12000:
+       case 16000:
+       case 22050:
+       case 24000:
+       case 32000:
+       case 44100:
+       case 48000:
+               return true;
+       }
+       return false;
+}
+
+enum{
+       PCM_FLAG_READ_ONLY,
+       PCM_FLAG_WRITE_ONLY,
+       PCM_FLAG_WRITE_READ,
+       PCM_FLAG_MAX,
+};
+#if defined(PLAT_Unisoc) || defined(PLAT_Unisoc_8910_R05)
+static int poc_mode_state = 0;
+#endif
+STATIC void machine_pcm_init_helper(machine_pcm_obj_t *self, size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
+       enum { ARG_channel, ARG_samplerate, ARG_flags, ARG_mode, ARG_periodcnt};
+    static const mp_arg_t allowed_args[] = {
+        { MP_QSTR_channel, MP_ARG_INT, {.u_int = 1} },
+        { MP_QSTR_samplerate, MP_ARG_INT, {.u_int = 8000} },
+        { MP_QSTR_flag, MP_ARG_INT, {.u_int = PCM_FLAG_WRITE_READ} },
+        { MP_QSTR_mode, MP_ARG_INT, {.u_int = QL_PCM_BLOCK_FLAG} },
+        { MP_QSTR_periodcnt, MP_ARG_INT, {.u_int = 3} },
+    };
+
+       
+    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
+    mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
+
+       if(args[ARG_channel].u_int > 2) {
+               mp_raise_ValueError(MP_ERROR_TEXT("invalid channels"));
+       }
+       
+       if(true != is_support_samplerate(args[ARG_samplerate].u_int)) {
+               mp_raise_ValueError(MP_ERROR_TEXT("invalid samplerate"));
+       }
+
+       if(args[ARG_flags].u_int >= PCM_FLAG_MAX) {
+               mp_raise_ValueError(MP_ERROR_TEXT("invalid flag"));
+       }
+
+       if(args[ARG_mode].u_int != QL_PCM_BLOCK_FLAG && args[ARG_mode].u_int != QL_PCM_NONBLOCK_FLAG){
+               mp_raise_ValueError(MP_ERROR_TEXT("invalid mode, Value range [1,2]. 1: BLOCK 2:NOBLOCK"));
+       }
+
+       if(args[ARG_periodcnt].u_int < 2 || args[ARG_periodcnt].u_int > 25){
+               mp_raise_ValueError(MP_ERROR_TEXT("invalid periodcnt, Value range [2,25]"));
+       }
+
+       self->channels = args[ARG_channel].u_int;
+       self->flags = args[ARG_flags].u_int;
+       self->samplerate = args[ARG_samplerate].u_int;
+       self->mode = args[ARG_mode].u_int;
+#if !(defined(PLAT_ASR_1803s) || defined(PLAT_ASR_1803sc))
+       Helios_set_mic_channel(self->mic_channel);
+#endif
+       Helios_PCM_CONFIG_T pcm_info = {0};
+       pcm_info.channels = args[ARG_channel].u_int;
+       pcm_info.samplerate = args[ARG_samplerate].u_int;
+       pcm_info.periodcnt = args[ARG_periodcnt].u_int;
+
+#if defined(PLAT_Unisoc) || defined(PLAT_Unisoc_8910_R05)
+       if(args[ARG_flags].u_int == PCM_FLAG_WRITE_READ){
+               Helios_set_pcm_type(HELIOS_PCM_POC, HELIOS_POC_TYPE_FULL_DUPLEX);
+       }
+       else{
+               Helios_set_pcm_type(HELIOS_PCM_LOCAL, HELIOS_POC_TYPE_FULL_DUPLEX);
+       }
+#endif
+
+#if defined(PLAT_Unisoc_8910_R06)
+       if (args[ARG_flags].u_int == PCM_FLAG_WRITE_READ) {
+               mp_raise_ValueError(MP_ERROR_TEXT("not support this mode")); // Unisoc 8910 C2 Audio do nont support duplex mode
+       }
+#endif
+       switch (args[ARG_flags].u_int)
+               {
+               case PCM_FLAG_READ_ONLY:
+#if CONFIG_AUDIO
+                               self->handle_read = Helios_PCM_Open(pcm_info.channels, pcm_info.samplerate, QL_PCM_READ_FLAG|args[ARG_mode].u_int);
+#else
+                               self->handle_read = Helios_PCM_Open(&pcm_info, QL_PCM_READ_FLAG|args[ARG_mode].u_int);
+#endif
+                               if(NULL == self->handle_read) {
+                               mp_raise_ValueError(MP_ERROR_TEXT("pcm open read only fail"));
+                       }
+                       self->handle_write = NULL;
+               break;
+               case PCM_FLAG_WRITE_ONLY:
+#if CONFIG_AUDIO
+                       self->handle_write = Helios_PCM_Open(pcm_info.channels, pcm_info.samplerate, QL_PCM_WRITE_FLAG|args[ARG_mode].u_int);
+#else
+                       self->handle_write = Helios_PCM_Open(&pcm_info, QL_PCM_WRITE_FLAG|args[ARG_mode].u_int);
+#endif
+                       if(NULL == self->handle_write) {
+                               mp_raise_ValueError(MP_ERROR_TEXT("pcm open write only fail"));
+                       }
+                       self->handle_read = NULL;
+               break;
+               case PCM_FLAG_WRITE_READ:
+#if CONFIG_AUDIO
+                       self->handle_read = Helios_PCM_Open(pcm_info.channels, pcm_info.samplerate, QL_PCM_READ_FLAG|args[ARG_mode].u_int);
+#else
+                       self->handle_read = Helios_PCM_Open(&pcm_info, QL_PCM_READ_FLAG|args[ARG_mode].u_int);
+#endif
+                       if(NULL == self->handle_read) {
+                               mp_raise_ValueError(MP_ERROR_TEXT("pcm open read fail"));
+                       }
+#if CONFIG_AUDIO
+                       self->handle_write = Helios_PCM_Open(pcm_info.channels, pcm_info.samplerate, QL_PCM_WRITE_FLAG|args[ARG_mode].u_int);
+#else
+                       self->handle_write = Helios_PCM_Open(&pcm_info, QL_PCM_WRITE_FLAG|args[ARG_mode].u_int);
+#endif
+#if defined(PLAT_Unisoc) || defined(PLAT_Unisoc_8910_R05)
+                       Helios_start_poc_mode(1);
+                       poc_mode_state = 1;
+#endif
+                       if(NULL == self->handle_write) {
+                               mp_raise_ValueError(MP_ERROR_TEXT("pcm open write fail"));
+                       }
+               break;          
+               }
+
+}
+
+
+STATIC mp_obj_t pcm_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) 
+{
+    mp_arg_check_num(n_args, n_kw, 1, MP_OBJ_FUN_ARGS_MAX, true);
+       int mic_channel = 1;
+    mic_channel = mp_obj_get_int(args[0]);
+       
+       if (mic_channel < 0 || mic_channel >= MIC_CHANNEL_MAX) {
+               mp_raise_ValueError(MP_ERROR_TEXT("Wrong mic channel, value range [0-2]. 0: Automatic 1: Headset 2: receiver"));
+       }
+
+       machine_pcm_obj_t *self = m_new_obj_with_finaliser(machine_pcm_obj_t);
+       self->base.type = &audio_audio_pcm;
+       self->mic_channel = mic_channel;
+       self->PCM_stream_ring_buf = NULL;
+       self->PCM_stream_RW_flag = 0;   
+    mp_map_t kw_args;
+    mp_map_init_fixed_table(&kw_args, n_kw, args + n_args);
+    machine_pcm_init_helper(self, n_args - 1, args + 1, &kw_args);
+
+    return MP_OBJ_FROM_PTR(self);
+}
+
+
+STATIC mp_uint_t audio_pcm_read(mp_obj_t self_in, void *buf_in, mp_uint_t size, int *errcode) {
+    machine_pcm_obj_t *self = MP_OBJ_TO_PTR(self_in);
+
+       
+       if(self->flags == PCM_FLAG_WRITE_ONLY || self->handle_read == NULL) {
+               mp_raise_ValueError(MP_ERROR_TEXT("This pcm only supports write operations"));
+       }
+
+    // make sure we want at least 1 char
+    if (size == 0) {
+        return 0;
+    }
+
+    //int bytes_read = ql_uart_read(self->uart_num, buf_in, size);
+    
+       int bytes_read =Helios_PCM_Read(self->handle_read, buf_in, size);
+    if (bytes_read < 0) {
+        *errcode = MP_EAGAIN;
+        return MP_STREAM_ERROR;
+    }
+
+    return bytes_read;
+}
+
+STATIC mp_uint_t audio_pcm_write(mp_obj_t self_in, const void *buf_in, mp_uint_t size, int *errcode) {
+    machine_pcm_obj_t *self = MP_OBJ_TO_PTR(self_in);
+
+       if(self->flags == PCM_FLAG_READ_ONLY || self->handle_write == NULL) {
+               mp_raise_ValueError(MP_ERROR_TEXT("This pcm only supports read operations"));
+       }
+       int bytes_written = Helios_PCM_Write(self->handle_write, (void*)buf_in, size);
+    if (bytes_written < 0) {
+        *errcode = MP_EAGAIN;
+        return MP_STREAM_ERROR;
+    }
+
+    // return number of bytes written
+    return bytes_written;
+}
+
+STATIC mp_uint_t audio_pcm_ioctl(mp_obj_t self_in, mp_uint_t request, uintptr_t arg, int *errcode) {
+    //machine_uart_obj_t *self = self_in;
+    mp_uint_t ret;
+    if (request == MP_STREAM_POLL) {
+        mp_uint_t flags = (mp_uint_t)arg;
+        ret = 0;
+        size_t rxbufsize = 1;
+        //rxbufsize = ql_uart_get_rx_data_len(self->uart_num);
+        if ((flags & MP_STREAM_POLL_RD) && rxbufsize > 0) {
+            ret |= MP_STREAM_POLL_RD;
+        }
+        if ((flags & MP_STREAM_POLL_WR) && 1) { // FIXME: uart_tx_any_room(self->uart_num)
+            ret |= MP_STREAM_POLL_WR;
+        }
+    } else {
+        *errcode = MP_EINVAL;
+        ret = MP_STREAM_ERROR;
+    }
+    return ret;
+}
+
+STATIC mp_obj_t helios_audio_pcm___del__(mp_obj_t self_in)
+{
+       uint8_t i = 0;
+       machine_pcm_obj_t *self = MP_OBJ_TO_PTR(self_in);
+#if defined(PLAT_Unisoc) || defined(PLAT_Unisoc_8910_R05)
+       if(self->handle_read && self->handle_write) {
+               if (poc_mode_state) {
+                       poc_mode_state = 0;
+                       Helios_stop_poc_mode();
+               }
+       }
+#endif
+
+       if(self->handle_read) {
+               Helios_PCM_Close(self->handle_read);
+               self->handle_read = NULL;
+       }
+       
+       if(self->handle_write) {
+               Helios_PCM_Close(self->handle_write);
+               self->handle_write = NULL;
+       }
+
+       return mp_obj_new_int(0);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(helios_audio_pcm___del___obj, helios_audio_pcm___del__);
+#include "helios_ringbuf.h"
+#if 1
+       //helios_ring_buf_t *PCM_stream_ring_buf = NULL;
+
+       Helios_Thread_t PCM_stream_task_id = 0;
+       typedef enum
+       {
+               PCM_STREAM_NONE,
+               PCM_STREAM_READ ,
+               PCM_STREAM_WRITE,
+       }PCM_STREAM_RW_TYPE;
+       #define PCM_READ_BUF_LEN 4*1024
+       //char p_data[PCM_READ_BUF_LEN]={0};
+       static void helios_audio_PCM_stream_task(void *self_in)
+       {
+               machine_pcm_obj_t *self = (machine_pcm_obj_t *)self_in;
+               self->pause_flag = 0;
+               //machine_pcm_obj_t *self = MP_OBJ_TO_PTR(*self_in);
+               char p_data[PCM_READ_BUF_LEN]={0};
+               //char *p_data  = NULL;
+               while(1)
+               {
+                       if(self->pause_flag == 0)
+                       {
+                               if(self->PCM_stream_RW_flag == PCM_STREAM_READ)
+                               {
+                                       int bytes_read =Helios_PCM_Read(self->handle_read, p_data, PCM_READ_BUF_LEN);   
+                                       if(bytes_read>0)
+                                       {
+                                               if((helios_ring_buf_t *)self->PCM_stream_ring_buf != NULL)
+                                                       helios_rb_write((helios_ring_buf_t *)self->PCM_stream_ring_buf, (unsigned char*)p_data, bytes_read);
+                                       }else
+                                       {
+                                               //printf("helios_audio_PCM_stream_task:READ no data\r\n");
+                                       }
+                               }else if(self->PCM_stream_RW_flag == PCM_STREAM_WRITE)
+                               {
+                                       int bytes_read = helios_rb_read((helios_ring_buf_t *)self->PCM_stream_ring_buf, (unsigned char*)p_data, PCM_READ_BUF_LEN);
+                                       if(bytes_read>0)
+                                       {
+                                               int ret = Helios_PCM_Write(self->handle_write, p_data, bytes_read);
+                                               if(ret<1)
+                                               {
+                                                       //printf("helios_audio_PCM_stream_task:pcm write error\r\n");
+                                               }
+                                       }
+
+                               }
+                               else
+                               {
+                                       //printf("helios_audio_PCM_stream_task:NO_READ_WRITE\r\n");
+                                       //Helios_msleep(2000);
+                               }
+                       }
+                       
+                       Helios_msleep(1);
+               }
+
+       }
+       #define ring_buf_len 64*1024
+       STATIC mp_obj_t helios_audio_PCM_stream_read_start(mp_obj_t self_in)
+       {
+               
+               machine_pcm_obj_t *self = MP_OBJ_TO_PTR(self_in);
+               self->PCM_stream_RW_flag = PCM_STREAM_READ;
+       
+               self->pause_flag = 0;
+               if(self->PCM_stream_ring_buf == NULL) {
+                       self->PCM_stream_ring_buf = helios_rb_create(ring_buf_len);
+               }
+               if(self->PCM_stream_ring_buf == NULL) 
+               {
+                       mp_raise_ValueError(MP_ERROR_TEXT("Repeat opening1!!!!!!!!!!!!!!!!!!\r\n\r\n"));
+                       return mp_obj_new_int(-2);
+                       
+               }
+               if(PCM_stream_task_id == 0)
+               {
+                       Helios_ThreadAttr attr = {0};
+                       attr.name = "PCM_stream";
+                       attr.stack_size = PCM_READ_BUF_LEN+4*1024;
+                       attr.priority = 95;
+                       attr.entry = helios_audio_PCM_stream_task;
+                       attr.argv = (void *)self;
+                       PCM_stream_task_id = Helios_Thread_Create(&attr);
+               }
+
+               if (0 == PCM_stream_task_id)
+               {
+                       mp_raise_ValueError(MP_ERROR_TEXT("helios_audio_PCM_stream_task error\n"));
+                       return mp_obj_new_int(-1);
+               }
+               
+               return mp_obj_new_int(0);
+       }
+
+       STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_helios_audio_PCM_stream_read_start_obj, helios_audio_PCM_stream_read_start);
+
+       STATIC mp_obj_t helios_audio_PCM_stream_write_start(mp_obj_t self_in)
+       {
+               
+               machine_pcm_obj_t *self = MP_OBJ_TO_PTR(self_in);
+               self->PCM_stream_RW_flag = PCM_STREAM_WRITE;
+
+               self->pause_flag = 0;
+               if(self->PCM_stream_ring_buf == NULL) {
+                       self->PCM_stream_ring_buf = helios_rb_create(ring_buf_len);
+               }
+               if(self->PCM_stream_ring_buf == NULL) 
+               {
+                       mp_raise_ValueError(MP_ERROR_TEXT("Repeat opening1!!!!!!!!!!!!!!!!!!\r\n\r\n"));
+                       return mp_obj_new_int(-2);
+                       
+               }
+               if(PCM_stream_task_id == 0)
+               {
+                       Helios_ThreadAttr attr = {0};
+                       attr.name = "PCM_stream";
+                       attr.stack_size = PCM_READ_BUF_LEN+4096;
+                       attr.priority = 95;
+                       attr.entry = helios_audio_PCM_stream_task;
+                       attr.argv = (void *)self;
+                       PCM_stream_task_id = Helios_Thread_Create(&attr);
+                       
+               }
+               if (0 == PCM_stream_task_id)
+               {
+                       mp_raise_ValueError(MP_ERROR_TEXT("helios_audio_PCM_stream_task error\n"));
+                       return mp_obj_new_int(-1);
+               }
+               
+               return mp_obj_new_int(0);
+       }
+       STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_helios_audio_PCM_stream_write_start_obj, helios_audio_PCM_stream_write_start);
+
+       STATIC mp_obj_t helios_audio_PCM_stream_read(mp_obj_t self_in,mp_obj_t read_buf, mp_obj_t len)
+       {
+               int read_actual_len = 0;
+               machine_pcm_obj_t *self = MP_OBJ_TO_PTR(self_in);
+
+               mp_buffer_info_t bufinfo;
+               mp_get_buffer_raise(read_buf, &bufinfo, MP_BUFFER_WRITE);
+               
+               int read_len = mp_obj_get_int(len);
+               if(read_len > 0 && self->PCM_stream_ring_buf) {
+                       read_actual_len = helios_rb_read((helios_ring_buf_t *)self->PCM_stream_ring_buf, bufinfo.buf, read_len);
+                       return mp_obj_new_int(read_actual_len);
+               }
+               return mp_obj_new_int(-1);
+       }
+       STATIC MP_DEFINE_CONST_FUN_OBJ_3(mp_helios_audio_PCM_stream_read_obj, helios_audio_PCM_stream_read);
+
+       /* 供外部 C 模块(如 modopus.c)直接写入 PCM ring buffer,避免 Python 层内存拷贝。
+          返回实际写入字节数;内部带 2000ms 背压等待。 */
+       int _helios_pcm_rb_write(void *pcm_obj, const unsigned char *buf, int len)
+       {
+               machine_pcm_obj_t *self = (machine_pcm_obj_t *)pcm_obj;
+               if (!self || !self->PCM_stream_ring_buf || len <= 0) {
+                       return 0;
+               }
+               int timerout = 2000;
+               while (1) {
+                       timerout--;
+                       if (timerout <= 0 || (helios_rb_data_len((helios_ring_buf_t *)self->PCM_stream_ring_buf) + len < ring_buf_len))
+                               break;
+                       Helios_msleep(1);
+               }
+               return (int)helios_rb_write((helios_ring_buf_t *)self->PCM_stream_ring_buf, (unsigned char *)buf, (unsigned int)len);
+       }
+
+       STATIC mp_obj_t helios_audio_PCM_stream_write(mp_obj_t self_in,mp_obj_t write_buf, mp_obj_t len)
+       {
+               int write_actual_len = 0;
+               machine_pcm_obj_t *self = MP_OBJ_TO_PTR(self_in);
+               
+               mp_buffer_info_t bufinfo;
+               mp_get_buffer_raise(write_buf, &bufinfo, MP_BUFFER_WRITE);
+               
+               int write_len = mp_obj_get_int(len);
+               if(write_len > 0 && self->PCM_stream_ring_buf) {
+                       int timerout = 2000;
+                       while(1)
+                       {
+                               timerout--;
+                               if(timerout <=0 ||(helios_rb_data_len((helios_ring_buf_t *)self->PCM_stream_ring_buf) + write_len < ring_buf_len))
+                                       break;
+                               Helios_msleep(1);
+                       }
+                       write_actual_len = helios_rb_write((helios_ring_buf_t *)self->PCM_stream_ring_buf, bufinfo.buf, write_len);
+                       return mp_obj_new_int(write_actual_len);
+               }
+               return mp_obj_new_int(-1);
+       }
+       STATIC MP_DEFINE_CONST_FUN_OBJ_3(mp_helios_audio_PCM_stream_write_obj, helios_audio_PCM_stream_write);
+
+       STATIC mp_obj_t helios_audio_PCM_stream_stop(mp_obj_t self_in)
+       {
+               int ret = 0;
+               machine_pcm_obj_t *self = MP_OBJ_TO_PTR(self_in);
+
+               if(PCM_stream_task_id != 0)
+                       Helios_Thread_Delete(PCM_stream_task_id);
+               PCM_stream_task_id = 0;
+               if(self->PCM_stream_ring_buf != NULL) 
+               {
+                       helios_rb_destroy((helios_ring_buf_t **)&self->PCM_stream_ring_buf);
+                       self->PCM_stream_ring_buf = NULL;
+               }
+               self->PCM_stream_RW_flag = PCM_STREAM_NONE;     
+               return mp_obj_new_int(ret);
+       }
+       STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_helios_audio_PCM_stream_stop_obj, helios_audio_PCM_stream_stop);
+       STATIC mp_obj_t helios_audio_PCM_stream_pause(mp_obj_t self_in,mp_obj_t pause_flag)//暂停/开始
+       {
+               machine_pcm_obj_t *self = MP_OBJ_TO_PTR(self_in);
+
+               self->pause_flag =mp_obj_get_int(pause_flag);
+               return mp_obj_new_int(1);
+       }
+       
+       STATIC MP_DEFINE_CONST_FUN_OBJ_2(mp_helios_audio_PCM_stream_pause_obj, helios_audio_PCM_stream_pause);
+       
+       STATIC mp_obj_t helios_audio_pcm_rb_is_empty(mp_obj_t self_in)
+       {
+               int ret = 0;
+               machine_pcm_obj_t *self = MP_OBJ_TO_PTR(self_in);
+
+               // if(self->handle_write) {
+               //      ret = Helios_PCM_Reset_Write_Buffer(self->handle_write);
+               // }
+               if(self->PCM_stream_ring_buf != NULL) 
+               {
+                       if (helios_rb_is_empty((helios_ring_buf_t *)self->PCM_stream_ring_buf))
+                               ret = 1;
+               }
+                       
+               return mp_obj_new_int(ret);
+       }
+       STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_helios_audio_pcm_rb_is_empty_obj, helios_audio_pcm_rb_is_empty);
+       //获取剩余长度
+       STATIC mp_obj_t helios_audio_pcm_rb_get_buf_len(mp_obj_t self_in)
+       {
+               int ret = 0;
+               machine_pcm_obj_t *self = MP_OBJ_TO_PTR(self_in);
+
+               // if(self->handle_write) {
+               //      ret = Helios_PCM_Reset_Write_Buffer(self->handle_write);
+               // }
+               if(self->PCM_stream_ring_buf != NULL) 
+               {
+                       ret = ring_buf_len - helios_rb_data_len((helios_ring_buf_t *)self->PCM_stream_ring_buf) ;
+                       
+               }
+                       
+               return mp_obj_new_int(ret);
+
+       }
+       STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_helios_audio_pcm_rb_get_buf_len_obj, helios_audio_pcm_rb_get_buf_len);
+#endif
+#if defined(PLAT_ASR_1606)
+STATIC mp_obj_t helios_audio_pcm_get_write_frame_count(mp_obj_t self_in)
+{
+       int ret = 0;
+       machine_pcm_obj_t *self = MP_OBJ_TO_PTR(self_in);
+
+       if(self->handle_write) {
+               ret = Helios_PCM_Get_Write_Frame_Count(self->handle_write);
+       }
+
+       return mp_obj_new_int(ret);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(helios_audio_pcm_get_write_frame_count_obj, helios_audio_pcm_get_write_frame_count);
+
+STATIC mp_obj_t helios_audio_pcm_reset_write_buffer(mp_obj_t self_in)
+{
+       int ret = 0;
+       machine_pcm_obj_t *self = MP_OBJ_TO_PTR(self_in);
+
+       if(self->handle_write) {
+               ret = Helios_PCM_Reset_Write_Buffer(self->handle_write);
+       }
+
+       return mp_obj_new_int(ret);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(helios_audio_pcm_reset_write_buffer_obj, helios_audio_pcm_reset_write_buffer);
+
+#endif
+STATIC const mp_stream_p_t pcm_stream_p = {
+    .read = audio_pcm_read,
+    .write = audio_pcm_write,
+    .ioctl = audio_pcm_ioctl,
+    .is_text = false,
+};
+
+
+STATIC const mp_rom_map_elem_t pcm_locals_dict[] = {
+    { MP_ROM_QSTR(MP_QSTR___del__), MP_ROM_PTR(&helios_audio_pcm___del___obj) },
+    { MP_ROM_QSTR(MP_QSTR_write), MP_ROM_PTR(&mp_stream_write_obj) },
+    { MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&mp_stream_read_obj) },
+    { MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&helios_audio_pcm___del___obj) },
+       { MP_ROM_QSTR(MP_QSTR_stream_read_start), MP_ROM_PTR(&mp_helios_audio_PCM_stream_read_start_obj)},
+       { MP_ROM_QSTR(MP_QSTR_stream_write_start), MP_ROM_PTR(&mp_helios_audio_PCM_stream_write_start_obj)},
+       { MP_ROM_QSTR(MP_QSTR_stream_read), MP_ROM_PTR(&mp_helios_audio_PCM_stream_read_obj)},
+       { MP_ROM_QSTR(MP_QSTR_stream_write), MP_ROM_PTR(&mp_helios_audio_PCM_stream_write_obj)},
+       { MP_ROM_QSTR(MP_QSTR_stream_stop), MP_ROM_PTR(&mp_helios_audio_PCM_stream_stop_obj)},
+       { MP_ROM_QSTR(MP_QSTR_stream_pause), MP_ROM_PTR(&mp_helios_audio_PCM_stream_pause_obj)},
+       
+       { MP_ROM_QSTR(MP_QSTR_stream_is_empty), MP_ROM_PTR(&mp_helios_audio_pcm_rb_is_empty_obj)},
+       { MP_ROM_QSTR(MP_QSTR_stream_get_buf_len), MP_ROM_PTR(&mp_helios_audio_pcm_rb_get_buf_len_obj)},
+       
+       
+    { MP_ROM_QSTR(MP_QSTR_setVolume), MP_ROM_PTR(&helios_set_volume_obj) },
+    { MP_ROM_QSTR(MP_QSTR_getVolume), MP_ROM_PTR(&helios_get_volume_obj) },
+       #if defined(PLAT_ASR_1606)
+       { MP_ROM_QSTR(MP_QSTR_getWriteFrameCount), MP_ROM_PTR(&helios_audio_pcm_get_write_frame_count_obj) },
+       { MP_ROM_QSTR(MP_QSTR_resetWriteBuffer), MP_ROM_PTR(&helios_audio_pcm_reset_write_buffer_obj) },
+       #endif
+       { MP_ROM_QSTR(MP_QSTR_MONO), MP_ROM_INT(1) },
+    { MP_ROM_QSTR(MP_QSTR_STEREO), MP_ROM_INT(2) },
+       { MP_ROM_QSTR(MP_QSTR_READONLY), MP_ROM_INT(PCM_FLAG_READ_ONLY) },
+       { MP_ROM_QSTR(MP_QSTR_WRITEONLY), MP_ROM_INT(PCM_FLAG_WRITE_ONLY) },
+       { MP_ROM_QSTR(MP_QSTR_WRITEREAD), MP_ROM_INT(PCM_FLAG_WRITE_READ) },
+       { MP_ROM_QSTR(MP_QSTR_BLOCK), MP_ROM_INT(QL_PCM_BLOCK_FLAG) },
+       { MP_ROM_QSTR(MP_QSTR_NOBLOCK), MP_ROM_INT(QL_PCM_NONBLOCK_FLAG) },
+};
+
+STATIC MP_DEFINE_CONST_DICT(pcm_locals_dict_obj, pcm_locals_dict);
+
+
+const mp_obj_type_t audio_audio_pcm = {
+    { &mp_type_type },
+    .name = MP_QSTR_PCM,
+    .make_new = pcm_make_new,
+    .getiter = mp_identity_getiter,
+    .iternext = mp_stream_unbuffered_iter,
+       .protocol = &pcm_stream_p,
+    .locals_dict = (mp_obj_dict_t *)&pcm_locals_dict_obj,
+};
+#endif
+
+#endif /* MICROPY_QPY_AUDIO_AUDIO */
+
+
+
+
index 121812d..f2e136c 100644 (file)
@@ -13,6 +13,9 @@
 \r
 #include "opus/opus.h"\r
 \r
+/* audio_audio.c 暴露的 ring-buffer 直接写入接口 */\r
+extern int _helios_pcm_rb_write(void *pcm_obj, const unsigned char *buf, int len);\r
+\r
 #define MOD_OPUS_LOG(msg, ...) custom_log("modopus", msg, ##__VA_ARGS__)\r
 \r
 #define OPUS_CODEC_SR_HZ     16000\r
@@ -136,6 +139,36 @@ STATIC mp_obj_t opus_codec_decode(mp_obj_t self_in, mp_obj_t pkt_in)
 }\r
 STATIC MP_DEFINE_CONST_FUN_OBJ_2(opus_decode_obj, opus_codec_decode);\r
 \r
+/* 解码 opus 包并直接写入 PCM 对象的 ring buffer,跳过 Python 层内存拷贝和队列。\r
+   参数: self (OpusCodec), pkt (opus 包 bytes), pcm_obj (audio.PCM 对象)\r
+   返回: 写入 ring buffer 的实际字节数(int) */\r
+STATIC mp_obj_t opus_decode_to_pcm(mp_obj_t self_in, mp_obj_t pkt_in, mp_obj_t pcm_in)\r
+{\r
+    mp_obj_OpusCodec_t *self = MP_OBJ_TO_PTR(self_in);\r
+    if (!self->has_dec || self->dec == NULL) {\r
+        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("decoder not open"));\r
+    }\r
+    mp_buffer_info_t pkt;\r
+    mp_get_buffer_raise(pkt_in, &pkt, MP_BUFFER_READ);\r
+    if (pkt.len == 0 || pkt.len > OPUS_CODEC_MAX_PKT) {\r
+        mp_raise_ValueError(MP_ERROR_TEXT("invalid opus packet"));\r
+    }\r
+    opus_int16 pcm[OPUS_CODEC_MAX_FRAME];\r
+    mp_int_t n;\r
+    MP_THREAD_GIL_EXIT();\r
+    n = opus_decode(self->dec, pkt.buf, (opus_int32)pkt.len, pcm,\r
+                    OPUS_CODEC_MAX_FRAME, 0);\r
+    MP_THREAD_GIL_ENTER();\r
+    if (n < 0) {\r
+        mp_raise_msg_varg(&mp_type_OSError, MP_ERROR_TEXT("opus_decode %d"), (int)n);\r
+    }\r
+    int pcm_bytes = (int)n * 2;\r
+    /* 直接写入 PCM 对象的 ring buffer(带背压),消除 mp_obj_new_bytes + bytearray 拷贝 */\r
+    int written = _helios_pcm_rb_write(MP_OBJ_TO_PTR(pcm_in), (const unsigned char *)pcm, pcm_bytes);\r
+    return mp_obj_new_int(written);\r
+}\r
+STATIC MP_DEFINE_CONST_FUN_OBJ_3(opus_decode_to_pcm_obj, opus_decode_to_pcm);\r
+\r
 STATIC mp_obj_t opus_close(mp_obj_t self_in)\r
 {\r
     mp_obj_OpusCodec_t *self = MP_OBJ_TO_PTR(self_in);\r
@@ -163,6 +196,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(opus_version_obj, opus_version);
 STATIC const mp_rom_map_elem_t OpusCodec_locals[] = {\r
     { MP_ROM_QSTR(MP_QSTR_encode), MP_ROM_PTR(&opus_encode_obj) },\r
     { MP_ROM_QSTR(MP_QSTR_decode), MP_ROM_PTR(&opus_decode_obj) },\r
+    { MP_ROM_QSTR(MP_QSTR_decode_to_pcm), MP_ROM_PTR(&opus_decode_to_pcm_obj) },\r
     { MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&opus_close_obj) },\r
 };\r
 STATIC MP_DEFINE_CONST_DICT(OpusCodec_locals_dict, OpusCodec_locals);\r
diff --git a/2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/source/modws_dispatcher.c b/2.sdk/project/7PIN_1_5/sdk/services/microPython/ports/quectel/core/source/modws_dispatcher.c
new file mode 100644 (file)
index 0000000..02dddfe
--- /dev/null
@@ -0,0 +1,98 @@
+/*
+ * MicroPython WebSocket 事件分发加速模块
+ * 将 O(n) Python if/elif 事件字符串比较替换为 C 层 O(1) 二分查找
+ */
+#include <string.h>
+#include "py/runtime.h"
+
+/* 事件 ID 枚举 —— 与 vc_session_io.py 的 if/elif 链一一对应 */
+#define WS_EV_STARTED                   0
+#define WS_EV_CONFIG_UPDATE             1
+#define WS_EV_ASR_STARTED               2
+#define WS_EV_ASR_RESULT                3
+#define WS_EV_ASR_COMPLETED             4
+#define WS_EV_VAD_ACTIVE                5
+#define WS_EV_VAD_SILENCE               6
+#define WS_EV_LLM_CREATED               7
+#define WS_EV_LLM_DELTA                 8
+#define WS_EV_LLM_COMPLETED             9
+#define WS_EV_TTS_STARTED               10
+#define WS_EV_TTS_COMPLETED             11
+#define WS_EV_CANCELED                  12
+#define WS_EV_COMPLETED                 13
+#define WS_EV_FAILED                    14
+#define WS_EV_COMMAND                   15
+#define WS_EV_AUDIO_CONVERT_COMPLETED   16
+#define WS_EV_AUDIO_CONVERT_FAILED      17
+#define WS_EV_UNKNOWN                   18
+
+/* 有序事件名数组(用于二分查找) */
+typedef struct _ws_event_entry {
+    const char *name;
+    int id;
+} ws_event_entry_t;
+
+static const ws_event_entry_t ws_event_table[] = {
+    { "asr.completed",             WS_EV_ASR_COMPLETED },
+    { "asr.result",                WS_EV_ASR_RESULT },
+    { "asr.started",               WS_EV_ASR_STARTED },
+    { "audio.convert.completed",   WS_EV_AUDIO_CONVERT_COMPLETED },
+    { "audio.convert.failed",      WS_EV_AUDIO_CONVERT_FAILED },
+    { "canceled",                  WS_EV_CANCELED },
+    { "command",                   WS_EV_COMMAND },
+    { "completed",                 WS_EV_COMPLETED },
+    { "config.update",             WS_EV_CONFIG_UPDATE },
+    { "failed",                    WS_EV_FAILED },
+    { "llm.completed",             WS_EV_LLM_COMPLETED },
+    { "llm.created",               WS_EV_LLM_CREATED },
+    { "llm.delta",                 WS_EV_LLM_DELTA },
+    { "started",                   WS_EV_STARTED },
+    { "tts.completed",             WS_EV_TTS_COMPLETED },
+    { "tts.started",               WS_EV_TTS_STARTED },
+    { "vad.active",                WS_EV_VAD_ACTIVE },
+    { "vad.silence",               WS_EV_VAD_SILENCE },
+};
+
+#define WS_EVENT_TABLE_LEN (sizeof(ws_event_table) / sizeof(ws_event_table[0]))
+
+/* 返回事件名对应的整数 ID;未找到返回 WS_EV_UNKNOWN */
+static int ws_classify_event(const char *name, mp_uint_t name_len)
+{
+    int lo = 0, hi = (int)WS_EVENT_TABLE_LEN - 1;
+    while (lo <= hi) {
+        int mid = (lo + hi) / 2;
+        int cmp = strncmp(name, ws_event_table[mid].name, name_len);
+        if (cmp == 0 && ws_event_table[mid].name[name_len] == '\0') {
+            return ws_event_table[mid].id;
+        }
+        if (cmp < 0) {
+            hi = mid - 1;
+        } else {
+            lo = mid + 1;
+        }
+    }
+    return WS_EV_UNKNOWN;
+}
+
+STATIC mp_obj_t mod_ws_classify(mp_obj_t event_in)
+{
+    mp_buffer_info_t buf;
+    mp_get_buffer_raise(event_in, &buf, MP_BUFFER_READ);
+    int id = ws_classify_event((const char *)buf.buf, buf.len);
+    return mp_obj_new_int(id);
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_1(mod_ws_classify_obj, mod_ws_classify);
+
+/* 模块注册 */
+STATIC const mp_rom_map_elem_t ws_dispatcher_globals_table[] = {
+    { MP_ROM_QSTR(MP_QSTR___name__),       MP_ROM_QSTR(MP_QSTR__ws_dispatcher) },
+    { MP_ROM_QSTR(MP_QSTR_classify),       MP_ROM_PTR(&mod_ws_classify_obj) },
+};
+STATIC MP_DEFINE_CONST_DICT(ws_dispatcher_globals, ws_dispatcher_globals_table);
+
+const mp_obj_module_t mp_module_ws_dispatcher = {
+    .base    = { &mp_type_module },
+    .globals = (mp_obj_dict_t *)&ws_dispatcher_globals,
+};
+
+MP_REGISTER_MODULE(MP_QSTR__ws_dispatcher, mp_module_ws_dispatcher, 1);
index 6d862da..28a9825 100644 (file)
@@ -792,6 +792,8 @@ extern const struct _mp_obj_module_t mp_module_websocket_mask;
 #define MICROPY_PORT_BUILTIN_MODULES_WEBSOCKET_MASK            { MP_OBJ_NEW_QSTR(MP_QSTR_websocket_mask), (mp_obj_t)&mp_module_websocket_mask},
 extern const struct _mp_obj_module_t mp_module_cws_frame;
 #define MICROPY_PORT_BUILTIN_MODULES_CWS_FRAME         { MP_OBJ_NEW_QSTR(MP_QSTR__cws_frame), (mp_obj_t)&mp_module_cws_frame},
+extern const struct _mp_obj_module_t mp_module_ws_dispatcher;
+#define MICROPY_PORT_BUILTIN_MODULES_WS_DISPATCHER             { MP_OBJ_NEW_QSTR(MP_QSTR__ws_dispatcher), (mp_obj_t)&mp_module_ws_dispatcher},
 #if CONFIG_VAD
 extern const struct _mp_obj_module_t mp_module_VAD ;
 #define MICROPY_PORT_BUILTIN_MODULES_VAD               { MP_OBJ_NEW_QSTR(MP_QSTR_VAD), (mp_obj_t)&mp_module_VAD},
@@ -966,6 +968,7 @@ extern const struct _mp_obj_type_t TiktokRTC_type;
                MICROPY_PORT_BUILTIN_MODULES_code128\
                MICROPY_PORT_BUILTIN_MODULES_WEBSOCKET_MASK\
                MICROPY_PORT_BUILTIN_MODULES_CWS_FRAME\
+               MICROPY_PORT_BUILTIN_MODULES_WS_DISPATCHER\
                MICROPY_PORT_BUILTIN_MODULES_VAD\
                MICROPY_PORT_BUILTIN_MODULES_NETWORK \
                MICROPY_PORT_BUILTIN_MODULES_ALIPAY_COLLECTION \
index 6dd164e..c17e9ed 100644 (file)
@@ -7,6 +7,7 @@ import ure as re
 import ustruct as struct
 import urandom as random
 import usocket as socket
+import utime
 from ucollections import namedtuple
 import websocket_mask
 try:
@@ -15,6 +16,26 @@ except ImportError:
     _cws_frame = None
 LOGGER = log.getLogger(__name__)
 
+# ---- 性能对比开关 ----
+# True 时即使 _cws_frame 可用也强制走 Python 路径,用于 AB 对比
+_FORCE_PYTHON_PATH = False
+
+# 性能计数器
+_perf_cnt = 0
+_perf_total_us = 0
+_PERF_REPORT_EVERY = 50
+
+
+def _perf_tick(elapsed_us):
+    global _perf_cnt, _perf_total_us
+    _perf_cnt += 1
+    _perf_total_us += elapsed_us
+    if _perf_cnt % _PERF_REPORT_EVERY == 0:
+        avg = _perf_total_us // _perf_cnt
+        path = "PY" if _FORCE_PYTHON_PATH else "C"
+        LOGGER.info("[PERF-%s] read_frame avg=%d us over %d frames",
+                    path, avg, _perf_cnt)
+
 
 def _vc_ws_native_ping_tx_enabled():
     """1=客户端主动发 RFC6455 OP_PING;0=不发。入站 OP_PING 始终回 OP_PONG(与配置无关)。"""
@@ -105,11 +126,14 @@ class Websocket(object):
         Read a frame from the socket.
         See https://tools.ietf.org/html/rfc6455#section-5.2 for the details.
         """
+        t0 = utime.ticks_us()
+
         # C 加速路径:_cws_frame 可用时,帧头解析 + unmask 在 C 层完成
-        if _cws_frame is not None:
+        if _cws_frame is not None and not _FORCE_PYTHON_PATH:
             _max = -1 if max_size is None else max_size
             try:
                 fin, opcode, data = _cws_frame.read_frame(self.sock, _max)
+                _perf_tick(utime.ticks_diff(utime.ticks_us(), t0))
                 if opcode == -1:        # CWS_RET_NO_DATA
                     raise NoDataException
                 if opcode == -2:        # CWS_RET_TOO_BIG
@@ -127,6 +151,7 @@ class Websocket(object):
         two_bytes = self.sock.read(2)
 
         if not two_bytes:
+            _perf_tick(utime.ticks_diff(utime.ticks_us(), t0))
             raise NoDataException
 
         byte1, byte2 = struct.unpack('!BB', two_bytes)
@@ -153,6 +178,7 @@ class Websocket(object):
             # We can't receive this many bytes, close the socket
             if self.debug: LOGGER.info("Frame of length %s too big. Closing", length)
             self.close(code=CLOSE_TOO_BIG)
+            _perf_tick(utime.ticks_diff(utime.ticks_us(), t0))
             return True, OP_CLOSE, None
 
         if mask:
@@ -160,6 +186,7 @@ class Websocket(object):
             websocket_mask.MASK(_arr, len(_arr), bytearray(mask_bits))
             data = bytes(_arr)
 
+        _perf_tick(utime.ticks_diff(utime.ticks_us(), t0))
         return fin, opcode, data
 
     def write_frame(self, opcode, data=b''):
index c0b4fec..2042e99 100644 (file)
@@ -6,6 +6,11 @@ from vc_utils import cfg_bool, cfg_attr, cfg_int, net_csq_rssi, net_csq_invalid
 # import * 不导入以下划线开头的符号;_thread 必须显式引入(否则 start_new_thread NameError)
 import _thread
 
+try:
+    import _ws_dispatcher
+except ImportError:
+    _ws_dispatcher = None
+
 class VCSessionIoMixin:
     _VC_STALE_DROP_EVENTS = (
         "tts.started", "tts.completed", "llm.created", "llm.completed", "completed",
@@ -964,12 +969,18 @@ class VCSessionIoMixin:
                             self._cur_sid = ""
                         try:
                             ev = jsload_data.get("event", "")
+                            ev_id = -1
+                            if ev and _ws_dispatcher is not None:
+                                try:
+                                    ev_id = _ws_dispatcher.classify(ev)
+                                except Exception:
+                                    pass
                             if ev:
                                 self._vc_dispatch_server_event(ev, jsload_data)
                         except Exception:
                             pass
                         
-                        if jsload_data["event"] == "started" :#会话开始
+                        if ev_id == 0 :#会话开始
                             #payload = jsload_data["payload"]
                             # self.VC_dialog_id = payload["dialog_id"] 
                             # self.VC_task_id = jsload_data["task_id"] 
@@ -1012,14 +1023,14 @@ class VCSessionIoMixin:
                             except Exception as e:
                                 usys.print_exception(e)
 
-                        elif jsload_data["event"] == "config.update" :#配置更新中,需要停止录音
+                        elif ev_id == 1 :#配置更新中,需要停止录音
                             try:
                                 self.fsm.reset_rx_phases()
                             except Exception:
                                 pass
                             self.request_uplink_stop("config.update")
 
-                        elif jsload_data["event"] == "asr.started" :#asr开始 
+                        elif ev_id == 2 :#asr开始 
                             try:
                                 self.fsm.on_server_asr_started()
                             except Exception:
@@ -1051,7 +1062,7 @@ class VCSessionIoMixin:
                                 pass
                             # 单对话:勿在 asr.started 置 flag=2(未真开麦会僵死);由 VC_Speech_Start 维护
                             self.LocalRespondingEnded_timerout = 0
-                        elif jsload_data["event"] == "asr.result" :#asr结果
+                        elif ev_id == 3 :#asr结果
                             try:
                                 raw = jsload_data["payload"]["content"]
                             except Exception:
@@ -1086,7 +1097,7 @@ class VCSessionIoMixin:
                             if self.AI_ASR_str == "":#没识别到
                                 self.AI_TTS_str = "我没听清,请再说一遍"
                                 self._vc_led_alert_rb_flash()
-                        elif jsload_data["event"] == "asr.completed" :#asr 终止的标识 
+                        elif ev_id == 4 :#asr 终止的标识 
                             self._turn_has_asr_completed = 1
                             try:
                                 if hasattr(self, "_vc_flush_deferred_vad_uplink_stop"):
@@ -1152,7 +1163,7 @@ class VCSessionIoMixin:
 
                             # if dev_type != "7PIN" :
                             #EventMesh.publish("publish_AI_btnInfo",{"func":self.send_tone}) 
-                        elif jsload_data["event"] == "vad.active" :#VAD 检测到说话→聆听
+                        elif ev_id == 5 :#VAD 检测到说话→聆听
                             if hasattr(self, "_vc_local_vad_endpoint") and self._vc_local_vad_endpoint():
                                 print("[VC][VAD] ignore server vad.active (local endpoint)")
                             else:
@@ -1161,7 +1172,7 @@ class VCSessionIoMixin:
                                 self._server_vad_silence = 0
                                 if cfg_bool("VAD_ACTIVE_BLUE_LED", True):
                                     self._server_vad_silence = 0
-                        elif jsload_data["event"] == "vad.silence" :#VAD 终止的标识 
+                        elif ev_id == 6 :#VAD 终止的标识 
                             if hasattr(self, "_vc_local_vad_endpoint") and self._vc_local_vad_endpoint():
                                 print("[VC][VAD] ignore server vad.silence (local endpoint)")
                             else:
@@ -1183,7 +1194,7 @@ class VCSessionIoMixin:
                                 except Exception:
                                     self._server_vad_silence = 1
                                     self._uplink_mark_end("vad.silence")
-                        elif jsload_data["event"] == "llm.created" :#思考(LLM)
+                        elif ev_id == 7 :#思考(LLM)
                             self._turn_has_llm_created = 1
                             self._vc_llm_reply_buf = ""
                             if (
@@ -1205,7 +1216,7 @@ class VCSessionIoMixin:
                                 and getattr(self, "_turn_has_asr_completed", 0) == 1
                             ):
                                 self._vc_expect_dialog_tts = 1
-                        elif jsload_data["event"] == "llm.completed" :#llm完成(可能无 tts)
+                        elif ev_id == 9 :#llm完成(可能无 tts)
                             try:
                                 _reply = getattr(self, "_vc_llm_reply_buf", "")
                                 if _reply:
@@ -1224,7 +1235,7 @@ class VCSessionIoMixin:
                                 self._cur_dialog_id = ""
                             if hasattr(self.fsm, "log"):
                                 self.fsm.log("server.llm.completed")
-                        elif jsload_data["event"] == "llm.delta" :#llm返回数据
+                        elif ev_id == 8 :#llm返回数据
                             if cfg_bool("VC_LLM_DELTA_LOG", False):
                                 try:
                                     _frag = (jsload_data.get("payload") or {}).get("content", "") or ""
@@ -1235,7 +1246,7 @@ class VCSessionIoMixin:
                             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开始
+                        elif ev_id == 10 :#tts开始
                             if not (
                                 hasattr(self, "_vc_ptt_drop_server_event")
                                 and self._vc_ptt_drop_server_event("tts.started", "recv")
@@ -1262,7 +1273,7 @@ class VCSessionIoMixin:
                                 self._pending_tts_kind = ""
                                 self._tts_completed_wall_ms = 0
                                 self._tts_play_end_due_ms = 0
-                        elif jsload_data["event"] == "tts.completed" :#tts结束
+                        elif ev_id == 11 :#tts结束
                             if (
                                 hasattr(self, "_vc_ptt_drop_server_event")
                                 and self._vc_ptt_drop_server_event("tts.completed", "recv")
@@ -1300,7 +1311,7 @@ class VCSessionIoMixin:
                                 )
                             # 播完上报完全由 FSM await_played + play_end 驱动
 
-                        elif jsload_data["event"] == "canceled" :#打断
+                        elif ev_id == 12 :#打断
                             # 长对话清 is_ruppt:仅在 btn 编排 _vc_orchestrator_server_event_cb 中处理,
                             # 勿在 recv 线程提前 settle(会与 stop_downlink 竞态,偶发放行旧 TTS 尾包)
                             if getattr(self, "VC_mode", 0) != 0:
@@ -1321,7 +1332,7 @@ class VCSessionIoMixin:
                                 print("AI_VC_start :AI_audio_queue_thread_id :{} ".format(self.AI_audio_queue_thread_id))
                             else:
                                 print("AI_VC_start :AI_audio_queue_thread_id != 0 ")
-                        elif jsload_data["event"] == "completed" :#会话结束(可能无 TTS,如 ASR 空)
+                        elif ev_id == 13 :#会话结束(可能无 TTS,如 ASR 空)
                             # 重要:服务端常在 tts.completed 后紧跟 completed。
                             # 若本轮存在 TTS/待发 audio.played,则不能在此清零 LocalRespondingEnded_timerout/_need_audio_played_ack,
                             # 否则会掐断「播完→audio.played→下一轮录音」链路,表现为最多 1~2 轮就停。
@@ -1355,7 +1366,7 @@ class VCSessionIoMixin:
                                     # 开麦由 FSM action list 统一触发(uplink_start:completed),这里不再重复调用
                             pass
 
-                        elif jsload_data["event"] == "command" :#命令匹配
+                        elif ev_id == 15 :#命令匹配
                             ret = -1
                             try:
                                 if self.commands_mode ==1:
@@ -1384,7 +1395,7 @@ class VCSessionIoMixin:
                             self.request_uplink_stop("command")
                             EventMesh.publish("publish_AI_btnInfo",{"func":self.websocket_deconnect_VC}) 
                             EventMesh.publish("publish_AI_btnInfo",{"func":self.AI_VC_start}) 
-                        elif jsload_data["event"] == "failed":#接口返回错误
+                        elif ev_id == 14:#接口返回错误
                             pl = jsload_data.get("payload") or {}
                             err = pl.get("error") or ""
                             msg = pl.get("message") or pl.get("msg") or err or ""
@@ -1403,7 +1414,7 @@ class VCSessionIoMixin:
                                 )
                             pass
                            
-                        elif jsload_data["event"] == "audio.convert.completed":#音频转成完成没有出错 接口 
+                        elif ev_id == 16:#音频转成完成没有出错 接口 
                             # self.VC_state = VC_State_End
                             print("未读留言初始数值:{}".format(self.pwk_cnt_voice))
                             if self.pwk_notice_flag == 1:#只有在播放的时候才会去计数
@@ -1453,7 +1464,7 @@ class VCSessionIoMixin:
                                 pass
                                 
                             pass
-                        elif jsload_data["event"] == "audio.convert.failed": #音频转换失败了
+                        elif ev_id == 17: #音频转换失败了
                             pass
                                 
                         
@@ -1490,21 +1501,59 @@ class VCSessionIoMixin:
                             utime.sleep_ms(1)
                             continue
 
-                        # 下行 opus:每个二进制帧=一个 opus 包,解码为 PCM 再走原播放/保存路径
+                        # 下行 opus:每个二进制帧=一个 opus 包
                         if not isinstance(recv_data, str) and self._vc_opus_downlink_on():
                             try:
                                 _ilen = len(recv_data)
                                 _dec_t0 = utime.ticks_us()
-                                recv_data = self._vc_opus_down_codec().decode(recv_data)
-                                _dec_us = utime.ticks_diff(utime.ticks_us(), _dec_t0)
-                                self._opus_dn_cnt = getattr(self, "_opus_dn_cnt", 0) + 1
-                                self._opus_dn_us_sum = getattr(self, "_opus_dn_us_sum", 0) + _dec_us
-                                if _dec_us > getattr(self, "_opus_dn_us_max", 0):
-                                    self._opus_dn_us_max = _dec_us
-                                if self._opus_dn_cnt <= 5 or (self._opus_dn_cnt % 50) == 0:
-                                    _avg = self._opus_dn_us_sum // self._opus_dn_cnt
-                                    print("[VC][opus_dn] #{} in={} out={} dec={}us avg={}us max={}us".format(
-                                        self._opus_dn_cnt, _ilen, len(recv_data), _dec_us, _avg, self._opus_dn_us_max))
+
+                                # C 加速路径:decode + ring-buffer 写入合并,消除 buf_len 忙等待和
+                                # Python 队列往返。play_data_save 调试模式时仍走旧路径。
+                                _fast = (
+                                    getattr(self, "play_data_save_flag", 0) != 1
+                                    and self.VC_play_TYPE == VC_play_TYPE_PCM
+                                    and self.play_pcm is not None
+                                )
+                                if _fast:
+                                    n = self._vc_opus_down_codec().decode_to_pcm(recv_data, self.play_pcm)
+                                    _dec_us = utime.ticks_diff(utime.ticks_us(), _dec_t0)
+
+                                    self._opus_dn_cnt = getattr(self, "_opus_dn_cnt", 0) + 1
+                                    self._opus_dn_us_sum = getattr(self, "_opus_dn_us_sum", 0) + _dec_us
+                                    if _dec_us > getattr(self, "_opus_dn_us_max", 0):
+                                        self._opus_dn_us_max = _dec_us
+                                    if self._opus_dn_cnt <= 5 or (self._opus_dn_cnt % 50) == 0:
+                                        _avg = self._opus_dn_us_sum // self._opus_dn_cnt
+                                        print("[VC][opus_dn] #{} in={} wr={} dec={}us avg={}us max={}us [C-fast]".format(
+                                            self._opus_dn_cnt, _ilen, n, _dec_us, _avg, self._opus_dn_us_max))
+
+                                    if n > 0:
+                                        if self.tts_in_data_len == 0:
+                                            try:
+                                                sid = getattr(self, "_cur_sid", "")
+                                                did = getattr(self, "_cur_dialog_id", "")
+                                            except Exception:
+                                                sid, did = "", ""
+                                            print("[TTS] first_chunk len={} play_pcm=1 sid={} did={} [C-fast]".format(
+                                                n, sid, did))
+                                        self.tts_in_data_len += n
+                                        self.tts_out_data_len = getattr(self, "tts_out_data_len", 0) + n
+
+                                    utime.sleep_ms(1)
+                                    continue
+                                else:
+                                    # 旧路径:decode 返回 bytes,经队列→stream_write
+                                    recv_data = self._vc_opus_down_codec().decode(recv_data)
+                                    _dec_us = utime.ticks_diff(utime.ticks_us(), _dec_t0)
+
+                                    self._opus_dn_cnt = getattr(self, "_opus_dn_cnt", 0) + 1
+                                    self._opus_dn_us_sum = getattr(self, "_opus_dn_us_sum", 0) + _dec_us
+                                    if _dec_us > getattr(self, "_opus_dn_us_max", 0):
+                                        self._opus_dn_us_max = _dec_us
+                                    if self._opus_dn_cnt <= 5 or (self._opus_dn_cnt % 50) == 0:
+                                        _avg = self._opus_dn_us_sum // self._opus_dn_cnt
+                                        print("[VC][opus_dn] #{} in={} out={} dec={}us avg={}us max={}us".format(
+                                            self._opus_dn_cnt, _ilen, len(recv_data), _dec_us, _avg, self._opus_dn_us_max))
                             except Exception as e:
                                 print("[VC][opus_dn] decode fail in={}".format(_ilen))
                                 usys.print_exception(e)
index dc11cd2..538d161 100644 (file)
@@ -982,7 +982,7 @@ class VCSessionMediaMixin:
             self.request_uplink_stop("local.vad.end/audio.completed")
 
     def _vc_local_vad_on_endpoint(self):
-        """本地 VAD 句末:silence_gate + merge 窗 + audio.completed。"""
+        """本地 VAD 句末:关闸→排空队列→opus_flush→think 音→audio.completed。"""
         if not self._vc_local_vad_endpoint():
             return
         if getattr(self, "record_data_save_flag", 0) != 0:
@@ -1009,9 +1009,24 @@ class VCSessionMediaMixin:
             print("[VC][VAD] local endpoint defer (merge window)")
             self._vc_local_vad_send_audio_completed(defer_stop=True)
             return
+        # --- 正常收尾(非 merge 窗)---
         self._server_vad_silence = 1
+        # 排空 AI_record_tmp_queue 中已缓存的 PCM(直接发送,不走 Record Thread 的 gate 检查)
+        try:
+            q = getattr(self, "AI_record_tmp_queue", None)
+            if q is not None and q.empty() != True:
+                drained = 0
+                while q.empty() != True:
+                    self.AI_client_VC_send(q.get())
+                    drained += 1
+                if drained:
+                    print("[VC][endpoint] drained {} from tmp_queue".format(drained))
+        except Exception:
+            pass
         self._uplink_mark_end("local.vad.end")
+        # 发送 audio.completed,触发 request_uplink_stop → VC_Speech_End
         self._vc_local_vad_send_audio_completed(defer_stop=False)
+        # think 音由 record_poll 在录音硬件释放后播(避免并行竞态)
         self._vc_arm_think_tone_pending()
 
     def _vc_endpoint_hangover_ms(self):