630 lines
18 KiB
C
Executable File
630 lines
18 KiB
C
Executable File
// Copyright 2023-2024 Beken
|
||
//
|
||
// 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.
|
||
#ifdef ILOCK_AI_ASR
|
||
#include "stdio.h"
|
||
#include <os/os.h>
|
||
#include <os/mem.h>
|
||
#include <os/str.h>
|
||
#include <modules/pm.h>
|
||
//#include "audio_record.h"
|
||
#include "bk_wanson_asr.h"
|
||
#include "cli.h"
|
||
#include "wanson_client.h"
|
||
#include "audio_record.h"
|
||
#include "aud_intf.h"
|
||
#include "aud_intf_types.h"
|
||
|
||
#define TAG "ws_asr_test"
|
||
#if defined(CONFIG_FATFS)
|
||
#include "diskio.h"
|
||
|
||
static FIL mic_file;
|
||
static char mic_file_name[50];
|
||
|
||
static FATFS *pfs = NULL;
|
||
|
||
|
||
static bk_err_t tf_mount(void)
|
||
{
|
||
FRESULT fr;
|
||
|
||
if (pfs != NULL)
|
||
{
|
||
os_free(pfs);
|
||
}
|
||
|
||
pfs = os_malloc(sizeof(FATFS));
|
||
if(NULL == pfs)
|
||
{
|
||
BK_LOGI(TAG, "f_mount malloc failed!\r\n");
|
||
return BK_FAIL;
|
||
}
|
||
|
||
fr = f_mount(pfs, "1:", 1);
|
||
if (fr != FR_OK)
|
||
{
|
||
BK_LOGE(TAG, "f_mount failed:%d\r\n", fr);
|
||
return BK_FAIL;
|
||
}
|
||
else
|
||
{
|
||
BK_LOGI(TAG, "f_mount OK!\r\n");
|
||
}
|
||
|
||
return BK_OK;
|
||
}
|
||
|
||
static bk_err_t tf_unmount(void)
|
||
{
|
||
FRESULT fr;
|
||
fr = f_unmount(DISK_NUMBER_SDIO_SD, "1:", 1);
|
||
if (fr != FR_OK)
|
||
{
|
||
BK_LOGE(TAG, "f_unmount failed:%d\r\n", fr);
|
||
return BK_FAIL;
|
||
}
|
||
else
|
||
{
|
||
BK_LOGI(TAG, "f_unmount OK!\r\n");
|
||
}
|
||
|
||
if (pfs)
|
||
{
|
||
os_free(pfs);
|
||
pfs = NULL;
|
||
}
|
||
|
||
return BK_OK;
|
||
}
|
||
#endif
|
||
|
||
|
||
#define WANSON_CLIENT_USE_UAC 1
|
||
|
||
static bool wanson_asr_running = false;
|
||
static beken_thread_t wanson_asr_task_hdl = NULL;
|
||
static beken_semaphore_t wanson_asr_sem = NULL;
|
||
|
||
static wanson_asr_handle_t gl_wanson_asr = NULL;
|
||
//static audio_record_t *gl_aud_record = NULL;
|
||
|
||
|
||
|
||
|
||
static bk_err_t wanson_asr_test_exit(void)
|
||
{
|
||
wanson_asr_running = false;
|
||
|
||
if (gl_wanson_asr)
|
||
{
|
||
bk_wanson_asr_destroy(gl_wanson_asr);
|
||
}
|
||
|
||
// if (gl_aud_record)
|
||
// {
|
||
// audio_record_destroy(gl_aud_record);
|
||
// }
|
||
|
||
return BK_OK;
|
||
}
|
||
|
||
static int wanson_asr_result_notify_handle(wanson_asr_handle_t wanson_asr, char *result, void *params)
|
||
{
|
||
|
||
BK_LOGE("%s \n", result);
|
||
if (os_strcmp(result, "小蜂管家") == 0) //识别出唤醒词 小蜂管家
|
||
{
|
||
BK_LOGE("%s \n", "xiao feng guan jia ");
|
||
}
|
||
else if (os_strcmp(result, "阿尔米诺") == 0) //识别出唤醒词 阿尔米诺
|
||
{
|
||
BK_LOGE("%s \n", "a er mi nuo ");
|
||
}
|
||
else if (os_strcmp(result, "会客模式") == 0) //识别出 会客模式
|
||
{
|
||
BK_LOGE("%s \n", "hui ke mo shi ");
|
||
}
|
||
else if (os_strcmp(result, "用餐模式") == 0) //识别出 用餐模式
|
||
{
|
||
BK_LOGE("%s \n", "yong can mo shi ");
|
||
}
|
||
else if (os_strcmp(result, "离开模式") == 0) //识别出 离开模式
|
||
{
|
||
BK_LOGE("%s \n", "li kai mo shi ");
|
||
}
|
||
else if (os_strcmp(result, "回家模式") == 0) //识别出 回家模式
|
||
{
|
||
BK_LOGE("%s \n", "hui jia mo shi ");
|
||
}
|
||
else
|
||
{
|
||
//nothing
|
||
}
|
||
|
||
return BK_OK;
|
||
}
|
||
static int count = 0;
|
||
//static uint16_t pcm8K16b [480] ;
|
||
//static uint16_t pcm16K16b [960] ;
|
||
static int send_mic_data_to_sd(uint8_t *data, unsigned int len)
|
||
{
|
||
//BK_LOGE(TAG, "send_mic_data_to_sd:%d\n", len);
|
||
uint8_t sounds[len/2];
|
||
int pos = 0;
|
||
for(int i = 2 ;i<len ;i=i+4){
|
||
//int16_t value = (data[i] << 8) | data[i+1];
|
||
//bk_wanson_asr_data_write(gl_wanson_asr, (void *)data+i, 1);
|
||
//bk_wanson_asr_data_write(gl_wanson_asr, (void *)data+i+1, 1);
|
||
|
||
//little endian
|
||
sounds[pos] = data[i+i];
|
||
pos++;
|
||
sounds[pos] = data[i];
|
||
|
||
pos++;
|
||
}
|
||
#if 0
|
||
FRESULT fr;
|
||
uint32 uiTemp = 0;
|
||
/* write data to file */
|
||
fr = f_write(&mic_file, (void *)sounds, len/2, &uiTemp);
|
||
if (fr != FR_OK) {
|
||
BK_LOGE(TAG, "write %s fail.\r\n", mic_file_name);
|
||
}
|
||
BK_LOGE(TAG, "write count %d \r\n", count);
|
||
if(count >800){
|
||
/* close mic file */
|
||
f_close(&mic_file);
|
||
|
||
tf_unmount();
|
||
}
|
||
count++;
|
||
#endif
|
||
//BK_LOGE(TAG, "@@ %02X %02X %02X %02X %02X %02X\n", sounds[0], sounds[1],sounds[2],sounds[3],sounds[4],sounds[5]);
|
||
bk_wanson_asr_data_write(gl_wanson_asr, (void *)sounds, len/2);
|
||
#if 0
|
||
/*
|
||
8K8位转8K16位
|
||
//对8K8位采样的每个字节加上0x80再移位成2个字节
|
||
short sData16 = (( short )( byData8 + 0x80 )) << 8;
|
||
*/
|
||
/*
|
||
8K16位转8K8位，把上面的表达式反转来就可以。
|
||
BYTE byData8 = ( BYTE )(( sData16 >> 8 ) - 0x80 );
|
||
*/
|
||
int pos = 0;
|
||
for(int i = 0 ;i<len; i++){
|
||
pcm8K16b[i] = (( short )( data[i] + 0x80 )) << 8 ;
|
||
|
||
// 插入插值样本：前一样本与当前样本的平均值
|
||
//int16_t interpolated = (sample16_prev + sample16_current) / 2;
|
||
//fwrite(&interpolated, sizeof(int16_t), 1, out);
|
||
|
||
//BK_LOGE(TAG, "pcm16K16b:%d\n", pos);
|
||
pcm16K16b[pos] = pcm8K16b[i];
|
||
|
||
pos++;
|
||
//BK_LOGE(TAG, "pcm16K16b:%d\n", pos);
|
||
pcm16K16b[pos] = pcm8K16b[i];
|
||
pos++;
|
||
|
||
//
|
||
// 写入当前样本
|
||
//fwrite(&sample16_current, sizeof(int16_t), 1, out);
|
||
}
|
||
|
||
BK_LOGE(TAG, "write count %d \r\n", count);
|
||
if(count >500){
|
||
/* close mic file */
|
||
f_close(&mic_file);
|
||
|
||
tf_unmount();
|
||
}
|
||
count++;
|
||
//bk_wanson_asr_data_write(gl_wanson_asr, (int16_t *)pcm16k, len);
|
||
//BK_LOGE(TAG, "%02X %02X %02X %02X %02X %02X\n", data[2], data[10],data[30],data[80],data[100],data[200]);
|
||
//bk_wanson_asr_data_write(gl_wanson_asr, (int16_t *)data, len/2);
|
||
|
||
|
||
//BK_LOGE(TAG, "%02X %02X %02X %02X %02X %02X\n", pcm16K16b[0], pcm16K16b[1],pcm16K16b[2],pcm16K16b[3],pcm16K16b[4],pcm16K16b[5]);
|
||
//bk_wanson_asr_data_write(gl_wanson_asr, (int16_t *)pcm16K16b, 960);
|
||
|
||
FRESULT fr;
|
||
uint32 uiTemp = 0;
|
||
/* write data to file */
|
||
fr = f_write(&mic_file, (void *)data, len, &uiTemp);
|
||
if (fr != FR_OK) {
|
||
BK_LOGE(TAG, "write %s fail.\r\n", mic_file_name);
|
||
}
|
||
#endif
|
||
|
||
return len;
|
||
}
|
||
|
||
#ifdef WANSON_CLIENT_USE_UAC
|
||
static int volume_adjust2(int16_t * in_buf, float in_vol)
|
||
{
|
||
int tmp;
|
||
|
||
// in_vol[0, 100]
|
||
float vol = in_vol - 98;
|
||
|
||
if(-98<vol && vol<0)
|
||
vol = 1/(vol*(-1));
|
||
else if(0<=vol && vol<=1)
|
||
vol = 1;
|
||
/*
|
||
else if(1<=vol && vol<=2)
|
||
vol = vol;
|
||
*/
|
||
else if(vol<=-98)
|
||
vol = 0;
|
||
else if(vol>=2)
|
||
vol = 30; //这个值可以根据你的实际情况去调整
|
||
|
||
tmp = (*in_buf)*vol; // 上面所有关于vol的判断，其实都是为了此处*in_buf乘以一个倍数，你可以根据自己的需要去修改
|
||
|
||
// 下面的code主要是为了溢出判断
|
||
if(tmp > 32767)
|
||
tmp = 32767;
|
||
else if(tmp < -32768)
|
||
tmp = -32768;
|
||
*in_buf = tmp;
|
||
return 0;
|
||
}
|
||
static int convert_8khz_to_16khz(void * dst_buf, void *src_buf, int src_size)
|
||
{
|
||
int i;
|
||
for(i=0; i<src_size/2; i++)
|
||
{
|
||
|
||
*((short *)dst_buf + i*2) = *((short *)src_buf + i);
|
||
volume_adjust2((short *)dst_buf + i*2,100);
|
||
*((short *)dst_buf + i*2 + 1) = *((short *)src_buf + i);
|
||
volume_adjust2((short *)dst_buf + i*2 + 1,100);
|
||
}
|
||
|
||
return src_size * 2;
|
||
}
|
||
|
||
|
||
//static uint16_t pcm8K16b [480] ;
|
||
//static uint8_t pcm16K16b [960] ;
|
||
static int send_uac_mic_data_to_sd(uint8_t *data, unsigned int len)
|
||
{
|
||
//UAC PCM signed 16bit ,little endian,8000k mono
|
||
if(count >800){
|
||
#if defined(CONFIG_FATFS)
|
||
/* close mic file */
|
||
f_close(&mic_file);
|
||
tf_unmount();
|
||
#endif
|
||
}else{
|
||
|
||
uint8_t pcm16K16b [len*2] ;
|
||
convert_8khz_to_16khz(&pcm16K16b,data,len);
|
||
bk_wanson_asr_data_write(gl_wanson_asr, (void *)pcm16K16b, len*2);
|
||
/*
|
||
|
||
FRESULT fr;
|
||
uint32 uiTemp = 0;
|
||
|
||
fr = f_write(&mic_file, (void *)pcm16K16b, len*2, &uiTemp);
|
||
if (fr != FR_OK) {
|
||
BK_LOGE(TAG, "write %s fail.\r\n", mic_file_name);
|
||
}
|
||
count++;
|
||
*/
|
||
}
|
||
|
||
return len;
|
||
}
|
||
|
||
void test(){
|
||
rtos_delay_milliseconds(3000);
|
||
//audio_tras_init();
|
||
bk_err_t ret = BK_OK;
|
||
aud_intf_drv_setup_t aud_intf_drv_setup = DEFAULT_AUD_INTF_DRV_SETUP_CONFIG();
|
||
aud_intf_drv_setup.aud_intf_tx_mic_data = send_uac_mic_data_to_sd;
|
||
ret = bk_aud_intf_drv_init(&aud_intf_drv_setup);
|
||
if (ret != BK_ERR_AUD_INTF_OK) {
|
||
BK_LOGE(TAG, "bk_aud_intf_drv_init fail, ret:%d \r\n", ret);
|
||
} else {
|
||
BK_LOGE(TAG, "bk_aud_intf_drv_init complete \r\n");
|
||
}
|
||
|
||
|
||
ret = bk_aud_intf_set_mode(AUD_INTF_WORK_MODE_VOICE);
|
||
if (ret != BK_ERR_AUD_INTF_OK) {
|
||
BK_LOGE(TAG, "bk_aud_intf_set_mode fail, ret:%d \r\n", ret);
|
||
} else {
|
||
BK_LOGE(TAG, "bk_aud_intf_set_mode complete \r\n");
|
||
}
|
||
aud_intf_voc_setup_t aud_intf_voc_setup = DEFAULT_AUD_INTF_VOC_SETUP_CONFIG();
|
||
aud_intf_voc_setup.data_type = AUD_INTF_VOC_DATA_TYPE_PCM;
|
||
aud_intf_voc_setup.samp_rate = 8000;
|
||
aud_intf_voc_setup.spk_en = AUD_INTF_VOC_SPK_OPEN;
|
||
aud_intf_voc_setup.spk_mode = AUD_DAC_WORK_MODE_SIGNAL_END;
|
||
aud_intf_voc_setup.mic_type = AUD_INTF_MIC_TYPE_UAC;
|
||
aud_intf_voc_setup.spk_type = AUD_INTF_MIC_TYPE_UAC;
|
||
|
||
|
||
ret = bk_aud_intf_voc_init(aud_intf_voc_setup);
|
||
if (ret != BK_ERR_AUD_INTF_OK) {
|
||
BK_LOGE(TAG, "bk_aud_intf_voc_init fail, ret:%d \r\n", ret);
|
||
} else {
|
||
BK_LOGE(TAG, "bk_aud_intf_voc_init complete \r\n");
|
||
}
|
||
|
||
|
||
ret = bk_aud_intf_voc_start();
|
||
}
|
||
#endif
|
||
static void wanson_asr_main(beken_thread_arg_t param_data)
|
||
{
|
||
|
||
|
||
#if defined(CONFIG_FATFS)
|
||
bk_err_t ret;
|
||
FRESULT fr;
|
||
#if 1
|
||
ret = tf_mount();
|
||
if (ret != BK_ERR_AUD_INTF_OK) {
|
||
BK_LOGE(TAG, "tfcard mount fail, ret:%d\n", ret);
|
||
|
||
}
|
||
|
||
/*open file to save pcm data */
|
||
sprintf(mic_file_name, "1:/%s", "999.pcm");
|
||
fr = f_open(&mic_file, mic_file_name, FA_CREATE_ALWAYS | FA_WRITE);
|
||
if (fr != FR_OK) {
|
||
BK_LOGE(TAG, "open %s fail\n", mic_file_name);
|
||
|
||
}
|
||
#endif
|
||
#endif
|
||
|
||
|
||
char *mic_data_buff = NULL;
|
||
|
||
/* init audio record */
|
||
//audio_record_cfg_t record_config = DEFAULT_AUDIO_RECORD_CONFIG();
|
||
//record_config.sampRate = 16000;
|
||
//record_config.frame_size = 960;
|
||
//record_config.pool_size = 1920;
|
||
//gl_aud_record = audio_record_create(AUDIO_RECORD_ONBOARD_MIC, &record_config);
|
||
//if (!gl_aud_record)
|
||
//{
|
||
// BK_LOGE(TAG, "%s, %d, create audio record handle fail\n", __func__, __LINE__);
|
||
// goto fail;
|
||
//}
|
||
//BK_LOGI(TAG, "audio record create complete\n");
|
||
|
||
#ifdef WANSON_CLIENT_USE_UAC
|
||
test();
|
||
#elif
|
||
aud_intf_drv_setup_t aud_intf_drv_setup = DEFAULT_AUD_INTF_DRV_SETUP_CONFIG();
|
||
aud_intf_mic_setup_t aud_intf_mic_setup = DEFAULT_AUD_INTF_MIC_SETUP_CONFIG();
|
||
aud_intf_drv_setup.aud_intf_tx_mic_data = send_mic_data_to_sd;
|
||
|
||
ret = bk_aud_intf_drv_init(&aud_intf_drv_setup);
|
||
if (ret != BK_ERR_AUD_INTF_OK) {
|
||
BK_LOGE(TAG, "bk_aud_intf_drv_init fail, ret:%d\n", ret);
|
||
goto fail;
|
||
}
|
||
|
||
ret = bk_aud_intf_set_mode(AUD_INTF_WORK_MODE_GENERAL);
|
||
if (ret != BK_ERR_AUD_INTF_OK) {
|
||
BK_LOGE(TAG, "bk_aud_intf_set_mode fail, ret:%d\n", ret);
|
||
goto fail;
|
||
}
|
||
|
||
aud_intf_mic_setup.mic_chl = AUD_INTF_MIC_CHL_DUAL;
|
||
aud_intf_mic_setup.samp_rate = 16000;//8000 16000
|
||
//aud_intf_mic_setup.mic_type = AUD_INTF_MIC_TYPE_UAC;
|
||
aud_intf_mic_setup.frame_size = 960;
|
||
//aud_intf_mic_setup.mic_gain = 0x2d;
|
||
ret = bk_aud_intf_mic_init(&aud_intf_mic_setup);
|
||
if (ret != BK_ERR_AUD_INTF_OK) {
|
||
BK_LOGE(TAG, "bk_aud_intf_mic_init fail, ret:%d\n", ret);
|
||
goto fail;
|
||
}
|
||
BK_LOGE(TAG, "bk_aud_intf_mic_init OK:\n");
|
||
ret = bk_aud_intf_mic_start();
|
||
if (ret != BK_ERR_AUD_INTF_OK) {
|
||
BK_LOGE(TAG, "bk_aud_intf_mic_start fail, ret:%d\n", ret);
|
||
goto fail;
|
||
}
|
||
BK_LOGE(TAG, "bk_aud_intf_mic_start OK:\n");
|
||
#endif
|
||
|
||
|
||
//test();
|
||
wanson_asr_cfg_t asr_config = DEFAULT_WANSON_ASR_CONFIG();
|
||
asr_config.asr_result_notify = wanson_asr_result_notify_handle;
|
||
gl_wanson_asr = bk_wanson_asr_create(&asr_config);
|
||
if (!gl_wanson_asr)
|
||
{
|
||
BK_LOGE(TAG, "%s, %d, create wanson asr handle fail\n", __func__, __LINE__);
|
||
goto fail;
|
||
}
|
||
BK_LOGI(TAG, "audio wanson asr complete\n");
|
||
|
||
#ifdef CONFIG_BEKEN_WANSON_ASR_USE_SRAM
|
||
mic_data_buff = os_malloc(960);
|
||
#else
|
||
mic_data_buff = psram_malloc(960);
|
||
#endif
|
||
if (!mic_data_buff)
|
||
{
|
||
BK_LOGE(TAG, "%s, %d, malloc mic_data_buff: 960 fail\n", __func__, __LINE__);
|
||
goto fail;
|
||
}
|
||
os_memset(mic_data_buff, 0, 960);
|
||
|
||
bk_wanson_asr_start(gl_wanson_asr);
|
||
BK_LOGI(TAG, "wanson asr start complete\n");
|
||
|
||
//audio_record_open(gl_aud_record);
|
||
//BK_LOGI(TAG, "audio record open complete\n");
|
||
|
||
rtos_set_semaphore(&wanson_asr_sem);
|
||
|
||
wanson_asr_running = true;
|
||
|
||
while (wanson_asr_running)
|
||
{
|
||
//bk_err_t read_size = audio_record_read_data(gl_aud_record, mic_data_buff, 960);
|
||
bk_err_t read_size = 0;
|
||
if (read_size == 960)
|
||
{
|
||
int write_size = bk_wanson_asr_data_write(gl_wanson_asr, (int16_t *)mic_data_buff, 960);
|
||
if (write_size != 960)
|
||
{
|
||
BK_LOGE(TAG, "%s, %d, wanson_asr write size: %d != 960\n", __func__, __LINE__, write_size);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
//BK_LOGE(TAG, "%s, %d, audio_record read size: %d != 960\n", __func__, __LINE__, read_size);
|
||
}
|
||
rtos_delay_milliseconds(500);
|
||
}
|
||
|
||
fail:
|
||
wanson_asr_running = false;
|
||
|
||
wanson_asr_test_exit();
|
||
|
||
if (mic_data_buff)
|
||
{
|
||
#ifdef CONFIG_BEKEN_WANSON_ASR_USE_SRAM
|
||
os_free(mic_data_buff);
|
||
#else
|
||
psram_free(mic_data_buff);
|
||
#endif
|
||
mic_data_buff = NULL;
|
||
}
|
||
|
||
rtos_set_semaphore(&wanson_asr_sem);
|
||
|
||
wanson_asr_task_hdl = NULL;
|
||
|
||
rtos_delete_thread(NULL);
|
||
}
|
||
|
||
static bk_err_t wanson_asr_test_start(void)
|
||
{
|
||
bk_err_t ret = BK_OK;
|
||
|
||
ret = rtos_init_semaphore(&wanson_asr_sem, 1);
|
||
if (ret != BK_OK)
|
||
{
|
||
BK_LOGE(TAG, "%s, %d, create semaphore fail\n", __func__, __LINE__);
|
||
return BK_FAIL;
|
||
}
|
||
|
||
ret = rtos_create_thread(&wanson_asr_task_hdl,
|
||
(BEKEN_DEFAULT_WORKER_PRIORITY - 1),
|
||
"audio_play",
|
||
(beken_thread_function_t)wanson_asr_main,
|
||
6*1024,
|
||
NULL);
|
||
if (ret != BK_OK)
|
||
{
|
||
BK_LOGE(TAG, "%s, %d, create wanson_asr_main task fail\n", __func__, __LINE__);
|
||
goto fail;
|
||
}
|
||
|
||
rtos_get_semaphore(&wanson_asr_sem, BEKEN_NEVER_TIMEOUT);
|
||
|
||
BK_LOGI(TAG, "%s, %d, create wanson_asr_main task complete\n", __func__, __LINE__);
|
||
|
||
return BK_OK;
|
||
|
||
fail:
|
||
if (wanson_asr_sem)
|
||
{
|
||
rtos_deinit_semaphore(&wanson_asr_sem);
|
||
wanson_asr_sem = NULL;
|
||
}
|
||
|
||
return BK_FAIL;
|
||
}
|
||
|
||
|
||
static bk_err_t wanson_asr_test_stop(void)
|
||
{
|
||
if (!wanson_asr_running)
|
||
{
|
||
BK_LOGW(TAG, "%s, %d, wanson_asr not work\n", __func__, __LINE__);
|
||
return BK_OK;
|
||
}
|
||
|
||
wanson_asr_running = false;
|
||
|
||
rtos_get_semaphore(&wanson_asr_sem, BEKEN_NEVER_TIMEOUT);
|
||
|
||
rtos_deinit_semaphore(&wanson_asr_sem);
|
||
wanson_asr_sem = NULL;
|
||
|
||
return BK_OK;
|
||
}
|
||
|
||
/*
|
||
static void cli_wanson_asr_test_help(void)
|
||
{
|
||
BK_LOGI(TAG, "wanson_asr_test {start|stop}\n");
|
||
}
|
||
|
||
void cli_wanson_asr_test_cmd(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
|
||
{
|
||
if (argc != 2)
|
||
{
|
||
cli_wanson_asr_test_help();
|
||
return;
|
||
}
|
||
|
||
if (os_strcmp(argv[1], "start") == 0)
|
||
{
|
||
wanson_asr_test_start();
|
||
}
|
||
else if (os_strcmp(argv[1], "stop") == 0)
|
||
{
|
||
wanson_asr_test_stop();
|
||
}
|
||
else
|
||
{
|
||
cli_wanson_asr_test_help();
|
||
}
|
||
}
|
||
|
||
|
||
#define WANSON_ASR_TEST_CMD_CNT (sizeof(s_wanson_asr_test_commands) / sizeof(struct cli_command))
|
||
static const struct cli_command s_wanson_asr_test_commands[] =
|
||
{
|
||
{"wanson_asr_test", "wanson_asr_test {start|stop}", cli_wanson_asr_test_cmd},
|
||
};
|
||
|
||
int cli_wanson_asr_test_init(void)
|
||
{
|
||
BK_LOGI(TAG, "cli_wanson_asr_test_init \n");
|
||
|
||
return cli_register_commands(s_wanson_asr_test_commands, WANSON_ASR_TEST_CMD_CNT);
|
||
}
|
||
*/
|
||
void poka_wanson_asr_test_init(){
|
||
wanson_asr_test_start();
|
||
}
|
||
#endif |