lmx/99_7018_lmx
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: Add rfid feature and .gitignore file

Browse Source
This commit is contained in:
lmx
2025-11-28 16:25:35 +08:00
parent 818e8c3778
commit ade4b0a1f8
1244 changed files with 342105 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

211
apps/common/audio/online_debug/aud_data_export.c Normal file
View File

@ -0,0 +1,211 @@
#include "aud_data_export.h"
#include "audio_online_debug.h"
#include "circular_buf.h"
#include "timer.h"
#define AUD_DE_LOG y_printf
/*支持的数据通道数：1~3*/
#define AUDIO_DATA_EXPORT_CH 1
enum {
AEC_ST_STOP = 0,
AEC_ST_INIT,
AEC_ST_START,
};
typedef struct {
u8 state;
u8 ch; /*export data ch num*/
u16 send_timer;
u8 packet[256];
#if (AUDIO_DATA_EXPORT_CH > 0)
u8 buf0[1024];
cbuffer_t data_cbuf0;
u32 seqn0;
#endif /*AUDIO_DATA_EXPORT_CH*/
#if (AUDIO_DATA_EXPORT_CH > 1)
u8 buf1[1024];
cbuffer_t data_cbuf1;
u32 seqn1;
#endif /*AUDIO_DATA_EXPORT_CH*/
#if (AUDIO_DATA_EXPORT_CH > 2)
u8 buf2[1024];
cbuffer_t data_cbuf2;
u32 seqn2;
#endif /*AUDIO_DATA_EXPORT_CH*/
} aud_data_export_t;
aud_data_export_t *aud_de = NULL;
typedef struct {
int cmd;
int data;
} rec_cmd_t;
int audio_data_export_start(u8 ch)
{
if (aud_de) {
AUD_DE_LOG("aud_de re-malloc !!!");
return 0;
}
aud_de = zalloc(sizeof(aud_data_export_t));
if (aud_de == NULL) {
AUD_DE_LOG("aud_de malloc failed!!!");
return -1;
}
if (ch <= AUDIO_DATA_EXPORT_CH) {
aud_de->ch = ch;
} else {
aud_de->ch = AUDIO_DATA_EXPORT_CH;
}
#if (AUDIO_DATA_EXPORT_CH > 0)
cbuf_init(&aud_de->data_cbuf0, aud_de->buf0, sizeof(aud_de->buf0));
aud_de->seqn0 = 0;
#endif /*AUDIO_DATA_EXPORT_CH*/
#if (AUDIO_DATA_EXPORT_CH > 1)
cbuf_init(&aud_de->data_cbuf1, aud_de->buf1, sizeof(aud_de->buf1));
aud_de->seqn1 = 0;
#endif /*AUDIO_DATA_EXPORT_CH*/
#if (AUDIO_DATA_EXPORT_CH > 2)
cbuf_init(&aud_de->data_cbuf2, aud_de->buf2, sizeof(aud_de->buf2));
aud_de->seqn2 = 0;
#endif /*AUDIO_DATA_EXPORT_CH*/
aud_de->state = AEC_ST_START;
return 0;
}
void audio_data_export_stop(void)
{
if (aud_de) {
if (aud_de->send_timer) {
sys_timer_del(aud_de->send_timer);
aud_de->send_timer = 0;
}
aud_de->state = AEC_ST_STOP;
free(aud_de);
aud_de = NULL;
}
}
static int spp_data_export(u8 ch, u8 *buf, u16 len)
{
u8 data_ch;
putchar('.');
if (ch == 0) {
data_ch = DB_PKT_TYPE_DAT_CH0;
} else if (ch == 1) {
data_ch = DB_PKT_TYPE_DAT_CH1;
} else {
data_ch = DB_PKT_TYPE_DAT_CH2;
}
int err = app_online_db_send_more(data_ch, buf, len);
if (err) {
printf("tx_err:%d", err);
}
return len;
}
int audio_data_export_run(u8 ch, u8 *data, int len)
{
int ret = 0;
if (aud_de && (aud_de->state == AEC_ST_START)) {
#if (AUDIO_DATA_EXPORT_CH > 0)
if (ch == 0) {
int wlen = cbuf_write(&aud_de->data_cbuf0, data, len);
if (cbuf_get_data_size(&aud_de->data_cbuf0) >= 640) {
u8 tmp_buf[RECORD_CH0_LENGTH];
memcpy(tmp_buf, &aud_de->seqn0, 4);
s16 *data_buf = &tmp_buf[4];
cbuf_read(&aud_de->data_cbuf0, data_buf, 640);
spp_data_export(ch, tmp_buf, 644);
aud_de->seqn0 ++;
putchar('s');
}
}
#endif /*AUDIO_DATA_EXPORT_CH*/
#if (AUDIO_DATA_EXPORT_CH > 1)
else if (ch == 1) {
int wlen = cbuf_write(&aud_de->data_cbuf1, data, len);
if (cbuf_get_data_size(&aud_de->data_cbuf1) >= 640) {
u8 tmp_buf[RECORD_CH1_LENGTH];
memcpy(tmp_buf, &aud_de->seqn1, 4);
s16 *data_buf = &tmp_buf[4];
cbuf_read(&aud_de->data_cbuf1, data_buf, 640);
spp_data_export(ch, tmp_buf, 644);
aud_de->seqn1 ++;
putchar('s');
}
}
#endif /*AUDIO_DATA_EXPORT_CH*/
#if (AUDIO_DATA_EXPORT_CH > 2)
else if (ch == 2) {
int wlen = cbuf_write(&aud_de->data_cbuf2, data, len);
if (cbuf_get_data_size(&aud_de->data_cbuf2) >= 640) {
u8 tmp_buf[RECORD_CH2_LENGTH];
memcpy(tmp_buf, &aud_de->seqn2, 4);
s16 *data_buf = &tmp_buf[4];
cbuf_read(&aud_de->data_cbuf2, data_buf, 640);
spp_data_export(ch, tmp_buf, 644);
aud_de->seqn2 ++;
putchar('s');
}
}
#endif /*AUDIO_DATA_EXPORT_CH*/
}
return ret;
}
static int aud_online_data_export_parse(u8 *packet, u8 size, u8 *ext_data, u16 ext_size)
{
int res_data = 0;
rec_cmd_t rec_cmd;
int err = 0;
u8 parse_seq = ext_data[1];
//AUD_DE_LOG("aec_spp_rx,seq:%d,size:%d\n", parse_seq, size);
//put_buf(packet, size);
memcpy(&rec_cmd, packet, sizeof(rec_cmd_t));
switch (rec_cmd.cmd) {
case AUD_RECORD_COUNT:
if (aud_de) {
/* res_data = aud_de->ch; */
res_data = AUDIO_DATA_EXPORT_CH;
} else {
res_data = AUDIO_DATA_EXPORT_CH;
}
err = app_online_db_ack(parse_seq, (u8 *)&res_data, 4);
AUD_DE_LOG("query record_ch num:%d\n", res_data);
break;
case AUD_RECORD_START:
audio_data_export_start(AUDIO_DATA_EXPORT_CH);
err = app_online_db_ack(parse_seq, (u8 *)&res_data, 1); //该命令随便ack一个byte即可
AUD_DE_LOG("record_start\n");
break;
case AUD_RECORD_STOP:
AUD_DE_LOG("record_stop\n");
audio_data_export_stop();
app_online_db_ack(parse_seq, (u8 *)&res_data, 1); //该命令随便ack一个byte即可
break;
case ONLINE_OP_QUERY_RECORD_PACKAGE_LENGTH:
if (rec_cmd.data == 0) {
res_data = RECORD_CH0_LENGTH;
} else if (rec_cmd.data == 1) {
res_data = RECORD_CH1_LENGTH;
} else {
res_data = RECORD_CH2_LENGTH;
}
AUD_DE_LOG("query record ch%d packet length:%d\n", rec_cmd.data, res_data);
err = app_online_db_ack(parse_seq, (u8 *)&res_data, 4); //回复对应的通道数据长度
break;
}
return 0;
}
int aud_data_export_open(void)
{
app_online_db_register_handle(DB_PKT_TYPE_EXPORT, aud_online_data_export_parse);
return 0;
}
int aud_data_export_close(void)
{
return 0;
}

8
apps/common/audio/online_debug/aud_data_export.h Normal file
View File

@ -0,0 +1,8 @@
#ifndef _AUD_DATA_EXPORT_H_
#define _AUD_DATA_EXPORT_H_
#include "generic/typedef.h"
#endif/*_AUD_DATA_EXPORT_H_*/

354
apps/common/audio/online_debug/aud_mic_dut.c Normal file
View File

@ -0,0 +1,354 @@
#include "aud_mic_dut.h"
#include "audio_online_debug.h"
#include "online_db_deal.h"
#include "app_config.h"
#include "system/includes.h"
#if ((defined TCFG_AUDIO_MIC_DUT_ENABLE) && TCFG_AUDIO_MIC_DUT_ENABLE)
#include "mic_dut_process.h"
#define AUDIO_MIC_DUT_TASK_NAME "AudioMicDut"
typedef struct {
u8 start; /*mic dut 开始和结束标志*/
u16 mic_gain; /*保存在线调试的mic gain*/
u32 sr; /*保存在线调试的mic采样率*/
u8 mic_idx; /*记录当前使用的那个mic*/
u8 scan_start; /*mic dut scan 开始和结束的标志*/
u8 dac_gain; /*保存在线调试的dac gain*/
u32 send_timer; /*定时器句柄*/
u32 seqn; /*数据的seqn*/
OS_SEM sem; /*信号量*/
} mic_online_info_t;
/*硬件信息*/
static mic_dut_info_t mic_info;
/*在线调试信息*/
static mic_online_info_t online_info_t;
static mic_online_info_t *online_info_hdl = &online_info_t;
static int spp_data_export(u8 ch, u8 *buf, u16 len)
{
u8 data_ch;
putchar('.');
if (ch == 0) {
data_ch = DB_PKT_TYPE_DAT_CH0;
} else if (ch == 1) {
data_ch = DB_PKT_TYPE_DAT_CH1;
} else {
data_ch = DB_PKT_TYPE_DAT_CH2;
}
int err = app_online_db_send_more(data_ch, buf, len);
if (err) {
printf("tx_err:%d", err);
}
return len;
}
/*在线数据初始化*/
static void mic_dut_online_init(void)
{
if (online_info_hdl) {
online_info_hdl->start = 0;
online_info_hdl->mic_gain = mic_info.mic_gain_default;
online_info_hdl->sr = mic_info.sr_default;
online_info_hdl->mic_idx = 0;
online_info_hdl->scan_start = 0;
online_info_hdl->dac_gain = mic_info.dac_gain_default;
online_info_hdl->send_timer = 0;
online_info_hdl->seqn = 1;
} else {
printf("online_info_hdl is NULL !!!\n");
}
}
static void audio_mic_dut_data_export_run(void)
{
if (online_info_hdl) {
u8 buf[644];
u8 *data = &buf[4];
int len = 640;
int rlen = 0;
if (audio_mic_dut_get_data_len() >= len) {
memcpy(buf, &online_info_hdl->seqn, 4);
rlen = audio_mic_dut_data_get(data, len);
extern void audio_mic_dut_eq_run(s16 * data, int len);
audio_mic_dut_eq_run(data, len);
/* printf("%d, %d", len, rlen); */
int ret = spp_data_export(0, buf, rlen + 4);
online_info_hdl->seqn ++;
/* printf("seqn %d %d\n", mic_online_info.seqn,*((int *) buf)); */
}
}
}
static void audio_mic_dut_timer(void *p)
{
audio_mic_dut_data_export_run();
}
static void audio_mic_dut_task(void *p)
{
while (1) {
os_sem_pend(&online_info_hdl->sem, 0);
audio_mic_dut_data_export_run();
}
}
static void mic_dut_online_start(void)
{
if (online_info_hdl) {
#if MIC_DUT_DATA_SEND_BY_TIMER
online_info_hdl->send_timer = usr_timer_add(NULL, audio_mic_dut_timer, MIC_DATA_SEND_INTERVAL, 1);
#else
os_sem_create(&online_info_hdl->sem, 0);
os_task_create(audio_mic_dut_task, NULL, 1, 768, 64, AUDIO_MIC_DUT_TASK_NAME);
#endif
}
}
/*释放mic dut 信号量*/
void mic_dut_online_sem_post(void)
{
if (online_info_hdl) {
#if (MIC_DUT_DATA_SEND_BY_TIMER == 0)
os_sem_post(&online_info_hdl->sem);
#endif /*SPP_SEND_BY_TIMER*/
}
}
static void mic_dut_online_stop(void)
{
if (online_info_hdl) {
if (online_info_hdl->start) {
audio_mic_dut_stop();
online_info_hdl->start = 0;
}
if (online_info_hdl->scan_start) {
audio_mic_dut_scan_stop();
online_info_hdl->scan_start = 0;
}
#if MIC_DUT_DATA_SEND_BY_TIMER
if (online_info_hdl->send_timer) {
usr_timer_del(online_info_hdl->send_timer);
online_info_hdl->send_timer = 0;
}
#else
os_task_del(AUDIO_MIC_DUT_TASK_NAME);
os_sem_del(&online_info_hdl->sem, 0);
#endif
/* online_info_hdl = NULL; */
}
}
/*数据解析*/
static int mic_dut_online_parse(u8 *packet, u8 size, u8 *ext_data, u16 ext_size)
{
int res_data = 0;
online_cmd_t mic_dut_cmd;
int err = 0;
u8 parse_seq = ext_data[1];
//AEC_ONLINE_LOG("[MIC_DUT]spp_rx,seq:%d,size:%d\n", parse_seq, size);
put_buf(packet, size);
memcpy(&mic_dut_cmd, packet, sizeof(online_cmd_t));
printf("[MIC_DUT]cmd:0x%x\n", mic_dut_cmd.cmd);
switch (mic_dut_cmd.cmd) {
case AUD_RECORD_COUNT:
y_printf("AEC_RECORD_COUNT\n");
res_data = 1;
err = app_online_db_ack(parse_seq, (u8 *)&res_data, 4);
break;
case ONLINE_OP_QUERY_RECORD_PACKAGE_LENGTH:
y_printf("ONLINE_OP_QUERY_RECORD_PACKAGE_LENGTH\n");
if (mic_dut_cmd.data == 0) {
res_data = RECORD_CH0_LENGTH;
} else if (mic_dut_cmd.data == 1) {
res_data = RECORD_CH1_LENGTH;
} else {
res_data = RECORD_CH2_LENGTH;
}
printf("query record ch%d packet length:%d\n", mic_dut_cmd.data, res_data);
err = app_online_db_ack(parse_seq, (u8 *)&res_data, 4); //回复对应的通道数据长度
break;
case MIC_DUT_INFO_QUERY:
y_printf("MIC_DUT_INFO_QUERY\n");
/*获取mic dut硬件数据*/
audio_mic_dut_info_get(&mic_info);
/*在线数据初始化*/
mic_dut_online_init();
err = app_online_db_ack(parse_seq, (u8 *)&mic_info, sizeof(mic_info));
break;
case MIC_DUT_GAIN_SET:
y_printf("MIC_DUT_GAIN_SET:%d\n", mic_dut_cmd.data);
if (online_info_hdl) {
online_info_hdl->mic_gain = mic_dut_cmd.data;
}
audio_mic_dut_gain_set(mic_dut_cmd.data);
err = app_online_db_ack(parse_seq, (u8 *)"OK", 2);
break;
case MIC_DUT_SAMPLE_RATE_SET:
y_printf("MIC_DUT_SAMPLE_RATE_SET:%d\n", mic_dut_cmd.data);
if (online_info_hdl) {
online_info_hdl->sr = mic_dut_cmd.data;
}
audio_mic_dut_sample_rate_set(mic_dut_cmd.data);
err = app_online_db_ack(parse_seq, (u8 *)"OK", 2);
break;
case MIC_DUT_START:
y_printf("MIC_DUT_START\n");
/*打开发数资源*/
mic_dut_online_start();
/*打开mic*/
audio_mic_dut_start();
if (online_info_hdl) {
online_info_hdl->start = 1;
}
err = app_online_db_ack(parse_seq, (u8 *)"OK", 2);
break;
case MIC_DUT_STOP:
y_printf("MIC_DUT_STOP\n");
if (online_info_hdl) {
online_info_hdl->start = 0;
}
/*关闭mic*/
audio_mic_dut_stop();
/*关闭发数资源*/
mic_dut_online_stop();
err = app_online_db_ack(parse_seq, (u8 *)"OK", 2);
break;
case MIC_DUT_AMIC_SEL:
y_printf("MIC_DUT_AMIC_SEL:%d\n", mic_dut_cmd.data);
if (online_info_hdl) {
online_info_hdl->mic_idx = mic_dut_cmd.data;
}
audio_mic_dut_amic_select(mic_dut_cmd.data);
err = app_online_db_ack(parse_seq, (u8 *)"OK", 2);
break;
case MIC_DUT_DMIC_SEL:
y_printf("MIC_DUT_DMIC_SEL:%d\n", mic_dut_cmd.data);
if (online_info_hdl) {
online_info_hdl->mic_idx = mic_dut_cmd.data;
}
audio_mic_dut_dmic_select(mic_dut_cmd.data);
err = app_online_db_ack(parse_seq, (u8 *)"OK", 2);
break;
case MIC_DUT_DAC_GAIN_SET:
y_printf("MIC_DUT_DAC_GAIN_SET:%d\n", mic_dut_cmd.data);
if (online_info_hdl) {
online_info_hdl->dac_gain = mic_dut_cmd.data;
}
audio_mic_dut_dac_gain_set(mic_dut_cmd.data);
err = app_online_db_ack(parse_seq, (u8 *)"OK", 2);
break;
case MIC_DUT_SCAN_START:
y_printf("MIC_DUT_SCAN_START\n");
/*打开发数资源*/
mic_dut_online_start();
/*打开dac*/
audio_mic_dut_scan_start();
if (online_info_hdl) {
online_info_hdl->scan_start = 1;
}
err = app_online_db_ack(parse_seq, (u8 *)"OK", 2);
break;
case MIC_DUT_SCAN_STOP:
y_printf("MIC_DUT_SCAN_STOP\n");
if (online_info_hdl) {
online_info_hdl->scan_start = 0;
}
/*关闭dac*/
audio_mic_dut_scan_stop();
/*关闭发数资源*/
mic_dut_online_stop();
err = app_online_db_ack(parse_seq, (u8 *)"OK", 2);
break;
default:
break;
}
printf("err:%d\n", err);
return 0;
}
/*获取当前设置的mic增益*/
int mic_dut_online_get_mic_gain(void)
{
if (online_info_hdl) {
return online_info_hdl->mic_gain;
}
return -1;
}
/*获取当前设置的dac增益*/
int mic_dut_online_get_dac_gain(void)
{
if (online_info_hdl) {
return online_info_hdl->dac_gain;
}
return -1;
}
/*获取当前设置的采样率*/
int mic_dut_online_get_sample_rate(void)
{
if (online_info_hdl) {
return online_info_hdl->sr;
}
return -1;
}
/*获取当前使能的模拟mic*/
u8 mic_dut_online_amic_enable_bit(void)
{
return mic_info.amic_enable_bit;
}
/*获取当前使能的数字mic*/
u8 mic_dut_online_dmic_enable_bit(void)
{
return mic_info.dmic_enable_bit;
}
/*获取当前在线使用的mic*/
int mic_dut_online_get_mic_idx(void)
{
if (online_info_hdl) {
return online_info_hdl->mic_idx;
}
return -1;
}
/*获取mic dut状态*/
int mic_dut_online_get_mic_state(void)
{
if (online_info_hdl) {
return online_info_hdl->start;
}
return -1;
}
/*获取dut scan状态*/
int mic_dut_online_get_scan_state(void)
{
if (online_info_hdl) {
return online_info_hdl->scan_start;
}
return -1;
}
/*注册mic dut解析回调*/
int aud_mic_dut_open(void)
{
app_online_db_register_handle(DB_PKT_TYPE_MIC_DUT, mic_dut_online_parse);
return 0;
}
int aud_mic_dut_close(void)
{
return 0;
}
#endif /*((defined TCFG_AUDIO_MIC_DUT_ENABLE) && TCFG_AUDIO_MIC_DUT_ENABLE)*/

68
apps/common/audio/online_debug/aud_mic_dut.h Normal file
View File

@ -0,0 +1,68 @@
#ifndef _AUD_MIC_DUT_H_
#define _AUD_MIC_DUT_H_
#include "generic/typedef.h"
#define MIC_DUT_DATA_SEND_BY_TIMER 0 /*1:使用定时器发spp数据，0:使用任务发数*/
/*定时器发送间隔*/
#define MIC_DATA_SEND_INTERVAL 4
//MIC采样率bitmap
#define MIC_ADC_SR_8000 BIT(0)
#define MIC_ADC_SR_11025 BIT(1)
#define MIC_ADC_SR_12000 BIT(2)
#define MIC_ADC_SR_16000 BIT(3)
#define MIC_ADC_SR_22050 BIT(4)
#define MIC_ADC_SR_24000 BIT(5)
#define MIC_ADC_SR_32000 BIT(6)
#define MIC_ADC_SR_44100 BIT(7)
#define MIC_ADC_SR_48000 BIT(8)
typedef struct {
u16 version;
u16 amic_enable_bit; /*模拟MIC使能位：AMIC0-AMIC15，默认使能模拟MIC最低使能位*/
u16 dmic_enable_bit; /*数字MIC使能位：DMIC0-DMIC15*/
u8 channel; /*声道*/
u8 bit_wide; /*位宽，有符号*/
u32 sr_enable_bit; /*采样率支持列表使能位*/
u32 sr_default; /*采样率默认值：16000*/
u16 mic_gain; /*MIC增益范围*/
u16 mic_gain_default; /*MIC增益默认值*/
u16 dac_gain; /*DAC增益范围*/
u16 dac_gain_default; /*DAC增益默认值*/
} mic_dut_info_t;
/*获取当前设置的mic增益*/
int mic_dut_online_get_mic_gain(void);
/*获取当前设置的dac增益*/
int mic_dut_online_get_dac_gain(void);
/*获取当前设置的采样率*/
int mic_dut_online_get_sample_rate(void);
/*获取当前使能的模拟mic*/
u8 mic_dut_online_amic_enable_bit(void);
/*获取当前使能的数字mic*/
u8 mic_dut_online_dmic_enable_bit(void);
/*获取当前在线使用的mic*/
int mic_dut_online_get_mic_idx(void);
/*获取mic dut状态*/
int mic_dut_online_get_mic_state(void);
/*获取dut scan状态*/
int mic_dut_online_get_scan_state(void);
int aud_mic_dut_open(void);
int aud_mic_dut_close(void);
#endif/*_AUD_MIC_DUT_H_*/

160
apps/common/audio/online_debug/aud_spatial_effect_dut.c Normal file
View File

@ -0,0 +1,160 @@
#include "aud_spatial_effect_dut.h"
#include "audio_online_debug.h"
#include "config/config_interface.h"
#include "app_config.h"
#include "os/os_api.h"
#include "classic/tws_api.h"
#include "timer.h"
#if (defined(TCFG_AUDIO_SPATIAL_EFFECT_ENABLE) && TCFG_AUDIO_SPATIAL_EFFECT_ENABLE && TCFG_SPATIAL_EFFECT_ONLINE_ENABLE)
#define IMU_DATA_SEND_INTERVAL 100
// 配置参数
typedef struct _RP_PARM_CONIFG {
int trackKIND; //角度合成算法选择: P360_T0或者P360_T1
int ReverbKIND; //混响算法选择：P360_R0或者P360_R1
int reverbance; //混响值 : 0到100
int dampingval; //高频decay：0到80
} RP_PARM_CONIFG;
static RP_PARM_CONIFG parmK;
extern void spatial_effect_online_updata(RP_PARM_CONIFG *params);
extern void get_spatial_effect_reverb_params(RP_PARM_CONIFG *params);
static u32 send_timer = 0;
static int global_angle = 0;
int set_bt_media_imu_angle(int angle)
{
global_angle = angle;
return global_angle;
}
void spatial_effect_imu_dut_data_timer(void *p)
{
int tmp_angle = 0;
extern u8 bt_media_is_running(void);
#if TCFG_USER_TWS_ENABLE
/*TWS连接的时候*/
if ((tws_api_get_tws_state() & TWS_STA_SIBLING_CONNECTED)) {
/*主机发送角度*/
if (tws_api_get_role() == TWS_ROLE_MASTER) {
/*播歌的时候*/
if (bt_media_is_running()) {
tmp_angle = global_angle;
if (tmp_angle > 180) {
tmp_angle = tmp_angle - 360;
}
int buf[2];
buf[0] = SPATIAL_EFFECT_IMU_DUT_DATA;
buf[1] = tmp_angle;
/* app_online_db_send(DB_PKT_TYPE_SPATIAL_EFFECT, buf, sizeof(buf)); */
app_online_db_send_more(DB_PKT_TYPE_SPATIAL_EFFECT, buf, sizeof(buf));
}
}
} else
#endif /*TCFG_USER_TWS_ENABLE*/
{
/*没有tws连接的时候*/
if (bt_media_is_running()) {/*发送播歌角度*/
tmp_angle = global_angle;
if (tmp_angle > 180) {
tmp_angle = tmp_angle - 360;
}
int buf[2];
buf[0] = SPATIAL_EFFECT_IMU_DUT_DATA;
buf[1] = tmp_angle;
/* app_online_db_send(DB_PKT_TYPE_SPATIAL_EFFECT, buf, sizeof(buf)); */
app_online_db_send_more(DB_PKT_TYPE_SPATIAL_EFFECT, buf, sizeof(buf));
}
}
}
int spatial_effect_imu_dut_start()
{
if (send_timer == 0) {
send_timer = usr_timer_add(NULL, spatial_effect_imu_dut_data_timer, IMU_DATA_SEND_INTERVAL, 1);
}
return 0;
}
int spatial_effect_imu_dut_stop()
{
if (send_timer) {
usr_timer_del(send_timer);
send_timer = 0;
}
return 0;
}
int spatial_effect_online_parse(u8 *packet, u8 size, u8 *ext_data, u16 ext_size)
{
put_buf(packet, size);
int res_data = 0;
int err = 0;
u8 parse_seq = ext_data[1];
int cmd;
memcpy(&cmd, packet, sizeof(cmd));
u8 *data = &packet[4];
printf("[SPATIAL EFFECT]cmd:0x%x\n", cmd);
switch (cmd) {
case SPATIAL_EFFECT_REVERB_INFO_QUERY:
printf("SPATIAL_EFFECT_REVERB_INFO_QUERY\n");
get_spatial_effect_reverb_params(&parmK);
err = app_online_db_ack(parse_seq, (u8 *)&parmK, sizeof(parmK));
break;
case SPATIAL_EFFECT_REVERB_PARAM:
printf("SPATIAL_EFFECT_REVERB_PARAM\n");
memcpy(&parmK, data, sizeof(parmK));
spatial_effect_online_updata(&parmK);
printf("%s\n trackKIND:%d, ReverbKIND:%d, reverbance:%d, dampingval:%d\n", __func__,
parmK.trackKIND, parmK.ReverbKIND, parmK.reverbance, parmK.dampingval);
err = app_online_db_ack(parse_seq, (u8 *)"OK", 2);
break;
case SPATIAL_EFFECT_IMU_TRIM:
printf("SPATIAL_EFFECT_IMU_TRIM\n");
static int tmp = -2;
extern int spatial_imu_trim_start();
spatial_imu_trim_start();
/*测试代码*/
res_data = 0;
err = app_online_db_ack(parse_seq, (u8 *)&res_data, 4);
break;
case SPATIAL_EFFECT_IMU_DUT_START:
printf("SPATIAL_EFFECT_IMU_DUT_START\n");
spatial_effect_imu_dut_start();
err = app_online_db_ack(parse_seq, (u8 *)"OK", 2);
break;
case SPATIAL_EFFECT_IMU_DUT_STOP:
printf("SPATIAL_EFFECT_IMU_DUT_STOP\n");
spatial_effect_imu_dut_stop();
err = app_online_db_ack(parse_seq, (u8 *)"OK", 2);
break;
default :
break;
}
printf("err:%d\n", err);
return 0;
}
int aud_spatial_effect_dut_open()
{
app_online_db_register_handle(DB_PKT_TYPE_SPATIAL_EFFECT, spatial_effect_online_parse);
return 0;
}
int aud_spatial_effect_dut_close()
{
return 0;
}
#endif /*(defined(TCFG_SPATIAL_EFFECT_ONLINE_ENABLE) && (TCFG_SPATIAL_EFFECT_ONLINE_ENABLE == 1))*/

9
apps/common/audio/online_debug/aud_spatial_effect_dut.h Normal file
View File

@ -0,0 +1,9 @@
#ifndef _AUD_SPATIAL_EFFECT_DUT__
#define _AUD_SPATIAL_EFFECT_DUT__
int aud_spatial_effect_dut_open();
int aud_spatial_effect_dut_close();
#endif _AUD_SPATIAL_EFFECT_DUT__

52
apps/common/audio/online_debug/audio_online_debug.c Normal file
View File

@ -0,0 +1,52 @@
#include "audio_online_debug.h"
#include "system/includes.h"
#include "generic/list.h"
#include "aud_mic_dut.h"
#include "aud_data_export.h"
#include "aud_spatial_effect_dut.h"
#include "board_config.h"
typedef struct {
struct list_head parser_head;
} aud_online_ctx_t;
aud_online_ctx_t *aud_online_ctx = NULL;
int audio_online_debug_init(void)
{
//aud_online_ctx = zalloc(sizeof(aud_online_ctx_t));
if (aud_online_ctx) {
//INIT_LIST_HEAD(&aud_online_ctx->parser_head);
}
}
int audio_online_debug_open()
{
/*空间音频陀螺仪数据导出*/
#if (TCFG_SENSOR_DATA_EXPORT_ENABLE == SENSOR_DATA_EXPORT_USE_SPP)
aud_data_export_open();
#endif /*TCFG_SENSOR_DATA_EXPORT_ENABLE*/
/*麦克风测试*/
#if (defined(TCFG_AUDIO_MIC_DUT_ENABLE) && (TCFG_AUDIO_MIC_DUT_ENABLE == 1))
aud_mic_dut_open();
#endif/*TCFG_AUDIO_MIC_DUT_ENABLE*/
/*空间音效在线调试*/
#if (defined(TCFG_SPATIAL_EFFECT_ONLINE_ENABLE) && (TCFG_SPATIAL_EFFECT_ONLINE_ENABLE == 1))
aud_spatial_effect_dut_open();
#endif /*(defined(TCFG_SPATIAL_EFFECT_ONLINE_ENABLE) && (TCFG_SPATIAL_EFFECT_ONLINE_ENABLE == 1))*/
return 0;
}
__initcall(audio_online_debug_open);
int audio_online_debug_close()
{
if (aud_online_ctx) {
}
}

45
apps/common/audio/online_debug/audio_online_debug.h Normal file
View File

@ -0,0 +1,45 @@
#ifndef _AUD_ONLINE_DEBUG_
#define _AUD_ONLINE_DEBUG_
#include "generic/typedef.h"
#include "online_db_deal.h"
enum {
AUD_RECORD_COUNT = 0x200,
AUD_RECORD_START,
AUD_RECORD_STOP,
ONLINE_OP_QUERY_RECORD_PACKAGE_LENGTH,
MIC_DUT_INFO_QUERY = 0x300,
MIC_DUT_GAIN_SET,
MIC_DUT_SAMPLE_RATE_SET,
MIC_DUT_START,
MIC_DUT_STOP,
MIC_DUT_AMIC_SEL,
MIC_DUT_DMIC_SEL,
MIC_DUT_DAC_GAIN_SET,
MIC_DUT_SCAN_START,
MIC_DUT_SCAN_STOP,
SPATIAL_EFFECT_REVERB_PARAM = 0x400,
SPATIAL_EFFECT_IMU_TRIM,
SPATIAL_EFFECT_IMU_DUT_START,
SPATIAL_EFFECT_IMU_DUT_STOP,
SPATIAL_EFFECT_IMU_DUT_DATA,
SPATIAL_EFFECT_REVERB_INFO_QUERY,
};
#define RECORD_CH0_LENGTH 644
#define RECORD_CH1_LENGTH 644
#define RECORD_CH2_LENGTH 644
typedef struct {
int cmd;
int data;
} online_cmd_t;
int audio_online_debug_open();
#endif/*_AUD_ONLINE_DEBUG_*/