946 lines
27 KiB
C
946 lines
27 KiB
C
#include "client.h"
|
||
#include "system/includes.h"
|
||
/* #include "os/os_compat.h" */
|
||
#include "btstack/avctp_user.h"
|
||
#include "server/audio_server.h"
|
||
#include "server/server_core.h"
|
||
#include "syscfg/syscfg_id.h"
|
||
|
||
#ifdef CONFIG_WIFIBOX_ENABLE
|
||
|
||
#ifdef WB_CLIENT_DEBUG_ENABLE
|
||
#define log_info(x, ...) printf("[WB_PRC][INFO] " x " ", ## __VA_ARGS__)
|
||
#define log_err(x, ...) printf("[WB_PRC][ERR] " x " ", ## __VA_ARGS__)
|
||
#else
|
||
#define log_info(...)
|
||
#define log_err(...)
|
||
#endif
|
||
|
||
MODULE_VERSION_EXPORT(wb_client, WB_CLIENT_VERSION);
|
||
|
||
|
||
typedef struct {
|
||
u8 serial[16];
|
||
u32 conn_fail;
|
||
u32 conn_cnt;
|
||
u32 finish_cnt;
|
||
} stat_data_type;
|
||
|
||
static stat_data_type stat_data = {0};
|
||
|
||
typedef struct {
|
||
struct server *dec_server; //解码服务
|
||
u8 dec_status; //解码器运行标志位
|
||
u8 *data_buf; //音频数据buffer
|
||
cbuffer_t data_cbuf; //音频数据cycle buffer
|
||
u32 total_size; //音频文件总长度
|
||
u32 recv_size; //已接收音频数据长度
|
||
u32 play_size; //当前播放进度
|
||
u8 dec_ready_flag; //解码器就绪标志位
|
||
OS_SEM audio_sem;
|
||
int init_data_len;
|
||
int init_tmp_len;
|
||
u8 *init_read_ptr;
|
||
} audio_hdl_type;
|
||
|
||
static audio_hdl_type audio_hdl = {0};
|
||
|
||
static struct {
|
||
u8 xosc[2];
|
||
test_option_type test_option;
|
||
u8 dut_reset_flag;
|
||
u8 freq_adj_flag;
|
||
u8 bt_freq_stat_flag;
|
||
u8 test_pass_flag;
|
||
OS_SEM conn_sem;
|
||
OS_SEM freq_sem;
|
||
FSM_T thradj_fsm;
|
||
FSM_T test_fsm;
|
||
u8 senthr_adj_flag;
|
||
u8 *remote_mac;
|
||
wbcp_operations_interface_type *wbcp_ops;
|
||
} client = {0};
|
||
|
||
#define __this (&client)
|
||
|
||
int bt_fre_offset_get();
|
||
|
||
static void exit_fsm_process(void);
|
||
static void bt_freq_test_before(void);
|
||
static void bt_freq_test_after(void);
|
||
static int wifibox_bt_connect_pend(int timeout);
|
||
static s32 wifibox_bt_freq_finish_pend(int timeout);
|
||
static s8 open_audio_dec(void);
|
||
/* static u32 wifibox_read_stat_data(stat_data_type *data); */
|
||
/* static s32 wifibox_write_stat_data(stat_data_type *data); */
|
||
|
||
static s8 pwrthr_adj_event_handler(void *priv);
|
||
static s8 senthr_adj_event_handler(void *priv);
|
||
static void thradj_fsm_err(void *priv);
|
||
|
||
static s8 pwr_test_event_handler(void *priv);
|
||
static s8 sen_test_event_handler(void *priv);
|
||
static s8 freq_test_event_handler(void *priv);
|
||
static s8 finish_test_event_handler(void *priv);
|
||
static void test_fsm_err(void *priv);
|
||
void __attribute__((weak)) wifibox_result_deal(u8 res);
|
||
|
||
static FsmTable_T thradj_fsm_tal[] = {
|
||
{PWRTHR_ADJ_EVENT, PWRTHR_ADJ_STATUS, pwrthr_adj_event_handler, SENTHR_ADJ_STATUS, 0},
|
||
{SENTHR_ADJ_EVENT, SENTHR_ADJ_STATUS, senthr_adj_event_handler, PWRTHR_ADJ_STATUS, 0},
|
||
};
|
||
|
||
static FsmTable_T test_fsm_tal[] = {
|
||
{PWR_TEST_EVENT, PWR_TEST_STATUS, pwr_test_event_handler, SEN_TEST_STATUS, 0},
|
||
{SEN_TEST_EVENT, SEN_TEST_STATUS, sen_test_event_handler, FREQ_TEST_STATUS, 0},
|
||
/* {FREQ_TEST_EVENT, FREQ_TEST_STATUS, freq_test_event_handler, PWR_TEST_STATUS, 0}, */
|
||
{FREQ_TEST_EVENT, FREQ_TEST_STATUS, freq_test_event_handler, FINISH_TEST_STATUS, 0},
|
||
{FINISH_TEST_EVENT, FINISH_TEST_STATUS, finish_test_event_handler, PWR_TEST_STATUS, 0},
|
||
};
|
||
|
||
|
||
static void fsm_tbl_init(void *priv)
|
||
{
|
||
wbcp_conn_params_type *conn_params = (wbcp_conn_params_type *)priv;
|
||
fsm_timeout_type *fsm_timeout = &conn_params->fsm_timeout;
|
||
test_option_type *test_option = &conn_params->test_option;
|
||
FsmTable_T fsm_tal[4] = {0};
|
||
static FsmTable_T init_fsm_tal[4] = {0};
|
||
u8 idx = 0;
|
||
static u8 init = 0;
|
||
|
||
if (!init) {
|
||
init = 1;
|
||
memcpy(&init_fsm_tal, &test_fsm_tal, sizeof(test_fsm_tal));
|
||
} else {
|
||
memcpy(&test_fsm_tal, &init_fsm_tal, sizeof(test_fsm_tal));
|
||
}
|
||
|
||
__this->dut_reset_flag = conn_params->dut_reset_flag;
|
||
__this->freq_adj_flag = conn_params->freq_adj_flag;
|
||
memcpy(&__this->test_option, test_option, sizeof(test_option_type));
|
||
|
||
thradj_fsm_tal[0].timeout = fsm_timeout->thradj_fsm[0];
|
||
thradj_fsm_tal[1].timeout = fsm_timeout->thradj_fsm[1];
|
||
|
||
for (u8 i = 0; i < ARRAY_SIZE(fsm_timeout->test_fsm); i++) {
|
||
test_fsm_tal[i].timeout = fsm_timeout->test_fsm[i];
|
||
}
|
||
|
||
if (__this->test_option.wifi_pwr_option) {
|
||
memcpy(&fsm_tal[idx], &test_fsm_tal[0], sizeof(FsmTable_T));
|
||
idx++;
|
||
}
|
||
|
||
if (__this->test_option.wifi_sen_option || __this->test_option.wifi_rx_rate_option) {
|
||
memcpy(&fsm_tal[idx], &test_fsm_tal[1], sizeof(FsmTable_T));
|
||
if (!__this->test_option.wifi_pwr_option) {
|
||
test_fsm_tal[ARRAY_SIZE(test_fsm_tal) - 1].NextState = test_fsm_tal[1].CurState;
|
||
}
|
||
idx++;
|
||
} else {
|
||
if (__this->test_option.wifi_pwr_option) {
|
||
fsm_tal[0].NextState = test_fsm_tal[1].NextState;
|
||
} else {
|
||
test_fsm_tal[ARRAY_SIZE(test_fsm_tal) - 1].NextState = test_fsm_tal[ARRAY_SIZE(test_fsm_tal) - 2].CurState;
|
||
}
|
||
}
|
||
memcpy(&fsm_tal[idx], &test_fsm_tal[2], sizeof(FsmTable_T) * 2);
|
||
memcpy(test_fsm_tal, fsm_tal, sizeof(test_fsm_tal));
|
||
|
||
FSM_Init(&__this->test_fsm, test_fsm_tal, idx + 2, test_fsm_tal[0].CurState, test_fsm_err);
|
||
}
|
||
|
||
|
||
static s8 pwrthr_adj_event_handler(void *priv)
|
||
{
|
||
log_info("==================== STATUS : PWRTHR_ADJ_STATUS ====================\n\n");
|
||
if (__this->wbcp_ops->start_send_test_data(__this->remote_mac, PWRTHR_SEND_TEST_DATA_PERIOD, 0) == 0) {
|
||
return FSM_NEXT_STATE;
|
||
}
|
||
return FSM_ERR;
|
||
}
|
||
|
||
|
||
static s8 senthr_adj_event_handler(void *priv)
|
||
{
|
||
log_info("==================== STATUS : SENTHR_ADJ_STATUS ====================\n\n");
|
||
stat_res_type *res = NULL;
|
||
event_data_type new_event = {0};
|
||
event_data_type *event_data = (event_data_type *)priv;
|
||
senthr_adj_event_params_type *params = &event_data->params.senthr_adj_event_params;
|
||
|
||
if (!__this->senthr_adj_flag) {
|
||
__this->senthr_adj_flag = 1;
|
||
__this->wbcp_ops->stop_send_test_data();
|
||
|
||
new_event.event = SENTHR_ADJ_EVENT;
|
||
if (__this->wbcp_ops->send_event_data(&new_event, __this->remote_mac, 1) != 0) {
|
||
log_err("SEND_FAIL : SENTHR_ADJ_EVENT");
|
||
goto _exit_;
|
||
}
|
||
return FSM_KEEP_STATE;
|
||
}
|
||
|
||
switch (params->stat) {
|
||
case 1 :
|
||
log_info("SENTHR_STEP : OPEN STAT");
|
||
__this->wbcp_ops->start_stat_prop(0, 0);
|
||
return FSM_KEEP_STATE;
|
||
|
||
case 2 :
|
||
res = __this->wbcp_ops->stop_stat_prop();
|
||
log_info("SENTHR_STEP : SEND RES, pcnt = %d, sen = %d.", res->pcnt, res->pwr);
|
||
new_event.event = SENTHR_ADJ_EVENT;
|
||
new_event.params.senthr_adj_event_params.pcnt = res->pcnt;
|
||
new_event.params.senthr_adj_event_params.sen = res->pwr;
|
||
if (__this->wbcp_ops->send_event_data(&new_event, __this->remote_mac, 1) != 0) {
|
||
log_err("SEND_FAIL : SENTHR_ADJ_EVENT");
|
||
goto _exit_;
|
||
}
|
||
return FSM_KEEP_STATE;
|
||
|
||
case 3 :
|
||
log_info("SENTHR_STEP : FINISH ADJUST");
|
||
cpu_reset();
|
||
/* return FSM_NEXT_STATE; */
|
||
|
||
default :
|
||
break;
|
||
}
|
||
|
||
_exit_:
|
||
__this->senthr_adj_flag = 0;
|
||
return FSM_ERR;
|
||
}
|
||
|
||
|
||
static void thradj_fsm_err(void *priv)
|
||
{
|
||
log_info("============================== THR_ADJ_FSM ERR =============================\n\n");
|
||
cpu_reset();
|
||
}
|
||
|
||
|
||
static s8 pwr_test_event_handler(void *priv)
|
||
{
|
||
log_info("==================== STATUS : PWR_TEST_STATUS =====================\n\n");
|
||
if (__this->wbcp_ops->start_send_test_data(__this->remote_mac, PWRTEST_SEND_TEST_DATA_PERIOD, 0) == 0) {
|
||
return FSM_NEXT_STATE;
|
||
}
|
||
return FSM_ERR;
|
||
}
|
||
|
||
|
||
static s8 sen_test_event_handler(void *priv)
|
||
{
|
||
log_info("==================== STATUS : SEN_TEST_STATUS =====================\n\n");
|
||
|
||
__this->wbcp_ops->stop_send_test_data();
|
||
__this->wbcp_ops->start_stat_prop(0, 0);
|
||
|
||
return FSM_NEXT_STATE;
|
||
}
|
||
|
||
|
||
static s8 freq_test_event_handler(void *priv)
|
||
{
|
||
log_info("==================== STATUS : FREQ_TEST_STATUS ====================\n\n");
|
||
|
||
event_data_type *event = (event_data_type *)priv;
|
||
freq_test_event_params_type *params = &event->params.freq_test_event_params;
|
||
event_data_type new_event = {0};
|
||
freq_test_event_params_type *new_params = &new_event.params.freq_test_event_params;
|
||
stat_res_type *res = NULL;
|
||
const u8 *bt_mac = NULL;
|
||
|
||
if (__this->test_option.wifi_pwr_option) {
|
||
__this->wbcp_ops->stop_send_test_data();
|
||
}
|
||
|
||
if (__this->test_option.wifi_sen_option || __this->test_option.wifi_rx_rate_option) {
|
||
res = __this->wbcp_ops->stop_stat_prop();
|
||
new_params->pcnt = res->pcnt;
|
||
new_params->sen = res->pwr;
|
||
log_info("SEN_RES : pcnt = %d, sen = %d.", res->pcnt, res->pwr);
|
||
}
|
||
|
||
if (__this->test_option.wifi_freq_option) {
|
||
const u8 *bt_get_mac_addr();
|
||
bt_mac = bt_get_mac_addr();
|
||
if (bt_mac == NULL) {
|
||
return FSM_ERR;
|
||
}
|
||
put_buf(bt_mac, MAC_ADDR_SIZE);
|
||
memcpy(&new_params->bt_mac, bt_mac, MAC_ADDR_SIZE);
|
||
}
|
||
|
||
new_event.event = FREQ_TEST_EVENT;
|
||
if (__this->wbcp_ops->send_event_data(&new_event, __this->remote_mac, 1) != 0) {
|
||
log_err("SEND_FAIL : FREQ_TEST_EVENT.");
|
||
return FSM_ERR;
|
||
}
|
||
|
||
if (__this->test_option.wifi_freq_option) {
|
||
/* wifi_off(); */
|
||
bt_freq_test_before();
|
||
/* if (wifibox_bt_connect_pend(BT_FREQ_CONN_TIMEOUT) != OS_NO_ERR) { */
|
||
/* log_err("BT CONN TIMEOUT.\n"); */
|
||
/* return FSM_ERR; */
|
||
/* } */
|
||
|
||
if (wifibox_bt_freq_finish_pend(BT_FREQ_STAT_TIMEOUT) != OS_NO_ERR) {
|
||
log_err("BT FREQ TEST TIMEOUT.\n");
|
||
return FSM_ERR;
|
||
}
|
||
bt_freq_test_after();
|
||
}
|
||
|
||
/* exit_fsm_process(); */
|
||
return FSM_NEXT_STATE;
|
||
}
|
||
|
||
|
||
static s8 finish_test_event_handler(void *priv)
|
||
{
|
||
log_info("=================== STATUS : FINISH_TEST_STATUS ===================\n\n");
|
||
|
||
s32 err = 0;
|
||
wifi_freq_offset_type wifi_offset = {0};
|
||
event_data_type *event = (event_data_type *)priv;
|
||
finish_test_event_params_type *params = &event->params.finish_test_event_params;
|
||
event_data_type new_event = {0};
|
||
|
||
wifibox_result_deal(params->result);
|
||
|
||
if (__this->freq_adj_flag) {
|
||
wifi_offset.offset = bt_fre_offset_get();
|
||
if (wifi_offset.offset < FREQ_ADJUST_LIMIT && \
|
||
wifi_offset.offset > -FREQ_ADJUST_LIMIT) {
|
||
wifi_get_xosc(wifi_offset.xosc);
|
||
wifi_offset.crc = CRC16(&wifi_offset.offset, sizeof(wifi_freq_offset_type) - sizeof(s16));
|
||
err = syscfg_write(CFG_WIFI_FRE_OFFSET, &wifi_offset, sizeof(wifi_freq_offset_type));
|
||
if (err == sizeof(wifi_freq_offset_type)) {
|
||
log_info("syscfg_write : fre = %d, osc = %d/%d\n", wifi_offset.offset, wifi_offset.xosc[0], wifi_offset.xosc[1]);
|
||
} else {
|
||
log_err("syscfg_write : err = %d\n", err);
|
||
}
|
||
} else {
|
||
log_info("freq = %d, out of FREQ_ADJUST_LIMIT\n", wifi_offset.offset);
|
||
}
|
||
}
|
||
|
||
#ifdef AUDIO_TRANSFER_ENABLE
|
||
if (!params->result) {
|
||
os_sem_set(&audio_hdl.audio_sem, 0);
|
||
if (os_sem_pend(&audio_hdl.audio_sem, AUDIO_RECV_TIMEOUT) != OS_NO_ERR) {
|
||
log_err("AUDIO RECV ERR");
|
||
return FSM_ERR;
|
||
}
|
||
log_info("AUDIO RECV COMPLETE");
|
||
__this->test_pass_flag = 1;
|
||
open_audio_dec();
|
||
}
|
||
#endif
|
||
stat_data.finish_cnt++;
|
||
os_time_dly(WBCP_WAIT_ACK_TIMEOUT);
|
||
exit_fsm_process();
|
||
return FSM_NEXT_STATE;
|
||
}
|
||
|
||
|
||
static void test_fsm_err(void *priv)
|
||
{
|
||
log_info("============================== FSM ERR =============================\n\n");
|
||
|
||
FSM_StateTransfer(&__this->test_fsm, __this->test_fsm.FsmTable[0].CurState);
|
||
exit_fsm_process();
|
||
}
|
||
|
||
|
||
static void exit_fsm_process(void)
|
||
{
|
||
log_info("======================== EXIT FSM PROCESS =========================\n\n");
|
||
/* wifibox_write_stat_data(&stat_data); */
|
||
if (__this->test_pass_flag) {
|
||
__this->wbcp_ops->rx_shield();
|
||
} else {
|
||
#ifdef WB_DUT_RESET_ENABLE
|
||
/* if (__this->dut_reset_flag) { */
|
||
cpu_reset();
|
||
/* } */
|
||
#endif
|
||
}
|
||
__this->senthr_adj_flag = 0;
|
||
__this->wbcp_ops->stop_send_test_data();
|
||
__this->wbcp_ops->stop_stat_prop();
|
||
bt_freq_test_after();
|
||
|
||
/* if (!wifi_is_on()) { */
|
||
/* wifi_on(); */
|
||
/* while (!wifi_is_on()); */
|
||
/* } */
|
||
__this->wbcp_ops->break_conn();
|
||
}
|
||
|
||
|
||
static void wbcp_event_handler(event_data_type *event_data)
|
||
{
|
||
switch (event_data->event) {
|
||
case PWRTHR_ADJ_EVENT :
|
||
case SENTHR_ADJ_EVENT :
|
||
case FINISH_ADJ_EVENT :
|
||
FSM_EventHandle(&__this->thradj_fsm, event_data->event, event_data);
|
||
break;
|
||
|
||
case PWR_TEST_EVENT :
|
||
case SEN_TEST_EVENT :
|
||
case FREQ_TEST_EVENT :
|
||
case FINISH_TEST_EVENT :
|
||
FSM_EventHandle(&__this->test_fsm, event_data->event, event_data);
|
||
break;
|
||
|
||
default :
|
||
break;
|
||
}
|
||
}
|
||
|
||
|
||
static void wbcp_event_handle_task(void *priv)
|
||
{
|
||
s32 msg[32] = {0}, timer_id = 0;
|
||
event_data_type *event_data = NULL;
|
||
|
||
for (;;) {
|
||
if (os_taskq_pend(NULL, msg, ARRAY_SIZE(msg)) != OS_TASKQ) {
|
||
continue;
|
||
}
|
||
|
||
if (__this->test_pass_flag) {
|
||
continue;
|
||
}
|
||
|
||
switch (msg[0]) {
|
||
case ENTER_TEST_SUCC_MSG:
|
||
log_info("ENTER_TEST_SUCC_MSG");
|
||
__this->remote_mac = (u8 *)msg[1];
|
||
log_info("======================= ENTER TEST_MODE SUCC =======================\n\n");
|
||
put_buf(__this->remote_mac, MAC_ADDR_SIZE);
|
||
stat_data.conn_cnt++;
|
||
timer_id = sys_timeout_add(NULL, exit_fsm_process, RECV_EVENT_TIMEOUT);
|
||
fsm_tbl_init((u8 *)msg[2]);
|
||
break;
|
||
|
||
case ENTER_TEST_FAIL_MSG :
|
||
log_info("ENTER_TEST_FAIL_MSG");
|
||
log_info("======================= ENTER TEST_MODE FAIL=======================\n\n");
|
||
stat_data.conn_fail++;
|
||
/* wifibox_write_stat_data(&stat_data); */
|
||
#ifdef WB_DUT_RESET_ENABLE
|
||
/* if (msg[1]) { */
|
||
cpu_reset();
|
||
/* } */
|
||
#endif
|
||
__this->wbcp_ops->break_conn();
|
||
break;
|
||
|
||
case NEW_EVENT_MSG:
|
||
event_data = (event_data_type *)&msg[1];
|
||
log_info("NEW_EVENT_MSG : %d.\n", event_data->event);
|
||
if (timer_id && (event_data->event == test_fsm_tal[0].event || event_data->event == thradj_fsm_tal[0].event)) {
|
||
sys_timeout_del(timer_id);
|
||
timer_id = 0;
|
||
}
|
||
wbcp_event_handler(event_data);
|
||
break;
|
||
|
||
default :
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
static void wbcp_audio_data_handler(void *priv)
|
||
{
|
||
u32 wlen = 0, rlen = 0, temp_len = 0;
|
||
audio_data_type *audio_data = (audio_data_type *)priv;
|
||
|
||
audio_hdl.total_size = audio_data->total_size;
|
||
temp_len = audio_hdl.total_size - audio_hdl.recv_size;
|
||
rlen = (temp_len < AUDIO_DATA_SIZE) ? temp_len : AUDIO_DATA_SIZE;
|
||
|
||
wlen = cbuf_write(&audio_hdl.data_cbuf, audio_data->data, rlen);
|
||
if (wlen) {
|
||
putchar('(');
|
||
audio_hdl.recv_size += wlen;
|
||
log_info("AUDIO_RECV : %d / %d\n", audio_hdl.recv_size, audio_hdl.total_size);
|
||
|
||
//音频下载成功，打开解码器，开始播放
|
||
if (audio_hdl.recv_size >= audio_hdl.total_size && audio_hdl.dec_status == 0) {
|
||
os_sem_post(&audio_hdl.audio_sem);
|
||
//保存cycle buffer初始参数，用于循环播放音频
|
||
audio_hdl.init_data_len = audio_hdl.data_cbuf.data_len;
|
||
audio_hdl.init_tmp_len = audio_hdl.data_cbuf.tmp_len;
|
||
audio_hdl.init_read_ptr = audio_hdl.data_cbuf.read_ptr;
|
||
audio_hdl.dec_status = 1;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
static int audio_vfs_fread(void *priv, void *data, u32 len)
|
||
{
|
||
audio_hdl_type *hdl = (audio_hdl_type *)priv;
|
||
u32 rlen = 0;
|
||
|
||
if (hdl->dec_ready_flag) {
|
||
if (hdl->total_size - hdl->play_size < 512) {
|
||
len = hdl->total_size - hdl->play_size;
|
||
}
|
||
|
||
rlen = cbuf_read(&hdl->data_cbuf, data, len);
|
||
if (rlen) {
|
||
putchar(')');
|
||
hdl->play_size += rlen;
|
||
log_info("AUDIO_PLAY : %d / %d\n", hdl->play_size, hdl->total_size);
|
||
|
||
if (hdl->play_size >= hdl->total_size) {
|
||
hdl->dec_ready_flag = 0;
|
||
log_info("AUDIO_PLAY_COMPLETE\n");
|
||
}
|
||
}
|
||
}
|
||
|
||
return ((hdl->play_size >= hdl->total_size) ? 0 : len);
|
||
}
|
||
|
||
|
||
static int audio_vfs_flen(void *priv)
|
||
{
|
||
audio_hdl_type *hdl = (audio_hdl_type *)priv;
|
||
return hdl->total_size;
|
||
}
|
||
|
||
|
||
static int audio_vfs_seek(void *priv, u32 offset, int orig)
|
||
{
|
||
audio_hdl_type *hdl = (audio_hdl_type *)priv;
|
||
|
||
if (offset > 0) {
|
||
hdl->dec_ready_flag = 1; //解码器开始偏移数据后，再开始播放，避免音频播放开端吞字
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
|
||
static const struct audio_vfs_ops audio_vfs_ops = {
|
||
.fread = audio_vfs_fread,
|
||
.flen = audio_vfs_flen,
|
||
.fseek = audio_vfs_seek,
|
||
};
|
||
|
||
|
||
static s8 open_audio_dec(void)
|
||
{
|
||
union audio_req req = {0};
|
||
|
||
req.dec.cmd = AUDIO_DEC_OPEN;
|
||
req.dec.volume = 100;
|
||
req.dec.output_buf = NULL;
|
||
req.dec.output_buf_len = 12 * 1024;
|
||
req.dec.channel = 0;
|
||
req.dec.sample_rate = 0;
|
||
req.dec.priority = 1;
|
||
req.dec.vfs_ops = &audio_vfs_ops;
|
||
req.dec.file = (FILE *)&audio_hdl;
|
||
req.dec.dec_type = "mp3";
|
||
req.dec.sample_source = "dac";
|
||
|
||
//打开解码器
|
||
if (server_request(audio_hdl.dec_server, AUDIO_REQ_DEC, &req) != 0) {
|
||
return -1;
|
||
}
|
||
|
||
//开始解码
|
||
req.dec.cmd = AUDIO_DEC_START;
|
||
if (server_request(audio_hdl.dec_server, AUDIO_REQ_DEC, &req) != 0) {
|
||
return -1;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
|
||
static int close_audio_dec(void)
|
||
{
|
||
union audio_req req = {0};
|
||
|
||
req.dec.cmd = AUDIO_DEC_STOP;
|
||
if (audio_hdl.dec_server) {
|
||
|
||
//关闭解码器
|
||
log_info("stop dec.\n");
|
||
server_request(audio_hdl.dec_server, AUDIO_REQ_DEC, &req);
|
||
|
||
//关闭解码服务
|
||
/* log_info("close audio_server.\n"); */
|
||
/* server_close(audio_hdl.dec_server); */
|
||
/* audio_hdl.dec_server = NULL; */
|
||
|
||
audio_hdl.dec_status = 0;
|
||
audio_hdl.recv_size = 0;
|
||
audio_hdl.play_size = 0;
|
||
|
||
//循环播放音频, 恢复cycle buffer读指针
|
||
audio_hdl.data_cbuf.data_len = audio_hdl.init_data_len;
|
||
audio_hdl.data_cbuf.tmp_len = audio_hdl.init_tmp_len;
|
||
audio_hdl.data_cbuf.read_ptr = audio_hdl.init_read_ptr;
|
||
open_audio_dec();
|
||
|
||
//单次播放音频，清除cycle buffer
|
||
/* cbuf_clear(&audio_hdl.data_cbuf); */
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
|
||
static void dec_server_event_handler(void *priv, int argc, int *argv)
|
||
{
|
||
audio_hdl_type *hdl = (audio_hdl_type *)priv;
|
||
|
||
switch (argv[0]) {
|
||
case AUDIO_SERVER_EVENT_ERR:
|
||
log_info("AUDIO_SERVER_EVENT_ERR\n");
|
||
break;
|
||
|
||
case AUDIO_SERVER_EVENT_END:
|
||
log_info("AUDIO_SERVER_EVENT_END\n");
|
||
close_audio_dec();
|
||
break;
|
||
|
||
case AUDIO_SERVER_EVENT_CURR_TIME:
|
||
log_info("AUDIO_PLAY_TIME : %d\n", argv[1]);
|
||
break;
|
||
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
static s8 audio_play_init(void)
|
||
{
|
||
audio_hdl.data_buf = (char *)calloc(1, AUDIO_BUFFER_SIZE);
|
||
if (audio_hdl.data_buf == NULL) {
|
||
log_err("audio buffer malloc error.\n");
|
||
return -1;
|
||
}
|
||
|
||
cbuf_init(&audio_hdl.data_cbuf, audio_hdl.data_buf, AUDIO_BUFFER_SIZE);
|
||
|
||
audio_hdl.dec_server = server_open("audio_server", "dec");
|
||
if (!audio_hdl.dec_server) {
|
||
log_err("audio server open fail.\n");
|
||
return -1;
|
||
} else {
|
||
log_info("open success");
|
||
}
|
||
|
||
server_register_event_handler(audio_hdl.dec_server, &audio_hdl, dec_server_event_handler);
|
||
|
||
return 0;
|
||
}
|
||
|
||
|
||
int wifibox_client_init(void)
|
||
{
|
||
static u8 init = 0;
|
||
|
||
#ifdef WB_ASSIST_ENABLE
|
||
u8 is_assist = 1;
|
||
#else
|
||
u8 is_assist = 0;
|
||
#endif
|
||
|
||
if (init) {
|
||
log_info("wifibox_client already init");
|
||
return 0;
|
||
}
|
||
|
||
FSM_Init(&__this->thradj_fsm, thradj_fsm_tal, ARRAY_SIZE(thradj_fsm_tal), PWRTHR_ADJ_STATUS, thradj_fsm_err);
|
||
/* FSM_Init(&__this->test_fsm, test_fsm_tal, ARRAY_SIZE(test_fsm_tal), PWR_TEST_STATUS, test_fsm_err); */
|
||
|
||
get_wbcp_operations_interface(&__this->wbcp_ops);
|
||
if (__this->wbcp_ops->init(WB_CLIENT_MODE, is_assist) != 0) {
|
||
log_err("wbcp init fail.\n");
|
||
}
|
||
|
||
os_sem_create(&__this->conn_sem, 0);
|
||
os_sem_create(&__this->freq_sem, 0);
|
||
os_sem_create(&audio_hdl.audio_sem, 0);
|
||
|
||
if (thread_fork("wbcp_event_handle_task", 14, 3 * 1024, 1024, NULL, wbcp_event_handle_task, NULL) != OS_NO_ERR) {
|
||
log_err("%s thread fork fail\n", __FILE__);
|
||
return -1;
|
||
}
|
||
|
||
#ifdef AUDIO_TRANSFER_ENABLE
|
||
audio_play_init();
|
||
__this->wbcp_ops->regist_audio_data_user_handler(wbcp_audio_data_handler);
|
||
#endif
|
||
|
||
__this->wbcp_ops->regist_usr_handler("wbcp_event_handle_task");
|
||
|
||
/* if (wifibox_read_stat_data(&stat_data) == 0) { */
|
||
/* stat_data.finish_cnt = 0; */
|
||
/* stat_data.conn_cnt = 0; */
|
||
/* stat_data.conn_fail = 0; */
|
||
/* } */
|
||
log_info("STAT_CNT : %d / %d, %d", stat_data.finish_cnt, stat_data.conn_cnt, stat_data.conn_fail);
|
||
|
||
init = 1;
|
||
|
||
return 0;
|
||
}
|
||
|
||
|
||
u32 user_send_cmd_prepare(USER_CMD_TYPE cmd, u16 param_len, u8 *param);
|
||
static void bt_freq_test_before(void)
|
||
{
|
||
if (__this->bt_freq_stat_flag == 0) {
|
||
log_info("bt_freq_test_before.\n");
|
||
__this->bt_freq_stat_flag = 1;
|
||
|
||
user_send_cmd_prepare(USER_CTRL_WRITE_SCAN_ENABLE, 0, NULL);
|
||
user_send_cmd_prepare(USER_CTRL_WRITE_CONN_ENABLE, 0, NULL);
|
||
user_send_cmd_prepare(USER_CTRL_POWER_ON, 0, NULL);
|
||
}
|
||
}
|
||
|
||
|
||
static void bt_freq_test_after(void)
|
||
{
|
||
if (__this->bt_freq_stat_flag) {
|
||
log_info("bt_freq_test_after.\n");
|
||
__this->bt_freq_stat_flag = 0;
|
||
|
||
user_send_cmd_prepare(USER_CTRL_WRITE_SCAN_DISABLE, 0, NULL);
|
||
user_send_cmd_prepare(USER_CTRL_WRITE_CONN_DISABLE, 0, NULL);
|
||
user_send_cmd_prepare(USER_CTRL_PAGE_CANCEL, 0, NULL);
|
||
user_send_cmd_prepare(USER_CTRL_CONNECTION_CANCEL, 0, NULL);
|
||
user_send_cmd_prepare(USER_CTRL_POWER_OFF, 0, NULL);
|
||
}
|
||
}
|
||
|
||
|
||
int wifibox_bt_connect_post(void)
|
||
{
|
||
log_info("wifibox_bt_connect_post\n");
|
||
return os_sem_post(&__this->conn_sem);
|
||
}
|
||
|
||
|
||
static int wifibox_bt_connect_pend(int timeout)
|
||
{
|
||
log_info("wifibox_bt_connect_pend\n");
|
||
os_sem_set(&__this->conn_sem, 0);
|
||
return os_sem_pend(&__this->conn_sem, timeout);
|
||
}
|
||
|
||
|
||
int wifibox_bt_freq_finish_post(void)
|
||
{
|
||
log_info("wifibox_bt_freq_finish_post\n");
|
||
return os_sem_post(&__this->freq_sem);
|
||
}
|
||
|
||
|
||
static s32 wifibox_bt_freq_finish_pend(int timeout)
|
||
{
|
||
log_info("wifibox_bt_freq_finish_pend\n");
|
||
int ret = -1;
|
||
os_sem_set(&__this->freq_sem, 0);
|
||
ret = os_sem_pend(&__this->freq_sem, timeout);
|
||
log_info("bt_freq test finish.\n");
|
||
return ret;
|
||
}
|
||
|
||
|
||
void __attribute__((weak)) wifibox_result_deal(u8 res)
|
||
{
|
||
//测试结果处理回调，可添加非阻塞操作
|
||
if (!res) {
|
||
log_info("wifibox test pass");
|
||
} else {
|
||
log_info("wifibox test nopass");
|
||
}
|
||
}
|
||
|
||
|
||
static void wifi_set_xosc(u8 *xosc)
|
||
{
|
||
memcpy(__this->xosc, xosc, sizeof(__this->xosc));
|
||
}
|
||
|
||
|
||
static void fre_to_xosc(s8 fre, u8 *cur_osc, u8 *cal_osc)
|
||
{
|
||
u8 tmp = 0;
|
||
tmp = (((1000000 * (cur_osc[0] + cur_osc[1])) + (195863 * fre) - (466 * fre * fre)) / 1000000);
|
||
cal_osc[0] = tmp / 2;
|
||
cal_osc[1] = (tmp / 2) + ((tmp % 2) ? 1 : 0);
|
||
printf("tmp = %d, %d/%d\n", tmp, cal_osc[0], cal_osc[1]);
|
||
}
|
||
|
||
|
||
void __attribute__((weak)) wf_rf_pll_offset_adj(long foffet_khz, char en)
|
||
{
|
||
|
||
}
|
||
|
||
|
||
u8 wifi_freq_adjust(void)
|
||
{
|
||
u16 crc = 0;
|
||
s32 ret = 0;
|
||
u8 cal_xosc[2] = {0};
|
||
wifi_freq_offset_type wifi_offset = {0};
|
||
|
||
ret = syscfg_read(CFG_WIFI_FRE_OFFSET, &wifi_offset, sizeof(wifi_freq_offset_type));
|
||
crc = CRC16(&wifi_offset.offset, sizeof(wifi_freq_offset_type) - sizeof(s16));
|
||
if (ret == sizeof(wifi_freq_offset_type) && crc == wifi_offset.crc) {
|
||
log_info("^^^syscfg_read : fre = %d, osc = %d/%d\n", wifi_offset.offset, wifi_offset.xosc[0], wifi_offset.xosc[1]);
|
||
if (wifi_offset.offset) {
|
||
wf_rf_pll_offset_adj(-wifi_offset.offset, 0);
|
||
/* fre_to_xosc(wifi_offset.offset, wifi_offset.xosc, cal_xosc); */
|
||
/* wifi_set_xosc(cal_xosc); */
|
||
}
|
||
return 0;
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
|
||
/* =============================================调试使用======================================== */
|
||
#if 0
|
||
|
||
#include "json_c/json_tokener.h"
|
||
#include "fs/fs.h"
|
||
#include "math.h"
|
||
#include <stdlib.h>
|
||
/* #include "hmc1122_attenuator.h" */
|
||
|
||
u8 dut_pa[7] = {0};
|
||
int dut_xosc_cls = 0;
|
||
int dut_xosc_crs = 0;
|
||
int dut_tx_attn = 0;
|
||
int dut_rx_attn = 0;
|
||
|
||
|
||
void wifi_get_xosc(u8 *xosc)
|
||
{
|
||
memcpy(xosc, __this->xosc, sizeof(__this->xosc));
|
||
}
|
||
|
||
|
||
static int wifibox_dut_read_config_info(void)
|
||
{
|
||
FILE *fd;
|
||
char *buf = NULL;
|
||
json_object *new_obj;
|
||
u32 cfg_pa = 0;
|
||
char *DUT_PA = NULL;
|
||
char *DUT_XOSC_CLS = NULL;
|
||
char *DUT_XOSC_CRS = NULL;
|
||
char *TX_ATTN = NULL;
|
||
char *RX_ATTN = NULL;
|
||
|
||
buf = malloc(1024 * 1);
|
||
if (!buf) {
|
||
log_err("malloc error: %d.\n", __LINE__);
|
||
}
|
||
|
||
fd = fopen("mnt/sdfile/res/cfg/dut_config.txt", "r");
|
||
if (!fd) {
|
||
log_err("wifibox config : open file error.\n");
|
||
return -1;
|
||
}
|
||
|
||
fread(buf, 1024, 1, fd);
|
||
fclose(fd);
|
||
|
||
new_obj = json_tokener_parse((const char *)buf);
|
||
if (!new_obj) {
|
||
log_err("wifibox config : json_tokener_parse error.\n");
|
||
return -1;
|
||
}
|
||
|
||
DUT_PA = json_object_get_string(json_object_object_get(new_obj, "PA"));
|
||
DUT_XOSC_CLS = json_object_get_string(json_object_object_get(new_obj, "XOSC_CLS"));
|
||
DUT_XOSC_CRS = json_object_get_string(json_object_object_get(new_obj, "XOSC_CRS"));
|
||
TX_ATTN = json_object_get_string(json_object_object_get(new_obj, "TX_ATTN"));
|
||
RX_ATTN = json_object_get_string(json_object_object_get(new_obj, "RX_ATTN"));
|
||
|
||
cfg_pa = atoi(DUT_PA);
|
||
for (int i = 0; i < ARRAY_SIZE(dut_pa); i++) {
|
||
dut_pa[i] = cfg_pa / ((int)pow(10, ARRAY_SIZE(dut_pa) - 1 - i)) % 10;
|
||
}
|
||
|
||
dut_xosc_cls = atoi(DUT_XOSC_CLS);
|
||
dut_xosc_crs = atoi(DUT_XOSC_CRS);
|
||
dut_tx_attn = atoi(TX_ATTN);
|
||
dut_rx_attn = atoi(RX_ATTN);
|
||
|
||
__this->xosc[0] = dut_xosc_cls;
|
||
__this->xosc[1] = dut_xosc_crs;
|
||
|
||
log_info("=====================DUT_CFG_INFO=====================");
|
||
put_buf(dut_pa, sizeof(dut_pa));
|
||
log_info("dut_xosc_cls = %d, dut_xosc_crs = %d.\n", dut_xosc_cls, dut_xosc_crs);
|
||
log_info("dut_tx_attn = %d, dut_rx_attn = %d.\n", dut_tx_attn, dut_rx_attn);
|
||
log_info("=====================DUT_CFG_INFO=====================");
|
||
|
||
json_object_put(new_obj);
|
||
|
||
if (buf) {
|
||
free(buf);
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
|
||
void wifibox_dut_config(void)
|
||
{
|
||
if (wifibox_dut_read_config_info() == 0) {
|
||
log_info("DUT SET : PA = %d,%d,%d,%d,%d,%d,%d; XOSC_L = %d, XSOC_R = %d.\n", dut_pa[0], dut_pa[1], dut_pa[2], dut_pa[3], dut_pa[4], dut_pa[5], dut_pa[6], dut_xosc_cls, dut_xosc_crs);
|
||
//衰减器初始化
|
||
/* struct attenuator_operation_t *attn_hdl = NULL; */
|
||
/* get_attn_hdl(&attn_hdl); */
|
||
/* if (attn_hdl) { */
|
||
/* attn_hdl->init(); */
|
||
/* attn_hdl->set_tx_state(dut_tx_attn); */
|
||
/* attn_hdl->set_rx_state(dut_rx_attn); */
|
||
/* } */
|
||
} else {
|
||
log_err("wifibox_dut_config fail.\n");
|
||
}
|
||
}
|
||
|
||
|
||
int wifi_get_pa_trim_data(u8 *pa_data)
|
||
{
|
||
memcpy(pa_data, dut_pa, 7);
|
||
return 1;//不使用自动tune
|
||
}
|
||
|
||
|
||
#endif
|
||
|
||
#endif
|
||
|
||
|
||
|
||
|