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

cun

Browse Source
This commit is contained in:
lmx
2025-10-30 17:53:59 +08:00
parent a6919c7e43
commit 1d0eaa037b
174 changed files with 196655 additions and 223635 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
apps/earphone/app_main.c
View File

@ -236,8 +236,13 @@ static void app_poweron_check(int update)
}
extern u32 timer_get_ms(void);
void app_main()
{
void xtell_app_main();
xtell_app_main();
#if 0
int update = 0;
u32 addr = 0, size = 0;
struct intent it;
@ -316,8 +321,10 @@ void app_main()
xtell_main();
#endif
}
int __attribute__((weak)) eSystemConfirmStopStatus(void)
{
/* 系统进入在未来时间里，无任务超时唤醒，可根据用户选择系统停止，或者系统定时唤醒(100ms)，或自己指定唤醒时间 */

32
apps/earphone/earphone.c
View File

@ -133,13 +133,14 @@ void __set_sbc_cap_bitpool(u8 sbc_cap_bitpoola);
static u16 power_mode_timer = 0;
u8 init_ok = 0;
u8 get_bt_init_status(void)
{
return init_ok;
}
static u8 sniff_out = 0;
u8 sniff_out = 0;
u8 get_sniff_out_status()
{
return sniff_out;
@ -149,6 +150,7 @@ void clear_sniff_out_status()
sniff_out = 0;
}
void earphone_change_pwr_mode(int mode, int msec)
{
#if TCFG_POWER_MODE_QUIET_ENABLE
@ -2236,7 +2238,7 @@ static void bt_vendor_meta_event_handle(u8 sub_evt, u8 *arg, u8 len)
extern void set_remote_test_flag(u8 own_remote_test);
static int bt_hci_event_handler(struct bt_event *bt)
int bt_hci_event_handler(struct bt_event *bt)
{
//对应原来的蓝牙连接上断开处理函数 ,bt->value=reason
log_info("------------------------bt_hci_event_handler reason %x %x", bt->event, bt->value);
@ -2774,17 +2776,17 @@ static int state_machine(struct application *app, enum app_state state, struct i
return error;
}
static const struct application_operation app_earphone_ops = {
.state_machine = state_machine,
.event_handler = event_handler,
};
// static const struct application_operation app_earphone_ops = {
// .state_machine = state_machine,
// .event_handler = event_handler,
// };
/*
* 注册earphone模式
*/
REGISTER_APPLICATION(app_earphone) = {
.name = "earphone",
.action = ACTION_EARPHONE_MAIN,
.ops = &app_earphone_ops,
.state = APP_STA_DESTROY,
};
// /*
// * 注册earphone模式
// */
// REGISTER_APPLICATION(app_earphone) = {
// .name = "earphone",
// .action = ACTION_EARPHONE_MAIN,
// .ops = &app_earphone_ops,
// .state = APP_STA_DESTROY,
// };

2
apps/earphone/xtell_Sensor/main.c → apps/earphone/xtell_Sensor/send_data.c
View File

@ -86,7 +86,7 @@ void rcsp_adv_fill_mac_addr(u8 *mac_addr_buf) //by xtell
swapX(bt_get_mac_addr(), mac_addr_buf, 6);
}
void xtell_main(void){
void xtell_task_create(void){
u8 mac_data[6];

117
apps/earphone/xtell_Sensor/xtell_app_main.c Normal file
View File

@ -0,0 +1,117 @@
#include "system/includes.h"
/*#include "btcontroller_config.h"*/
#include "btstack/btstack_task.h"
#include "app_config.h"
#include "app_action.h"
#include "asm/pwm_led.h"
#include "tone_player.h"
#include "gpio.h"
#include "app_main.h"
#include "asm/charge.h"
#include "update.h"
#include "app_power_manage.h"
#include "app_charge.h"
#include "bt_profile_cfg.h"
#include "dev_manager/dev_manager.h"
#include "update_loader_download.h"
#define xlog(format, ...) printf("[%s] " format, __func__, ##__VA_ARGS__)
#define LOG_TAG_CONST APP
#define LOG_TAG "[APP]"
#define LOG_ERROR_ENABLE
#define LOG_DEBUG_ENABLE
#define LOG_INFO_ENABLE
/* #define LOG_DUMP_ENABLE */
#define LOG_CLI_ENABLE
#include "debug.h"
#ifdef CONFIG_BOARD_AISPEECH_VAD_ASR
u8 user_at_cmd_send_support = 1;
#endif
extern APP_VAR app_var;
/*
* 2ms timer中断回调函数
*/
extern void timer_2ms_handler();
extern void app_var_init(void);
void app_earphone_play_voice_file(const char *name);
void clr_wdt(void);
extern void check_power_on_key(void);
extern int cpu_reset_by_soft();
extern int audio_dec_init();
extern int audio_enc_init();
/*充电拔出,CPU软件复位, 不检测按键，直接开机*/
static void app_poweron_check(int update)
{
#if (CONFIG_BT_MODE == BT_NORMAL)
if (!update && cpu_reset_by_soft()) {
app_var.play_poweron_tone = 0;
return;
}
#if TCFG_CHARGE_OFF_POWERON_NE
if (is_ldo5v_wakeup()) {
app_var.play_poweron_tone = 0;
return;
}
#endif
//#ifdef CONFIG_RELEASE_ENABLE
#if TCFG_POWER_ON_NEED_KEY
check_power_on_key();
#endif
//#endif
#endif
}
extern u32 timer_get_ms(void);
void xtell_app_main()
{
int update = 0;
u32 addr = 0, size = 0;
struct intent it;
xlog("==============xtell_app_main================\n");
if (!UPDATE_SUPPORT_DEV_IS_NULL()) {
update = update_result_deal();
}
app_var_init();
// if (get_charge_online_flag()) {
#if(TCFG_SYS_LVD_EN == 1)
vbat_check_init();
#endif
// init_intent(&it);
// it.name = "idle";
// it.action = ACTION_IDLE_MAIN;
// start_app(&it);
// } else {
check_power_on_voltage();
app_poweron_check(update);
init_intent(&it);
it.name = "handler";
it.action = ACTION_EARPHONE_MAIN;
start_app(&it);
// }
log_info("app_main\n");
app_var.start_time = timer_get_ms();
extern void xtell_task_create(void);
xtell_task_create();
}

424
apps/earphone/xtell_Sensor/xtell_handler.c Normal file
View File

@ -0,0 +1,424 @@
#include "system/includes.h"
#include "media/includes.h"
#include "tone_player.h"
#include "earphone.h"
#include "app_config.h"
#include "app_action.h"
#include "app_task.h"
#include "btstack/avctp_user.h"
#include "btstack/btstack_task.h"
#include "btctrler/btctrler_task.h"
#include "btstack/frame_queque.h"
#include "user_cfg.h"
// #include "aec_user.h"
#include "classic/hci_lmp.h"
#include "bt_common.h"
#include "bt_ble.h"
#include "bt_tws.h"
#include "pbg_user.h"
#include "btstack/bluetooth.h"
#include "colorful_lights/colorful_lights.h"
#include "app_chargestore.h"
#include "jl_kws/jl_kws_api.h"
#include "asm/charge.h"
#include "app_charge.h"
#include "ui_manage.h"
#include "app_chargestore.h"
#include "app_umidigi_chargestore.h"
#include "app_testbox.h"
#include "app_online_cfg.h"
#include "app_main.h"
#include "app_power_manage.h"
#include "gSensor/gSensor_manage.h"
#include "key_event_deal.h"
#include "classic/tws_api.h"
#include "asm/pwm_led.h"
#include "ir_sensor/ir_manage.h"
#include "in_ear_detect/in_ear_manage.h"
#include "vol_sync.h"
#include "bt_background.h"
#include "default_event_handler.h"
#define LOG_TAG_CONST EARPHONE
#define LOG_TAG "[EARPHONE]"
#define LOG_ERROR_ENABLE
#define LOG_DEBUG_ENABLE
#define LOG_INFO_ENABLE
#include "debug.h"
#if(USE_DMA_UART_TEST) //使用dm串口测试时不能同时打开
#define MY_SNIFF_EN 0
#else
#define MY_SNIFF_EN 1 //默认打开
#endif
///////////////////////////////////////////////////////////////////////////////////////////////////
//变量
extern u8 init_ok;
extern u8 sniff_out;
unsigned char xtell_bl_state=0; //存放经典蓝牙的连接状态，0断开，1是连接
u8 bt_newname =0;
unsigned char xt_ble_new_name[9] = "CM-11111";
static u16 play_poweron_ok_timer_id = 0;
///////////////////////////////////////////////////////////////////////////////////////////////////
// u8 get_bt_init_status(void)
// {
// return init_ok;
// }
// u8 get_sniff_out_status()
// {
// return sniff_out;
// }
// void clear_sniff_out_status()
// {
// sniff_out = 0;
// }
extern int bt_hci_event_handler(struct bt_event *bt);
///////////////////////////////////////////////////////////////////////////////////////////////////
/*
* 模式状态机, 通过start_app()控制状态切换
*/
/* extern int audio_mic_init(); */
static int state_machine(struct application *app, enum app_state state, struct intent *it){
int error = 0;
static u8 tone_player_err = 0;
r_printf("bt_state_machine=%d\n", state);
switch (state) {
case APP_STA_CREATE:
/* set_adjust_conn_dac_check(0); */
STATUS *p_tone = get_tone_config();
tone_play_index(p_tone->bt_init_ok, 1);
break;
case APP_STA_START:
if (!it) {
break;
}
switch (it->action) {
case ACTION_EARPHONE_MAIN:
/*
* earphone 模式初始化
*/
clk_set("sys", BT_NORMAL_HZ);
u32 sys_clk = clk_get("sys");
bt_pll_para(TCFG_CLOCK_OSC_HZ, sys_clk, 0, 0);
/* bredr_set_dut_enble(1, 1); */
bt_function_select_init();
bredr_handle_register();
EARPHONE_STATE_INIT();
btstack_init();
sys_auto_shut_down_enable();
bt_sniff_feature_init();
sys_auto_sniff_controle(MY_SNIFF_EN, NULL);
app_var.dev_volume = -1;
break;
case ACTION_A2DP_START: //蓝牙音频传输协议
break;
case ACTION_BY_KEY_MODE:
break;
case ACTION_TONE_PLAY:
STATUS *p_tone = get_tone_config();
tone_play_index(p_tone->bt_init_ok, 1);
break;
case ACTION_DO_NOTHING:
break;
}
break;
case APP_STA_PAUSE:
break;
case APP_STA_RESUME:
//恢复前台运行
sys_auto_shut_down_disable();
sys_key_event_enable();
break;
case APP_STA_STOP:
break;
case APP_STA_DESTROY:
r_printf("APP_STA_DESTROY\n");
if (!app_var.goto_poweroff_flag) {
bt_app_exit(NULL);
}
break;
}
return error;
}
///////////////////////////////////////////////////////////////////////////////////////////////////
//handle
static void play_poweron_ok_timer(void *priv)
{
app_var.wait_timer_do = 0;
log_d("\n-------play_poweron_ok_timer-------\n", priv);
if (is_dac_power_off()) {
#if TCFG_USER_TWS_ENABLE
bt_tws_poweron();
#else
bt_wait_connect_and_phone_connect_switch(0);
#endif
return;
}
app_var.wait_timer_do = sys_timeout_add(priv, play_poweron_ok_timer, 100);
}
static void play_bt_connect_dly(void *priv)
{
app_var.wait_timer_do = 0;
log_d("\n-------play_bt_connect_dly-------\n", priv);
if (!app_var.goto_poweroff_flag) {
STATUS *p_tone = get_tone_config();
tone_play_index(p_tone->bt_connect_ok, 1);
}
}
static int bt_connction_status_event_handler(struct bt_event *bt)
{
STATUS *p_tone = get_tone_config();
u8 *phone_number = NULL;
switch (bt->event) {
case BT_STATUS_INIT_OK:
/*
* 蓝牙初始化完成
*/
log_info("BT_STATUS_INIT_OK\n");
init_ok = 1;
__set_sbc_cap_bitpool(38);
#if (TCFG_USER_BLE_ENABLE)
if (BT_MODE_IS(BT_BQB)) {
ble_bqb_test_thread_init();
} else {
#if !TCFG_WIRELESS_MIC_ENABLE
bt_ble_init();
#endif
}
#endif
bt_init_ok_search_index();
#if TCFG_TEST_BOX_ENABLE
testbox_set_bt_init_ok(1);
#endif
#if ((CONFIG_BT_MODE == BT_BQB)||(CONFIG_BT_MODE == BT_PER))
bt_wait_phone_connect_control(1);
#else
if (is_dac_power_off()) {
bt_wait_connect_and_phone_connect_switch(0);
} else {
app_var.wait_timer_do = sys_timeout_add(NULL, play_poweron_ok_timer, 100);
}
#endif
/*if (app_var.play_poweron_tone) {
tone_play_index(p_tone->power_on, 1);
}*/
break;
case BT_STATUS_SECOND_CONNECTED:
clear_current_poweron_memory_search_index(0);
case BT_STATUS_FIRST_CONNECTED:
log_info("BT_STATUS_CONNECTED\n");
xtell_bl_state = 1; //蓝牙连接成功 置1
if(strcmp(xt_ble_new_name,"CM-1111") != 0){
//蓝牙连接成功
bt_newname =1;
u8 temp[5]={0xBB,0xBE,0x02,0x04,0x00};
temp[4] = xtell_bl_state; //经典蓝牙连接状态
send_data_to_ble_client(&temp,5);
}
earphone_change_pwr_mode(PWR_DCDC15, 3000);
sys_auto_shut_down_disable();
ui_update_status(STATUS_BT_CONN); //单台在此处设置连接状态,对耳的连接状态需要同步，在bt_tws.c中去设置
/* tone_play(TONE_CONN); */
/*os_time_dly(40); // for test*/
log_info("tone status:%d\n", tone_get_status());
if (get_call_status() == BT_CALL_HANGUP) {
if (app_var.phone_dly_discon_time) {
sys_timeout_del(app_var.phone_dly_discon_time);
app_var.phone_dly_discon_time = 0;
} else {
app_var.wait_timer_do = sys_timeout_add(NULL, play_bt_connect_dly, 1600);
/* tone_play_index(p_tone->bt_connect_ok, 1); */
}
}
/*int timeout = 5000 + rand32() % 10000;
sys_timeout_add(NULL, connect_phone_test, timeout);*/
break;
case BT_STATUS_FIRST_DISCONNECT:
case BT_STATUS_SECOND_DISCONNECT:
log_info("BT_STATUS_DISCONNECT\n");
xtell_bl_state = 0; //断开蓝牙 清0
//蓝牙断开连接
if(bt_newname){ //已经改成新蓝牙名字，断开才播报
bt_newname=0;
u8 temp[5]={0xBB,0xBE,0x02,0x04,0x00};
temp[4] = xtell_bl_state; //经典蓝牙连接状态
send_data_to_ble_client(&temp,5);
}
if (app_var.goto_poweroff_flag) {
/*关机不播断开提示音*/
/*关机时不改UI*/
break;
}
// bt_discon_dly_handle(NULL);
break;
//phone status deal
case BT_STATUS_PHONE_INCOME:
break;
case BT_STATUS_PHONE_OUT:
break;
case BT_STATUS_PHONE_ACTIVE:
break;
case BT_STATUS_PHONE_HANGUP:
break;
case BT_STATUS_PHONE_NUMBER:
break;
case BT_STATUS_INBAND_RINGTONE: //铃声
break;
case BT_STATUS_CALL_VOL_CHANGE:
break;
case BT_STATUS_SNIFF_STATE_UPDATE:
log_info(" BT_STATUS_SNIFF_STATE_UPDATE %d\n", bt->value); //0退出SNIFF
if (bt->value == 0) {
sniff_out = 1;
sys_auto_sniff_controle(MY_SNIFF_EN, bt->args);
} else {
sys_auto_sniff_controle(0, bt->args);
}
break;
case BT_STATUS_LAST_CALL_TYPE_CHANGE:
break;
case BT_STATUS_CONN_A2DP_CH:
case BT_STATUS_CONN_HFP_CH:
if ((!is_1t2_connection()) && (get_current_poweron_memory_search_index(NULL))) { //回连下一个device
if (get_esco_coder_busy_flag()) {
clear_current_poweron_memory_search_index(0);
} else {
user_send_cmd_prepare(USER_CTRL_START_CONNECTION, 0, NULL);
}
}
break;
case BT_STATUS_PHONE_MANUFACTURER:
break;
case BT_STATUS_VOICE_RECOGNITION:
break;
case BT_STATUS_AVRCP_INCOME_OPID:
#define AVC_VOLUME_UP 0x41
#define AVC_VOLUME_DOWN 0x42
log_info("BT_STATUS_AVRCP_INCOME_OPID:%d\n", bt->value);
if (bt->value == AVC_VOLUME_UP) {
}
if (bt->value == AVC_VOLUME_DOWN) {
}
break;
default:
log_info(" BT STATUS DEFAULT\n");
break;
}
return 0;
}
static int event_handler(struct application *app, struct sys_event *event)
{
if (SYS_EVENT_REMAP(event)) {
g_printf("****SYS_EVENT_REMAP**** \n");
return 0;
}
switch (event->type) {
case SYS_KEY_EVENT:
break;
case SYS_BT_EVENT:
/*
* 蓝牙事件处理
*/
if ((u32)event->arg == SYS_BT_EVENT_TYPE_CON_STATUS) {
printf("in event_handler:bt_connction_status_event_handler");
bt_connction_status_event_handler(&event->u.bt);
} else if ((u32)event->arg == SYS_BT_EVENT_TYPE_HCI_STATUS) {
bt_hci_event_handler(&event->u.bt);
}
break;
case SYS_DEVICE_EVENT:
/*
* 系统设备事件处理
*/
if ((u32)event->arg == DEVICE_EVENT_FROM_CHARGE) {
} else if ((u32)event->arg == DEVICE_EVENT_FROM_POWER) {
return app_power_event_handler(&event->u.dev);
}
#if TCFG_UMIDIGI_BOX_ENABLE
else if ((u32)event->arg == DEVICE_EVENT_UMIDIGI_CHARGE_STORE) {
app_umidigi_chargestore_event_handler(&event->u.umidigi_chargestore);
}
#endif
#if TCFG_TEST_BOX_ENABLE
else if ((u32)event->arg == DEVICE_EVENT_TEST_BOX) {
app_testbox_event_handler(&event->u.testbox);
}
#endif
break;
default:
return false;
}
SYS_EVENT_HANDLER_SPECIFIC(event);
#ifdef CONFIG_BT_BACKGROUND_ENABLE
if (app) {
default_event_handler(event);
}
#endif
return false;
}
///////////////////////////////////////////////////////////////////////////////////////////////////
static const struct application_operation app_handler_ops = {
.state_machine = state_machine,
.event_handler = event_handler,
};
/*
* 注册earphone模式
*/
REGISTER_APPLICATION(app_handler) = {
.name = "handler",
.action = ACTION_EARPHONE_MAIN,
.ops = &app_handler_ops,
.state = APP_STA_DESTROY,
};

259
apps/xtell_hide/app_main.c Normal file
View File

@ -0,0 +1,259 @@
#include "system/includes.h"
/*#include "btcontroller_config.h"*/
#include "btstack/btstack_task.h"
#include "app_config.h"
#include "app_action.h"
#include "asm/pwm_led.h"
#include "tone_player.h"
#include "gpio.h"
#include "app_main.h"
#include "asm/charge.h"
#include "update.h"
#include "app_power_manage.h"
#include "app_charge.h"
#include "bt_profile_cfg.h"
#include "dev_manager/dev_manager.h"
#include "update_loader_download.h"
#define LOG_TAG_CONST APP
#define LOG_TAG "[APP]"
#define LOG_ERROR_ENABLE
#define LOG_DEBUG_ENABLE
#define LOG_INFO_ENABLE
/* #define LOG_DUMP_ENABLE */
#define LOG_CLI_ENABLE
#include "debug.h"
#ifdef CONFIG_BOARD_AISPEECH_VAD_ASR
u8 user_at_cmd_send_support = 1;
#endif
/*任务列表 */
const struct task_info task_info_table[] = {
{"app_core", 1, 0, 768, 256 },
{"sys_event", 7, 0, 256, 0 },
{"systimer", 7, 0, 128, 0 },
{"btctrler", 4, 0, 512, 384 },
{"btencry", 1, 0, 512, 128 },
{"tws", 5, 0, 512, 128 },
#if (BT_FOR_APP_EN)
{"btstack", 3, 0, 1024, 256 },
#else
{"btstack", 3, 0, 768, 256 },
#endif
{"audio_dec", 5, 0, 800, 128 },
{"aud_effect", 5, 1, 800, 128 },
/*
*为了防止dac buf太大，通话一开始一直解码，
*导致编码输入数据需要很大的缓存，这里提高编码的优先级
*/
{"audio_enc", 6, 0, 768, 128 },
{"aec", 2, 1, 768, 128 },
#if TCFG_AUDIO_HEARING_AID_ENABLE
{"HearingAid", 6, 0, 768, 128 },
#endif/*TCFG_AUDIO_HEARING_AID_ENABLE*/
#ifdef CONFIG_BOARD_AISPEECH_NR
{"aispeech_enc", 2, 1, 512, 128 },
#endif /*CONFIG_BOARD_AISPEECH_NR*/
#ifdef CONFIG_BOARD_AISPEECH_VAD_ASR
{"asr", 1, 0, 768, 128 },
{"audio_asr_export_task", 1, 0, 512, 128 },
#endif/*CONFIG_BOARD_AISPEECH_VAD_ASR*/
#ifndef CONFIG_256K_FLASH
{"aec_dbg", 3, 0, 128, 128 },
#if AUDIO_ENC_MPT_SELF_ENABLE
{"enc_mpt_self", 3, 0, 512, 128 },
#endif/*AUDIO_ENC_MPT_SELF_ENABLE*/
{"update", 1, 0, 256, 0 },
{"tws_ota", 2, 0, 256, 0 },
{"tws_ota_msg", 2, 0, 256, 128 },
{"dw_update", 2, 0, 256, 128 },
{"rcsp_task", 2, 0, 640, 128 },
{"aud_capture", 4, 0, 512, 256 },
{"data_export", 5, 0, 512, 256 },
{"anc", 3, 1, 512, 128 },
#endif
#if TCFG_GX8002_NPU_ENABLE
{"gx8002", 2, 0, 256, 64 },
#endif /* #if TCFG_GX8002_NPU_ENABLE */
#if TCFG_GX8002_ENC_ENABLE
{"gx8002_enc", 2, 0, 128, 64 },
#endif /* #if TCFG_GX8002_ENC_ENABLE */
#if TCFG_KWS_VOICE_RECOGNITION_ENABLE
{"kws", 2, 0, 256, 64 },
#endif /* #if TCFG_KWS_VOICE_RECOGNITION_ENABLE */
{"usb_msd", 1, 0, 512, 128 },
#if !TCFG_USB_MIC_CVP_ENABLE
{"usbmic_write", 2, 0, 256, 128 },
#endif
#if AI_APP_PROTOCOL
{"app_proto", 2, 0, 768, 64 },
#endif
#if (TCFG_SPI_LCD_ENABLE||TCFG_SIMPLE_LCD_ENABLE)
{"ui", 2, 0, 768, 256 },
#else
{"ui", 3, 0, 384 - 64, 128 },
#endif
#if (TCFG_DEV_MANAGER_ENABLE)
{"dev_mg", 3, 0, 512, 512 },
#endif
{"audio_vad", 1, 1, 512, 128 },
#if TCFG_KEY_TONE_EN
{"key_tone", 5, 0, 256, 32 },
#endif
#if (TCFG_WIRELESS_MIC_ENABLE)
{"wl_mic_enc", 2, 0, 768, 128 },
#endif
#if (TUYA_DEMO_EN)
{"user_deal", 7, 0, 512, 512 },//定义线程 tuya任务调度
{"dw_update", 2, 0, 256, 128 },
#endif
#if TCFG_AUDIO_SPATIAL_EFFECT_ENABLE
{"imu_trim", 1, 0, 256, 128 },
#endif /*TCFG_AUDIO_SPATIAL_EFFECT_ENABLE*/
#if TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN
{"speak_to_chat", 2, 0, 256, 128 },
{"icsd_adt", 2, 0, 512, 128 },
{"icsd_src", 2, 1, 512, 128 },
#endif /*TCFG_AUDIO_ANC_ACOUSTIC_DETECTOR_EN*/
{"pmu_task", 6, 0, 256, 128 },
{"WindDetect", 2, 0, 256, 128 },
{0, 0},
};
APP_VAR app_var;
/*
* 2ms timer中断回调函数
*/
void timer_2ms_handler()
{
}
void app_var_init(void)
{
memset((u8 *)&bt_user_priv_var, 0, sizeof(BT_USER_PRIV_VAR));
app_var.play_poweron_tone = 1;
}
void app_earphone_play_voice_file(const char *name);
void clr_wdt(void);
void check_power_on_key(void)
{
u32 delay_10ms_cnt = 0;
#if 0 //PC_MODE_DETECTION
gpio_set_pull_up(IO_PORTP_00, 0);
gpio_set_pull_down(IO_PORTP_00, 1);
gpio_set_direction(IO_PORTP_00, 1);
gpio_set_die(IO_PORTP_00, 1);
#endif
while (1) {
clr_wdt();
os_time_dly(1);
extern u8 get_power_on_status(void);
if (get_power_on_status()) {
log_info("+");
delay_10ms_cnt++;
if (delay_10ms_cnt > 70) {
/* extern void set_key_poweron_flag(u8 flag); */
/* set_key_poweron_flag(1); */
return;
}
} else {
log_info("-");
delay_10ms_cnt = 0;
log_info("enter softpoweroff\n");
power_set_soft_poweroff();
}
}
}
extern int cpu_reset_by_soft();
extern int audio_dec_init();
extern int audio_enc_init();
__attribute__((weak))
u8 get_charge_online_flag(void)
{
return 0;
}
/*充电拔出,CPU软件复位, 不检测按键，直接开机*/
static void app_poweron_check(int update)
{
#if (CONFIG_BT_MODE == BT_NORMAL)
if (!update && cpu_reset_by_soft()) {
app_var.play_poweron_tone = 0;
return;
}
#if TCFG_CHARGE_OFF_POWERON_NE
if (is_ldo5v_wakeup()) {
app_var.play_poweron_tone = 0;
return;
}
#endif
//#ifdef CONFIG_RELEASE_ENABLE
#if TCFG_POWER_ON_NEED_KEY
check_power_on_key();
#endif
//#endif
#endif
}
extern u32 timer_get_ms(void);
void app_main()
{
int update = 0;
u32 addr = 0, size = 0;
struct intent it;
if (!UPDATE_SUPPORT_DEV_IS_NULL()) {
update = update_result_deal();
}
app_var_init();
// if (get_charge_online_flag()) {
#if(TCFG_SYS_LVD_EN == 1)
vbat_check_init();
#endif
// init_intent(&it);
// it.name = "idle";
// it.action = ACTION_IDLE_MAIN;
// start_app(&it);
// } else {
check_power_on_voltage();
app_poweron_check(update);
init_intent(&it);
it.name = "handler";
it.action = ACTION_EARPHONE_MAIN;
start_app(&it);
// }
log_info("app_main\n");
app_var.start_time = timer_get_ms();
}

66
apps/xtell_hide/board/br28/app.ld Normal file
View File

@ -0,0 +1,66 @@
#include "app_config.h"
SECTIONS
{
.text : ALIGN(4)
{
gsensor_dev_begin = .;
KEEP(*(.gsensor_dev))
gsensor_dev_end = .;
fm_dev_begin = .;
KEEP(*(.fm_dev))
fm_dev_end = .;
fm_emitter_dev_begin = .;
KEEP(*(.fm_emitter_dev))
fm_emitter_dev_end = .;
storage_device_begin = .;
KEEP(*(.storage_device))
storage_device_end = .;
imusensor_dev_begin = .;
KEEP(*(.imusensor_dev))
imusensor_dev_end = .;
#if TCFG_APP_PC_EN
aac_dec_code_begin = .;
*(.bt_aac_dec_code)
*(.bt_aac_dec_sparse_code)
aac_dec_code_end = .;
aac_dec_code_size = aac_dec_code_end - aac_dec_code_begin ;
. = ALIGN(4);
bt_aac_dec_const_begin = .;
*(.bt_aac_dec_const)
*(.bt_aac_dec_sparse_const)
bt_aac_dec_const_end = .;
bt_aac_dec_const_size = bt_aac_dec_const_end - bt_aac_dec_const_begin ;
*(.bt_aac_dec_data)
*(.bt_aac_dec_bss)
. = ALIGN(4);
*(.aac_mem)
*(.aac_ctrl_mem)
/* . += 0x5fe8 ; */
/* . += 0xef88 ; */
#endif
. = ALIGN(32);
}
.data ALIGN(32):
{
} > ram0
.bss ALIGN(32):
{
} > ram0
.data_code ALIGN(32):
{
} > ram0
}

164
apps/xtell_hide/board/br28/app_overlay.ld Normal file
View File

@ -0,0 +1,164 @@
OVERLAY : AT(0x200000) SUBALIGN(4)
{
.overlay_aec
{
aec_code_begin = . ;
*(.text._*)
*(.data._*)
*(.aec_code)
*(.aec_const)
*(.res_code)
*(.res_const)
*(.ns_code)
*(.ns_const)
*(.bark_const)
*(.fft_code)
*(.fft_const)
*(.agc_code)
*(.dms_code)
*(.dms_const)
*(.dms_sparse_code)
aec_code_end = . ;
aec_code_size = aec_code_end - aec_code_begin ;
*(.msbc_enc)
*(.cvsd_codec)
*(.aec_bss)
*(.aec_data)
*(.res_data)
*(.ns_data)
*(.dns_common_data)
*(.dns_param_data_single)
*(.dns_param_data_dual)
*(.jlsp_nlp_code)
*(.jlsp_nlp_const)
*(.jlsp_aec_code)
*(.jlsp_aec_const)
*(.jlsp_prep_code)
*(.jlsp_prep_const)
*(.jlsp_enc_code)
*(.jlsp_enc_const)
*(.jlsp_wn_code)
*(.jlsp_wn_const)
*(.jlsp_tri_code)
*(.jlsp_tri_const)
*(.jlsp_agc_code)
*(.jlsp_agc_const)
*(.res_bss)
*(.ns_bss)
*(.aec_mem)
}
.overlay_aac
{
#if !TCFG_APP_PC_EN
aac_dec_code_begin = .;
*(.bt_aac_dec_code)
*(.bt_aac_dec_sparse_code)
aac_dec_code_end = .;
aac_dec_code_size = aac_dec_code_end - aac_dec_code_begin ;
. = ALIGN(4);
bt_aac_dec_const_begin = .;
*(.bt_aac_dec_const)
*(.bt_aac_dec_sparse_const)
bt_aac_dec_const_end = .;
bt_aac_dec_const_size = bt_aac_dec_const_end - bt_aac_dec_const_begin ;
*(.bt_aac_dec_data)
*(.bt_aac_dec_bss)
. = ALIGN(4);
*(.aac_mem)
*(.aac_ctrl_mem)
/* . += 0x5fe8 ; */
/* . += 0xef88 ; */
#endif
}
/*
.overlay_lc3
{
lc3_dec_code_begin = .;
*(.lc3_dec_code)
lc3_dec_code_end = .;
lc3_dec_code_size = lc3_dec_code_end - lc3_dec_code_begin;
. = ALIGN(4);
lc3_dec_const_begin = .;
*(.lc3_dec_const)
lc3_dec_const_end = .;
lc3_dec_const_size = lc3_dec_const_end - lc3_dec_const_begin;
*(.lc3_dec_data)
*(.lc3_dec_bss)
}
*/
.overlay_mp3
{
*(.mp3_mem)
*(.mp3_ctrl_mem)
*(.mp3pick_mem)
*(.mp3pick_ctrl_mem)
*(.dec2tws_mem)
}
.overlay_wma
{
*(.wma_mem)
*(.wma_ctrl_mem)
*(.wmapick_mem)
*(.wmapick_ctrl_mem)
}
.overlay_wav
{
*(.wav_mem)
*(.wav_ctrl_mem)
}
.overlay_ape
{
*(.ape_mem)
*(.ape_ctrl_mem)
}
.overlay_flac
{
*(.flac_mem)
*(.flac_ctrl_mem)
}
.overlay_m4a
{
*(.m4a_mem)
*(.m4a_ctrl_mem)
}
.overlay_amr
{
*(.amr_mem)
*(.amr_ctrl_mem)
}
.overlay_dts
{
*(.dts_mem)
*(.dts_ctrl_mem)
}
.overlay_fm
{
*(.fm_mem)
}
.overlay_pc
{
*(.usb_audio_play_dma)
*(.usb_audio_rec_dma)
*(.uac_rx)
*(.mass_storage)
*(.usb_ep0)
*(.usb_msd_dma)
*(.usb_hid_dma)
*(.usb_iso_dma)
*(.usb_cdc_dma)
*(.uac_var)
*(.usb_config_var)
*(.cdc_var)
}
} > ram0

27
apps/xtell_hide/board/br28/board_config.h Normal file
View File

@ -0,0 +1,27 @@
#ifndef BOARD_CONFIG_H
#define BOARD_CONFIG_H
/*
* 板级配置选择
*/
#define CONFIG_BOARD_JL701N_DEMO //编译正常 2025-4-29
// #define CONFIG_BOARD_JL701N_BTEMITTER
// #define CONFIG_BOARD_JL701N_ANC
// #define CONFIG_BOARD_JL7016G_HYBRID
// #define CONFIG_BOARD_JL7018F_DEMO //编译不过 2025-4-29
#include "media/audio_def.h"
#include "board_jl701n_demo_cfg.h"
#include "board_jl701n_btemitter_cfg.h"
#include "board_jl701n_anc_cfg.h"
#include "board_jl7016g_hybrid_cfg.h"
#include "board_jl7018f_demo_cfg.h"
#define DUT_AUDIO_DAC_LDO_VOLT DACVDD_LDO_1_25V
#ifdef CONFIG_NEW_CFG_TOOL_ENABLE
#define CONFIG_ENTRY_ADDRESS 0x6000100
#endif
#endif

1025
apps/xtell_hide/board/br28/board_jl7016g_hybrid.c Normal file
View File

File diff suppressed because it is too large Load Diff

1111
apps/xtell_hide/board/br28/board_jl7016g_hybrid_cfg.h Normal file
View File

File diff suppressed because it is too large Load Diff

123
apps/xtell_hide/board/br28/board_jl7016g_hybrid_global_build_cfg.h Normal file
View File

@ -0,0 +1,123 @@
#ifndef CONFIG_BOARD_JL7016G_HYBRID_POST_BUILD_CFG_H
#define CONFIG_BOARD_JL7016G_HYBRID_POST_BUILD_CFG_H
/* 改文件只添加和isd_config.ini相关的配置，用以生成isd_config.ini */
/* 其他不相关的配置请勿添加在改文件 */
#ifdef CONFIG_BOARD_JL7016G_HYBRID
/* Following Macros Affect Periods Of Both Code Compiling And Post-build */
#define CONFIG_DOUBLE_BANK_ENABLE 0 //单双备份选择(若打开了改宏,FLASH结构变为双备份结构，适用于接入第三方协议的OTA， PS: JL-OTA同样支持双备份升级, 需要根据实际FLASH大小同时配置CONFIG_FLASH_SIZE)
#define CONFIG_APP_OTA_ENABLE 0 //是否支持RCSP升级(JL-OTA)
#define CONFIG_UPDATE_JUMP_TO_MASK 0 //配置升级到loader的方式0为直接reset,1为跳转(适用于芯片电源由IO口KEEP住的方案,需要注意检查跳转前是否将使用DMA的硬件模块全部关闭)
#define CONFIG_IO_KEY_EN 0 //配置是否使用IO按键，配合RESET1
#define CONFIG_UPDATE_WITH_MD5_CHECK_EN 0 //配置升级是否支持MD5校验
#define CONFIG_ANC_ENABLE 1 //配置是否支持ANC
//flash size vaule definition
#define FLASH_SIZE_256K 0x40000
#define FLASH_SIZE_512K 0x80000
#define FLASH_SIZE_1M 0x100000
#define FLASH_SIZE_2M 0x200000
#define FLASH_SIZE_4M 0x400000
#define CONFIG_FLASH_SIZE FLASH_SIZE_1M //配置FLASH大小
/* Above Macros Affect Periods Of Both Code Compiling And Post-build */
/* Following Macros Only For Post Bulid Configuaration */
#define CONFIG_DB_UPDATE_DATA_GENERATE_EN 0 //是否生成db_data.bin(用于第三方协议接入使用)
#define CONFIG_ONLY_GRENERATE_ALIGN_4K_CODE 0 //ufw只生成1份4K对齐的代码
//config for supported chip version
#ifdef CONFIG_BR30_C_VERSION
#define CONFIG_SUPPORTED_CHIP_VERSION C
#else
#define CONFIG_SUPPORTED_CHIP_VERSION B,D,E,M,N,O,P
#endif
//DON'T MODIFY THIS CONFIG EXCEPT SDK PUBLISHER
#define CONFIG_CHIP_NAME AC701N //除了SDK发布者,请不要修改
//it can be modified before first programming,but keep the same as the original version
#define CONFIG_PID AC701N //烧写或强制升级之前可以修改,之后升级要保持一致
//it can be modified before first programming,but keep the same as the original version
#define CONFIG_VID 0.01 //烧写或强制升级之前可以修改,之后升级要保持一致
//Project with bluetooth,it must use OSC as PLL_SOURCE;
#define CONFIG_PLL_SOURCE_USING_LRC 0 //PLL时钟源选择 1:LRC 2:OSC
//config alignment size unit
#ifdef CONFIG_256K_FLASH
#define ALIGN_UNIT_256B 1 //FLASH对齐方式选择，如果是256K的FLASH，选择256BYTE对齐方式
#else
#define ALIGN_UNIT_256B 0
#endif
//partial platform check this config to select the uart IO for wired update
#define CONFIG_UART_UPDATE_PIN PP00
//isd_download loader/uboot/update_loader debug io config
//#define CONFIG_UBOOT_DEBUG_PIN PA05
//#define CONFIG_UBOOT_DEBUG_BAUD_RATE 1000000
//config long-press reset io pin,time,trigger level
#define CONFIG_RESET_PIN LDO //io pin
#define CONFIG_RESET_TIME 04 //unit:second
#define CONFIG_RESET_LEVEL 1 //tigger level(0/1)
#if CONFIG_IO_KEY_EN
#define CONFIG_SUPPORT_RESET1
#define CONFIG_RESET1_PIN PB01 //io pin
#define CONFIG_RESET1_TIME 08 //unit:second
#define CONFIG_RESET1_LEVEL 0 //tigger level(0/1)
#endif
//reserved three custom cfg item for the future definition
//#define CONFIG_CUSTOM_CFG1_TYPE POWER_PIN
//#define CONFIG_CUSTOM_CFG1_VALUE PC01_1
//#define CONFIG_CUSTOM_CFG2_TYPE
//#define CONFIG_CUSTOM_CFG2_VALUE
//#define CONFIG_CUSTOM_CFG3_TYPE
//#define CONFIG_CUSTOM_CFG3_VALUE
//#define CONFIG_VDDIO_LVD_LEVEL 4 ////VDDIO_LVD挡位，0: 1.9V 1: 2.0V 2: 2.1V 3: 2.2V 4: 2.3V 5: 2.4V 6: 2.5V 7: 2.6V
//with single-bank mode,actual vm size should larger this VM_LEAST_SIZE,and dual bank mode,actual vm size equals this;
#define CONFIG_VM_LEAST_SIZE 8K
//config whether erased this area when do a update,1-No Operation,0-Erase
#define CONFIG_VM_OPT 1
//config whether erased this area when do a update,1-No Operation,0-Erase
#define CONFIG_BTIF_OPT 1
//reserved two custom cfg area for the future definition
//#define CONFIG_RESERVED_AREA1 EXIF1
#ifdef CONFIG_RESERVED_AREA1
#define CONFIG_RESERVED_AREA1_ADDR AUTO
#define CONFIG_RESERVED_AREA1_LEN 0x1000
#define CONFIG_RESERVED_AREA1_OPT 1
//#define CONFIG_RESERVED_AREA1_FILE anc_gains.bin
#endif
//#define CONFIG_RESERVED_AREA2 EXIF2
#ifdef CONFIG_RESERVED_AREA2
#define CONFIG_RESERVED_AREA2_ADDR AUTO
#define CONFIG_RESERVED_AREA2_LEN 0x1000
#define CONFIG_RESERVED_AREA2_OPT 1
//#define CONFIG_RESERVED_AREA2_FILE anc_gains.bin
#endif
/* Above Macros Only For Post Bulid Configuaration */
#endif /* #ifdef CONFIG_BOARD_JL7016G_HYBRID */
#endif /* #ifndef CONFIG_BOARD_JL701N_ANC_POST_BUILD_CFG_H */

1038
apps/xtell_hide/board/br28/board_jl7018f_demo.c Normal file
View File

File diff suppressed because it is too large Load Diff

1119
apps/xtell_hide/board/br28/board_jl7018f_demo_cfg.h Normal file
View File

File diff suppressed because it is too large Load Diff

123
apps/xtell_hide/board/br28/board_jl7018f_demo_global_build_cfg.h Normal file
View File

@ -0,0 +1,123 @@
#ifndef CONFIG_BOARD_JL7018F_DEMO_POST_BUILD_CFG_H
#define CONFIG_BOARD_JL7018F_DEMO_POST_BUILD_CFG_H
/* 改文件只添加和isd_config.ini相关的配置，用以生成isd_config.ini */
/* 其他不相关的配置请勿添加在改文件 */
#ifdef CONFIG_BOARD_JL7018F_DEMO
/* Following Macros Affect Periods Of Both Code Compiling And Post-build */
#define CONFIG_DOUBLE_BANK_ENABLE 0 //单双备份选择(若打开了改宏,FLASH结构变为双备份结构，适用于接入第三方协议的OTA， PS: JL-OTA同样支持双备份升级, 需要根据实际FLASH大小同时配置CONFIG_FLASH_SIZE)
#define CONFIG_APP_OTA_ENABLE 0 //是否支持RCSP升级(JL-OTA)
#define CONFIG_UPDATE_JUMP_TO_MASK 0 //配置升级到loader的方式0为直接reset,1为跳转(适用于芯片电源由IO口KEEP住的方案,需要注意检查跳转前是否将使用DMA的硬件模块全部关闭)
#define CONFIG_IO_KEY_EN 0 //配置是否使用IO按键，配合RESET1
#define CONFIG_UPDATE_WITH_MD5_CHECK_EN 0 //配置升级是否支持MD5校验
#define CONFIG_ANC_ENABLE 1 //配置是否支持ANC
//flash size vaule definition
#define FLASH_SIZE_256K 0x40000
#define FLASH_SIZE_512K 0x80000
#define FLASH_SIZE_1M 0x100000
#define FLASH_SIZE_2M 0x200000
#define FLASH_SIZE_4M 0x400000
#define CONFIG_FLASH_SIZE FLASH_SIZE_1M //配置FLASH大小
/* Above Macros Affect Periods Of Both Code Compiling And Post-build */
/* Following Macros Only For Post Bulid Configuaration */
#define CONFIG_DB_UPDATE_DATA_GENERATE_EN 0 //是否生成db_data.bin(用于第三方协议接入使用)
#define CONFIG_ONLY_GRENERATE_ALIGN_4K_CODE 0 //ufw只生成1份4K对齐的代码
//config for supported chip version
#ifdef CONFIG_BR30_C_VERSION
#define CONFIG_SUPPORTED_CHIP_VERSION C
#else
#define CONFIG_SUPPORTED_CHIP_VERSION B,D,E,M,N,O,P
#endif
//DON'T MODIFY THIS CONFIG EXCEPT SDK PUBLISHER
#define CONFIG_CHIP_NAME AC701N //除了SDK发布者,请不要修改
//it can be modified before first programming,but keep the same as the original version
#define CONFIG_PID AC701N //烧写或强制升级之前可以修改,之后升级要保持一致
//it can be modified before first programming,but keep the same as the original version
#define CONFIG_VID 0.01 //烧写或强制升级之前可以修改,之后升级要保持一致
//Project with bluetooth,it must use OSC as PLL_SOURCE;
#define CONFIG_PLL_SOURCE_USING_LRC 0 //PLL时钟源选择 1:LRC 2:OSC
//config alignment size unit
#ifdef CONFIG_256K_FLASH
#define ALIGN_UNIT_256B 1 //FLASH对齐方式选择，如果是256K的FLASH，选择256BYTE对齐方式
#else
#define ALIGN_UNIT_256B 0
#endif
//partial platform check this config to select the uart IO for wired update
#define CONFIG_UART_UPDATE_PIN PP00
//isd_download loader/uboot/update_loader debug io config
//#define CONFIG_UBOOT_DEBUG_PIN PA05
//#define CONFIG_UBOOT_DEBUG_BAUD_RATE 1000000
//config long-press reset io pin,time,trigger level
#define CONFIG_RESET_PIN LDO //io pin
#define CONFIG_RESET_TIME 04 //unit:second
#define CONFIG_RESET_LEVEL 1 //tigger level(0/1)
#if CONFIG_IO_KEY_EN
#define CONFIG_SUPPORT_RESET1
#define CONFIG_RESET1_PIN PB01 //io pin
#define CONFIG_RESET1_TIME 08 //unit:second
#define CONFIG_RESET1_LEVEL 0 //tigger level(0/1)
#endif
//reserved three custom cfg item for the future definition
//#define CONFIG_CUSTOM_CFG1_TYPE POWER_PIN
//#define CONFIG_CUSTOM_CFG1_VALUE PC01_1
//#define CONFIG_CUSTOM_CFG2_TYPE
//#define CONFIG_CUSTOM_CFG2_VALUE
//#define CONFIG_CUSTOM_CFG3_TYPE
//#define CONFIG_CUSTOM_CFG3_VALUE
//#define CONFIG_VDDIO_LVD_LEVEL 4 ////VDDIO_LVD挡位，0: 1.9V 1: 2.0V 2: 2.1V 3: 2.2V 4: 2.3V 5: 2.4V 6: 2.5V 7: 2.6V
//with single-bank mode,actual vm size should larger this VM_LEAST_SIZE,and dual bank mode,actual vm size equals this;
#define CONFIG_VM_LEAST_SIZE 8K
//config whether erased this area when do a update,1-No Operation,0-Erase
#define CONFIG_VM_OPT 1
//config whether erased this area when do a update,1-No Operation,0-Erase
#define CONFIG_BTIF_OPT 1
//reserved two custom cfg area for the future definition
//#define CONFIG_RESERVED_AREA1 EXIF1
#ifdef CONFIG_RESERVED_AREA1
#define CONFIG_RESERVED_AREA1_ADDR AUTO
#define CONFIG_RESERVED_AREA1_LEN 0x1000
#define CONFIG_RESERVED_AREA1_OPT 1
//#define CONFIG_RESERVED_AREA1_FILE anc_gains.bin
#endif
//#define CONFIG_RESERVED_AREA2 EXIF2
#ifdef CONFIG_RESERVED_AREA2
#define CONFIG_RESERVED_AREA2_ADDR AUTO
#define CONFIG_RESERVED_AREA2_LEN 0x1000
#define CONFIG_RESERVED_AREA2_OPT 1
//#define CONFIG_RESERVED_AREA2_FILE anc_gains.bin
#endif
/* Above Macros Only For Post Bulid Configuaration */
#endif /* #ifdef CONFIG_BOARD_JL7018F_DEMO */
#endif /* #ifndef CONFIG_BOARD_JL7018F_DEMO_POST_BUILD_CFG_H */

992
apps/xtell_hide/board/br28/board_jl701n_anc.c Normal file
View File

@ -0,0 +1,992 @@
#include "app_config.h"
#ifdef CONFIG_BOARD_JL701N_ANC
#include "system/includes.h"
#include "media/includes.h"
#include "asm/sdmmc.h"
#include "asm/chargestore.h"
#include "asm/umidigi_chargestore.h"
#include "asm/charge.h"
#include "asm/pwm_led.h"
#include "tone_player.h"
#include "audio_config.h"
#include "gSensor/gSensor_manage.h"
#include "key_event_deal.h"
#include "asm/lp_touch_key_api.h"
#include "user_cfg.h"
#include "norflash_sfc.h"
#include "asm/power/power_port.h"
#include "app_umidigi_chargestore.h"
#include "audio_link.h"
#if TCFG_AUDIO_ANC_ENABLE
#include "audio_anc.h"
#endif/*TCFG_AUDIO_ANC_ENABLE*/
#define LOG_TAG_CONST BOARD
#define LOG_TAG "[BOARD]"
#define LOG_ERROR_ENABLE
#define LOG_DEBUG_ENABLE
#define LOG_INFO_ENABLE
/* #define LOG_DUMP_ENABLE */
#define LOG_CLI_ENABLE
#include "debug.h"
void board_power_init(void);
/*各个状态下默认的闪灯方式和提示音设置，如果USER_CFG中设置了USE_CONFIG_STATUS_SETTING为1，则会从配置文件读取对应的配置来填充改结构体*/
STATUS_CONFIG status_config = {
//灯状态设置
.led = {
.charge_start = PWM_LED1_ON,
.charge_full = PWM_LED0_ON,
.power_on = PWM_LED0_ON,
.power_off = PWM_LED1_FLASH_THREE,
.lowpower = PWM_LED1_SLOW_FLASH,
.max_vol = PWM_LED_NULL,
.phone_in = PWM_LED_NULL,
.phone_out = PWM_LED_NULL,
.phone_activ = PWM_LED_NULL,
.bt_init_ok = PWM_LED0_LED1_SLOW_FLASH,
.bt_connect_ok = PWM_LED0_ONE_FLASH_5S,
.bt_disconnect = PWM_LED0_LED1_FAST_FLASH,
.tws_connect_ok = PWM_LED0_LED1_FAST_FLASH,
.tws_disconnect = PWM_LED0_LED1_SLOW_FLASH,
},
//提示音设置
.tone = {
.charge_start = IDEX_TONE_NONE,
.charge_full = IDEX_TONE_NONE,
.power_on = IDEX_TONE_POWER_ON,
.power_off = IDEX_TONE_POWER_OFF,
.lowpower = IDEX_TONE_LOW_POWER,
.max_vol = IDEX_TONE_MAX_VOL,
.phone_in = IDEX_TONE_NONE,
.phone_out = IDEX_TONE_NONE,
.phone_activ = IDEX_TONE_NONE,
.bt_init_ok = IDEX_TONE_BT_MODE,
.bt_connect_ok = IDEX_TONE_BT_CONN,
.bt_disconnect = IDEX_TONE_BT_DISCONN,
.tws_connect_ok = IDEX_TONE_TWS_CONN,
.tws_disconnect = IDEX_TONE_TWS_DISCONN,
}
};
#define __this (&status_config)
/************************** KEY MSG****************************/
/*各个按键的消息设置，如果USER_CFG中设置了USE_CONFIG_KEY_SETTING为1，则会从配置文件读取对应的配置来填充改结构体*/
#if CLIENT_BOARD == CUSTOM10_CFG
u8 key_table[KEY_NUM_MAX][KEY_EVENT_MAX] = {
// SHORT LONG HOLD UP DOUBLE TRIPLE
{KEY_MUSIC_PP, KEY_NULL, KEY_NULL, KEY_NULL, KEY_ANC_SWITCH, KEY_NULL}, //KEY_0
{KEY_MUSIC_NEXT, KEY_VOL_UP, KEY_VOL_UP, KEY_NULL, KEY_OPEN_SIRI, KEY_NULL}, //KEY_1
{KEY_MUSIC_PREV, KEY_VOL_DOWN, KEY_VOL_DOWN, KEY_NULL, KEY_HID_CONTROL, KEY_NULL}, //KEY_2
};
#else
u8 key_table[KEY_NUM_MAX][KEY_EVENT_MAX] = {
// SHORT LONG HOLD UP DOUBLE TRIPLE
{KEY_MUSIC_PP, KEY_ANC_SWITCH, KEY_NULL, KEY_NULL, KEY_CALL_LAST_NO, KEY_NULL}, //KEY_0
{KEY_MUSIC_NEXT, KEY_VOL_UP, KEY_VOL_UP, KEY_NULL, KEY_OPEN_SIRI, KEY_NULL}, //KEY_1
{KEY_MUSIC_PREV, KEY_VOL_DOWN, KEY_VOL_DOWN, KEY_NULL, KEY_HID_CONTROL, KEY_NULL}, //KEY_2
};
#endif
// *INDENT-OFF*
/************************** UART config****************************/
#if TCFG_UART0_ENABLE
UART0_PLATFORM_DATA_BEGIN(uart0_data)
.tx_pin = TCFG_UART0_TX_PORT, //串口打印TX引脚选择
.rx_pin = TCFG_UART0_RX_PORT, //串口打印RX引脚选择
.baudrate = TCFG_UART0_BAUDRATE, //串口波特率
.flags = UART_DEBUG, //串口用来打印需要把改参数设置为UART_DEBUG
UART0_PLATFORM_DATA_END()
#endif //TCFG_UART0_ENABLE
/************************** CHARGE config****************************/
#if TCFG_CHARGE_ENABLE
CHARGE_PLATFORM_DATA_BEGIN(charge_data)
.charge_en = TCFG_CHARGE_ENABLE, //内置充电使能
.charge_poweron_en = TCFG_CHARGE_POWERON_ENABLE, //是否支持充电开机
.charge_full_V = TCFG_CHARGE_FULL_V, //充电截止电压
.charge_full_mA = TCFG_CHARGE_FULL_MA, //充电截止电流
.charge_mA = TCFG_CHARGE_MA, //恒流充电电流
.charge_trickle_mA = TCFG_CHARGE_TRICKLE_MA, //涓流充电电流
/*ldo5v拔出过滤值，过滤时间 = (filter*2 + 20)ms,ldoin<0.6V且时间大于过滤时间才认为拔出
对于充满直接从5V掉到0V的充电仓，该值必须设置成0，对于充满由5V先掉到0V之后再升压到xV的
充电仓，需要根据实际情况设置该值大小*/
.ldo5v_off_filter = 100,
.ldo5v_on_filter = 50,
.ldo5v_keep_filter = 220,
.ldo5v_pulldown_lvl = CHARGE_PULLDOWN_200K, //下拉电阻档位选择
.ldo5v_pulldown_keep = 0,
//1、对于自动升压充电舱,若充电舱需要更大的负载才能检测到插入时，请将该变量置1,并且根据需求配置下拉电阻档位
//2、对于按键升压,并且是通过上拉电阻去提供维持电压的舱,请将该变量设置1,并且根据舱的上拉配置下拉需要的电阻挡位
//3、对于常5V的舱,可将改变量设为0,省功耗
//4、为LDOIN防止被误触发唤醒,可设置为200k下拉
.ldo5v_pulldown_en = 1,
CHARGE_PLATFORM_DATA_END()
#endif//TCFG_CHARGE_ENABLE
/************************** chargestore config****************************/
#if TCFG_CHARGESTORE_ENABLE || TCFG_TEST_BOX_ENABLE || TCFG_ANC_BOX_ENABLE
CHARGESTORE_PLATFORM_DATA_BEGIN(chargestore_data)
.io_port = TCFG_CHARGESTORE_PORT,
CHARGESTORE_PLATFORM_DATA_END()
#endif
/************************** DAC ****************************/
#if TCFG_AUDIO_DAC_ENABLE
struct dac_platform_data dac_data = {
.mode = TCFG_AUDIO_DAC_MODE, //dac输出模式
.ldo_id = TCFG_AUDIO_DAC_LDO_SEL, //保留位
.pa_mute_port = TCFG_AUDIO_DAC_PA_PORT, //暂时无作用
.vcmo_en = 0, //是否打开VCOMO
.pa_mute_value = 1, //暂时无作用
.output = TCFG_AUDIO_DAC_CONNECT_MODE, //DAC输出配置，和具体硬件连接有关，需根据硬件来设置
.lpf_isel = 0xf,
.sys_vol_type = SYS_VOL_TYPE, //系统音量选择：模拟音量/数字音量，调节时调节对应的音量
.max_ana_vol = MAX_ANA_VOL, //模拟音量最大等级
.max_dig_vol = MAX_DIG_VOL, //数字音量最大等级
/* .dig_vol_tab = (s16 *)dig_vol_table, //数字音量表 */
.vcm_cap_en = 1, //配1代表走外部通路,vcm上有电容时,可以提升电路抑制电源噪声能力，提高ADC的性能，配0相当于vcm上无电容，抑制电源噪声能力下降,ADC性能下降
#if (SYS_VOL_TYPE == VOL_TYPE_AD)
.digital_gain_limit = 16384,
#endif // #if (SYS_VOL_TYPE == VOL_TYPE_AD)
.power_on_mode = 0,
};
#endif
/************************** ADC ****************************/
#if TCFG_AUDIO_ADC_ENABLE
#ifndef TCFG_AUDIO_MIC0_BIAS_EN
#define TCFG_AUDIO_MIC0_BIAS_EN 0
#endif/*TCFG_AUDIO_MIC0_BIAS_EN*/
#ifndef TCFG_AUDIO_MIC1_BIAS_EN
#define TCFG_AUDIO_MIC1_BIAS_EN 0
#endif/*TCFG_AUDIO_MIC1_BIAS_EN*/
#ifndef TCFG_AUDIO_MIC2_BIAS_EN
#define TCFG_AUDIO_MIC2_BIAS_EN 0
#endif/*TCFG_AUDIO_MIC2_BIAS_EN*/
#ifndef TCFG_AUDIO_MIC3_BIAS_EN
#define TCFG_AUDIO_MIC3_BIAS_EN 0
#endif/*TCFG_AUDIO_MIC3_BIAS_EN*/
#ifndef TCFG_AUDIO_MIC_LDO_EN
#define TCFG_AUDIO_MIC_LDO_EN 0
#endif/*TCFG_AUDIO_MIC_LDO_EN*/
struct adc_platform_data adc_data = {
/*MIC LDO电流档位设置：
0:0.625ua 1:1.25ua 2:1.875ua 3:2.5ua*/
.mic_ldo_isel = TCFG_AUDIO_ADC_LD0_SEL,
/*mic_mode 工作模式定义
#define AUDIO_MIC_CAP_MODE 0 //单端隔直电容模式
#define AUDIO_MIC_CAP_DIFF_MODE 1 //差分隔直电容模式
#define AUDIO_MIC_CAPLESS_MODE 2 //单端省电容模式
*/
.mic_mode = TCFG_AUDIO_MIC_MODE,
.mic1_mode = TCFG_AUDIO_MIC1_MODE,
.mic2_mode = TCFG_AUDIO_MIC2_MODE,
.mic3_mode = TCFG_AUDIO_MIC3_MODE,
.mic_bias_inside = TCFG_AUDIO_MIC0_BIAS_EN,
.mic1_bias_inside = TCFG_AUDIO_MIC1_BIAS_EN,
.mic2_bias_inside = TCFG_AUDIO_MIC2_BIAS_EN,
.mic3_bias_inside = TCFG_AUDIO_MIC3_BIAS_EN,
/*MICLDO供电输出到PAD(PA0)控制使能*/
.mic_ldo_pwr = TCFG_AUDIO_MIC_LDO_EN, // MIC LDO 输出到 PA0
/*MIC免电容方案需要设置，影响MIC的偏置电压
0b0001~0b1001 : 0.5k ~ 4.5k step = 0.5k
0b1010~0b1111 : 5k ~ 10k step = 1k */
.mic_bias_res = 4,
.mic1_bias_res = 4,
.mic2_bias_res = 4,
.mic3_bias_res = 4,
/*MIC LDO电压档位设置,也会影响MIC的偏置电压
3:2.0v 4:2.2v 5:2.4v 6:2.6v 7:2.8v */
.mic_ldo_vsel = 5,
//mic的去直流dcc寄存器配置值,可配0到15,数值越大,其高通转折点越低
.mic_dcc = 8,
/*ADC低功耗等级,越大功耗越低，对应影响THD和底噪, 范围 (0 - 2)*/
.lowpower_lvl = 0,
};
#endif
const struct vad_mic_platform_data vad_mic_data = {
.mic_data = { //
.mic_mode = TCFG_AUDIO_MIC_MODE,
.mic_ldo_isel = 2,
.mic_ldo_vsel = 5,
.mic_ldo2PAD_en = 1,
.mic_bias_en = 0,
.mic_bias_res = 0,
.mic_bias_inside = TCFG_AUDIO_MIC0_BIAS_EN,
/* ADC偏置电阻配置*/
.adc_rbs = 3,
/* ADC输入电阻配置*/
.adc_rin = 3,
/*.adc_test = 1,*/
},
.power_data = {
/*VADLDO电压档位：0~7*/
.ldo_vs = 3,
/*VADLDO误差运放电流档位：0~3*/
#if TCFG_VAD_LOWPOWER_CLOCK == VAD_CLOCK_USE_PMU_STD12M
.ldo_is = 1,
#else
.ldo_is = 2,
#endif
.clock = TCFG_VAD_LOWPOWER_CLOCK, /*VAD时钟选项*/
.acm_select = 8,
},
};
/* struct audio_pf_data audio_pf_d = { */
/* #if TCFG_AUDIO_DAC_ENABLE */
/* .adc_pf_data = &adc_data, */
/* #endif */
/* #if TCFG_AUDIO_ADC_ENABLE */
/* .dac_pf_data = &dac_data, */
/* #endif */
/* }; */
/* struct audio_platform_data audio_data = { */
/* .private_data = (void *) &audio_pf_d, */
/* }; */
/************************** IO KEY ****************************/
#if TCFG_IOKEY_ENABLE
const struct iokey_port iokey_list[] = {
{
.connect_way = TCFG_IOKEY_POWER_CONNECT_WAY, //IO按键的连接方式
.key_type.one_io.port = TCFG_IOKEY_POWER_ONE_PORT, //IO按键对应的引脚
.key_value = 0, //按键值
},
};
const struct iokey_platform_data iokey_data = {
.enable = TCFG_IOKEY_ENABLE, //是否使能IO按键
.num = ARRAY_SIZE(iokey_list), //IO按键的个数
.port = iokey_list, //IO按键参数表
};
#if MULT_KEY_ENABLE
//组合按键消息映射表
//配置注意事项:单个按键按键值需要按照顺序编号,如power:0, prev:1, next:2
//bit_value = BIT(0) | BIT(1) 指按键值为0和按键值为1的两个按键被同时按下,
//remap_value = 3指当这两个按键被同时按下后重新映射的按键值;
const struct key_remap iokey_remap_table[] = {
{.bit_value = BIT(0) | BIT(1), .remap_value = 3},
{.bit_value = BIT(0) | BIT(2), .remap_value = 4},
{.bit_value = BIT(1) | BIT(2), .remap_value = 5},
};
const struct key_remap_data iokey_remap_data = {
.remap_num = ARRAY_SIZE(iokey_remap_table),
.table = iokey_remap_table,
};
#endif
#endif
/*********************** LP TOUCH KEY ****************************/
#if TCFG_LP_TOUCH_KEY_ENABLE
const struct lp_touch_key_platform_data lp_touch_key_config = {
/*触摸按键*/
.ch[0].enable = TCFG_LP_TOUCH_KEY0_EN,
.ch[0].wakeup_enable = TCFG_LP_TOUCH_KEY0_WAKEUP_EN,
.ch[0].port = IO_PORTB_00,
.ch[0].sensitivity = TCFG_LP_TOUCH_KEY0_SENSITIVITY,
.ch[0].key_value = 0,
.ch[1].enable = TCFG_LP_TOUCH_KEY1_EN,
.ch[1].wakeup_enable = TCFG_LP_TOUCH_KEY1_WAKEUP_EN,
.ch[1].port = IO_PORTB_01,
.ch[1].sensitivity = TCFG_LP_TOUCH_KEY1_SENSITIVITY,
.ch[1].key_value = 0,
.ch[2].enable = TCFG_LP_TOUCH_KEY2_EN,
.ch[2].wakeup_enable = TCFG_LP_TOUCH_KEY2_WAKEUP_EN,
.ch[2].port = IO_PORTB_02,
.ch[2].sensitivity = TCFG_LP_TOUCH_KEY2_SENSITIVITY,
.ch[2].key_value = 1,
.ch[3].enable = TCFG_LP_TOUCH_KEY3_EN,
.ch[3].wakeup_enable = TCFG_LP_TOUCH_KEY3_WAKEUP_EN,
.ch[3].port = IO_PORTB_04,
.ch[3].sensitivity = TCFG_LP_TOUCH_KEY3_SENSITIVITY,
.ch[3].key_value = 2,
.ch[4].enable = TCFG_LP_TOUCH_KEY4_EN,
.ch[4].wakeup_enable = TCFG_LP_TOUCH_KEY4_WAKEUP_EN,
.ch[4].port = IO_PORTB_05,
.ch[4].sensitivity = TCFG_LP_TOUCH_KEY4_SENSITIVITY,
.ch[4].key_value = 3,
//把触摸按键之间的滑动也当做按键处理，有上滑，下滑，左滑，右滑
.slide_mode_en = TCFG_LP_SLIDE_KEY_ENABLE,
.slide_mode_key_value = 3,
//入耳检测相关的配置
.eartch_en = TCFG_LP_EARTCH_KEY_ENABLE,
.eartch_ch = TCFG_LP_EARTCH_KEY_CH,
.eartch_ref_ch = TCFG_LP_EARTCH_KEY_REF_CH,
.eartch_soft_inear_val = TCFG_LP_EARTCH_SOFT_INEAR_VAL,
.eartch_soft_outear_val = TCFG_LP_EARTCH_SOFT_OUTEAR_VAL,
};
#endif /* #if TCFG_LP_TOUCH_KEY_ENABLE */
/************************** PLCNT TOUCH_KEY ****************************/
#if TCFG_TOUCH_KEY_ENABLE
const const struct touch_key_port touch_key_list[] = {
{
.press_delta = TCFG_TOUCH_KEY0_PRESS_DELTA,
.port = TCFG_TOUCH_KEY0_PORT,
.key_value = TCFG_TOUCH_KEY0_VALUE,
},
{
.press_delta = TCFG_TOUCH_KEY1_PRESS_DELTA,
.port = TCFG_TOUCH_KEY1_PORT,
.key_value = TCFG_TOUCH_KEY1_VALUE,
},
};
const struct touch_key_platform_data touch_key_data = {
.num = ARRAY_SIZE(touch_key_list),
.port_list = touch_key_list,
};
#endif /* #if TCFG_TOUCH_KEY_ENABLE */
/************************** AD KEY ****************************/
#if TCFG_ADKEY_ENABLE
const struct adkey_platform_data adkey_data = {
.enable = TCFG_ADKEY_ENABLE, //AD按键使能
.adkey_pin = TCFG_ADKEY_PORT, //AD按键对应引脚
.ad_channel = TCFG_ADKEY_AD_CHANNEL, //AD通道值
.extern_up_en = TCFG_ADKEY_EXTERN_UP_ENABLE, //是否使用外接上拉电阻
.ad_value = { //根据电阻算出来的电压值
TCFG_ADKEY_VOLTAGE0,
TCFG_ADKEY_VOLTAGE1,
TCFG_ADKEY_VOLTAGE2,
TCFG_ADKEY_VOLTAGE3,
TCFG_ADKEY_VOLTAGE4,
TCFG_ADKEY_VOLTAGE5,
TCFG_ADKEY_VOLTAGE6,
TCFG_ADKEY_VOLTAGE7,
TCFG_ADKEY_VOLTAGE8,
TCFG_ADKEY_VOLTAGE9,
},
.key_value = { //AD按键各个按键的键值
TCFG_ADKEY_VALUE0,
TCFG_ADKEY_VALUE1,
TCFG_ADKEY_VALUE2,
TCFG_ADKEY_VALUE3,
TCFG_ADKEY_VALUE4,
TCFG_ADKEY_VALUE5,
TCFG_ADKEY_VALUE6,
TCFG_ADKEY_VALUE7,
TCFG_ADKEY_VALUE8,
TCFG_ADKEY_VALUE9,
},
};
#endif
/************************** RDEC_KEY ****************************/
#if TCFG_RDEC_KEY_ENABLE
const struct rdec_device rdeckey_list[] = {
{
.index = RDEC0 ,
.sin_port0 = TCFG_RDEC0_ECODE1_PORT,
.sin_port1 = TCFG_RDEC0_ECODE2_PORT,
.key_value0 = TCFG_RDEC0_KEY0_VALUE | BIT(7),
.key_value1 = TCFG_RDEC0_KEY1_VALUE | BIT(7),
},
{
.index = RDEC1 ,
.sin_port0 = TCFG_RDEC1_ECODE1_PORT,
.sin_port1 = TCFG_RDEC1_ECODE2_PORT,
.key_value0 = TCFG_RDEC1_KEY0_VALUE | BIT(7),
.key_value1 = TCFG_RDEC1_KEY1_VALUE | BIT(7),
},
{
.index = RDEC2 ,
.sin_port0 = TCFG_RDEC2_ECODE1_PORT,
.sin_port1 = TCFG_RDEC2_ECODE2_PORT,
.key_value0 = TCFG_RDEC2_KEY0_VALUE | BIT(7),
.key_value1 = TCFG_RDEC2_KEY1_VALUE | BIT(7),
},
};
const struct rdec_platform_data rdec_key_data = {
.enable = 1, //TCFG_RDEC_KEY_ENABLE, //是否使能RDEC按键
.num = ARRAY_SIZE(rdeckey_list), //RDEC按键的个数
.rdec = rdeckey_list, //RDEC按键参数表
};
#endif
/************************** IIS config ****************************/
#if (TCFG_AUDIO_INPUT_IIS || TCFG_AUDIO_OUTPUT_IIS)
ALINK_PARM alink0_platform_data = {
.module = ALINK0,
.mclk_io = TCFG_IIS_MCLK_IO,
.sclk_io = TCFG_SCLK_IO,
.lrclk_io = TCFG_LRCLK_IO,
.ch_cfg[0].data_io = TCFG_DATA0_IO,
.ch_cfg[1].data_io = TCFG_DATA1_IO,
.ch_cfg[2].data_io = TCFG_DATA2_IO,
.ch_cfg[3].data_io = TCFG_DATA3_IO,
.mode = ALINK_MD_IIS,
#if TCFG_IIS_MODE
.role = ALINK_ROLE_SLAVE,
#else
.role = ALINK_ROLE_MASTER,
#endif /*TCFG_IIS_MODE*/
.clk_mode = ALINK_CLK_FALL_UPDATE_RAISE_SAMPLE,
.bitwide = ALINK_LEN_16BIT,
.sclk_per_frame = ALINK_FRAME_32SCLK,
.dma_len = 4 * 1024,
.sample_rate = TCFG_IIS_SR,
.buf_mode = ALINK_BUF_CIRCLE,
/*.iperiod = 64, //配置该项可以控制输入的延时*/
};
#endif
/************************** PWM_LED ****************************/
#if TCFG_PWMLED_ENABLE
LED_PLATFORM_DATA_BEGIN(pwm_led_data)
.io_mode = TCFG_PWMLED_IOMODE, //推灯模式设置:支持单个IO推两个灯和两个IO推两个灯
.io_cfg.one_io.pin = TCFG_PWMLED_PIN, //单个IO推两个灯的IO口配置
LED_PLATFORM_DATA_END()
#endif
const struct soft_iic_config soft_iic_cfg[] = {
#if 0
//iic0 data
{
.scl = TCFG_SW_I2C0_CLK_PORT, //IIC CLK脚
.sda = TCFG_SW_I2C0_DAT_PORT, //IIC DAT脚
.delay = TCFG_SW_I2C0_DELAY_CNT, //软件IIC延时参数，影响通讯时钟频率
.io_pu = 1, //是否打开上拉电阻，如果外部电路没有焊接上拉电阻需要置1
},
#endif
#if 0
//iic1 data
{
.scl = IO_PORTA_05,
.sda = IO_PORTA_06,
.delay = 50,
.io_pu = 1,
},
#endif
};
const struct hw_iic_config hw_iic_cfg[] = {
#if 0
//iic0 data
{
/*硬件IIC端口下选择
SCL SDA
{IO_PORT_DP, IO_PORT_DM}, //group a
{IO_PORTC_04, IO_PORTC_05}, //group b
{IO_PORTC_02, IO_PORTC_03}, //group c
{IO_PORTA_05, IO_PORTA_06}, //group d
*/
.port = TCFG_HW_I2C0_PORTS,
.baudrate = TCFG_HW_I2C0_CLK, //IIC通讯波特率
.hdrive = 0, //是否打开IO口强驱
.io_filter = 1, //是否打开滤波器（去纹波）
.io_pu = 1, //是否打开上拉电阻，如果外部电路没有焊接上拉电阻需要置1
},
#endif
};
#if TCFG_SD0_ENABLE
SD0_PLATFORM_DATA_BEGIN(sd0_data)
.port = {
TCFG_SD0_PORT_CMD,
TCFG_SD0_PORT_CLK,
TCFG_SD0_PORT_DA0,
TCFG_SD0_PORT_DA1,
TCFG_SD0_PORT_DA2,
TCFG_SD0_PORT_DA3,
},
.data_width = TCFG_SD0_DAT_MODE,
.speed = TCFG_SD0_CLK,
.detect_mode = TCFG_SD0_DET_MODE,
.priority = 3,
#if (TCFG_SD0_DET_MODE == SD_IO_DECT)
.detect_io = TCFG_SD0_DET_IO,
.detect_io_level = TCFG_SD0_DET_IO_LEVEL,
.detect_func = sdmmc_0_io_detect,
.power = sd_set_power,
/* .power = NULL, */
#elif (TCFG_SD0_DET_MODE == SD_CLK_DECT)
.detect_io_level = TCFG_SD0_DET_IO_LEVEL,
.detect_func = sdmmc_0_clk_detect,
.power = sd_set_power,
/* .power = NULL, */
#else
.detect_func = sdmmc_cmd_detect,
.power = NULL,
#endif
SD0_PLATFORM_DATA_END()
#endif /* #if TCFG_SD0_ENABLE */
REGISTER_DEVICES(device_table) = {
/* { "audio", &audio_dev_ops, (void *) &audio_data }, */
#if TCFG_CHARGE_ENABLE
{ "charge", &charge_dev_ops, (void *)&charge_data },
#endif
#if TCFG_SD0_ENABLE
{ "sd0", &sd_dev_ops, (void *) &sd0_data},
#endif
};
/************************** power_param ****************************/
const struct low_power_param power_param = {
.config = TCFG_LOWPOWER_LOWPOWER_SEL, //低功耗使能，蓝牙&&系统空闲可进入低功耗
.btosc_hz = TCFG_CLOCK_OSC_HZ, //蓝牙晶振频率
.delay_us = TCFG_CLOCK_SYS_HZ / 1000000L, //提供给低功耗模块的延时(不需要需修改)
.vddiom_lev = TCFG_LOWPOWER_VDDIOM_LEVEL, //vddiom等级
.osc_type = TCFG_LOWPOWER_OSC_TYPE, //低功耗晶振类型，btosc/lrc
#if (TCFG_LOWPOWER_RAM_SIZE)
.mem_init_con = MEM_PWR_RAM_SET(TCFG_LOWPOWER_RAM_SIZE),
#else
.mem_init_con = 0,
#endif
#if (TCFG_LP_TOUCH_KEY_ENABLE && \
(TCFG_LP_TOUCH_KEY0_WAKEUP_EN || \
TCFG_LP_TOUCH_KEY1_WAKEUP_EN || \
TCFG_LP_TOUCH_KEY2_WAKEUP_EN || \
TCFG_LP_TOUCH_KEY3_WAKEUP_EN || \
TCFG_LP_TOUCH_KEY4_WAKEUP_EN ))
.lpctmu_en = 1,
#else
.lpctmu_en = 0,
#endif
};
/************************** wk_param ****************************/
struct port_wakeup port0 = {
.pullup_down_enable = ENABLE, //配置I/O 内部上下拉是否使能
.edge = FALLING_EDGE, //唤醒方式选择,可选：上升沿\下降沿
.filter = PORT_FLT_8ms,
.iomap = TCFG_IOKEY_POWER_ONE_PORT, //唤醒口选择
};
#if (TCFG_TEST_BOX_ENABLE || TCFG_CHARGESTORE_ENABLE || TCFG_ANC_BOX_ENABLE || TCFG_UMIDIGI_BOX_ENABLE)
struct port_wakeup port1 = {
.pullup_down_enable = DISABLE, //配置I/O 内部上下拉是否使能
.edge = FALLING_EDGE, //唤醒方式选择,可选：上升沿\下降沿
.filter = PORT_FLT_1ms,
.iomap = TCFG_CHARGESTORE_PORT, //唤醒口选择
};
#endif
#if TCFG_CHARGE_ENABLE
struct port_wakeup charge_port = {
.edge = RISING_EDGE, //唤醒方式选择,可选：上升沿\下降沿\双边沿
.filter = PORT_FLT_16ms,
.iomap = IO_CHGFL_DET, //唤醒口选择
};
struct port_wakeup vbat_port = {
.edge = BOTH_EDGE, //唤醒方式选择,可选：上升沿\下降沿\双边沿
.filter = PORT_FLT_16ms,
.iomap = IO_VBTCH_DET, //唤醒口选择
};
struct port_wakeup ldoin_port = {
.edge = BOTH_EDGE, //唤醒方式选择,可选：上升沿\下降沿\双边沿
.filter = PORT_FLT_16ms,
.iomap = IO_LDOIN_DET, //唤醒口选择
};
#endif
const struct wakeup_param wk_param = {
#if (!(TCFG_LP_TOUCH_KEY_ENABLE && TCFG_LP_TOUCH_KEY1_EN))
.port[1] = &port0,
#endif
#if (TCFG_TEST_BOX_ENABLE || TCFG_CHARGESTORE_ENABLE || TCFG_ANC_BOX_ENABLE || TCFG_UMIDIGI_BOX_ENABLE)
.port[2] = &port1,
#endif
#if TCFG_CHARGE_ENABLE
.aport[0] = &charge_port,
.aport[1] = &vbat_port,
.aport[2] = &ldoin_port,
#endif
};
void gSensor_wkupup_disable(void)
{
log_info("gSensor wkup disable\n");
power_wakeup_index_enable(1, 0);
}
void gSensor_wkupup_enable(void)
{
log_info("gSensor wkup enable\n");
power_wakeup_index_enable(1, 1);
}
void debug_uart_init(const struct uart_platform_data *data)
{
#if TCFG_UART0_ENABLE
if (data) {
uart_init(data);
} else {
uart_init(&uart0_data);
}
#endif
}
STATUS *get_led_config(void)
{
return &(__this->led);
}
STATUS *get_tone_config(void)
{
return &(__this->tone);
}
u8 get_sys_default_vol(void)
{
return 21;
}
u8 get_power_on_status(void)
{
#if TCFG_IOKEY_ENABLE
struct iokey_port *power_io_list = NULL;
power_io_list = iokey_data.port;
if (iokey_data.enable) {
if (gpio_read(power_io_list->key_type.one_io.port) == power_io_list->connect_way){
return 1;
}
}
#endif
#if TCFG_ADKEY_ENABLE
if (adkey_data.enable) {
return 1;
}
#endif
#if TCFG_LP_TOUCH_KEY_ENABLE
return lp_touch_key_power_on_status();
#endif
return 0;
}
static void board_devices_init(void)
{
#if TCFG_PWMLED_ENABLE
pwm_led_init(&pwm_led_data);
#endif
#if (TCFG_IOKEY_ENABLE || TCFG_ADKEY_ENABLE || TCFG_RDEC_KEY_ENABLE || TCFG_TOUCH_KEY_ENABLE)
key_driver_init();
#endif
#if TCFG_UART_KEY_ENABLE
extern int uart_key_init(void);
uart_key_init();
#endif /* #if TCFG_UART_KEY_ENABLE */
#if TCFG_LP_TOUCH_KEY_ENABLE
lp_touch_key_init(&lp_touch_key_config);
#endif /* #if TCFG_LP_TOUCH_KEY_ENABLE */
#if (!TCFG_CHARGE_ENABLE)
CHARGE_EN(0);
CHGGO_EN(0);
#endif
#if TCFG_CHARGESTORE_ENABLE || TCFG_TEST_BOX_ENABLE || TCFG_ANC_BOX_ENABLE
chargestore_api_init(&chargestore_data);
#endif
}
//外置触摸电源控制 1:输出高 0:输出地
static void pwr_set_external_touch(u8 high_low)
{
if(TCFG_EXTERNAL_TOUCH_KEY_POWER_PORT == NO_CONFIG_PORT){
return;
}
gpio_set_pull_up(TCFG_EXTERNAL_TOUCH_KEY_POWER_PORT, 1);
gpio_set_pull_down(TCFG_EXTERNAL_TOUCH_KEY_POWER_PORT, 0);
gpio_set_direction(TCFG_EXTERNAL_TOUCH_KEY_POWER_PORT, 0);
gpio_set_output_value(TCFG_EXTERNAL_TOUCH_KEY_POWER_PORT, high_low);
}
#if CLIENT_BOARD == CUSTOM9_CFG
#define TCFG_TALKING_FB_MIC_IO IO_PORTB_02
/*
0:MIC0 作为FB MIC,引脚输出低电平。
1：MIC0 作为通话MIC，引脚输出高电平。
*/
void TALKING_FB_MIC_sel(u8 mic_type)
{
gpio_set_pull_up(TCFG_TALKING_FB_MIC_IO , 0);
gpio_set_pull_down(TCFG_TALKING_FB_MIC_IO , 0);
gpio_set_direction(TCFG_TALKING_FB_MIC_IO , 0);
gpio_set_die(TCFG_TALKING_FB_MIC_IO , 1);
switch (mic_type)
{
case 0:
gpio_set_output_value(TCFG_TALKING_FB_MIC_IO , 0);
break;
case 1:
gpio_set_output_value(TCFG_TALKING_FB_MIC_IO , 1);
break;
default:
break;
}
}
static u8 dcda_en_state = 0;
#define DCDC_EN_PORT IO_PORTC_02
static void dcdc_en(u8 en)
{
if (dcda_en_state == en)
{
return ;
}
dcda_en_state = en;
gpio_set_die(DCDC_EN_PORT, 0);
gpio_set_direction(IO_PORTB_04, 0);
gpio_set_pull_up(DCDC_EN_PORT, 0);
gpio_set_pull_down(DCDC_EN_PORT, 0);
switch (en)
{
case 0:
printf("external dcdc disable \n");
gpio_direction_output(DCDC_EN_PORT, 0);
break;
case 1:
printf("external dcdc enable \n");
gpio_direction_output(DCDC_EN_PORT, 1);
break;
default:
break;
}
}
static void dcdc_init(void)
{
gpio_set_die(DCDC_EN_PORT, 0);
gpio_set_direction(IO_PORTB_04, 0);
gpio_set_pull_up(DCDC_EN_PORT, 0);
gpio_set_pull_down(DCDC_EN_PORT, 0);
gpio_direction_output(DCDC_EN_PORT, 0);
dcda_en_state = 0;
}
/*dcdc switch*/
void audio_dac_power_state(u8 state)
{
switch (state)
{
case DAC_ANALOG_OPEN_PREPARE:
dcdc_en(1);
break;
case DAC_ANALOG_OPEN_FINISH:
break;
case DAC_ANALOG_CLOSE_PREPARE:
break;
case DAC_ANALOG_CLOSE_FINISH:
dcdc_en(0);
break;
default:
break;
}
}
#endif
extern void cfg_file_parse(u8 idx);
void board_init()
{
pwr_set_external_touch(1);
board_power_init();
//adc_vbg_init();
adc_init();
#if CLIENT_BOARD == CUSTOM9_CFG
dcdc_init();
TALKING_FB_MIC_sel(0);
#endif
cfg_file_parse(0);
devices_init();
#if TCFG_AUDIO_ANC_ENABLE
anc_init();
#endif/*TCFG_AUDIO_ANC_ENABLE*/
board_devices_init();
#if TCFG_CHARGE_ENABLE
if(get_charge_online_flag())
#else
if (0)
#endif
{
power_set_mode(PWR_LDO15);
}else{
power_set_mode(TCFG_LOWPOWER_POWER_SEL);
}
//针对硅mic要输出1给mic供电
/* gpio_set_pull_up(IO_PORTA_04, 0); */
/* gpio_set_pull_down(IO_PORTA_04, 0); */
/* gpio_set_direction(IO_PORTA_04, 0); */
/* gpio_set_output_value(IO_PORTA_04,1); */
#if TCFG_UART0_ENABLE
if (uart0_data.rx_pin < IO_MAX_NUM) {
gpio_set_die(uart0_data.rx_pin, 1);
}
#endif
#if TCFG_SMART_VOICE_ENABLE
int audio_smart_voice_detect_init(struct vad_mic_platform_data *mic_data);
audio_smart_voice_detect_init((struct vad_mic_platform_data *)&vad_mic_data);
#endif /* #if TCFG_SMART_VOICE_ENABLE */
#ifdef CONFIG_BOARD_AISPEECH_VAD_ASR
extern int audio_ais_platform_asr_init(struct vad_mic_platform_data *mic_data);
audio_ais_platform_asr_init((struct vad_mic_platform_data *)&vad_mic_data);
#endif /*CONFIG_BOARD_AISPEECH_VAD_ASR*/
#ifdef AUDIO_PCM_DEBUG
extern void uartSendInit();
uartSendInit();
#endif/*AUDIO_PCM_DEBUG*/
}
/*进软关机之前默认将IO口都设置成高阻状态，需要保留原来状态的请修改该函数*/
extern void dac_power_off(void);
void board_set_soft_poweroff(void)
{
//power按键
#if TCFG_IOKEY_ENABLE
soff_gpio_protect(TCFG_IOKEY_POWER_ONE_PORT);
#endif
soff_gpio_protect(TCFG_EXTERNAL_TOUCH_KEY_POWER_PORT);//软关机KEEP外置触摸供电
#if (!(TCFG_LP_TOUCH_KEY_ENABLE && TCFG_LP_TOUCH_KEY1_EN))
//默认唤醒io
soff_gpio_protect(IO_PORTB_01);
#endif
#if (TCFG_TEST_BOX_ENABLE || TCFG_CHARGESTORE_ENABLE || TCFG_ANC_BOX_ENABLE || TCFG_UMIDIGI_BOX_ENABLE)
power_wakeup_index_enable(2, 0);
#endif
board_set_soft_poweroff_common(NULL);
dac_power_off();
}
#define APP_IO_DEBUG_0(i,x) {JL_PORT##i->DIR &= ~BIT(x), JL_PORT##i->OUT &= ~BIT(x);}
#define APP_IO_DEBUG_1(i,x) {JL_PORT##i->DIR &= ~BIT(x), JL_PORT##i->OUT |= BIT(x);}
void sleep_exit_callback(u32 usec)
{
sleep_exit_callback_common(NULL);
putchar('>');
}
void sleep_enter_callback(u8 step)
{
/* 此函数禁止添加打印 */
if (step == 1) {
putchar('<');
} else {
//外置触摸供电
pwr_set_external_touch(1);
sleep_enter_callback_common(NULL);
}
}
static void port_wakeup_callback(u8 index, u8 gpio)
{
log_info("%s:%d,%d",__FUNCTION__,index,gpio);
#if TCFG_UMIDIGI_BOX_ENABLE
if (index == 2) {
ldo_port_wakeup_to_cmessage();
}
#endif
switch (index) {
#if (TCFG_TEST_BOX_ENABLE || TCFG_CHARGESTORE_ENABLE || TCFG_ANC_BOX_ENABLE)
case 2:
extern void chargestore_ldo5v_fall_deal(void);
chargestore_ldo5v_fall_deal();
break;
#endif
}
}
static void aport_wakeup_callback(u8 index, u8 gpio, u8 edge)
{
log_info("%s:%d,%d",__FUNCTION__,index,gpio);
#if TCFG_CHARGE_ENABLE
switch (gpio) {
case IO_CHGFL_DET://charge port
charge_wakeup_isr();
break;
case IO_VBTCH_DET://vbat port
case IO_LDOIN_DET://ldoin port
ldoin_wakeup_isr();
break;
}
#endif
}
void board_power_init(void)
{
log_info("Power init : %s", __FILE__);
power_init(&power_param);
power_set_callback(TCFG_LOWPOWER_LOWPOWER_SEL, sleep_enter_callback, sleep_exit_callback, board_set_soft_poweroff);
#if TCFG_UMIDIGI_BOX_ENABLE
gpio_set_die(TCFG_CHARGESTORE_PORT, 1);
umidigi_chargestore_message_callback(app_umidigi_chargetore_message_deal);
#endif
power_keep_dacvdd_en(0);
power_wakeup_init(&wk_param);
power_awakeup_set_callback(aport_wakeup_callback);
power_wakeup_set_callback(port_wakeup_callback);
}
#endif /* #ifdef CONFIG_BOARD_JL701N_ANC */

1382
apps/xtell_hide/board/br28/board_jl701n_anc_cfg.h Normal file
View File

File diff suppressed because it is too large Load Diff

123
apps/xtell_hide/board/br28/board_jl701n_anc_global_build_cfg.h Normal file
View File

@ -0,0 +1,123 @@
#ifndef CONFIG_BOARD_JL701N_ANC_POST_BUILD_CFG_H
#define CONFIG_BOARD_JL701N_ANC_POST_BUILD_CFG_H
/* 改文件只添加和isd_config.ini相关的配置，用以生成isd_config.ini */
/* 其他不相关的配置请勿添加在改文件 */
#ifdef CONFIG_BOARD_JL701N_ANC
/* Following Macros Affect Periods Of Both Code Compiling And Post-build */
#define CONFIG_DOUBLE_BANK_ENABLE 0 //单双备份选择(若打开了改宏,FLASH结构变为双备份结构，适用于接入第三方协议的OTA， PS: JL-OTA同样支持双备份升级, 需要根据实际FLASH大小同时配置CONFIG_FLASH_SIZE)
#define CONFIG_APP_OTA_ENABLE 0 //是否支持RCSP升级(JL-OTA)
#define CONFIG_UPDATE_JUMP_TO_MASK 0 //配置升级到loader的方式0为直接reset,1为跳转(适用于芯片电源由IO口KEEP住的方案,需要注意检查跳转前是否将使用DMA的硬件模块全部关闭)
#define CONFIG_IO_KEY_EN 0 //配置是否使用IO按键，配合RESET1
#define CONFIG_UPDATE_WITH_MD5_CHECK_EN 0 //配置升级是否支持MD5校验
#define CONFIG_ANC_ENABLE 1 //配置是否支持ANC
//flash size vaule definition
#define FLASH_SIZE_256K 0x40000
#define FLASH_SIZE_512K 0x80000
#define FLASH_SIZE_1M 0x100000
#define FLASH_SIZE_2M 0x200000
#define FLASH_SIZE_4M 0x400000
#define CONFIG_FLASH_SIZE FLASH_SIZE_1M //配置FLASH大小
/* Above Macros Affect Periods Of Both Code Compiling And Post-build */
/* Following Macros Only For Post Bulid Configuaration */
#define CONFIG_DB_UPDATE_DATA_GENERATE_EN 0 //是否生成db_data.bin(用于第三方协议接入使用)
#define CONFIG_ONLY_GRENERATE_ALIGN_4K_CODE 0 //ufw只生成1份4K对齐的代码
//config for supported chip version
#ifdef CONFIG_BR30_C_VERSION
#define CONFIG_SUPPORTED_CHIP_VERSION C
#else
#define CONFIG_SUPPORTED_CHIP_VERSION B,D,E,M,N,O,P
#endif
//DON'T MODIFY THIS CONFIG EXCEPT SDK PUBLISHER
#define CONFIG_CHIP_NAME AC701N //除了SDK发布者,请不要修改
//it can be modified before first programming,but keep the same as the original version
#define CONFIG_PID AC701N //烧写或强制升级之前可以修改,之后升级要保持一致
//it can be modified before first programming,but keep the same as the original version
#define CONFIG_VID 0.01 //烧写或强制升级之前可以修改,之后升级要保持一致
//Project with bluetooth,it must use OSC as PLL_SOURCE;
#define CONFIG_PLL_SOURCE_USING_LRC 0 //PLL时钟源选择 1:LRC 2:OSC
//config alignment size unit
#ifdef CONFIG_256K_FLASH
#define ALIGN_UNIT_256B 1 //FLASH对齐方式选择，如果是256K的FLASH，选择256BYTE对齐方式
#else
#define ALIGN_UNIT_256B 0
#endif
//partial platform check this config to select the uart IO for wired update
#define CONFIG_UART_UPDATE_PIN PP00
//isd_download loader/uboot/update_loader debug io config
//#define CONFIG_UBOOT_DEBUG_PIN PA05
//#define CONFIG_UBOOT_DEBUG_BAUD_RATE 1000000
//config long-press reset io pin,time,trigger level
#define CONFIG_RESET_PIN LDO //io pin
#define CONFIG_RESET_TIME 04 //unit:second
#define CONFIG_RESET_LEVEL 1 //tigger level(0/1)
#if CONFIG_IO_KEY_EN
#define CONFIG_SUPPORT_RESET1
#define CONFIG_RESET1_PIN PB01 //io pin
#define CONFIG_RESET1_TIME 08 //unit:second
#define CONFIG_RESET1_LEVEL 0 //tigger level(0/1)
#endif
//reserved three custom cfg item for the future definition
//#define CONFIG_CUSTOM_CFG1_TYPE POWER_PIN
//#define CONFIG_CUSTOM_CFG1_VALUE PC01_1
//#define CONFIG_CUSTOM_CFG2_TYPE
//#define CONFIG_CUSTOM_CFG2_VALUE
//#define CONFIG_CUSTOM_CFG3_TYPE
//#define CONFIG_CUSTOM_CFG3_VALUE
//#define CONFIG_VDDIO_LVD_LEVEL 4 ////VDDIO_LVD挡位，0: 1.9V 1: 2.0V 2: 2.1V 3: 2.2V 4: 2.3V 5: 2.4V 6: 2.5V 7: 2.6V
//with single-bank mode,actual vm size should larger this VM_LEAST_SIZE,and dual bank mode,actual vm size equals this;
#define CONFIG_VM_LEAST_SIZE 8K
//config whether erased this area when do a update,1-No Operation,0-Erase
#define CONFIG_VM_OPT 1
//config whether erased this area when do a update,1-No Operation,0-Erase
#define CONFIG_BTIF_OPT 1
//reserved two custom cfg area for the future definition
//#define CONFIG_RESERVED_AREA1 EXIF1
#ifdef CONFIG_RESERVED_AREA1
#define CONFIG_RESERVED_AREA1_ADDR AUTO
#define CONFIG_RESERVED_AREA1_LEN 0x1000
#define CONFIG_RESERVED_AREA1_OPT 1
//#define CONFIG_RESERVED_AREA1_FILE anc_gains.bin
#endif
//#define CONFIG_RESERVED_AREA2 EXIF2
#ifdef CONFIG_RESERVED_AREA2
#define CONFIG_RESERVED_AREA2_ADDR AUTO
#define CONFIG_RESERVED_AREA2_LEN 0x1000
#define CONFIG_RESERVED_AREA2_OPT 1
//#define CONFIG_RESERVED_AREA2_FILE anc_gains.bin
#endif
/* Above Macros Only For Post Bulid Configuaration */
#endif /* #ifdef CONFIG_BOARD_JL701N_ANC */
#endif /* #ifndef CONFIG_BOARD_JL701N_ANC_POST_BUILD_CFG_H */

1042
apps/xtell_hide/board/br28/board_jl701n_btemitter.c Normal file
View File

File diff suppressed because it is too large Load Diff

1215
apps/xtell_hide/board/br28/board_jl701n_btemitter_cfg.h Normal file
View File

File diff suppressed because it is too large Load Diff

123
apps/xtell_hide/board/br28/board_jl701n_btemitter_global_build_cfg.h Normal file
View File

@ -0,0 +1,123 @@
#ifndef CONFIG_BOARD_JL701N_BTEMITTER_BUILD_CFG_H
#define CONFIG_BOARD_JL701N_BTEMITTER_BUILD_CFG_H
/* 改文件只添加和isd_config.ini相关的配置，用以生成isd_config.ini */
/* 其他不相关的配置请勿添加在改文件 */
#ifdef CONFIG_BOARD_JL701N_BTEMITTER
/* Following Macros Affect Periods Of Both Code Compiling And Post-build */
#define CONFIG_DOUBLE_BANK_ENABLE 0 //单双备份选择(若打开了改宏,FLASH结构变为双备份结构，适用于接入第三方协议的OTA， PS: JL-OTA同样支持双备份升级, 需要根据实际FLASH大小同时配置CONFIG_FLASH_SIZE)
#define CONFIG_APP_OTA_ENABLE 0 //是否支持RCSP升级(JL-OTA)
#define CONFIG_UPDATE_JUMP_TO_MASK 0 //配置升级到loader的方式0为直接reset,1为跳转(适用于芯片电源由IO口KEEP住的方案,需要注意检查跳转前是否将使用DMA的硬件模块全部关闭)
#define CONFIG_IO_KEY_EN 0 //配置是否使用IO按键，配合RESET1
#define CONFIG_UPDATE_WITH_MD5_CHECK_EN 0 //配置升级是否支持MD5校验
#define CONFIG_ANC_ENABLE 0 //配置是否支持ANC
//flash size vaule definition
#define FLASH_SIZE_256K 0x40000
#define FLASH_SIZE_512K 0x80000
#define FLASH_SIZE_1M 0x100000
#define FLASH_SIZE_2M 0x200000
#define FLASH_SIZE_4M 0x400000
#define CONFIG_FLASH_SIZE FLASH_SIZE_1M //配置FLASH大小
/* Above Macros Affect Periods Of Both Code Compiling And Post-build */
/* Following Macros Only For Post Bulid Configuaration */
#define CONFIG_DB_UPDATE_DATA_GENERATE_EN 0 //是否生成db_data.bin(用于第三方协议接入使用)
#define CONFIG_ONLY_GRENERATE_ALIGN_4K_CODE 0 //ufw只生成1份4K对齐的代码
//config for supported chip version
#ifdef CONFIG_BR30_C_VERSION
#define CONFIG_SUPPORTED_CHIP_VERSION C
#else
#define CONFIG_SUPPORTED_CHIP_VERSION B,D,E,M,N,O,P
#endif
//DON'T MODIFY THIS CONFIG EXCEPT SDK PUBLISHER
#define CONFIG_CHIP_NAME AC701N //除了SDK发布者,请不要修改
//it can be modified before first programming,but keep the same as the original version
#define CONFIG_PID AC701N //烧写或强制升级之前可以修改,之后升级要保持一致
//it can be modified before first programming,but keep the same as the original version
#define CONFIG_VID 0.01 //烧写或强制升级之前可以修改,之后升级要保持一致
//Project with bluetooth,it must use OSC as PLL_SOURCE;
#define CONFIG_PLL_SOURCE_USING_LRC 0 //PLL时钟源选择 1:LRC 2:OSC
//config alignment size unit
#ifdef CONFIG_256K_FLASH
#define ALIGN_UNIT_256B 1 //FLASH对齐方式选择，如果是256K的FLASH，选择256BYTE对齐方式
#else
#define ALIGN_UNIT_256B 0
#endif
//partial platform check this config to select the uart IO for wired update
#define CONFIG_UART_UPDATE_PIN PP00
//isd_download loader/uboot/update_loader debug io config
//#define CONFIG_UBOOT_DEBUG_PIN PA05
//#define CONFIG_UBOOT_DEBUG_BAUD_RATE 1000000
//config long-press reset io pin,time,trigger level
#define CONFIG_RESET_PIN LDO //io pin
#define CONFIG_RESET_TIME 04 //unit:second
#define CONFIG_RESET_LEVEL 1 //tigger level(0/1)
#if CONFIG_IO_KEY_EN
#define CONFIG_SUPPORT_RESET1
#define CONFIG_RESET1_PIN PB01 //io pin
#define CONFIG_RESET1_TIME 08 //unit:second
#define CONFIG_RESET1_LEVEL 0 //tigger level(0/1)
#endif
//reserved three custom cfg item for the future definition
//#define CONFIG_CUSTOM_CFG1_TYPE POWER_PIN
//#define CONFIG_CUSTOM_CFG1_VALUE PC01_1
//#define CONFIG_CUSTOM_CFG2_TYPE
//#define CONFIG_CUSTOM_CFG2_VALUE
//#define CONFIG_CUSTOM_CFG3_TYPE
//#define CONFIG_CUSTOM_CFG3_VALUE
//#define CONFIG_VDDIO_LVD_LEVEL 4 ////VDDIO_LVD挡位，0: 1.9V 1: 2.0V 2: 2.1V 3: 2.2V 4: 2.3V 5: 2.4V 6: 2.5V 7: 2.6V
//with single-bank mode,actual vm size should larger this VM_LEAST_SIZE,and dual bank mode,actual vm size equals this;
#define CONFIG_VM_LEAST_SIZE 8K
//config whether erased this area when do a update,1-No Operation,0-Erase
#define CONFIG_VM_OPT 1
//config whether erased this area when do a update,1-No Operation,0-Erase
#define CONFIG_BTIF_OPT 1
//reserved two custom cfg area for the future definition
//#define CONFIG_RESERVED_AREA1 EXIF1
#ifdef CONFIG_RESERVED_AREA1
#define CONFIG_RESERVED_AREA1_ADDR AUTO
#define CONFIG_RESERVED_AREA1_LEN 0x1000
#define CONFIG_RESERVED_AREA1_OPT 1
//#define CONFIG_RESERVED_AREA1_FILE anc_gains.bin
#endif
//#define CONFIG_RESERVED_AREA2 EXIF2
#ifdef CONFIG_RESERVED_AREA2
#define CONFIG_RESERVED_AREA2_ADDR AUTO
#define CONFIG_RESERVED_AREA2_LEN 0x1000
#define CONFIG_RESERVED_AREA2_OPT 1
//#define CONFIG_RESERVED_AREA2_FILE anc_gains.bin
#endif
/* Above Macros Only For Post Bulid Configuaration */
#endif /* #ifdef CONFIG_BOARD_JL701N_BTEMITTER */
#endif /* #ifndef CONFIG_BOARD_JL701N_BTEMITTER_BUILD_CFG_H */

1087
apps/xtell_hide/board/br28/board_jl701n_demo.c Normal file
View File

File diff suppressed because it is too large Load Diff

1242
apps/xtell_hide/board/br28/board_jl701n_demo_cfg.h Normal file
View File

File diff suppressed because it is too large Load Diff

123
apps/xtell_hide/board/br28/board_jl701n_demo_global_build_cfg.h Normal file
View File

@ -0,0 +1,123 @@
#ifndef CONFIG_BOARD_JL701N_DEMO_POST_BUILD_CFG_H
#define CONFIG_BOARD_JL701N_DEMO_POST_BUILD_CFG_H
/* 改文件只添加和isd_config.ini相关的配置，用以生成isd_config.ini */
/* 其他不相关的配置请勿添加在改文件 */
#ifdef CONFIG_BOARD_JL701N_DEMO
/* Following Macros Affect Periods Of Both Code Compiling And Post-build */
#define CONFIG_DOUBLE_BANK_ENABLE 0 //单双备份选择(若打开了改宏,FLASH结构变为双备份结构，适用于接入第三方协议的OTA， PS: JL-OTA同样支持双备份升级, 需要根据实际FLASH大小同时配置CONFIG_FLASH_SIZE)
#define CONFIG_APP_OTA_ENABLE 0 //是否支持RCSP升级(JL-OTA)
#define CONFIG_UPDATE_JUMP_TO_MASK 0 //配置升级到loader的方式0为直接reset,1为跳转(适用于芯片电源由IO口KEEP住的方案,需要注意检查跳转前是否将使用DMA的硬件模块全部关闭)
#define CONFIG_IO_KEY_EN 0 //配置是否使用IO按键，配合RESET1
#define CONFIG_UPDATE_WITH_MD5_CHECK_EN 0 //配置升级是否支持MD5校验
#define CONFIG_ANC_ENABLE 0 //配置是否支持ANC
//flash size vaule definition
#define FLASH_SIZE_256K 0x40000
#define FLASH_SIZE_512K 0x80000
#define FLASH_SIZE_1M 0x100000
#define FLASH_SIZE_2M 0x200000
#define FLASH_SIZE_4M 0x400000
#define CONFIG_FLASH_SIZE FLASH_SIZE_1M //配置FLASH大小
/* Above Macros Affect Periods Of Both Code Compiling And Post-build */
/* Following Macros Only For Post Bulid Configuaration */
#define CONFIG_DB_UPDATE_DATA_GENERATE_EN 0 //是否生成db_data.bin(用于第三方协议接入使用)
#define CONFIG_ONLY_GRENERATE_ALIGN_4K_CODE 0 //ufw只生成1份4K对齐的代码
//config for supported chip version
#ifdef CONFIG_BR30_C_VERSION
#define CONFIG_SUPPORTED_CHIP_VERSION C
#else
#define CONFIG_SUPPORTED_CHIP_VERSION B,D,E,M,N,O,P
#endif
//DON'T MODIFY THIS CONFIG EXCEPT SDK PUBLISHER
#define CONFIG_CHIP_NAME AC701N //除了SDK发布者,请不要修改
//it can be modified before first programming,but keep the same as the original version
#define CONFIG_PID AC701N //烧写或强制升级之前可以修改,之后升级要保持一致
//it can be modified before first programming,but keep the same as the original version
#define CONFIG_VID 0.01 //烧写或强制升级之前可以修改,之后升级要保持一致
//Project with bluetooth,it must use OSC as PLL_SOURCE;
#define CONFIG_PLL_SOURCE_USING_LRC 0 //PLL时钟源选择 1:LRC 2:OSC
//config alignment size unit
#ifdef CONFIG_256K_FLASH
#define ALIGN_UNIT_256B 1 //FLASH对齐方式选择，如果是256K的FLASH，选择256BYTE对齐方式
#else
#define ALIGN_UNIT_256B 0
#endif
//partial platform check this config to select the uart IO for wired update
#define CONFIG_UART_UPDATE_PIN PP00
//isd_download loader/uboot/update_loader debug io config
//#define CONFIG_UBOOT_DEBUG_PIN PA05
//#define CONFIG_UBOOT_DEBUG_BAUD_RATE 1000000
//config long-press reset io pin,time,trigger level
#define CONFIG_RESET_PIN LDO //io pin
#define CONFIG_RESET_TIME 04 //unit:second
#define CONFIG_RESET_LEVEL 1 //tigger level(0/1)
#if CONFIG_IO_KEY_EN
#define CONFIG_SUPPORT_RESET1
#define CONFIG_RESET1_PIN PB01 //io pin
#define CONFIG_RESET1_TIME 08 //unit:second
#define CONFIG_RESET1_LEVEL 0 //tigger level(0/1)
#endif
//reserved three custom cfg item for the future definition
//#define CONFIG_CUSTOM_CFG1_TYPE POWER_PIN
//#define CONFIG_CUSTOM_CFG1_VALUE PC01_1
//#define CONFIG_CUSTOM_CFG2_TYPE
//#define CONFIG_CUSTOM_CFG2_VALUE
//#define CONFIG_CUSTOM_CFG3_TYPE
//#define CONFIG_CUSTOM_CFG3_VALUE
//#define CONFIG_VDDIO_LVD_LEVEL 4 ////VDDIO_LVD挡位，0: 1.9V 1: 2.0V 2: 2.1V 3: 2.2V 4: 2.3V 5: 2.4V 6: 2.5V 7: 2.6V
//with single-bank mode,actual vm size should larger this VM_LEAST_SIZE,and dual bank mode,actual vm size equals this;
#define CONFIG_VM_LEAST_SIZE 8K
//config whether erased this area when do a update,1-No Operation,0-Erase
#define CONFIG_VM_OPT 1
//config whether erased this area when do a update,1-No Operation,0-Erase
#define CONFIG_BTIF_OPT 1
//reserved two custom cfg area for the future definition
//#define CONFIG_RESERVED_AREA1 EXIF1
#ifdef CONFIG_RESERVED_AREA1
#define CONFIG_RESERVED_AREA1_ADDR AUTO
#define CONFIG_RESERVED_AREA1_LEN 0x1000
#define CONFIG_RESERVED_AREA1_OPT 1
//#define CONFIG_RESERVED_AREA1_FILE anc_gains.bin
#endif
//#define CONFIG_RESERVED_AREA2 EXIF2
#ifdef CONFIG_RESERVED_AREA2
#define CONFIG_RESERVED_AREA2_ADDR AUTO
#define CONFIG_RESERVED_AREA2_LEN 0x1000
#define CONFIG_RESERVED_AREA2_OPT 1
//#define CONFIG_RESERVED_AREA2_FILE anc_gains.bin
#endif
/* Above Macros Only For Post Bulid Configuaration */
#endif /* #ifdef CONFIG_BOARD_JL701N_DEMO */
#endif /* #ifndef CONFIG_BOARD_JL701N_DEMO_POST_BUILD_CFG_H */

418
apps/xtell_hide/handler.c Normal file
View File

@ -0,0 +1,418 @@
#include "system/includes.h"
#include "media/includes.h"
#include "tone_player.h"
#include "earphone.h"
#include "app_config.h"
#include "app_action.h"
#include "app_task.h"
#include "btstack/avctp_user.h"
#include "btstack/btstack_task.h"
#include "btctrler/btctrler_task.h"
#include "btstack/frame_queque.h"
#include "user_cfg.h"
// #include "aec_user.h"
#include "classic/hci_lmp.h"
#include "bt_common.h"
#include "bt_ble.h"
#include "bt_tws.h"
#include "pbg_user.h"
#include "btstack/bluetooth.h"
#include "colorful_lights/colorful_lights.h"
#include "app_chargestore.h"
#include "jl_kws/jl_kws_api.h"
#include "asm/charge.h"
#include "app_charge.h"
#include "ui_manage.h"
#include "app_chargestore.h"
#include "app_umidigi_chargestore.h"
#include "app_testbox.h"
#include "app_online_cfg.h"
#include "app_main.h"
#include "app_power_manage.h"
#include "gSensor/gSensor_manage.h"
#include "key_event_deal.h"
#include "classic/tws_api.h"
#include "asm/pwm_led.h"
#include "ir_sensor/ir_manage.h"
#include "in_ear_detect/in_ear_manage.h"
#include "vol_sync.h"
#include "bt_background.h"
#include "default_event_handler.h"
#if(USE_DMA_UART_TEST) //使用dm串口测试时不能同时打开
#define MY_SNIFF_EN 0
#else
#define MY_SNIFF_EN 1 //默认打开
#endif
///////////////////////////////////////////////////////////////////////////////////////////////////
//变量
u8 init_ok = 0;
static u8 sniff_out = 0;
unsigned char xtell_bl_state=0; //存放经典蓝牙的连接状态，0断开，1是连接
u8 bt_newname =0;
unsigned char xt_ble_new_name[9] = "CM-11111";
static u16 play_poweron_ok_timer_id = 0;
///////////////////////////////////////////////////////////////////////////////////////////////////
u8 get_bt_init_status(void)
{
return init_ok;
}
u8 get_sniff_out_status()
{
return sniff_out;
}
void clear_sniff_out_status()
{
sniff_out = 0;
}
///////////////////////////////////////////////////////////////////////////////////////////////////
/*
* 模式状态机, 通过start_app()控制状态切换
*/
/* extern int audio_mic_init(); */
static int state_machine(struct application *app, enum app_state state, struct intent *it){
int error = 0;
static u8 tone_player_err = 0;
r_printf("bt_state_machine=%d\n", state);
switch (state) {
case APP_STA_CREATE:
/* set_adjust_conn_dac_check(0); */
STATUS *p_tone = get_tone_config();
tone_play_index(p_tone->bt_init_ok, 1);
break;
case APP_STA_START:
if (!it) {
break;
}
switch (it->action) {
case ACTION_EARPHONE_MAIN:
/*
* earphone 模式初始化
*/
clk_set("sys", BT_NORMAL_HZ);
u32 sys_clk = clk_get("sys");
bt_pll_para(TCFG_CLOCK_OSC_HZ, sys_clk, 0, 0);
/* bredr_set_dut_enble(1, 1); */
bt_function_select_init();
bredr_handle_register();
EARPHONE_STATE_INIT();
btstack_init();
sys_auto_shut_down_enable();
bt_sniff_feature_init();
sys_auto_sniff_controle(MY_SNIFF_EN, NULL);
app_var.dev_volume = -1;
break;
case ACTION_A2DP_START: //蓝牙音频传输协议
break;
case ACTION_BY_KEY_MODE:
break;
case ACTION_TONE_PLAY:
STATUS *p_tone = get_tone_config();
tone_play_index(p_tone->bt_init_ok, 1);
break;
case ACTION_DO_NOTHING:
break;
}
break;
case APP_STA_PAUSE:
break;
case APP_STA_RESUME:
//恢复前台运行
sys_auto_shut_down_disable();
sys_key_event_enable();
break;
case APP_STA_STOP:
break;
case APP_STA_DESTROY:
r_printf("APP_STA_DESTROY\n");
if (!app_var.goto_poweroff_flag) {
bt_app_exit(NULL);
}
break;
}
return error;
}
///////////////////////////////////////////////////////////////////////////////////////////////////
//handle
static void play_poweron_ok_timer(void *priv)
{
app_var.wait_timer_do = 0;
log_d("\n-------play_poweron_ok_timer-------\n", priv);
if (is_dac_power_off()) {
#if TCFG_USER_TWS_ENABLE
bt_tws_poweron();
#else
bt_wait_connect_and_phone_connect_switch(0);
#endif
return;
}
app_var.wait_timer_do = sys_timeout_add(priv, play_poweron_ok_timer, 100);
}
static void play_bt_connect_dly(void *priv)
{
app_var.wait_timer_do = 0;
log_d("\n-------play_bt_connect_dly-------\n", priv);
if (!app_var.goto_poweroff_flag) {
STATUS *p_tone = get_tone_config();
tone_play_index(p_tone->bt_connect_ok, 1);
}
}
static int bt_connction_status_event_handler(struct bt_event *bt)
{
STATUS *p_tone = get_tone_config();
u8 *phone_number = NULL;
switch (bt->event) {
case BT_STATUS_INIT_OK:
/*
* 蓝牙初始化完成
*/
log_info("BT_STATUS_INIT_OK\n");
init_ok = 1;
__set_sbc_cap_bitpool(38);
#if (TCFG_USER_BLE_ENABLE)
if (BT_MODE_IS(BT_BQB)) {
ble_bqb_test_thread_init();
} else {
#if !TCFG_WIRELESS_MIC_ENABLE
bt_ble_init();
#endif
}
#endif
bt_init_ok_search_index();
#if TCFG_TEST_BOX_ENABLE
testbox_set_bt_init_ok(1);
#endif
#if ((CONFIG_BT_MODE == BT_BQB)||(CONFIG_BT_MODE == BT_PER))
bt_wait_phone_connect_control(1);
#else
if (is_dac_power_off()) {
bt_wait_connect_and_phone_connect_switch(0);
} else {
app_var.wait_timer_do = sys_timeout_add(NULL, play_poweron_ok_timer, 100);
}
#endif
/*if (app_var.play_poweron_tone) {
tone_play_index(p_tone->power_on, 1);
}*/
break;
case BT_STATUS_SECOND_CONNECTED:
clear_current_poweron_memory_search_index(0);
case BT_STATUS_FIRST_CONNECTED:
log_info("BT_STATUS_CONNECTED\n");
xtell_bl_state = 1; //蓝牙连接成功 置1
if(strcmp(xt_ble_new_name,"CM-1111") != 0){
//蓝牙连接成功
bt_newname =1;
u8 temp[5]={0xBB,0xBE,0x02,0x04,0x00};
temp[4] = xtell_bl_state; //经典蓝牙连接状态
send_data_to_ble_client(&temp,5);
}
earphone_change_pwr_mode(PWR_DCDC15, 3000);
sys_auto_shut_down_disable();
ui_update_status(STATUS_BT_CONN); //单台在此处设置连接状态,对耳的连接状态需要同步，在bt_tws.c中去设置
/* tone_play(TONE_CONN); */
/*os_time_dly(40); // for test*/
log_info("tone status:%d\n", tone_get_status());
if (get_call_status() == BT_CALL_HANGUP) {
if (app_var.phone_dly_discon_time) {
sys_timeout_del(app_var.phone_dly_discon_time);
app_var.phone_dly_discon_time = 0;
} else {
app_var.wait_timer_do = sys_timeout_add(NULL, play_bt_connect_dly, 1600);
/* tone_play_index(p_tone->bt_connect_ok, 1); */
}
}
/*int timeout = 5000 + rand32() % 10000;
sys_timeout_add(NULL, connect_phone_test, timeout);*/
break;
case BT_STATUS_FIRST_DISCONNECT:
case BT_STATUS_SECOND_DISCONNECT:
log_info("BT_STATUS_DISCONNECT\n");
xtell_bl_state = 0; //断开蓝牙 清0
//蓝牙断开连接
if(bt_newname){ //已经改成新蓝牙名字，断开才播报
bt_newname=0;
u8 temp[5]={0xBB,0xBE,0x02,0x04,0x00};
temp[4] = xtell_bl_state; //经典蓝牙连接状态
send_data_to_ble_client(&temp,5);
}
if (app_var.goto_poweroff_flag) {
/*关机不播断开提示音*/
/*关机时不改UI*/
break;
}
bt_discon_dly_handle(NULL);
break;
//phone status deal
case BT_STATUS_PHONE_INCOME:
break;
case BT_STATUS_PHONE_OUT:
break;
case BT_STATUS_PHONE_ACTIVE:
break;
case BT_STATUS_PHONE_HANGUP:
break;
case BT_STATUS_PHONE_NUMBER:
break;
case BT_STATUS_INBAND_RINGTONE: //铃声
break;
case BT_STATUS_CALL_VOL_CHANGE:
break;
case BT_STATUS_SNIFF_STATE_UPDATE:
log_info(" BT_STATUS_SNIFF_STATE_UPDATE %d\n", bt->value); //0退出SNIFF
if (bt->value == 0) {
sniff_out = 1;
sys_auto_sniff_controle(MY_SNIFF_EN, bt->args);
} else {
sys_auto_sniff_controle(0, bt->args);
}
break;
case BT_STATUS_LAST_CALL_TYPE_CHANGE:
break;
case BT_STATUS_CONN_A2DP_CH:
case BT_STATUS_CONN_HFP_CH:
if ((!is_1t2_connection()) && (get_current_poweron_memory_search_index(NULL))) { //回连下一个device
if (get_esco_coder_busy_flag()) {
clear_current_poweron_memory_search_index(0);
} else {
user_send_cmd_prepare(USER_CTRL_START_CONNECTION, 0, NULL);
}
}
break;
case BT_STATUS_PHONE_MANUFACTURER:
break;
case BT_STATUS_VOICE_RECOGNITION:
break;
case BT_STATUS_AVRCP_INCOME_OPID:
#define AVC_VOLUME_UP 0x41
#define AVC_VOLUME_DOWN 0x42
log_info("BT_STATUS_AVRCP_INCOME_OPID:%d\n", bt->value);
if (bt->value == AVC_VOLUME_UP) {
}
if (bt->value == AVC_VOLUME_DOWN) {
}
break;
default:
log_info(" BT STATUS DEFAULT\n");
break;
}
return 0;
}
static int event_handler(struct application *app, struct sys_event *event)
{
if (SYS_EVENT_REMAP(event)) {
g_printf("****SYS_EVENT_REMAP**** \n");
return 0;
}
switch (event->type) {
case SYS_KEY_EVENT:
break;
case SYS_BT_EVENT:
/*
* 蓝牙事件处理
*/
if ((u32)event->arg == SYS_BT_EVENT_TYPE_CON_STATUS) {
printf("in event_handler:bt_connction_status_event_handler");
bt_connction_status_event_handler(&event->u.bt);
} else if ((u32)event->arg == SYS_BT_EVENT_TYPE_HCI_STATUS) {
bt_hci_event_handler(&event->u.bt);
}
break;
case SYS_DEVICE_EVENT:
/*
* 系统设备事件处理
*/
if ((u32)event->arg == DEVICE_EVENT_FROM_CHARGE) {
} else if ((u32)event->arg == DEVICE_EVENT_FROM_POWER) {
return app_power_event_handler(&event->u.dev);
}
#if TCFG_UMIDIGI_BOX_ENABLE
else if ((u32)event->arg == DEVICE_EVENT_UMIDIGI_CHARGE_STORE) {
app_umidigi_chargestore_event_handler(&event->u.umidigi_chargestore);
}
#endif
#if TCFG_TEST_BOX_ENABLE
else if ((u32)event->arg == DEVICE_EVENT_TEST_BOX) {
app_testbox_event_handler(&event->u.testbox);
}
#endif
break;
default:
return false;
}
SYS_EVENT_HANDLER_SPECIFIC(event);
#ifdef CONFIG_BT_BACKGROUND_ENABLE
if (app) {
default_event_handler(event);
}
#endif
return false;
}
///////////////////////////////////////////////////////////////////////////////////////////////////
static const struct application_operation app_handler_ops = {
.state_machine = state_machine,
.event_handler = event_handler,
};
/*
* 注册earphone模式
*/
REGISTER_APPLICATION(app_handler) = {
.name = "handler",
.action = ACTION_EARPHONE_MAIN,
.ops = &app_handler_ops,
.state = APP_STA_DESTROY,
};

31
apps/xtell_hide/include/app_action.h Normal file
View File

@ -0,0 +1,31 @@
#ifndef APP_ACTION_H
#define APP_ACTION_H
#define ACTION_EARPHONE_MAIN 0x0001
#define ACTION_A2DP_START 0x0002
#define ACTION_ESCO_START 0x0003
#define ACTION_BY_KEY_MODE 0x0004
#define ACTION_IDLE_MAIN 0x0010
#define ACTION_IDLE_POWER_OFF 0x0011
#define ACTION_MUSIC_MAIN 0x0020
#define ACTION_MUSIC_TWS_RX 0x0021
#define ACTION_PC_MAIN 0x0030
#define ACTION_AUX_MAIN 0x0040
#define APP_NAME_BT "earphone"
#define APP_NAME_IDLE "idle"
#define APP_NAME_PC "pc"
#define APP_NAME_MUSIC "music"
#define APP_NAME_AUX "aux"
extern void task_switch(const char *name, int action);
#define task_switch_to_bt() task_switch(APP_NAME_BT, ACTION_EARPHONE_MAIN)
#endif

12
apps/xtell_hide/include/app_ancbox.h Normal file
View File

@ -0,0 +1,12 @@
#ifndef _APP_ANCBOX_H_
#define _APP_ANCBOX_H_
#include "typedef.h"
#include "system/event.h"
extern int app_ancbox_event_handler(struct ancbox_event *anc_dev);
extern u8 ancbox_get_status(void);
extern void ancbox_clear_status(void);
#endif //_APP_CHARGESTORE_H_

13
apps/xtell_hide/include/app_anctool.h Normal file
View File

@ -0,0 +1,13 @@
#ifndef _APP_ANCTOOL_H_
#define _APP_ANCTOOL_H_
#include "typedef.h"
#include "anctool.h"
u8 app_anctool_spp_rx_data(u8 *packet, u16 size);
void app_anctool_spp_connect(void);
void app_anctool_spp_disconnect(void);
u8 get_app_anctool_spp_connected_flag();
#endif //_APP_CHARGESTORE_H_

17
apps/xtell_hide/include/app_charge.h Normal file
View File

@ -0,0 +1,17 @@
#ifndef _APP_CHARGE_H_
#define _APP_CHARGE_H_
#include "typedef.h"
#include "system/event.h"
extern void charge_close_deal(void);
extern void charge_start_deal(void);
extern void ldo5v_keep_deal(void);
extern void charge_full_deal(void);
extern void charge_ldo5v_in_deal(void);
extern void charge_ldo5v_off_deal(void);
extern u8 get_charge_full_flag(void);
extern int app_charge_event_handler(struct device_event *dev);
#endif //_APP_CHARGE_H_

78
apps/xtell_hide/include/app_chargestore.h Normal file
View File

@ -0,0 +1,78 @@
#ifndef _APP_CHARGESTORE_H_
#define _APP_CHARGESTORE_H_
#include "typedef.h"
#include "system/event.h"
//LDOIN升级口命令定义
#define CMD_TWS_CHANNEL_SET 0x01
#define CMD_TWS_REMOTE_ADDR 0x02
#define CMD_TWS_ADDR_DELETE 0x03
#define CMD_BOX_TWS_CHANNEL_SEL 0x04//测试盒获取地址
#define CMD_BOX_TWS_REMOTE_ADDR 0x05//测试盒交换地址
#define CMD_POWER_LEVEL_OPEN 0x06//开盖充电舱报告/获取电量
#define CMD_POWER_LEVEL_CLOSE 0x07//合盖充电舱报告/获取电量
#define CMD_RESTORE_SYS 0x08//恢复出厂设置
#define CMD_ENTER_DUT 0x09//进入测试模式
#define CMD_EX_FIRST_READ_INFO 0x0A//F95读取数据首包信息
#define CMD_EX_CONTINUE_READ_INFO 0x0B//F95读取数据后续包信息
#define CMD_EX_FIRST_WRITE_INFO 0x0C//F95写入数据首包信息
#define CMD_EX_CONTINUE_WRITE_INFO 0x0D//F95写入数据后续包信息
#define CMD_EX_INFO_COMPLETE 0x0E//F95完成信息交换
#define CMD_TWS_SET_CHANNEL 0x0F//F95设置左右声道信息
#define CMD_BOX_UPDATE 0x20//测试盒升级
#define CMD_BOX_MODULE 0x21//测试盒一级命令
#define CMD_SHUT_DOWN 0x80//充电舱关机,充满电关机,或者是低电关机
#define CMD_CLOSE_CID 0x81//充电舱盒盖
#define CMD_ANC_MODULE 0x90//ANC一级命令
#define CMD_FAIL 0xfe//失败
#define CMD_UNDEFINE 0xff//未知命令回复
enum {
TWS_CHANNEL_LEFT = 1, //左耳
TWS_CHANNEL_RIGHT, //右耳
};
enum {
TWS_DEL_TWS_ADDR = 1, //删除对箱地址
TWS_DEL_PHONE_ADDR,//删除手机地址
TWS_DEL_ALL_ADDR,//删除手机与对箱地址
};
struct _CHARGE_STORE_INFO {
u8 tws_local_addr[6];
u8 tws_remote_addr[6];
u8 tws_mac_addr[6];
u32 search_aa;
u32 pair_aa;
u8 local_channel;
u16 device_ind;
u16 reserved_data;
} _GNU_PACKED_;
typedef struct _CHARGE_STORE_INFO CHARGE_STORE_INFO;
extern void chargestore_set_tws_channel_info(u8 channel);
extern bool chargestore_set_tws_remote_info(u8 *data, u8 len);
extern u16 chargestore_get_tws_remote_info(u8 *data);
extern u8 chargestore_get_power_level(void);
extern u8 chargestore_get_power_status(void);
extern u8 chargestore_get_cover_status(void);
extern u8 chargestore_get_sibling_power_level(void);
extern void chargestore_set_bt_init_ok(u8 flag);
extern int app_chargestore_event_handler(struct chargestore_event *chargestore_dev);
extern u8 chargestore_get_earphone_online(void);
extern u8 chargestore_get_earphone_pos(void);
extern int chargestore_sync_chg_level(void);
extern void chargestore_set_power_level(u8 power);
extern void chargestore_set_sibling_chg_lev(u8 chg_lev);
extern void chargestore_set_phone_disconnect(void);
extern void chargestore_set_phone_connect(void);
extern u8 chargestore_check_going_to_poweroff(void);
extern void chargestore_shutdown_reset(void);
extern void testbox_set_testbox_tws_paired(u8 flag);
extern u8 testbox_get_testbox_tws_paired(void);
extern u8 testbox_get_touch_trim_en(u8 *sec);
extern u8 testbox_get_softpwroff_after_paired(void);
#endif //_APP_CHARGESTORE_H_

555
apps/xtell_hide/include/app_config.h Normal file
View File

@ -0,0 +1,555 @@
#ifndef APP_CONFIG_H
#define APP_CONFIG_H
/*
* 系统打印总开关
*/
#define LIB_DEBUG 1 //1 //xtelllog 1是打开库打印
#define CONFIG_DEBUG_LIB(x) (x & LIB_DEBUG)
#define CONFIG_DEBUG_ENABLE //xtelllog 注释就关闭log
#ifndef CONFIG_DEBUG_ENABLE
//#define CONFIG_DEBUG_LITE_ENABLE //轻量级打印开关, 默认关闭
#endif
//*********************************************************************************//
// AI配置 //
//*********************************************************************************//
#define CONFIG_APP_BT_ENABLE
#ifdef CONFIG_APP_BT_ENABLE
#define TRANS_DATA_EN 0
#define RCSP_BTMATE_EN 0
#define RCSP_ADV_EN 1
#define AI_APP_PROTOCOL 0
#define LL_SYNC_EN 0
#define TUYA_DEMO_EN 0
#else
#define TRANS_DATA_EN 1
#define RCSP_BTMATE_EN 0
#define RCSP_ADV_EN 0
#define AI_APP_PROTOCOL 0
#define LL_SYNC_EN 0
#define TUYA_DEMO_EN 0
#endif
#include "board_config.h"
#ifdef TCFG_AUDIO_CVP_NS_MODE
#if (TCFG_AUDIO_CVP_NS_MODE==CVP_DNS_MODE) || (TCFG_KWS_VOICE_RECOGNITION_ENABLE == 1)||(TCFG_AUDIO_ANC_ENABLE==1&&TCFG_AUDIO_DUAL_MIC_ENABLE==1)
#undef CONFIG_MOVABLE_ENABLE
#define CONFIG_MOVABLE_ENABLE //省ram空间，将部分ram空间的代码挪到flash
#endif
#endif
#if defined(TCFG_CVP_DEVELOP_ENABLE) && (TCFG_CVP_DEVELOP_ENABLE == 1)
#undef CONFIG_MOVABLE_ENABLE
#define CONFIG_MOVABLE_ENABLE //省ram空间，将部分ram空间的代码挪到flash
#endif
#if CONFIG_UPDATE_WITH_MD5_CHECK_EN
#define UPDATE_MD5_ENABLE 1
#else
#define UPDATE_MD5_ENABLE 0
#endif
//升级需要打开CONFIG_APP_OTA_ENABLE,同时单双备份的配置也在board_xxx_global_cfg里配置，需要注意只有JL_RCSP才支持单备份，其余升级都是只支持双备份升级
//支持TWS同步升级，OTA_TWS_SAME_TIME_NEW宏需要配置为1，旧的流程已不再支持
#if (RCSP_ADV_EN) //rcsp需要打开ble
#define JL_EARPHONE_APP_EN 1
// #define CONFIG_CHARGESTORE_REMAP_ENABLE //充电仓重映射接收函数使能
#if CONFIG_APP_OTA_ENABLE
#define RCSP_UPDATE_EN 1 //是否支持rcsp升级
#if CONFIG_DOUBLE_BANK_ENABLE //双备份才能打开同步升级流程
#define OTA_TWS_SAME_TIME_ENABLE 1 //是否支持TWS同步升级
#define OTA_TWS_SAME_TIME_NEW 1 //使用新的tws ota流程
#else
#define OTA_TWS_SAME_TIME_ENABLE 1//0 xtellota //是否支持TWS同步升级
#define OTA_TWS_SAME_TIME_NEW 1//0 //使用新的tws ota流程
#endif //CONFIG_DOUBLE_BANK_ENABLE
#else
#define RCSP_UPDATE_EN 0 //是否支持rcsp升级
#define OTA_TWS_SAME_TIME_ENABLE 0 //是否支持TWS同步升级
#define OTA_TWS_SAME_TIME_NEW 0 //使用新的tws ota流程
#endif
#undef TCFG_USER_BLE_ENABLE
#define TCFG_USER_BLE_ENABLE 1 //BLE功能使能
#elif (AI_APP_PROTOCOL)
#define BT_MIC_EN 0
#define OTA_TWS_SAME_TIME_ENABLE 0 //是否支持TWS同步升级
#elif (LL_SYNC_EN)
#define JL_EARPHONE_APP_EN 0
#define OTA_TWS_SAME_TIME_ENABLE 1
#define OTA_TWS_SAME_TIME_NEW 1 //使用新的tws ota流程
#elif (TUYA_DEMO_EN)
#define JL_EARPHONE_APP_EN 0
#define OTA_TWS_SAME_TIME_ENABLE 0
#define OTA_TWS_SAME_TIME_NEW 0 //使用新的tws ota流程
#else
#define JL_EARPHONE_APP_EN 0
#define OTA_TWS_SAME_TIME_ENABLE 0
#define OTA_TWS_SAME_TIME_NEW 0 //使用新的tws ota流程
#endif
#define CONFIG_MEDIA_LIB_USE_MALLOC 1
#include "usb_std_class_def.h"
#undef USB_MALLOC_ENABLE
#define USB_MALLOC_ENABLE 1
///USB 配置重定义
// #undef USB_DEVICE_CLASS_CONFIG
// #define USB_DEVICE_CLASS_CONFIG (AUDIO_CLASS)
/////要确保 上面 undef 后在include usb
#include "usb_common_def.h"
#define USB_PC_NO_APP_MODE 0
#if ((TCFG_CHARGESTORE_ENABLE || TCFG_TEST_BOX_ENABLE || TCFG_ANC_BOX_ENABLE) \
&& TCFG_CHARGESTORE_PORT == IO_PORT_DP)
#undef TCFG_OTG_MODE
#define TCFG_OTG_MODE (TCFG_OTG_MODE_HOST|TCFG_OTG_MODE_SLAVE|TCFG_OTG_MODE_CHARGE|OTG_DET_DM_ONLY)
#endif
#include "btcontroller_mode.h"
#include "user_cfg_id.h"
#ifndef __LD__
#include "bt_profile_cfg.h"
#endif
// #ifdef CONFIG_APP_BT_ENABLE
// #if(APP_ONLINE_DEBUG)
// #error "they can not enable at the same time,just select one!!!"
// #endif
// #endif
#ifdef CONFIG_SDFILE_ENABLE
#define SDFILE_DEV "sdfile"
#define SDFILE_MOUNT_PATH "mnt/sdfile"
#if (USE_SDFILE_NEW)
#define SDFILE_APP_ROOT_PATH SDFILE_MOUNT_PATH"/app/" //app分区
#define SDFILE_RES_ROOT_PATH SDFILE_MOUNT_PATH"/res/" //资源文件分区
#else
#define SDFILE_RES_ROOT_PATH SDFILE_MOUNT_PATH"/C/"
#endif
#endif
#define STYLE_JL_WTACH (1)//彩屏demo
#define STYLE_JL_SOUNDBOX (2)//点阵屏demo
#define STYLE_JL_CHARGE (3)//点阵屏充电仓
#define STYLE_JL_LED7 (4)//led7
#define STYLE_UI_SIMPLE (5)//没有ui框架
//*********************************************************************************//
// 测试模式配置 //
//*********************************************************************************//
#if (CONFIG_BT_MODE != BT_NORMAL)
#undef TCFG_BD_NUM
#define TCFG_BD_NUM 1
#undef TCFG_USER_TWS_ENABLE
#define TCFG_USER_TWS_ENABLE 0 //tws功能使能
#undef TCFG_USER_BLE_ENABLE
#define TCFG_USER_BLE_ENABLE 1 //BLE功能使能
#undef TCFG_AUTO_SHUT_DOWN_TIME
#define TCFG_AUTO_SHUT_DOWN_TIME 0
#undef TCFG_SYS_LVD_EN
#define TCFG_SYS_LVD_EN 0
#undef TCFG_LOWPOWER_LOWPOWER_SEL
#define TCFG_LOWPOWER_LOWPOWER_SEL 0
#undef TCFG_AUDIO_DAC_LDO_VOLT
#define TCFG_AUDIO_DAC_LDO_VOLT DUT_AUDIO_DAC_LDO_VOLT
#undef TCFG_LOWPOWER_POWER_SEL
#define TCFG_LOWPOWER_POWER_SEL PWR_LDO15
#undef TCFG_PWMLED_ENABLE
#define TCFG_PWMLED_ENABLE DISABLE_THIS_MOUDLE
#undef TCFG_ADKEY_ENABLE
#define TCFG_ADKEY_ENABLE DISABLE_THIS_MOUDLE
#undef TCFG_IOKEY_ENABLE
#define TCFG_IOKEY_ENABLE DISABLE_THIS_MOUDLE
#undef TCFG_TEST_BOX_ENABLE
#define TCFG_TEST_BOX_ENABLE 0
#undef TCFG_AUTO_SHUT_DOWN_TIME
#define TCFG_AUTO_SHUT_DOWN_TIME 0
#undef TCFG_POWER_ON_NEED_KEY
#define TCFG_POWER_ON_NEED_KEY 0
/* #undef TCFG_UART0_ENABLE
#define TCFG_UART0_ENABLE DISABLE_THIS_MOUDLE */
dzfghsdfhgsfgh
#endif //(CONFIG_BT_MODE != BT_NORMAL)
#if TCFG_USER_TWS_ENABLE
#define CONFIG_TWS_COMMON_ADDR_AUTO 0 /* 自动生成TWS配对后的MAC地址 */
#define CONFIG_TWS_COMMON_ADDR_USED_LEFT 1 /* 使用左耳的MAC地址作为TWS配对后的地址
可配合烧写器MAC地址自增功能一起使用
多台交叉配对会出现MAC地址相同情况 */
#define CONFIG_TWS_COMMON_ADDR_SELECT CONFIG_TWS_COMMON_ADDR_AUTO
//*********************************************************************************//
// 对耳配置方式配置 //
//*********************************************************************************//
#define CONFIG_TWS_CONNECT_SIBLING_TIMEOUT 4 /* 开机或超时断开后对耳互连超时时间，单位s */
// #define CONFIG_TWS_REMOVE_PAIR_ENABLE [> 不连手机的情况下双击按键删除配对信息 <]
#define CONFIG_TWS_POWEROFF_SAME_TIME 1 /*按键关机时两个耳机同时关机*/
#define ONE_KEY_CTL_DIFF_FUNC 1 /*通过左右耳实现一个按键控制两个功能*/
#define CONFIG_TWS_SCO_ONLY_MASTER 0 /*通话的时候只有主机出声音*/
/* 配对方式选择 */
#define CONFIG_TWS_PAIR_BY_CLICK 0 /* 按键发起配对 */
#define CONFIG_TWS_PAIR_BY_AUTO 1 /* 开机自动配对 */
#define CONFIG_TWS_PAIR_BY_FAST_CONN 2 /* 开机快速连接,连接速度比自动配对快,不支持取消配对操作 */
#define CONFIG_TWS_PAIR_MODE CONFIG_TWS_PAIR_BY_AUTO
/* 声道确定方式选择 */
#define CONFIG_TWS_MASTER_AS_LEFT 0 //主机作为左耳
#define CONFIG_TWS_AS_LEFT_CHANNEL 1 //固定左耳
#define CONFIG_TWS_AS_RIGHT_CHANNEL 2 //固定右耳
#define CONFIG_TWS_LEFT_START_PAIR 3 //双击发起配对的耳机做左耳
#define CONFIG_TWS_RIGHT_START_PAIR 4 //双击发起配对的耳机做右耳
#define CONFIG_TWS_EXTERN_UP_AS_LEFT 5 //外部有上拉电阻作为左耳
#define CONFIG_TWS_EXTERN_DOWN_AS_LEFT 6 //外部有下拉电阻作为左耳
#define CONFIG_TWS_SECECT_BY_CHARGESTORE 7 //充电仓决定左右耳
#define CONFIG_TWS_CHANNEL_SELECT CONFIG_TWS_LEFT_START_PAIR //配对方式选择
#define CONFIG_TWS_CHANNEL_CHECK_IO IO_PORTA_07 //上下拉电阻检测引脚
#if CONFIG_TWS_PAIR_MODE != CONFIG_TWS_PAIR_BY_CLICK
#if (CONFIG_TWS_CHANNEL_SELECT == CONFIG_TWS_LEFT_START_PAIR) ||\
(CONFIG_TWS_CHANNEL_SELECT == CONFIG_TWS_RIGHT_START_PAIR)
#undef CONFIG_TWS_CHANNEL_SELECT
#define CONFIG_TWS_CHANNEL_SELECT CONFIG_TWS_MASTER_AS_LEFT
#endif
#if CONFIG_TWS_PAIR_MODE == CONFIG_TWS_PAIR_BY_AUTO
#define CONFIG_TWS_AUTO_PAIR_WITHOUT_UNPAIR /* 不取消配对也可以配对新的耳机 */
#endif
#if CONFIG_TWS_PAIR_MODE == CONFIG_TWS_PAIR_BY_FAST_CONN
#undef CONFIG_TWS_REMOVE_PAIR_ENABLE
#endif
#endif
#define CONFIG_A2DP_GAME_MODE_ENABLE 0 //游戏模式
#define CONFIG_A2DP_GAME_MODE_DELAY_TIME 35 //游戏模式延时ms
//*********************************************************************************//
// 低延时游戏模式脚步声、枪声增强,需使能蓝牙音乐10段eq以及蓝牙音乐drc
// 用户开关宏AUDIO_GAME_EFFECT_CONFIG(开关蓝牙低延时模式的游戏音效)
// 低延时eq效果文件使用eq_game_eff.bin,调试时需保存成该文件,并在批处理-res后添加
// 非低延时eq效果文件使用eq_cfg_hw.bin,也需在批处理-res后添加
//*********************************************************************************//
#if CONFIG_A2DP_GAME_MODE_ENABLE
#define AUDIO_GAME_EFFECT_CONFIG 1 //低延时游戏模式脚步声、枪声增强 1:使能、0：关闭
#else
#define AUDIO_GAME_EFFECT_CONFIG 0 //低延时游戏模式脚步声、枪声增强 1:使能、0：关闭
#endif
/***********************************非用户配置区***********************************/
//以下宏定义，是游戏音效使能后，需要开启的宏定义,已配好，用户不用修改
#if AUDIO_GAME_EFFECT_CONFIG
#if (TCFG_EQ_ENABLE == 0)
#undef TCFG_EQ_ENABLE
#define TCFG_EQ_ENABLE 1
#endif/* (TCFG_EQ_ENABLE == 0) */
#if (TCFG_BT_MUSIC_EQ_ENABLE == 0)
#undef TCFG_BT_MUSIC_EQ_ENABLE
#define TCFG_BT_MUSIC_EQ_ENABLE 1
#endif/*(TCFG_BT_MUSIC_EQ_ENABLE == 0)*/
#if (TCFG_DRC_ENABLE == 0)
#undef TCFG_DRC_ENABLE
#define TCFG_DRC_ENABLE 1
#endif/* (TCFG_DRC_ENABLE == 0) */
#if (TCFG_BT_MUSIC_DRC_ENABLE == 0)
#undef TCFG_BT_MUSIC_DRC_ENABLE
#define TCFG_BT_MUSIC_DRC_ENABLE 1
#endif/* (TCFG_BT_MUSIC_DRC_ENABLE == 0) */
#if (EQ_SECTION_MAX < 10)
#undef EQ_SECTION_MAX
#define EQ_SECTION_MAX 10
#endif/* (EQ_SECTION_MAX < 10) */
#if (TCFG_USE_EQ_FILE == 0)
#undef TCFG_USE_EQ_FILE
#define TCFG_USE_EQ_FILE 1
#endif/* TCFG_USE_EQ_FILE */
#endif/* AUDIO_GAME_EFFECT_CONFIG */
/**********************************************************************************/
#if CONFIG_TWS_PAIR_MODE == CONFIG_TWS_PAIR_BY_CLICK
#define CONFIG_TWS_BY_CLICK_PAIR_WITHOUT_PAIR /*双击按键可以配对已配对过的样机，即交叉配对 */
#ifdef CONFIG_TWS_BY_CLICK_PAIR_WITHOUT_PAIR
#define CONFIG_TWS_AUTO_PAIR_WITHOUT_UNPAIR /* 不取消配对也可以配对新的耳机 */
#endif
#endif
#if TCFG_CHARGESTORE_ENABLE
#undef CONFIG_TWS_CHANNEL_SELECT
#define CONFIG_TWS_CHANNEL_SELECT CONFIG_TWS_SECECT_BY_CHARGESTORE //充电仓区分左右
#endif //TCFG_CHARGESTORE_ENABLE
#if TCFG_TEST_BOX_ENABLE && (!TCFG_CHARGESTORE_ENABLE)
#define CONFIG_TWS_SECECT_CHARGESTORE_PRIO 1 //测试盒配置左右耳优先
#else
#define CONFIG_TWS_SECECT_CHARGESTORE_PRIO 0
#endif //TCFG_TEST_BOX_ENABLE
//*********************************************************************************//
// 对耳电量显示方式 //
//*********************************************************************************//
#if BT_SUPPORT_DISPLAY_BAT
#define CONFIG_DISPLAY_TWS_BAT_LOWER 1 //对耳手机端电量显示，显示低电量耳机的电量
#define CONFIG_DISPLAY_TWS_BAT_HIGHER 2 //对耳手机端电量显示，显示高电量耳机的电量
#define CONFIG_DISPLAY_TWS_BAT_LEFT 3 //对耳手机端电量显示，显示左耳的电量
#define CONFIG_DISPLAY_TWS_BAT_RIGHT 4 //对耳手机端电量显示，显示右耳的电量
#define CONFIG_DISPLAY_TWS_BAT_TYPE CONFIG_DISPLAY_TWS_BAT_LOWER
#endif //BT_SUPPORT_DISPLAY_BAT
#define CONFIG_DISPLAY_DETAIL_BAT 0 //BLE广播显示具体的电量
#define CONFIG_NO_DISPLAY_BUTTON_ICON 1 //BLE广播不显示按键界面,智能充电仓置1
#endif //TCFG_USER_TWS_ENABLE
#ifndef CONFIG_BT_RX_BUFF_SIZE
#define CONFIG_BT_RX_BUFF_SIZE (14 * 1024)
#endif
#ifdef CONFIG_APP_BT_ENABLE
#if TCFG_BT_SUPPORT_AAC || TCFG_BT_SUPPORT_LDAC
#define CONFIG_BT_TX_BUFF_SIZE (5 * 1024)
#else
#define CONFIG_BT_TX_BUFF_SIZE (4 * 1024)
#endif
#else
#if TCFG_BT_SUPPORT_AAC || TCFG_BT_SUPPORT_LDAC
#define CONFIG_BT_TX_BUFF_SIZE (4 * 1024)
#else
#define CONFIG_BT_TX_BUFF_SIZE (3 * 1024)
#endif
#endif
#ifndef CONFIG_NEW_BREDR_ENABLE
#if TCFG_USER_TWS_ENABLE
#ifdef CONFIG_LOCAL_TWS_ENABLE
#define CONFIG_TWS_BULK_POOL_SIZE (4 * 1024)
#else
#define CONFIG_TWS_BULK_POOL_SIZE (2 * 1024)
#endif
#endif
#endif
#if (CONFIG_BT_MODE != BT_NORMAL)
////bqb 如果测试3M tx buf 最好加大一点
#undef CONFIG_BT_TX_BUFF_SIZE
#define CONFIG_BT_TX_BUFF_SIZE (6 * 1024)
#endif
//*********************************************************************************//
// 电源切换配置 //
//*********************************************************************************//
#define PHONE_CALL_USE_LDO15 CONFIG_PHONE_CALL_USE_LDO15
//*********************************************************************************//
// 时钟切换配置 //
//*********************************************************************************//
#define BT_NORMAL_HZ CONFIG_BT_NORMAL_HZ
#define BT_CONNECT_HZ CONFIG_BT_CONNECT_HZ
#define BT_A2DP_HZ CONFIG_BT_A2DP_HZ
#define BT_CALL_HZ CONFIG_BT_CALL_HZ
#define BT_CALL_ADVANCE_HZ CONFIG_BT_CALL_ADVANCE_HZ
#define BT_CALL_16k_HZ CONFIG_BT_CALL_16k_HZ
#define BT_CALL_16k_ADVANCE_HZ CONFIG_BT_CALL_16k_ADVANCE_HZ
#define MUSIC_DEC_FASTEST_CLOCK CONFIG_MUSIC_DEC_FASTEST_CLOCK
#define MUSIC_DEC_FAST_CLOCK CONFIG_MUSIC_DEC_FAST_CLOCK
#define MUSIC_DEC_CLOCK CONFIG_MUSIC_DEC_CLOCK
#define MUSIC_DEC_IDLE_CLOCK CONFIG_MUSIC_IDLE_CLOCK
#define MUSIC_FSCAN_CLOCK CONFIG_MUSIC_FSCAN_CLOCK
#define LINEIN_CLOCK CONFIG_LINEIN_CLOCK
#define FM_CLOCK CONFIG_FM_CLOCK
#define FM_EMITTER_CLOCK CONFIG_FM_EMITTER_CLOCK
#define PC_CLOCK CONFIG_PC_CLOCK
#define RECODRD_CLOCK CONFIG_RECORD_CLOCK
#define SPDIF_CLOCK CONFIG_SPDIF_CLOCK
////////////////////////
#if TCFG_BT_SUPPORT_AAC || TCFG_BT_SUPPORT_LDAC
#define BT_A2DP_STEREO_EQ_HZ 48 * 1000000L
#else
#define BT_A2DP_STEREO_EQ_HZ 32 * 1000000L
#endif
#define BT_A2DP_AAC_HZ 48 * 1000000L
#define BT_A2DP_TWS_AAC_HZ 64 * 1000000L
#define BT_A2DP_MONO_EQ_HZ 32 * 1000000L
#define BT_A2DP_ONLINE_EQ_HZ 48 * 1000000L
#define BT_CALL_SIMPLEX_HZ 96 * 1000000L
#ifdef CONFIG_ANS_V2
//#define BT_CALL_16k_HZ 96 * 1000000L
//#define BT_CALL_16k_ADVANCE_HZ 120 * 1000000L
#else
//#define BT_CALL_16k_HZ 80 * 1000000L
//#define BT_CALL_16k_ADVANCE_HZ 96 * 1000000L
#endif
#define BT_CALL_16k_SIMPLEX_HZ 120 * 1000000L
////////////////////////
#ifdef CONFIG_FPGA_ENABLE
// #undef TCFG_CLOCK_OSC_HZ
// #define TCFG_CLOCK_OSC_HZ 12000000
#endif
#ifdef CONFIG_CPU_BR26
#undef BT_CALL_16k_HZ
#undef BT_CALL_16k_ADVANCE_HZ
#define BT_CALL_16k_HZ 96 * 1000000L
#define BT_CALL_16k_ADVANCE_HZ 96 * 1000000L
#endif
#ifdef CONFIG_CPU_BR23
#undef BT_A2DP_STEREO_EQ_HZ
#define BT_A2DP_STEREO_EQ_HZ 48 * 1000000L
#undef BT_A2DP_MONO_EQ_HZ
#define BT_A2DP_MONO_EQ_HZ 48 * 1000000L
#endif
#ifdef CONFIG_CPU_BR25
#undef BT_A2DP_STEREO_EQ_HZ
#define BT_A2DP_STEREO_EQ_HZ 48 * 1000000L
#undef BT_A2DP_MONO_EQ_HZ
#define BT_A2DP_MONO_EQ_HZ 48 * 1000000L
#endif
#ifdef CONFIG_FPGA_ENABLE
// #undef TCFG_CLOCK_OSC_HZ
// #define TCFG_CLOCK_OSC_HZ 12000000
#undef TCFG_MC_BIAS_AUTO_ADJUST
#define TCFG_MC_BIAS_AUTO_ADJUST MC_BIAS_ADJUST_DISABLE
#endif
//*********************************************************************************//
// 低功耗配置 //
//*********************************************************************************//
#if TCFG_IRKEY_ENABLE
#undef TCFG_LOWPOWER_LOWPOWER_SEL
#define TCFG_LOWPOWER_LOWPOWER_SEL 0 //开红外不进入低功耗
#endif /* #if TCFG_IRKEY_ENABLE */
//*********************************************************************************//
// LED使用 16SLOT TIMER 同步 //
//*********************************************************************************//
//LED模块使用slot timer同步使用注意点:
// 1.soundbox不开该功能, 原因: 默认打开osc时钟, 使用原来的osc流程同步即可
// 2.带sd卡earphone不开该功能, 一般为单耳, 不需要同步, 使用原来的流程(lrc)
// 3.一般用在tws应用中, 而且默认关闭osc;
#if TCFG_USER_TWS_ENABLE
#define TCFG_PWMLED_USE_SLOT_TIME ENABLE_THIS_MOUDLE
#endif
//*********************************************************************************//
// 升级配置 //
//*********************************************************************************//
//升级LED显示使能
#define UPDATE_LED_REMIND
//升级提示音使能
#define UPDATE_VOICE_REMIND
#ifndef CONFIG_UPDATE_JUMP_TO_MASK
#define CONFIG_UPDATE_JUMP_TO_MASK 0
#endif
#if CONFIG_UPDATE_JUMP_TO_MASK
//升级IO保持使能
#define DEV_UPDATE_SUPPORT_JUMP //目前只有br23\br25支持
#endif
#if TCFG_APP_MUSIC_EN
#define CONFIG_SD_UPDATE_ENABLE
#define CONFIG_USB_UPDATE_ENABLE
#endif
//*********************************************************************************//
// Audio配置 //
//*********************************************************************************//
#if TCFG_AUDIO_ANC_ENABLE
#if ((defined VOL_TYPE_ANALOG) && (SYS_VOL_TYPE == VOL_TYPE_ANALOG)) || \
((defined VOL_TYPE_AD) && (SYS_VOL_TYPE == VOL_TYPE_AD))
#error "ANC can not use VOL_TYPE_ANALOG and VOL_TYPE_AD!!!"
#endif/*(SYS_VOL_TYPE = VOL_TYPE_ANALOG) || (SYS_VOL_TYPE = VOL_TYPE_AD)*/
#endif/*TCFG_AUDIO_ANC_ENABLE*/
/*通话语音处理算法放在.data段*/
#ifndef TCFG_AUDIO_CVP_CODE_AT_RAM
#define TCFG_AUDIO_CVP_CODE_AT_RAM 1
#endif/*TCFG_AUDIO_CVP_CODE_AT_RAM*/
/*AAC解码算法放在.data段*/
#ifndef TCFG_AUDIO_AAC_CODE_AT_RAM
#define TCFG_AUDIO_AAC_CODE_AT_RAM 1
#endif/*TCFG_AUDIO_AAC_CODE_AT_RAM*/
#if (TCFG_AUDIO_DUAL_MIC_ENABLE && TCFG_AUDIO_TRIPLE_MIC_ENABLE)
#error "TCFG_AUDIO_DUAL_MIC_ENABLE and TCFG_AUDIO_TRIPLE_MIC_ENABLE can not enable together !!!"
#endif
//*********************************************************************************//
// 充电中按键清除手机配对信息配置 //
//*********************************************************************************//
#define CHARGING_CLEAN_PHONE_INFO 0
#define PC_MODE_DETECTION
#endif

90
apps/xtell_hide/include/app_main.h Normal file
View File

@ -0,0 +1,90 @@
#ifndef APP_MAIN_H
#define APP_MAIN_H
typedef struct {
float talk;
float ff;
float fb;
} audio_mic_cmp_t;
typedef struct _APP_VAR {
s8 bt_volume;
s8 dev_volume;
s8 music_volume;
s8 call_volume;
s8 wtone_volume;
u8 opid_play_vol_sync;
u8 aec_dac_gain;
u8 aec_mic_gain;
u8 aec_mic1_gain;
u8 aec_mic2_gain;
u8 aec_mic3_gain;
u8 rf_power;
u8 goto_poweroff_flag;
u8 goto_poweroff_cnt;
u8 play_poweron_tone;
u8 remote_dev_company;
u8 siri_stu;
u8 cycle_mode;
u8 have_mass_storage;
int auto_stop_page_scan_timer; //用于1拖2时，有一台连接上后，超过三分钟自动关闭Page Scan
volatile int auto_shut_down_timer;
volatile int wait_exit_timer;
u16 auto_off_time;
u16 warning_tone_v;
u16 poweroff_tone_v;
u16 phone_dly_discon_time;
u8 usb_mic_gain;
int wait_timer_do;
u32 start_time;
float audio_mic_array_diff_cmp;//麦克风阵列补偿值
u8 audio_mic_array_trim_en; //麦克风阵列校准
audio_mic_cmp_t audio_mic_cmp;
float enc_degradation;//default:1,range[0:1]
/*3麦通话配置使用:选择第几个mic*/
u8 talk_mic_ch; //主MIC通道选择
u8 talk_ref_mic_ch; //副MIC通道选择
u8 talk_fb_mic_ch; //FB通道选择
} APP_VAR;
typedef struct _BT_USER_PRIV_VAR {
//phone
u8 phone_ring_flag: 1;
u8 phone_num_flag: 1;
u8 phone_income_flag: 1;
u8 phone_call_dec_begin: 1;
u8 phone_con_sync_num_ring: 1;
u8 phone_con_sync_ring: 1;
// u8 reserved: 2;
u8 emitter_or_receiver: 2;
u8 get_phone_num_timecnt;
u8 inband_ringtone;
u8 phone_vol;
u16 phone_timer_id;
u8 last_call_type;
u8 income_phone_num[30];
u8 income_phone_len;
s32 auto_connection_counter;
int auto_connection_timer;
u8 auto_connection_addr[6];
int tws_con_timer;
u8 tws_start_con_cnt;
u8 tws_conn_state;
bool search_tws_ing;
int sniff_timer;
bool fast_test_mode;
} BT_USER_PRIV_VAR;
#define BT_EMITTER_EN 1
#define BT_RECEIVER_EN 2
typedef struct _BT_USER_COMM_VAR {
} BT_USER_COMM_VAR;
extern APP_VAR app_var;
extern BT_USER_PRIV_VAR bt_user_priv_var;
#define earphone (&bt_user_priv_var)
#endif

8
apps/xtell_hide/include/app_music.h Normal file
View File

@ -0,0 +1,8 @@
#ifndef CONFIG_APP_MUSIC_H
#define CONFIG_APP_MUSIC_H
void app_music_exit();
int music_app_check(void);
#endif

13
apps/xtell_hide/include/app_online_cfg.h Normal file
View File

@ -0,0 +1,13 @@
#ifndef ONLINE_CONFIG_H
#define ONLINE_CONFIG_H
#define DEVICE_EVENT_FROM_CI_UART (('C' << 24) | ('I' << 16) | ('U' << 8) | '\0')
#define DEVICE_EVENT_FROM_CI_TWS (('C' << 24) | ('I' << 16) | ('T' << 8) | '\0')
#define CI_UART 0
#define CI_TWS 1
void ci_data_rx_handler(u8 type);
u32 eq_cfg_sync(u8 priority);
#endif

39
apps/xtell_hide/include/app_power_manage.h Normal file
View File

@ -0,0 +1,39 @@
#ifndef APP_POWER_MANAGE_H
#define APP_POWER_MANAGE_H
#include "typedef.h"
#include "system/event.h"
#define LOW_POWER_SHUTDOWN 300 //低电直接关机电压-拔出不开机-开盖不开机
#define LOW_POWER_OFF_VAL 330 //低电关机电压
#define LOW_POWER_WARN_VAL 340 //低电提醒电压
#define LOW_POWER_WARN_TIME (60 * 1000) //低电提醒时间
#define DEVICE_EVENT_FROM_POWER (('P' << 24) | ('O' << 16) | ('W' << 8) | '\0')
enum {
POWER_EVENT_POWER_NORMAL,
POWER_EVENT_POWER_WARNING,
POWER_EVENT_POWER_LOW,
POWER_EVENT_POWER_CHANGE,
POWER_EVENT_SYNC_TWS_VBAT_LEVEL,
POWER_EVENT_POWER_CHARGE,
};
int app_power_event_handler(struct device_event *dev);
void check_power_on_voltage(void);
u16 get_vbat_level(void);
u8 get_vbat_percent(void);
void vbat_check_init(void);
void vbat_timer_update(u32 msec);
void vbat_timer_delete(void);
void tws_sync_bat_level(void);
u8 get_tws_sibling_bat_level(void);
u8 get_tws_sibling_bat_persent(void);
bool get_vbat_need_shutdown(void);
u8 get_self_battery_level(void);
void app_power_set_tws_sibling_bat_level(u8 vbat, u8 percent);
#endif

6
apps/xtell_hide/include/app_sd_music.h Normal file
View File

@ -0,0 +1,6 @@
#ifndef CONFIG_APP_SD_MUSIC_H
#define CONFIG_APP_SD_MUSIC_H
int music_app_check(void);//music 在线检测 切换模式判断使用
#endif

31
apps/xtell_hide/include/app_task.h Normal file
View File

@ -0,0 +1,31 @@
#ifndef APP_TASK_H
#define APP_TASK_H
#include "typedef.h"
#define NULL_VALUE 0
enum {
APP_BT_TASK,
#if TCFG_APP_MUSIC_EN
APP_MUSIC_TASK,
#endif
#if TCFG_PC_ENABLE
APP_PC_TASK,
#endif
#if TCFG_APP_AUX_EN
APP_AUX_TASK,
#endif
};
extern u8 app_curr_task;
extern u8 app_next_task;
extern u8 app_prev_task;
int app_task_switch_check(u8 app_task);
int app_core_back_to_prev_app_over_check(void);
int app_task_switch_to(u8 app_task, int priv);
void app_task_switch_next(void);
void app_task_switch_prev(void);
u8 app_get_curr_task(void);
#endif

18
apps/xtell_hide/include/app_testbox.h Normal file
View File

@ -0,0 +1,18 @@
#ifndef _APP_TESTBOX_H_
#define _APP_TESTBOX_H_
#include "typedef.h"
#include "system/event.h"
extern void testbox_set_bt_init_ok(u8 flag);
extern u8 testbox_get_status(void);
extern void testbox_clear_status(void);
extern u8 testbox_get_ex_enter_dut_flag(void);
extern u8 testbox_get_ex_enter_storage_mode_flag(void);
extern u8 testbox_get_connect_status(void);
extern void testbox_clear_connect_status(void);
extern u8 testbox_get_keep_tws_conn_flag(void);
extern int app_testbox_event_handler(struct testbox_event *testbox_dev);
#endif //_APP_TESTBOX_H_

50
apps/xtell_hide/include/app_umidigi_chargestore.h Normal file
View File

@ -0,0 +1,50 @@
#ifndef _APP_UMIDIGI_CHARGESTORE_H_
#define _APP_UMIDIGI_CHARGESTORE_H_
#include "typedef.h"
#include "system/event.h"
#include "board_config.h"
/*******************************UMIDIGI充电舱数据包格式*****************************/
/*
* |<--1bit-->||<-------4bits----->||<--------------8bits------------>||<--1bit-->||<--1bits-->|
* |<-start-->||<-------CMD------->||<--------------DATA------------->|| crc_odd ||<--stop--->|
* | 14 || 13 | 12 | 11 | 10 || 9 | 8 | 7 | 6 | 5 | 4 | 3 | 2 || 1 || 0 |
*/
/*充电舱发送的命令列表*/
#define CMD_RESERVED_0 0x00 //reserved
#define CMD_FACTORY_RESET 0x01 //恢复出厂设置
#define CMD_RESERVED_2 0x02 //reserved
#define CMD_OPEN_CASE 0x03 //充电舱开盖
#define CMD_CLOSE_CASE 0x04 //充电舱关盖
#define CMD_ENTER_PAIRING_MODE 0x06 //进入配对模式
#define CMD_DUT_MODE_CMD 0x08 //进入DUT模式
#define CMD_USB_STATE 0x0A //USB状态
#define CMD_RESERVED_B 0x0B //reserved(RTK internal use)
#define CMD_SEND_CASE_BATTERY 0x0D //发送充电舱电量
/*message中的CMD与DATA位置，用于从一个完整的数据包中截取CMD和DATA*/
/*CMD_IN_MESSAGE = 0xf000*/
#define CMD_IN_MESSAGE (BIT(13) | BIT(12) | BIT(11) | BIT(10))
/*DATA_IN_MESSAGE = 0x0ff0*/
#define DATA_IN_MESSAGE (BIT(9) | BIT(8) | BIT(7) | BIT(6) | BIT(5) | BIT(4) | BIT(3) | BIT(2))
void app_umidigi_chargetore_message_deal(u16 message);
extern u8 umidigi_chargestore_get_power_level(void); //获取充电舱电池电量
extern u8 umidigi_chargestore_get_power_status(void); //获取充电舱充电状态
extern u8 umidigi_chargestore_get_cover_status(void); //获取充电舱合盖或开盖状态
extern u8 umidigi_chargestore_get_earphone_online(void); //获取合盖状态时耳机在仓数量
extern void umidigi_chargestore_set_bt_init_ok(u8 flag); //获取蓝牙初始化成功标志位
extern u8 umidigi_chargestore_check_going_to_poweroff(void); //获取允许poweroff标志位
extern void umidigi_chargestore_set_phone_disconnect(void);
extern void umidigi_chargestore_set_phone_connect(void);
extern void umidigi_chargestore_set_sibling_chg_lev(u8 chg_lev);//设置对耳同步的充电舱电量
extern void umidigi_chargestore_set_power_level(u8 power); //设置充电舱电池电量
extern int umidigi_chargestore_sync_chg_level(void);
extern int app_umidigi_chargestore_event_handler(struct umidigi_chargestore_event *umidigi_chargestore_dev);
#endif

69
apps/xtell_hide/include/audio_enc_mpt_self.h Normal file
View File

@ -0,0 +1,69 @@
#ifndef __AUDIO_ENC_MPT_FRE_RESPONE_H_
#define __AUDIO_ENC_MPT_FRE_RESPONE_H_
#include "asm/cpu.h"
/********************用户配置****************************/
//计算长度 输入单位s16/输出单位float
#define AUDIO_ENC_MPT_FRERES_POINT 1024
/********************非用户配置****************************/
//MIC频响测试通道ID u16
#define AUDIO_ENC_MPT_FF_MIC 0X01 //测试TWS FFMIC or 头戴式LFF MIC
#define AUDIO_ENC_MPT_FB_MIC 0X02 //测试TWS FBMIC or 头戴式LFB MIC
#define AUDIO_ENC_MPT_RFF_MIC 0X04 //测试头戴式RFF MIC
#define AUDIO_ENC_MPT_RFB_MIC 0X08 //测试头戴式RFB MIC
#define AUDIO_ENC_MPT_CVP_OUT 0X10 //测试通话算法输出
#define AUDIO_ENC_MPT_TALK_MIC 0X20 //测试通话TALK 主MIC
#define AUDIO_ENC_MPT_SLAVE_MIC 0X40 //测试通话TALK 副MIC
#define AUDIO_ENC_MPT_TALK_FB_MIC 0X80 //测试通话TALK FBMIC
//常见通道组合
//FF+TALK+算法输出频响测试，默认关闭DNS, 外部喇叭发声
#define AUDIO_ENC_MPT_CH_TWS_CVP_ENC (AUDIO_ENC_MPT_SLAVE_MIC | AUDIO_ENC_MPT_TALK_MIC | AUDIO_ENC_MPT_CVP_OUT)
//FF回声/气密性+FB频响测试，耳机喇叭发声
#define AUDIO_ENC_MPT_CH_TWS_FF_FB (AUDIO_ENC_MPT_FF_MIC | AUDIO_ENC_MPT_FB_MIC)
#define AUDIO_ENC_MPT_FRERES_ASYNC 1 //是否异步处理， 异步算不过来要加时钟提醒
enum {
ENC_FRE_RES_STATE_START = 0,
ENC_FRE_RES_STATE_RUN,
ENC_FRE_RES_STATE_STOP,
};
enum {
ENC_FRE_RESPONE_MSG_RUN = 0xA1,
};
//更新目标通道输入buf、len
void audio_enc_mpt_fre_response_inbuf(u16 id, s16 *buf, int len);
//音频测试频响计算运行
void audio_enc_mpt_fre_response_post_run(u16 id);
//音频测试频响计算启动, ch 对应目标的通道
void audio_enc_mpt_fre_response_start(u16 ch);
//音频测试频响计算停止
void audio_enc_mpt_fre_response_stop(void);
//工具获取数据文件
int audio_enc_mpt_fre_response_file_get(u8 **buf);
//数据获取结束，释放内存
void audio_enc_mpt_fre_response_release(void);
//音频测试MIC频响开启， ch 对应目标的通道
void audio_enc_mpt_fre_response_open(u16 ch);
//音频测试MIC频响关闭
void audio_enc_mpt_fre_response_close(void);
#endif /*__AUDIO_ENC_MPT_FRE_RESPONE_H_*/

43
apps/xtell_hide/include/bt_background.h Normal file
View File

@ -0,0 +1,43 @@
#ifndef BT_BACKGROUND_H
#define BT_BACKGROUND_H
#include "generic/typedef.h"
bool bt_in_background();
void bt_switch_to_foreground(int action, bool exit_curr_app);
int bt_switch_to_background();
void bt_stop_a2dp_slience_detect();
void bt_start_a2dp_slience_detect(int ingore_packet_num);
int bt_background_event_probe_handler(struct bt_event *bt);
#endif

48
apps/xtell_hide/include/bt_ble.h Normal file
View File

@ -0,0 +1,48 @@
#ifndef APP_BT_BLE_H
#define APP_BT_BLE_H
#include "typedef.h"
// #define ADV_RSP_PACKET_MAX 31
#define ADV_RAND_MAX 7
// typedef struct {
// u16 pid; //厂家id，默认用杰理的id (0x5d6)
// u8 private_data[17];//厂家自定义数据内容
// } manufacturer_data_t;
enum {
ICON_TYPE_INQUIRY = 0,
ICON_TYPE_CONNECTED,
ICON_TYPE_RECONNECT,
ICON_TYPE_PRE_DEV,
};
enum {
ADV_ST_NULL,
ADV_ST_PRE1,
ADV_ST_PRE2,
ADV_ST_INQUIRY,
ADV_ST_CONN,
ADV_ST_RECONN,
ADV_ST_DISMISS,
ADV_ST_FAST_DISMISS,
ADV_ST_END,
};
extern void bt_ble_icon_set(u8 *info, u8 len);
extern u8 bt_ble_get_adv_enable(void);
extern void bt_ble_icon_open(u8 type);
extern void bt_ble_icon_close(u8 dismiss_flag);
extern void bt_ble_icon_set_comm_address(u8 *addr);
extern void bt_ble_icon_reset(void);
extern void bt_ble_set_control_en(u8 en);
extern void bt_ble_icon_slave_en(u8 en);
extern u8 bt_ble_icon_get_adv_state(void);
extern void bt_ble_icon_role_switch(u8 role);
extern void bt_ble_icon_state_sniff(u8 state);
#endif

26
apps/xtell_hide/include/bt_emitter.h Normal file
View File

@ -0,0 +1,26 @@
#ifndef _BT_EMITTER_H
#define _BT_EMITTER_H
extern void bt_search_device(void);
extern void emitter_search_noname(u8 status, u8 *addr, u8 *name);
extern u8 bt_emitter_stu_set(u8 *addr, u8 on);
extern u8 bt_emitter_stu_get(void);
extern int bt_emitter_mic_open(void);
extern void bt_emitter_mic_close(void);
extern int bt_emitter_iis_open(void);
extern void bt_emitter_iis_close(void);
extern void emitter_media_source(u8 *addr, u8 source, u8 en);
extern u8 emitter_search_result(char *name, u8 name_len, u8 *addr, u32 dev_class, char rssi);
extern void emitter_search_stop(u8 result);
extern void emitter_media_source(u8 *addr, u8 source, u8 en);
extern void bt_emitter_receiver_sw();
extern u8 bt_emitter_pp(u8 pp);
extern void emitter_or_receiver_switch(u8 flag);
extern u8 bt_emitter_role_get();
extern void bt_emitter_start_search_device();
extern void bt_emitter_stop_search_device();
extern void emitter_open(u8 source);
extern void emitter_close(u8 source);
#endif

194
apps/xtell_hide/include/bt_tws.h Normal file
View File

@ -0,0 +1,194 @@
#ifndef APP_BT_TWS_H
#define APP_BT_TWS_H
#include "classic/tws_api.h"
#include "classic/tws_event.h"
#include "system/includes.h"
#define TWS_FUNC_ID_VOL_SYNC TWS_FUNC_ID('V', 'O', 'L', 'S')
#define TWS_FUNC_ID_VBAT_SYNC TWS_FUNC_ID('V', 'B', 'A', 'T')
#define TWS_FUNC_ID_CHARGE_SYNC TWS_FUNC_ID('C', 'H', 'G', 'S')
#define TWS_FUNC_ID_BOX_SYNC TWS_FUNC_ID('B', 'O', 'X', 'S')
#define TWS_FUNC_ID_AI_DMA_RAND TWS_FUNC_ID('A', 'I', 'D', 'M')
#define TWS_FUNC_ID_AI_SPEECH_STOP TWS_FUNC_ID('A', 'I', 'S', 'T')
#define TWS_FUNC_ID_APP_MODE TWS_FUNC_ID('M', 'O', 'D', 'E')
#define TWS_FUNC_ID_AI_SYNC TWS_FUNC_ID('A', 'I', 'P', 'A')
#define TWS_FUNC_ID_EAR_DETECT_SYNC TWS_FUNC_ID('E', 'D', 'E', 'T')
#define TWS_FUNC_ID_LL_SYNC_STATE TWS_FUNC_ID('L', 'L', 'S', 'S')
#define TWS_FUNC_ID_TUYA_STATE TWS_FUNC_ID('T', 'U', 'Y', 'A')
enum {
DEBUG_LINK_PAGE_STATE = 0,
DEBUG_LINK_INQUIRY_STATE,
DEBUG_LINK_PAGE_SCAN_STATE,
DEBUG_LINK_INQUIRY_SCAN_STATE,
DEBUG_LINK_CONNECTION_STATE,
DEBUG_LINK_PAGE_TWS_STATE,
DEBUG_LINK_PAGE_SCAN_TWS_STATE,
};
enum {
BT_TWS_STATUS_INIT_OK = 1,
BT_TWS_STATUS_SEARCH_START,
BT_TWS_STATUS_SEARCH_TIMEOUT,
BT_TWS_STATUS_PHONE_CONN,
BT_TWS_STATUS_PHONE_DISCONN,
};
enum {
SYNC_TONE_TWS_CONNECTED = 1,
SYNC_TONE_PHONE_CONNECTED,
SYNC_TONE_PHONE_DISCONNECTED,
SYNC_TONE_PHONE_NUM,
SYNC_TONE_PHONE_RING,
SYNC_TONE_PHONE_NUM_RING,
SYNC_TONE_MAX_VOL,
SYNC_TONE_POWER_OFF,
SYNC_TONE_ANC_ON,
SYNC_TONE_ANC_OFF,
SYNC_TONE_ANC_TRANS,
SYNC_TONE_EARDET_IN,
SYNC_TONE_VOICE_RECOGNIZE,
SYNC_TONE_HEARING_AID_OPEN,
SYNC_TONE_DHA_FITTING_CLOSE,
SYNC_TONE_ICSD_ADT_SUSPEND,
SYNC_TONE_ICSD_ADT_VOICE_STATE,
SYNC_TONE_ICSD_ADT_OPEN,
};
enum {
SYNC_LED_STA_TWS_CONN,
SYNC_LED_STA_PHONE_CONN,
SYNC_LED_STA_PHONE_DISCONN,
};
enum {
SYNC_CMD_SHUT_DOWN_TIME,
SYNC_CMD_POWER_OFF_TOGETHER,
SYNC_CMD_LOW_LATENCY_ENABLE,
SYNC_CMD_LOW_LATENCY_DISABLE,
SYNC_CMD_EARPHONE_CHAREG_START,
SYNC_CMD_IRSENSOR_EVENT_NEAR,
SYNC_CMD_IRSENSOR_EVENT_FAR,
#if(USE_DMA_TONE)
SYNC_CMD_CUT_TWS_TONE, //断开对耳提示音
SYNC_CMD_START_SPEECH_TONE,//AI键提示音
SYNC_CMD_DMA_CONNECTED_ALL_FINISH_TONE, //AI连接成功
SYNC_CMD_NEED_BT_TONE, //需要连接蓝牙
SYNC_CMD_PLEASE_OPEN_XIAODU_TONE,//请打开小度
#endif
#if(RCSP_ADV_EN)
SYNC_CMD_SYNC_ADV_SETTING,
SYNC_CMD_ADV_COMMON_SETTING_SYNC,
SYNC_CMD_APP_RESET_LED_UI,
SYNC_CMD_MUSIC_INFO,
SYNC_CMD_RCSP_AUTH_RES,
SYNC_CMD_MUSIC_PLAYER_STATE,
SYNC_CMD_MUSIC_PLAYER_TIEM_EN,
#endif
SYNC_CMD_OPUS_CLOSE,
};
enum {
TWS_SYNC_VOL = 0,
TWS_SYNC_VBAT,
TWS_SYNC_CHG,
TWS_SYNC_CALL_VOL,
TWS_SYNC_PBG_INFO,
TWS_SYNC_ADSP_UART_CMD,
TWS_APP_DATA_SEND,
TWS_AI_DMA_RAND,
TWS_DATA_SEND,
TWS_UPDATE_START,
TWS_UPDATE_RESULT_EXCHANGE,
TWS_UPDATE_RESULT_EXCHANGE_RES,
TWS_UPDATE_OVER,
TWS_UPDATE_OVER_CONFIRM,
TWS_UPDATE_OVER_CONFIRM_REQ,
TWS_UPDATE_OVER_CONFIRM_RES,
TWS_UPDATE_VERIFY,
TWS_AI_A2DP_DROP_FRAME_CTL,
};
struct tws_sync_info_t {
u8 type;
union {
s8 volume_lev;
u16 vbat_lev;
u8 chg_lev;
u8 adsp_cmd[2];
u8 conn_type;
u8 data[9];
u8 data_large[32];
} u;
};
struct tws_sync_big_info_t {
u8 type;
u8 sub_type;
union {
u8 pbg_info[36];
} u;
};
typedef struct time_stamp_bt_name {
u8 bt_name[32];
u32 time_stamp;
} tws_time_stamp_bt_name;
#define TWS_WAIT_CONN_TIMEOUT (400)
#define TWS_SYNC_TIME_DO 400
// #define TWS_CON_SUPER_TIMEOUT 8000
#define TWS_CON_SEARCH_TIMEOUT 0x07//(n*1.28s)
char bt_tws_get_local_channel();
int bt_tws_connction_status_event_handler(struct bt_event *evt);
int bt_tws_poweron();
int bt_tws_poweroff();
int bt_tws_start_search_sibling();
void bt_tws_hci_event_connect();
bool get_tws_phone_connect_state(void);
int bt_tws_phone_connected();
void bt_tws_phone_page_timeout();
void bt_tws_phone_connect_timeout();
void bt_tws_phone_disconnected();
int bt_tws_sync_phone_num(void *priv);
int bt_tws_sync_led_status();
int get_bt_tws_connect_status();
u8 get_bt_tws_discon_dly_state();
void bt_tws_sync_volume();
u8 tws_network_audio_was_started(void);
void tws_network_local_audio_start(void);
u32 bt_tws_future_slot_time(u32 msecs);
void bt_tws_play_tone_at_same_time(int tone_name, int msec);
void bt_tws_led_state_sync(int led_state, int msec);
bool get_tws_sibling_connect_state(void);
void tws_cancle_all_noconn();
void tws_sniff_controle_check_enable(void);
void tws_sniff_controle_check_disable(void);
#endif

41
apps/xtell_hide/include/default_event_handler.h Normal file
View File

@ -0,0 +1,41 @@
#ifndef DEFAULT_EVENT_HANDLER_H
#define DEFAULT_EVENT_HANDLER_H
#include "system/includes.h"
void default_event_handler(struct sys_event *event);
#endif

272
apps/xtell_hide/include/earphone.h Normal file
View File

@ -0,0 +1,272 @@
#ifndef EARPHONE_H
#define EARPHONE_H
#include "system/includes.h"
///搜索完整结束的事件
#define HCI_EVENT_INQUIRY_COMPLETE 0x01
///连接完成的事件
#define HCI_EVENT_CONNECTION_COMPLETE 0x03
///断开的事件,会有一些错误码区分不同情况的断开
#define HCI_EVENT_DISCONNECTION_COMPLETE 0x05
///连接中请求pin code的事件,给这个事件上来目前是做了一个确认的操作
#define HCI_EVENT_PIN_CODE_REQUEST 0x16
///连接设备发起了简易配对加密的连接
#define HCI_EVENT_IO_CAPABILITY_REQUEST 0x31
///这个事件上来目前是做了一个连接确认的操作
#define HCI_EVENT_USER_CONFIRMATION_REQUEST 0x33
///这个事件是需要输入6个数字的连接消息，一般在键盘应用才会有
#define HCI_EVENT_USER_PASSKEY_REQUEST 0x34
///<可用于显示输入passkey位置 value 0:start 1:enrer 2:earse 3:clear 4:complete
#define HCI_EVENT_USER_PRESSKEY_NOTIFICATION 0x3B
///杰理自定义的事件，上电回连的时候读不到VM的地址。
#define HCI_EVENT_VENDOR_NO_RECONN_ADDR 0xF8
///杰理自定义的事件，有测试盒连接的时候会有这个事件
#define HCI_EVENT_VENDOR_REMOTE_TEST 0xFE
///杰理自定义的事件，可以认为是断开之后协议栈资源释放完成的事件
#define BTSTACK_EVENT_HCI_CONNECTIONS_DELETE 0x6D
#define ERROR_CODE_SUCCESS 0x00
///<回连超时退出消息
#define ERROR_CODE_PAGE_TIMEOUT 0x04
///<连接过程中linkkey错误
#define ERROR_CODE_AUTHENTICATION_FAILURE 0x05
///<连接过程中linkkey丢失，手机删除了linkkey，回连就会出现一次
#define ERROR_CODE_PIN_OR_KEY_MISSING 0x06
///<连接超时，一般拿远就会断开有这个消息
#define ERROR_CODE_CONNECTION_TIMEOUT 0x08
///<连接个数超出了资源允许
#define ERROR_CODE_SYNCHRONOUS_CONNECTION_LIMIT_TO_A_DEVICE_EXCEEDED 0x0A
///<回连的时候发现设备还没释放我们这个地址，一般直接断电开机回连会出现
#define ERROR_CODE_ACL_CONNECTION_ALREADY_EXISTS 0x0B
///<需要回连的设备资源不够。有些手机连了一个设备之后就会用这个拒绝。或者其它的资源原因
#define ERROR_CODE_CONNECTION_REJECTED_DUE_TO_LIMITED_RESOURCES 0x0D
///<有些可能只允许指定地址连接的，可能会用这个去拒绝连接。或者我们设备的地址全0或者有问题
#define ERROR_CODE_CONNECTION_REJECTED_DUE_TO_UNACCEPTABLE_BD_ADDR 0x0F
///<连接的时间太长了，手机要断开了。这种容易复现可以联系我们分析
#define ERROR_CODE_CONNECTION_ACCEPT_TIMEOUT_EXCEEDED 0x10
///<经常用的连接断开消息。就认为断开就行
#define ERROR_CODE_REMOTE_USER_TERMINATED_CONNECTION 0x13
///<正常的断开消息，本地L2CAP资源释放之后就会发这个值上来了
#define ERROR_CODE_CONNECTION_TERMINATED_BY_LOCAL_HOST 0x16
///<回连的时候发现设备两次role switch失败了，发断开在重新连接
#define ERROR_CODE_ROLE_SWITCH_FAILED 0x35
///杰理自定义，在回连的过程中使用page cancel命令主动取消成功会有这个命令
#define CUSTOM_BB_AUTO_CANCEL_PAGE 0xFD //// app cancle page
///杰理自定义，库里面有些功能需要停止page的时候会有。比如page的时候来了电话
#define BB_CANCEL_PAGE 0xFE //// bb cancle page
#if (TCFG_USER_BLE_ENABLE && (CONFIG_BT_MODE == BT_NORMAL))
#if RCSP_ADV_EN
int rcsp_earphone_state_init();
int rcsp_earphone_state_set_page_scan_enable();
int rcsp_earphone_state_get_connect_mac_addr();
int rcsp_earphone_state_cancel_page_scan();
int rcsp_earphone_state_enter_soft_poweroff();
int rcsp_earphone_state_tws_init(int paired);
int rcsp_earphone_state_tws_connected(int first_pair, u8 *comm_addr);
int rcsp_sys_event_handler_specific(struct sys_event *event);
#define EARPHONE_STATE_INIT() rcsp_earphone_state_init()
#define EARPHONE_STATE_SET_PAGE_SCAN_ENABLE() rcsp_earphone_state_set_page_scan_enable()
#define EARPHONE_STATE_GET_CONNECT_MAC_ADDR() rcsp_earphone_state_get_connect_mac_addr()
#define EARPHONE_STATE_CANCEL_PAGE_SCAN() rcsp_earphone_state_cancel_page_scan()
#define EARPHONE_STATE_ENTER_SOFT_POWEROFF() rcsp_earphone_state_enter_soft_poweroff()
#define EARPHONE_STATE_TWS_INIT(a) rcsp_earphone_state_tws_init(a)
#define EARPHONE_STATE_TWS_CONNECTED(a, b) rcsp_earphone_state_tws_connected(a,b)
#define SYS_EVENT_HANDLER_SPECIFIC(a) rcsp_sys_event_handler_specific(a)
#define SYS_EVENT_REMAP(a) 0
#define EARPHONE_STATE_SNIFF(a)
#define EARPHONE_STATE_ROLE_SWITCH(a)
#elif TRANS_DATA_EN
int trans_data_earphone_state_init();
int trans_data_earphone_state_set_page_scan_enable();
int trans_data_earphone_state_get_connect_mac_addr();
int trans_data_earphone_state_cancel_page_scan();
int trans_data_earphone_state_enter_soft_poweroff();
int trans_data_earphone_state_tws_init(int paired);
int trans_data_earphone_state_tws_connected(int first_pair, u8 *comm_addr);
int trans_data_sys_event_handler_specific(struct sys_event *event);
#define EARPHONE_STATE_INIT() trans_data_earphone_state_init()
#define EARPHONE_STATE_SET_PAGE_SCAN_ENABLE() trans_data_earphone_state_set_page_scan_enable()
#define EARPHONE_STATE_GET_CONNECT_MAC_ADDR() trans_data_earphone_state_get_connect_mac_addr()
#define EARPHONE_STATE_CANCEL_PAGE_SCAN() trans_data_earphone_state_cancel_page_scan()
#define EARPHONE_STATE_ENTER_SOFT_POWEROFF() trans_data_earphone_state_enter_soft_poweroff()
#define EARPHONE_STATE_TWS_INIT(a) trans_data_earphone_state_tws_init(a)
#define EARPHONE_STATE_TWS_CONNECTED(a, b) trans_data_earphone_state_tws_connected(a,b)
#define SYS_EVENT_HANDLER_SPECIFIC(a) trans_data_sys_event_handler_specific(a)
#define SYS_EVENT_REMAP(a) 0
#define EARPHONE_STATE_SNIFF(a)
#define EARPHONE_STATE_ROLE_SWITCH(a)
#elif BLE_HID_EN
int ble_hid_earphone_state_init();
int ble_hid_earphone_state_set_page_scan_enable();
int ble_hid_earphone_state_get_connect_mac_addr();
int ble_hid_earphone_state_cancel_page_scan();
int ble_hid_earphone_state_enter_soft_poweroff();
int ble_hid_earphone_state_tws_init(int paired);
int ble_hid_earphone_state_tws_connected(int first_pair, u8 *comm_addr);
int ble_hid_sys_event_handler_specific(struct sys_event *event);
#define EARPHONE_STATE_INIT() ble_hid_earphone_state_init()
#define EARPHONE_STATE_SET_PAGE_SCAN_ENABLE() ble_hid_earphone_state_set_page_scan_enable()
#define EARPHONE_STATE_GET_CONNECT_MAC_ADDR() ble_hid_earphone_state_get_connect_mac_addr()
#define EARPHONE_STATE_CANCEL_PAGE_SCAN() ble_hid_earphone_state_cancel_page_scan()
#define EARPHONE_STATE_ENTER_SOFT_POWEROFF() ble_hid_earphone_state_enter_soft_poweroff()
#define EARPHONE_STATE_TWS_INIT(a) ble_hid_earphone_state_tws_init(a)
#define EARPHONE_STATE_TWS_CONNECTED(a, b) ble_hid_earphone_state_tws_connected(a,b)
#define SYS_EVENT_HANDLER_SPECIFIC(a) ble_hid_sys_event_handler_specific(a)
#define SYS_EVENT_REMAP(a) 0
#define EARPHONE_STATE_SNIFF(a)
#define EARPHONE_STATE_ROLE_SWITCH(a)
#elif LL_SYNC_EN
int ll_sync_earphone_state_init();
int ll_sync_earphone_state_set_page_scan_enable();
int ll_sync_earphone_state_get_connect_mac_addr();
int ll_sync_earphone_state_cancel_page_scan();
int ll_sync_earphone_state_enter_soft_poweroff();
int ll_sync_earphone_state_tws_init(int paired);
int ll_sync_earphone_state_tws_connected(int first_pair, u8 *comm_addr);
int ll_sync_sys_event_handler_specific(struct sys_event *event);
#define EARPHONE_STATE_INIT() ll_sync_earphone_state_init()
#define EARPHONE_STATE_SET_PAGE_SCAN_ENABLE() ll_sync_earphone_state_set_page_scan_enable()
#define EARPHONE_STATE_GET_CONNECT_MAC_ADDR() ll_sync_earphone_state_get_connect_mac_addr()
#define EARPHONE_STATE_CANCEL_PAGE_SCAN() ll_sync_earphone_state_cancel_page_scan()
#define EARPHONE_STATE_ENTER_SOFT_POWEROFF() ll_sync_earphone_state_enter_soft_poweroff()
#define EARPHONE_STATE_TWS_INIT(a) ll_sync_earphone_state_tws_init(a)
#define EARPHONE_STATE_TWS_CONNECTED(a, b) ll_sync_earphone_state_tws_connected(a,b)
#define SYS_EVENT_HANDLER_SPECIFIC(a) ll_sync_sys_event_handler_specific(a)
#define SYS_EVENT_REMAP(a) 0
#define EARPHONE_STATE_SNIFF(a)
#define EARPHONE_STATE_ROLE_SWITCH(a)
#elif TUYA_DEMO_EN
int tuya_earphone_state_init();
int tuya_earphone_state_set_page_scan_enable();
int tuya_earphone_state_get_connect_mac_addr();
int tuya_earphone_state_cancel_page_scan();
int tuya_earphone_state_enter_soft_poweroff();
int tuya_earphone_state_tws_init(int paired);
int tuya_earphone_state_tws_connected(int first_pair, u8 *comm_addr);
int tuya_sys_event_handler_specific(struct sys_event *event);
#define EARPHONE_STATE_INIT() tuya_earphone_state_init()
#define EARPHONE_STATE_SET_PAGE_SCAN_ENABLE() tuya_earphone_state_set_page_scan_enable()
#define EARPHONE_STATE_GET_CONNECT_MAC_ADDR() tuya_earphone_state_get_connect_mac_addr()
#define EARPHONE_STATE_CANCEL_PAGE_SCAN() tuya_earphone_state_cancel_page_scan()
#define EARPHONE_STATE_ENTER_SOFT_POWEROFF() tuya_earphone_state_enter_soft_poweroff()
#define EARPHONE_STATE_TWS_INIT(a) tuya_earphone_state_tws_init(a)
#define EARPHONE_STATE_TWS_CONNECTED(a, b) tuya_earphone_state_tws_connected(a,b)
#define SYS_EVENT_HANDLER_SPECIFIC(a) tuya_sys_event_handler_specific(a)
#define SYS_EVENT_REMAP(a) 0
#define EARPHONE_STATE_SNIFF(a)
#define EARPHONE_STATE_ROLE_SWITCH(a)
#elif (AI_APP_PROTOCOL | LE_AUDIO_EN)
int app_protocol_sys_event_handler(struct sys_event *event);
#define EARPHONE_STATE_INIT() do { } while(0)
#define EARPHONE_STATE_SET_PAGE_SCAN_ENABLE() do { } while(0)
#define EARPHONE_STATE_GET_CONNECT_MAC_ADDR() do { } while(0)
#define EARPHONE_STATE_CANCEL_PAGE_SCAN() do { } while(0)
#define EARPHONE_STATE_ENTER_SOFT_POWEROFF() do { } while(0)
#define EARPHONE_STATE_TWS_INIT(a) do { } while(0)
#define EARPHONE_STATE_TWS_CONNECTED(a, b) do { } while(0)
#define SYS_EVENT_HANDLER_SPECIFIC(a) app_protocol_sys_event_handler(a)
#define SYS_EVENT_REMAP(a) 0
#define EARPHONE_STATE_SNIFF(a)
#define EARPHONE_STATE_ROLE_SWITCH(a)
#elif TCFG_WIRELESS_MIC_ENABLE
#define EARPHONE_STATE_INIT() do { } while(0)
#define EARPHONE_STATE_SET_PAGE_SCAN_ENABLE() do { } while(0)
#define EARPHONE_STATE_GET_CONNECT_MAC_ADDR() do { } while(0)
#define EARPHONE_STATE_CANCEL_PAGE_SCAN() do { } while(0)
#define EARPHONE_STATE_ENTER_SOFT_POWEROFF() do { } while(0)
#define EARPHONE_STATE_TWS_INIT(a) do { } while(0)
#define EARPHONE_STATE_TWS_CONNECTED(a, b) do { } while(0)
#define SYS_EVENT_HANDLER_SPECIFIC(a) do { } while(0)
#define SYS_EVENT_REMAP(a) 0
#define EARPHONE_STATE_SNIFF(a)
#define EARPHONE_STATE_ROLE_SWITCH(a)
#else
int adv_earphone_state_init();
int adv_earphone_state_set_page_scan_enable();
int adv_earphone_state_get_connect_mac_addr();
int adv_earphone_state_cancel_page_scan();
int adv_earphone_state_enter_soft_poweroff();
int adv_earphone_state_tws_init(int paired);
int adv_earphone_state_tws_connected(int first_pair, u8 *comm_addr);
int adv_sys_event_handler_specific(struct sys_event *event);
int adv_earphone_state_sniff(u8 state);
int adv_earphone_state_role_switch(u8 role);
#define EARPHONE_STATE_INIT() adv_earphone_state_init()
#define EARPHONE_STATE_SET_PAGE_SCAN_ENABLE() adv_earphone_state_set_page_scan_enable()
#define EARPHONE_STATE_GET_CONNECT_MAC_ADDR() adv_earphone_state_get_connect_mac_addr()
#define EARPHONE_STATE_CANCEL_PAGE_SCAN() adv_earphone_state_cancel_page_scan()
#define EARPHONE_STATE_ENTER_SOFT_POWEROFF() adv_earphone_state_enter_soft_poweroff()
#define EARPHONE_STATE_TWS_INIT(a) adv_earphone_state_tws_init(a)
#define EARPHONE_STATE_TWS_CONNECTED(a, b) adv_earphone_state_tws_connected(a,b)
#define SYS_EVENT_HANDLER_SPECIFIC(a) adv_sys_event_handler_specific(a)
#define SYS_EVENT_REMAP(a) 0
#define EARPHONE_STATE_SNIFF(a) adv_earphone_state_sniff(a)
#define EARPHONE_STATE_ROLE_SWITCH(a) adv_earphone_state_role_switch(a)
#endif
#else
#define EARPHONE_STATE_INIT() do { } while(0)
#define EARPHONE_STATE_SET_PAGE_SCAN_ENABLE() do { } while(0)
#define EARPHONE_STATE_GET_CONNECT_MAC_ADDR() do { } while(0)
#define EARPHONE_STATE_CANCEL_PAGE_SCAN() do { } while(0)
#define EARPHONE_STATE_ENTER_SOFT_POWEROFF() do { } while(0)
#define EARPHONE_STATE_TWS_INIT(a) do { } while(0)
#define EARPHONE_STATE_TWS_CONNECTED(a, b) do { } while(0)
#define SYS_EVENT_HANDLER_SPECIFIC(a) do { } while(0)
#define SYS_EVENT_REMAP(a) 0
#define EARPHONE_STATE_SNIFF(a)
#define EARPHONE_STATE_ROLE_SWITCH(a)
#endif
extern void sys_auto_shut_down_enable(void);
extern void sys_auto_shut_down_disable(void);
extern int bt_in_background_event_handler(struct sys_event *event);
extern u8 bt_app_exit_check(void);
#endif

100
apps/xtell_hide/include/key_event_deal.h Normal file
View File

@ -0,0 +1,100 @@
#ifndef __KEY_EVENT_DEAL_H__
#define __KEY_EVENT_DEAL_H__
#include "typedef.h"
#include "bt_profile_cfg.h"
#include "system/event.h"
enum {
KEY_POWER_ON = KEY_EVENT_MAX,
KEY_POWEROFF,
KEY_POWEROFF_HOLD,
KEY_MUSIC_PP,
KEY_MUSIC_PREV,
KEY_MUSIC_NEXT,
KEY_VOL_UP,
KEY_VOL_DOWN,
KEY_CALL_LAST_NO,
KEY_CALL_HANG_UP,
KEY_CALL_ANSWER,
KEY_CALL_ANSWER_UP,
KEY_OPEN_SIRI,
KEY_HID_CONTROL,
KEY_LOW_LANTECY,
KEY_MODE_SWITCH,
KEY_EQ_MODE,
KEY_THIRD_CLICK,
KEY_MUSIC_FF,
KEY_MUSIC_FR,
KEY_MUSIC_PLAYER_START,
KEY_MUSIC_PLAYER_END,
KEY_MUSIC_PLAYER_DEC_ERR,
KEY_MUSIC_DEVICE_TONE_END,
KEY_MUSIC_PLAYER_QUIT,
KEY_MUSIC_PLAYER_AUTO_NEXT,
KEY_MUSIC_PLAYER_PLAY_FIRST,
KEY_MUSIC_PLAYER_PLAY_LAST,
KEY_MUSIC_CHANGE_REPEAT,
KEY_MUSIC_CHANGE_DEV,
KEY_MUSIC_AUTO_NEXT_DEV,
KEY_MUSIC_CHANGE_DEV_REPEAT,
KEY_MUSIC_SET_PITCH,
KEY_MUSIC_SET_SPEED,
KEY_MUSIC_PLAYE_BY_DEV_FILENUM,
KEY_MUSIC_PLAYE_BY_DEV_SCLUST,
KEY_MUSIC_PLAYE_BY_DEV_PATH,
KEY_MUSIC_DELETE_FILE,
KEY_MUSIC_PLAYE_NEXT_FOLDER,
KEY_MUSIC_PLAYE_PREV_FOLDER,
KEY_MUSIC_PLAYE_REC_FOLDER_SWITCH,
KEY_MUSIC_PLAYER_AB_REPEAT_SWITCH,
KEY_SEND_SPEECH_START,
KEY_SEND_SPEECH_STOP,
#if (BT_FOR_APP_EN)
KEY_AI_DEC_SUSPEND,
KEY_AI_DEC_RESUME,
#endif
KEY_EARTCH_ENABLE,
KEY_EARTCH_DISABLE,
KEY_ANC_SWITCH,
KEY_ANC_EAR_ADAPTIVE,
KEY_ANC_COEFF_SWITCH,
KEY_MUSIC_EFF, //播歌音效切换
KEY_PHONE_PITCH,//通话上行 变声切换
KEY_HEARING_AID_TOGGLE,//辅听功能开关
MSG_HALF_SECOND,
KEY_CLEAN_PHONE_INFO,
KEY_CLEAN_PHONE_INFO_HOLD,
KEY_CLEAN_PHONE_INFO_UP,
KEY_SPATIAL_EFFECT_MODE_SWITCH, /*切换空间音频模式*/
KEY_SPEAK_TO_CHAT_SWITCH, /*智能免摘开关*/
KEY_WIND_NOISE_DET_SWITCH, /*风噪检测开关*/
KEY_WIDE_AREA_TAP_SWITCH, /*广域点击开关*/
KEY_ANC_MULT_SCENE_SWITCH, /*多滤波器切换demo*/
KEY_NULL = 0xFF,
};
enum {
ONE_KEY_CTL_NEXT_PREV = 1,
ONE_KEY_CTL_VOL_UP_DOWN,
};
enum {
EARTCH_STATE_IN,
EARTCH_STATE_OUT,
EARTCH_STATE_TRIM_OK,
EARTCH_STATE_TRIM_ERR,
};
extern void volume_up(u8 inc);
extern void volume_down(u8 inc);
extern int app_earphone_key_event_handler(struct sys_event *);
#endif

31
apps/xtell_hide/include/pbg_user.h Normal file
View File

@ -0,0 +1,31 @@
#ifndef PBG_USER_H_
#define PBG_USER_H_
#include "typedef.h"
#include "key_event_deal.h"
enum {
PBG_POS_IN_EAR = 0, //入耳
PBG_POS_OUT_BOX, //出仓
PBG_POS_IN_BOX, //在仓
PBG_POS_NOT_EXIST, //不在线
PBG_POS_KEEP_NOW = 0x0f, //维持，不改变
PBG_POS_MAX, //
};
#define BD_ADDR_LEN 6
typedef uint8_t bd_addr_t[BD_ADDR_LEN];
void pbg_user_set_tws_state(u8 conn_flag);
void pbg_user_recieve_sync_info(u8 *sync_info);
void pbg_user_mic_fixed_deal(u8 mode);
void pbg_user_event_deal(struct pbg_event *evt);
bool pbg_user_key_vaild(u8 *key_msg, struct sys_event *event);
void pbg_user_ear_pos_sync(u8 left, u8 right);
void pbg_user_battery_level_sync(u8 *dev_bat);
int pbg_user_is_connected(void);
#endif

157
apps/xtell_hide/include/tone_player.h Normal file
View File

@ -0,0 +1,157 @@
#ifndef TONE_PLAYER_H
#define TONE_PLAYER_H
#include "app_config.h"
#include "tone_player_api.h"
#define TONE_NUM_0 SDFILE_RES_ROOT_PATH"tone/0.*"
#define TONE_NUM_1 SDFILE_RES_ROOT_PATH"tone/1.*"
#define TONE_NUM_2 SDFILE_RES_ROOT_PATH"tone/2.*"
#define TONE_NUM_3 SDFILE_RES_ROOT_PATH"tone/3.*"
#define TONE_NUM_4 SDFILE_RES_ROOT_PATH"tone/4.*"
#define TONE_NUM_5 SDFILE_RES_ROOT_PATH"tone/5.*"
#define TONE_NUM_6 SDFILE_RES_ROOT_PATH"tone/6.*"
#define TONE_NUM_7 SDFILE_RES_ROOT_PATH"tone/7.*"
#define TONE_NUM_8 SDFILE_RES_ROOT_PATH"tone/8.*"
#define TONE_NUM_9 SDFILE_RES_ROOT_PATH"tone/9.*"
#define TONE_BT_MODE SDFILE_RES_ROOT_PATH"tone/bt.*"
#define TONE_BT_CONN SDFILE_RES_ROOT_PATH"tone/bt_conn.*"
#define TONE_BT_DISCONN SDFILE_RES_ROOT_PATH"tone/bt_dconn.*"
#define TONE_TWS_CONN SDFILE_RES_ROOT_PATH"tone/tws_conn.*"
#define TONE_TWS_DISCONN SDFILE_RES_ROOT_PATH"tone/tws_dconn.*"
#define TONE_LOW_POWER SDFILE_RES_ROOT_PATH"tone/low_power.*"
#define TONE_POWER_OFF SDFILE_RES_ROOT_PATH"tone/power_off.*"
#define TONE_POWER_ON SDFILE_RES_ROOT_PATH"tone/power_on.*"
#define TONE_RING SDFILE_RES_ROOT_PATH"tone/ring.*"
#define TONE_MAX_VOL SDFILE_RES_ROOT_PATH"tone/vol_max.*"
#define TONE_ANC_OFF SDFILE_RES_ROOT_PATH"tone/anc_off.*"
#define TONE_ANC_ON SDFILE_RES_ROOT_PATH"tone/anc_on.*"
#define TONE_TRANSPARENCY SDFILE_RES_ROOT_PATH"tone/anc_trans.*"
#define TONE_ANC_ADAPTIVE SDFILE_RES_ROOT_PATH"tone/adaptive.*"
#define TONE_ANC_ADAPTIVE_COEFF SDFILE_RES_ROOT_PATH"tone/adap_coeff.*"
#define TONE_ANC_NORMAL_COEFF SDFILE_RES_ROOT_PATH"tone/nor_coeff.*"
#define TONE_EAR_CHECK SDFILE_RES_ROOT_PATH"tone/ear_check.*"
#define TONE_MUSIC_MODE SDFILE_RES_ROOT_PATH"tone/music.*"
#define TONE_PC_MODE SDFILE_RES_ROOT_PATH"tone/pc.*"
#define TONE_SPKCHAT_OFF SDFILE_RES_ROOT_PATH"tone/spkchat_off.*"
#define TONE_SPKCHAT_ON SDFILE_RES_ROOT_PATH"tone/spkchat_on.*"
#define TONE_WCLICK_OFF SDFILE_RES_ROOT_PATH"tone/wclick_off.*"
#define TONE_WCLICK_ON SDFILE_RES_ROOT_PATH"tone/wclick_on.*"
#define TONE_WINDDET_OFF SDFILE_RES_ROOT_PATH"tone/winddet_off.*"
#define TONE_WINDDET_ON SDFILE_RES_ROOT_PATH"tone/winddet_on.*"
#define SINE_WTONE_NORAML 0
#define SINE_WTONE_TWS_CONNECT 1
#define SINE_WTONE_TWS_DISCONNECT 2
#define SINE_WTONE_LOW_POWER 4
#define SINE_WTONE_RING 5
#define SINE_WTONE_MAX_VOLUME 6
#define SINE_WTONE_ADSP 7
#define SINE_WTONE_LOW_LATENRY_IN 8
#define SINE_WTONE_LOW_LATENRY_OUT 9
#define SINE_WTONE_ANC_ADAPTIVE_1 10
#define SINE_WTONE_ANC_ADAPTIVE_2 11
#if CONFIG_USE_DEFAULT_SINE
#undef TONE_TWS_CONN
#define TONE_TWS_CONN DEFAULT_SINE_TONE(SINE_WTONE_TWS_CONNECT)
#undef TONE_TWS_DISCONN
#define TONE_TWS_DISCONN DEFAULT_SINE_TONE(SINE_WTONE_TWS_DISCONNECT)
#undef TONE_MAX_VOL
#define TONE_MAX_VOL DEFAULT_SINE_TONE(SINE_WTONE_MAX_VOLUME)
#undef TONE_NORMAL
#define TONE_NORMAL DEFAULT_SINE_TONE(SINE_WTONE_NORAML)
#if BT_PHONE_NUMBER
#else
#undef TONE_RING
#define TONE_RING DEFAULT_SINE_TONE(SINE_WTONE_RING)
#endif
#undef TONE_LOW_POWER
#define TONE_LOW_POWER DEFAULT_SINE_TONE(SINE_WTONE_LOW_POWER)
#endif
#define TONE_SIN_NORMAL DEFAULT_SINE_TONE(SINE_WTONE_NORAML)
#define TONE_LOW_LATENCY_IN DEFAULT_SINE_TONE(SINE_WTONE_LOW_LATENRY_IN)
#define TONE_LOW_LATENCY_OUT DEFAULT_SINE_TONE(SINE_WTONE_LOW_LATENRY_OUT)
#define TONE_ANC_ADAPTIVE_LVL1 DEFAULT_SINE_TONE(SINE_WTONE_ANC_ADAPTIVE_1)
#define TONE_ANC_ADAPTIVE_LVL2 DEFAULT_SINE_TONE(SINE_WTONE_ANC_ADAPTIVE_2)
enum {
IDEX_TONE_NUM_0,
IDEX_TONE_NUM_1,
IDEX_TONE_NUM_2,
IDEX_TONE_NUM_3,
IDEX_TONE_NUM_4,
IDEX_TONE_NUM_5,
IDEX_TONE_NUM_6,
IDEX_TONE_NUM_7,
IDEX_TONE_NUM_8,
IDEX_TONE_NUM_9,
IDEX_TONE_BT_MODE,
IDEX_TONE_BT_CONN,
IDEX_TONE_BT_DISCONN,
IDEX_TONE_TWS_CONN,
IDEX_TONE_TWS_DISCONN,
IDEX_TONE_LOW_POWER,
IDEX_TONE_POWER_OFF,
IDEX_TONE_POWER_ON,
IDEX_TONE_RING,
IDEX_TONE_MAX_VOL,
IDEX_TONE_NORMAL,
IDEX_TONE_ANC_OFF,
IDEX_TONE_ANC_ON,
IDEX_TONE_TRANSPARCNCY,
IDEX_TONE_ANC_ADAPTIVE,
IDEX_TONE_ANC_ADAPTIVE_COEFF,
IDEX_TONE_ANC_NORMAL_COEFF,
IDEX_TONE_NONE = 0xFF,
};
int tone_play_init(void);
int tone_play_index(u8 index, u8 preemption);
int tone_play_index_with_callback(u8 index, u8 preemption, void (*user_evt_handler)(void *priv), void *priv);
int tone_play_index_no_tws(u8 index, u8 preemption);
/*
*@brief:提示音比较，确认目标提示音和正在播放的提示音是否一致
*@return: 0 匹配
* 非0 不匹配或者当前没有提示音播放
*@note:通过提示音索引比较
*/
int tone_name_cmp_by_index(u8 index);
// 按键提示音初始化
int audio_key_tone_init(void);
// 注销按键提示音播放
void audio_key_tone_destroy(void);
// 播放正弦波数组
int audio_key_tone_play_sin(struct audio_sin_param *sin, u8 sin_num, u8 preemption);
// 播放文件
int audio_key_tone_play_name(const char *name, u8 preemption);
// 按序号播放文件 // 使用key_tone_index[]数组
int audio_key_tone_play_index(u8 index, u8 preemption);
// 按键提示音播放 // 默认播放数组中第一个
void audio_key_tone_play(void);
// 检测按键提示音是否在播放
int audio_key_tone_is_play(void);
// 设置按键提示音的音量
void audio_key_tone_digvol_set(u8 volume);
#endif

39
apps/xtell_hide/include/ui_manage.h Normal file
View File

@ -0,0 +1,39 @@
#ifndef __UI_MANAGE_H_
#define __UI_MANAGE_H_
#include "typedef.h"
typedef enum {
STATUS_NULL = 0,
STATUS_POWERON,
STATUS_POWEROFF,
STATUS_POWERON_LOWPOWER,
STATUS_BT_INIT_OK,
STATUS_BT_CONN,
STATUS_BT_SLAVE_CONN_MASTER,
STATUS_BT_MASTER_CONN_ONE,
STATUS_BT_DISCONN,
STATUS_BT_TWS_CONN,
STATUS_BT_TWS_DISCONN,
STATUS_PHONE_INCOME,
STATUS_PHONE_OUT,
STATUS_PHONE_ACTIV,
STATUS_CHARGE_START,
STATUS_CHARGE_FULL,
STATUS_CHARGE_CLOSE,
STATUS_CHARGE_ERR,
STATUS_LOWPOWER,
STATUS_CHARGE_LDO5V_OFF,
STATUS_EXIT_LOWPOWER,
STATUS_NORMAL_POWER,
STATUS_POWER_NULL,
} UI_STATUS;
int ui_manage_init(void);
void ui_update_status(u8 status);
u8 get_ui_busy_status();
void led_module_enter_sniff_mode();
void led_module_exit_sniff_mode();
#endif

68
apps/xtell_hide/include/user_cfg_id.h Normal file
View File

@ -0,0 +1,68 @@
#ifndef _USER_CFG_ID_H_
#define _USER_CFG_ID_H_
//=================================================================================//
// 与APP CASE相关配置项[1 ~ 60] //
//=================================================================================//
#define CFG_EARTCH_ENABLE_ID 1
#define CFG_PBG_MODE_INFO 2
#define CFG_CHARGESTORE_TWS_CHANNEL 3
#define CFG_SYS_VOL 4
#define CFG_MIC_ARRAY_DIFF_CMP_VALUE 5//麦克风阵列算法前补偿值
#define CFG_MIC_ARRAY_TRIM_EN 6//麦克风补偿使能
#define CFG_DMS_MALFUNC_STATE_ID 7//dms故障麦克风检测默认使用哪个mic的参数id
#define CFG_MIC_TARGET_DIFF_CMP 8//目标MIC补偿值
#define CFG_DHA_FITTING_ID 26 //辅听验配保存参数的id
#define CFG_REMOTE_DN_00 27
#define CFG_IMU_GYRO_OFFEST_ID 28 //空间音频imu陀螺仪偏置
#define CFG_IMU_ACC_OFFEST_ID 29 //空间音频imu加速度偏置
#define VM_LP_TOUCH_KEY0_ALOG_CFG 30
#define VM_LP_TOUCH_KEY1_ALOG_CFG 31
#define VM_LP_TOUCH_KEY2_ALOG_CFG 32
#define VM_LP_TOUCH_KEY3_ALOG_CFG 33
#define VM_LP_TOUCH_KEY4_ALOG_CFG 34
#define VM_UPDATE_FLAG 35
#define VM_DMA_RAND 36
#define VM_DMA_RAND 37
#define VM_GMA_ALI_PARA 38
#define CFG_BCS_MAP_WEIGHT 39
#define CFG_RCSP_ADV_HIGH_LOW_VOL 40
#define CFG_RCSP_ADV_EQ_MODE_SETTING 41
#define CFG_RCSP_ADV_EQ_DATA_SETTING 42
#define ADV_SEQ_RAND 43
#define CFG_RCSP_ADV_TIME_STAMP 44
#define CFG_RCSP_ADV_WORK_SETTING 45
#define CFG_RCSP_ADV_MIC_SETTING 46
#define CFG_RCSP_ADV_LED_SETTING 47
#define CFG_RCSP_ADV_KEY_SETTING 48
#define CFG_USB_BREAKPOINT0 49
#define CFG_SD0_BREAKPOINT0 50
#define CFG_SD1_BREAKPOINT0 51
#define CFG_HAVE_MASS_STORAGE 52
#define CFG_MUSIC_MODE 53
#define LP_KEY_EARTCH_TRIM_VALUE 54
#define CFG_RCSP_ADV_ANC_VOICE 55
#define CFG_RCSP_ADV_ANC_VOICE_MODE 56
#define CFG_RCSP_ADV_ANC_VOICE_KEY 57
#define CFG_SPK_EQ_SEG_SAVE 58
#define CFG_SPK_EQ_GLOBAL_GAIN_SAVE 59
#define CFG_ANC_ADAPTIVE_DATA_ID 60//保存ANC自适应参数id
#define CFG_REMOTE_DN_00 63
#endif /* #ifndef _USER_CFG_ID_H_ */

9
apps/xtell_hide/include/vol_sync.h Normal file
View File

@ -0,0 +1,9 @@
#ifndef __VOL_SYNC_H__
#define __VOL_SYNC_H__
void vol_sys_tab_init(void);
void set_music_device_volume(int volume);
int phone_get_device_vol(void);
void opid_play_vol_sync_fun(u8 *vol, u8 mode);
#endif

104
apps/xtell_hide/include/wireless_mic/bt_edr_fun.h Normal file
View File

@ -0,0 +1,104 @@
#ifndef __BT_EDR_FUN_H__
#define __BT_EDR_FUN_H__
#include "adapter_odev_bt.h"
#include "app_main.h"
/*配置通话时前面丢掉的数据包包数*/
#define ESCO_DUMP_PACKET_ADJUST 1 /*配置使能*/
#define ESCO_DUMP_PACKET_DEFAULT 0
#define ESCO_DUMP_PACKET_CALL 120 /*0~0xFF*/
#if(TCFG_UI_ENABLE && TCFG_SPI_LCD_ENABLE)//点阵屏断开蓝牙连接时可选择不跳回蓝牙模式
#define BACKGROUND_GOBACK 0 //后台链接是否跳回蓝牙 1：跳回
#else
#define BACKGROUND_GOBACK 1
#endif
#define TIMEOUT_CONN_TIME 60 //超时断开之后回连的时间s
#define POWERON_AUTO_CONN_TIME 12 //开机去回连的时间
#define PHONE_CALL_FORCE_POWEROFF 0 //通话时候强制关机
#define SBC_FILTER_TIME_MS 1000 //后台音频过滤时间ms
#define SBC_ZERO_TIME_MS 500 //静音多长时间认为已经退出
#define NO_SBC_TIME_MS 200 //无音频时间ms
#define SNIFF_CNT_TIME 5/////<空闲5S之后进入sniff模式
#define SNIFF_MAX_INTERVALSLOT 800
#define SNIFF_MIN_INTERVALSLOT 100
#define SNIFF_ATTEMPT_SLOT 4
#define SNIFF_TIMEOUT_SLOT 1
enum {
BT_AS_IDEV = 0,
BT_AS_ODEV,
};
void set_bt_dev_role(u8 role);
struct app_bt_opr {
u8 init_ok : 1; // 1-初始化完成
u8 call_flag : 1; // 1-由于蓝牙打电话命令切回蓝牙模式
u8 exit_flag : 1; // 1-可以退出蓝牙标志
u8 exiting : 1; // 1-正在退出蓝牙模式
u8 wait_exit : 1; // 1-等退出蓝牙模式
u8 a2dp_decoder_type: 3; // 从后台返回时记录解码格式用
u8 cmd_flag ; // 1-由于蓝牙命令切回蓝牙模式
u8 init_start ; //蓝牙协议栈初始化开始 ,但未初始化不一定已经完成，要判断initok完成的标志
u8 ignore_discon_tone; // 1-退出蓝牙模式， 不响应discon提示音
u8 sbc_packet_valid_cnt; // 有效sbc包计数
u8 sbc_packet_valid_cnt_max;// 最大有效sbc包计数
u8 sbc_packet_lose_cnt; // sbc丢失的包数
u8 sbc_packet_step; // 0-正常；1-退出中；2-后台
u32 tws_local_back_role : 4;
u32 tws_local_to_bt_mode : 1;
u32 a2dp_start_flag : 1;
u32 bt_back_flag : 4;
u32 replay_tone_flag : 1;
u8 esco_dump_packet;
u8 last_connecting_addr[6];
u32 sbc_packet_filter_to; // 过滤超时
u32 no_sbc_packet_to; // 无声超时
u32 init_ok_time; // 初始化完成时间
u32 auto_exit_limit_time; // 自动退出时间限制
u8 bt_direct_init;
u8 bt_close_bredr;
u8 hid_mode;
u8 force_poweroff;
u8 call_back_flag; //BIT(0):hfp_status BIT(1):esco_status
int timer;
int tmr_cnt;
int back_mode_systime;
int max_tone_timer_hdl;
int exit_sniff_timer ;
u32 sco_info;
};
extern struct app_bt_opr app_bt_hdl;
extern BT_USER_PRIV_VAR bt_user_priv_var;
void bt_init();
void bt_close(void);
void sys_auto_shut_down_enable(void);
void sys_auto_shut_down_disable(void);
u8 get_bt_init_status();
void bt_set_led_status(u8 status);
void sys_auto_sniff_controle(u8 enable, u8 *addr);
void bt_wait_phone_connect_control(u8 enable);
int bt_wait_connect_and_phone_connect_switch(void *p);
u8 is_call_now();
//bt status
int bt_connction_status_event_handler(struct bt_event *bt, struct _odev_bt *odev_bt);
//hci event
int bt_hci_event_handler(struct bt_event *bt, struct _odev_bt *odev_bt);
#endif //__BT_EDR_FUN_H__

12
apps/xtell_hide/include/wireless_mic/wireless_mic_test.h Normal file
View File

@ -0,0 +1,12 @@
#ifndef _WIRELESS_MIC_TEST_
#define _WIRELESS_MIC_TEST_
#include "system/includes.h"
// struct adapter_media {
// };
#endif

743
apps/xtell_hide/power_manage/app_charge.c Normal file
View File

@ -0,0 +1,743 @@
#include "app_config.h"
#include "asm/charge.h"
#include "asm/pwm_led.h"
#include "asm/power_interface.h"
#include "ui_manage.h"
#include "system/event.h"
#include "system/app_core.h"
#include "system/includes.h"
#include "app_action.h"
#include "asm/wdt.h"
#include "app_power_manage.h"
#include "app_chargestore.h"
#include "app_testbox.h"
#include "btstack/avctp_user.h"
#include "app_action.h"
#include "app_main.h"
#include "bt_tws.h"
#include "usb/otg.h"
#include "bt_common.h"
#if TCFG_AUDIO_ANC_ENABLE
#include "audio_anc.h"
#endif
#if NTC_DET_EN
#include "ntc_det_api.h"
#endif
#if TCFG_ANC_BOX_ENABLE
#include "app_ancbox.h"
#endif
#define LOG_TAG_CONST APP_CHARGE
#define LOG_TAG "[APP_CHARGE]"
#define LOG_ERROR_ENABLE
#define LOG_DEBUG_ENABLE
#define LOG_INFO_ENABLE
/* #define LOG_DUMP_ENABLE */
#define LOG_CLI_ENABLE
#include "debug.h"
extern void sys_enter_soft_poweroff(void *priv);
extern void gSensor_wkupup_enable(void);
extern void gSensor_wkupup_disable(void);
extern u32 dual_bank_update_exist_flag_get(void);
extern u32 classic_update_task_exist_flag_get(void);
extern void lp_touch_key_disable(void);
extern void linein_det_disable(void);
extern void linein_det_enable(void);
#if TCFG_CHARGE_ENABLE
static u8 charge_full_flag = 0;
#if TCFG_TEST_BOX_ENABLE || TCFG_ANC_BOX_ENABLE
static int ldo5v_keep_timer = 0;
#endif
static u8 delay_timeout = 20;
static int ldo5v_in_reset_timer = 0;
static void ldo5v_in_reset_delay(void)
{
int deal_state = tws_api_get_tws_state();
u8 cpu_reset_flag = 1;
if (delay_timeout) {
delay_timeout--;
}
if (deal_state & TWS_STA_SIBLING_CONNECTED && deal_state & TWS_STA_PHONE_CONNECTED && !(deal_state & TWS_STA_MONITOR_START)) {
//tws已连接 手机已连接 从机未监听手机
cpu_reset_flag = 0;
} else {
if (deal_state & TWS_STA_SIBLING_CONNECTED && deal_state & TWS_STA_ESCO_OPEN && !get_esco_coder_busy_flag()) {
//手机有请求但没建立ESCO链路
cpu_reset_flag = 0;
}
}
printf("----------------ldo5v_in_reset_delay tws state:%x, delay_timeout:%d, cpu_reset_flag:%d\n", deal_state, delay_timeout, cpu_reset_flag);
if (delay_timeout == 0 || cpu_reset_flag == 1) {
if (ldo5v_in_reset_timer) {
sys_timer_del(ldo5v_in_reset_timer);
ldo5v_in_reset_timer = 0;
}
sys_enter_soft_poweroff((void *)1);
}
}
extern void power_event_to_user(u8 event);
u8 get_charge_full_flag(void)
{
return charge_full_flag;
}
void charge_start_deal(void)
{
log_info("%s\n", __FUNCTION__);
power_set_mode(PWR_LDO15);
struct application *app;
app = get_current_app();
//在IDLE时才开启充电UI
if (app && (!strcmp(app->name, APP_NAME_IDLE))) {
ui_update_status(STATUS_CHARGE_START);
}
}
static void ldo5v_keep_delay_deal(void *priv)
{
log_info("%s\n", __func__);
#if TCFG_TEST_BOX_ENABLE
ldo5v_keep_timer = 0;
if (testbox_get_status()) {
log_info("testbox online!\n");
return;
}
#endif
#if TCFG_ANC_BOX_ENABLE
ldo5v_keep_timer = 0;
if (ancbox_get_status()) {
log_info("ancbox online!\n");
return;
}
#endif
struct application *app;
app = get_current_app();
if (app) {
if (strcmp(app->name, APP_NAME_IDLE)) {
sys_enter_soft_poweroff((void *)2);
}
}
pwm_led_mode_set(PWM_LED_ALL_OFF);
os_time_dly(30);
pwm_led_mode_set(PWM_LED1_ON);
os_time_dly(40);
//兼容一些充电仓5v输出慢的时候会导致无法充电的问题
if (get_lvcmp_det()) {
log_info("...charge ing...\n");
cpu_reset();
}
log_info("get_charge_online_flag:%d %d\n", get_charge_online_flag(), get_ldo5v_online_hw());
if (get_ldo5v_online_hw() && get_charge_online_flag()) {
power_set_soft_poweroff();
} else {
#if TCFG_CHARGE_OFF_POWERON_NE
cpu_reset();
#else
charge_check_and_set_pinr(1);
power_set_soft_poweroff();
#endif
}
}
/*ldoin电压大于拔出电压(0.6V左右)且小于VBat电压时调用该函数进行一些错误提示或其他处理*/
void ldo5v_keep_deal(void)
{
log_info("%s\n", __func__);
//插入交换
power_event_to_user(POWER_EVENT_POWER_CHANGE);
#if TCFG_GSENSOR_ENABLE
//在舱关闭gSensor
gSensor_wkupup_disable();
#endif
#if TCFG_LINEIN_ENABLE
//入舱关闭linein
linein_det_disable();
#endif
#if TCFG_LP_TOUCH_KEY_ENABLE
extern void lp_touch_key_charge_mode_enter();
lp_touch_key_charge_mode_enter();
#endif /* #if TCFG_LP_TOUCH_KEY_ENABLE */
#if TCFG_GX8002_NPU_ENABLE
extern void gx8002_module_suspend(u8 keep_vddio);
gx8002_module_suspend(0);
#endif /* #if TCFG_GX8002_NPU_ENABLE */
charge_check_and_set_pinr(0);
#if TCFG_AUDIO_ANC_ENABLE
#if TCFG_ANC_BOX_ENABLE
if (!ancbox_get_status())
#endif
{
anc_suspend();
}
#endif
if (get_charge_poweron_en() == 0) {
#if TCFG_CHARGESTORE_ENABLE
//智能充电舱不处理充电err
struct application *app;
app = get_current_app();
if (app && (!strcmp(app->name, APP_NAME_IDLE))) {
ui_update_status(STATUS_CHARGE_LDO5V_OFF);
}
#else //TCFG_CHARGESTORE_ENABLE
#if defined(TCFG_CHARGE_KEEP_UPDATA) && TCFG_CHARGE_KEEP_UPDATA
if (dual_bank_update_exist_flag_get() || classic_update_task_exist_flag_get()) {
return;
}
#endif
#if TCFG_TEST_BOX_ENABLE || TCFG_ANC_BOX_ENABLE
if (testbox_get_ex_enter_dut_flag()) {
putchar('D');
return;
}
if (testbox_get_ex_enter_storage_mode_flag()) {
putchar('S');
return;
}
if (ldo5v_keep_timer == 0) {
//延时执行避免测试盒通信不上
ldo5v_keep_timer = sys_timeout_add(NULL, ldo5v_keep_delay_deal, 250);
}
#else
ldo5v_keep_delay_deal(NULL);
#endif//TCFG_TEST_BOX_ENABLE || TCFG_ANC_BOX_ENABLE
#endif//TCFG_CHARGESTORE_ENABLE
} else {
ui_update_status(STATUS_CHARGE_ERR);
}
}
extern u8 umidigi_chargestore_get_cover_status(void);
void charge_full_deal(void)
{
log_info("%s\n", __func__);
charge_full_flag = 1;
charge_close();
if (get_charge_poweron_en() == 0) {
#if (TCFG_LP_TOUCH_KEY_ENABLE && CHARGING_CLEAN_PHONE_INFO)
extern void lp_touch_key_charge_mode_enter();
lp_touch_key_charge_mode_enter();
#endif
/* power_set_soft_poweroff(); */
#if TCFG_USER_TWS_ENABLE
#else
ui_update_status(STATUS_CHARGE_FULL);
#endif
#if (!TCFG_CHARGESTORE_ENABLE)
#if TCFG_UMIDIGI_BOX_ENABLE
//当前为开盖
if (umidigi_chargestore_get_cover_status() == 1) {
vbat_timer_delete();
}
#else
vbat_timer_delete();
#endif
#endif
} else {
ui_update_status(STATUS_CHARGE_FULL);
}
}
void charge_close_deal(void)
{
log_info("%s\n", __FUNCTION__);
power_set_mode(TCFG_LOWPOWER_POWER_SEL);
#if TCFG_USER_TWS_ENABLE
//在idle的时候才执行充电关闭的UI
struct application *app;
app = get_current_app();
if (app && (!strcmp(app->name, APP_NAME_IDLE))) {
ui_update_status(STATUS_CHARGE_CLOSE);
}
#endif
}
void charge_ldo5v_in_deal(void)
{
log_info("%s\n", __FUNCTION__);
#if TCFG_IRSENSOR_ENABLE
if (get_bt_tws_connect_status()) {
tws_api_sync_call_by_uuid('T', SYNC_CMD_EARPHONE_CHAREG_START, 300);
}
#endif
//插入交换
power_event_to_user(POWER_EVENT_POWER_CHANGE);
charge_full_flag = 0;
#if TCFG_GSENSOR_ENABLE
//入舱关闭gSensor
gSensor_wkupup_disable();
#endif
#if TCFG_LINEIN_ENABLE
//入舱关闭linein
linein_det_disable();
#endif
#if (TCFG_LP_TOUCH_KEY_ENABLE && !CHARGING_CLEAN_PHONE_INFO)
extern void lp_touch_key_charge_mode_enter();
lp_touch_key_charge_mode_enter();
#endif /* #if TCFG_LP_TOUCH_KEY_ENABLE */
#if TCFG_GX8002_NPU_ENABLE
extern void gx8002_module_suspend(u8 keep_vddio);
gx8002_module_suspend(0);
#endif /* #if TCFG_GX8002_NPU_ENABLE */
charge_check_and_set_pinr(0);
#if TCFG_AUDIO_ANC_ENABLE
anc_suspend();
#endif
#if TCFG_TEST_BOX_ENABLE
testbox_clear_status();
if (ldo5v_keep_timer) {
sys_timeout_del(ldo5v_keep_timer);
ldo5v_keep_timer = 0;
}
#endif
#if TCFG_ANC_BOX_ENABLE
ancbox_clear_status();
if (ldo5v_keep_timer) {
sys_timeout_del(ldo5v_keep_timer);
ldo5v_keep_timer = 0;
}
#endif
#if TCFG_CHARGESTORE_ENABLE
chargestore_shutdown_reset();
#endif
if (get_charge_poweron_en() == 0) {
#if defined(TCFG_CHARGE_KEEP_UPDATA) && TCFG_CHARGE_KEEP_UPDATA
if (dual_bank_update_exist_flag_get() || classic_update_task_exist_flag_get()) {
return;
}
#endif
struct application *app;
app = get_current_app();
#if TCFG_WIRELESS_MIC_ENABLE
if (strcmp(app->name, APP_NAME_IDLE) != 0) {
sys_enter_soft_poweroff((void *)1);
}
#endif
if (app && strcmp(app->name, APP_NAME_IDLE)) {
#if (TCFG_CHARGESTORE_ENABLE && TCFG_BLE_DEMO_SELECT == DEF_BLE_DEMO_ADV)
if (!chargestore_check_going_to_poweroff()) {
#endif
#if TCFG_USER_TWS_ENABLE
printf("----------------tws_api_get_tws_state %x\n", tws_api_get_tws_state());
int deal_state = tws_api_get_tws_state();
if (tws_api_get_role() == TWS_ROLE_MASTER && deal_state & TWS_STA_SIBLING_CONNECTED && deal_state & TWS_STA_PHONE_CONNECTED && !(deal_state & TWS_STA_MONITOR_START)) {
if (ldo5v_in_reset_timer == 0) {
delay_timeout = 30;
ldo5v_in_reset_timer = sys_timer_add(NULL, ldo5v_in_reset_delay, 100);
}
} else {
if (ldo5v_in_reset_timer) {
sys_timer_del(ldo5v_in_reset_timer);
ldo5v_in_reset_timer = 0;
}
sys_enter_soft_poweroff((void *)1);
}
#else
sys_enter_soft_poweroff((void *)1);
#endif
#if (TCFG_CHARGESTORE_ENABLE && TCFG_BLE_DEMO_SELECT == DEF_BLE_DEMO_ADV)
} else {
log_info("chargestore do poweroff!\n");
}
#endif
} else {
charge_start();
wdt_init(WDT_32S);
log_info("set wdt to 32s!\n");
goto _check_reset;
}
} else {
charge_start();
goto _check_reset;
}
return;
_check_reset:
//防止耳机低电时,插拔充电有几率出现关机不充电问题
if (app_var.goto_poweroff_flag) {
cpu_reset();
}
}
#if TCFG_EARTCH_EVENT_HANDLE_ENABLE
static u8 _enter_softoff_flag = 0;
extern lp_touch_key_testbox_inear_trim(u8 flag);
void exit_lp_touch_eartch_trim(void *priv)
{
log_info("<<<<<<<<<< exit_lp_touch_eartch_trim!\n");
lp_touch_key_testbox_inear_trim(0);
#if TCFG_PWMLED_ENABLE
gpio_set_direction(TCFG_PWMLED_PIN, 1);
#endif
if (_enter_softoff_flag) {
log_info("<<<<<<<<<<< sys_enter_soft_poweroff after eartch_trim!\n");
sys_enter_soft_poweroff(NULL);
} else {
cpu_reset();
}
}
void enter_lp_touch_eartch_trim(void *priv)
{
log_info(">>>>>>>>>> enter_lp_touch_eartch_trim!\n");
lp_touch_key_testbox_inear_trim(1);
sys_timeout_add(NULL, exit_lp_touch_eartch_trim, 1000);
}
#endif
//外置触摸断电
void __attribute__((weak)) external_touch_key_disable(void)
{
}
//使能外置电源控制芯片对耳机进行断电
void __attribute__((weak)) external_storage_io_disable(void)
{
}
//关闭vddio keep
u8 __attribute__((weak)) power_set_vddio_keep(u8 en)
{
}
void charge_ldo5v_off_deal(void)
{
log_info("%s\n", __FUNCTION__);
//拨出交换
power_event_to_user(POWER_EVENT_POWER_CHANGE);
#if (TCFG_CHARGESTORE_ENABLE && TCFG_USER_TWS_ENABLE)
if (TWS_ROLE_SLAVE == tws_api_get_role()) {
chargestore_set_power_level(0xFF);
}
#endif
charge_full_flag = 0;
charge_close();
struct application *app;
app = get_current_app();
//在idle的时候才执行充电拔出的UI
if (app && (!strcmp(app->name, APP_NAME_IDLE))) {
ui_update_status(STATUS_CHARGE_LDO5V_OFF);
}
charge_check_and_set_pinr(1);
#if TCFG_TEST_BOX_ENABLE
#if TCFG_EARTCH_EVENT_HANDLE_ENABLE
u8 sec = 0;
u8 eartch_trim_en = testbox_get_touch_trim_en(&sec);
if (eartch_trim_en) {
log_info("******* testbox_get_touch_trim_en : %ds\n", sec);
sys_timeout_add(NULL, enter_lp_touch_eartch_trim, sec * 1000);
#if TCFG_PWMLED_ENABLE
gpio_set_pull_up(TCFG_PWMLED_PIN, 0);
gpio_set_pull_down(TCFG_PWMLED_PIN, 0);
gpio_set_die(TCFG_PWMLED_PIN, 0);
gpio_set_direction(TCFG_PWMLED_PIN, 0);
gpio_write(TCFG_PWMLED_PIN, 1);
#endif
}
#endif
if (testbox_get_status() && !get_total_connect_dev()) {
if (!testbox_get_keep_tws_conn_flag()) {
log_info("<<<<<<<<<<<<<<testbox out and bt noconn reset>>>>>>>>>>>>>>>\n");
if (testbox_get_testbox_tws_paired() && testbox_get_softpwroff_after_paired()) {
#if TCFG_EARTCH_EVENT_HANDLE_ENABLE
if (eartch_trim_en) {
_enter_softoff_flag = 1;
} else
#endif
{
sys_enter_soft_poweroff(NULL);
}
} else {
#if TCFG_EARTCH_EVENT_HANDLE_ENABLE
if (eartch_trim_en) {
} else
#endif
{
cpu_reset();
}
}
} else {
log_info("testbox out ret\n");
}
}
testbox_clear_status();
if (ldo5v_keep_timer) {
sys_timeout_del(ldo5v_keep_timer);
ldo5v_keep_timer = 0;
}
#endif
#if TCFG_CHARGESTORE_ENABLE
chargestore_shutdown_reset();
#endif
#if TCFG_AUDIO_ANC_ENABLE
#if TCFG_ANC_BOX_ENABLE
if (ldo5v_keep_timer) {
sys_timeout_del(ldo5v_keep_timer);
ldo5v_keep_timer = 0;
}
if (ancbox_get_status()) {
return;
} else
#endif
{
anc_resume();
}
#endif
#if TCFG_TEST_BOX_ENABLE
if (testbox_get_ex_enter_storage_mode_flag()) {
power_set_vddio_keep(0);//关VDDIO KEEP
#if TCFG_LP_TOUCH_KEY_ENABLE
lp_touch_key_disable();//仓储模式关内置触摸
#else
external_touch_key_disable(); //仓储模式关外置触摸供电
#endif /* #if TCFG_LP_TOUCH_KEY_ENABLE */
#if TCFG_EXTERN_STORAGE_MODE_ENABLE
external_storage_io_disable();
#endif/* TCFG_EXTERN_STORAGE_MODE_ENABLE */
power_set_soft_poweroff();
}
#endif
if ((get_charge_poweron_en() == 0)) {
wdt_init(WDT_4S);
log_info("set wdt to 4s!\n");
#if TCFG_CHARGESTORE_ENABLE
if (chargestore_get_power_status()) {
#endif
#if TCFG_CHARGE_OFF_POWERON_NE
log_info("ldo5v off,task switch to BT\n");
app_var.play_poweron_tone = 0;
#if TCFG_SYS_LVD_EN
vbat_check_init();
#endif
if (app && (app_var.goto_poweroff_flag == 0)) {
if (strcmp(app->name, APP_NAME_BT)) {
#if TCFG_SYS_LVD_EN
if (get_vbat_need_shutdown() == FALSE) {
#if TCFG_WIRELESS_MIC_ENABLE
cpu_reset();
#endif
task_switch_to_bt();
} else {
log_info("ldo5v off,lowpower,need enter softpoweroff\n");
power_set_soft_poweroff();
}
#else
task_switch_to_bt();
#endif
}
}
#else //TCFG_CHARGE_OFF_POWERON_NE
log_info("ldo5v off,enter softpoweroff\n");
#if TCFG_LP_TOUCH_KEY_ENABLE
extern void lp_touch_key_charge_mode_exit();
lp_touch_key_charge_mode_exit();
#endif /* #if TCFG_LP_TOUCH_KEY_ENABLE */
power_set_soft_poweroff();
#endif //TCFG_CHARGE_OFF_POWERON_NE
#if TCFG_CHARGESTORE_ENABLE
} else {
log_info("ldo5v off,enter softpoweroff\n");
if (app && (!strcmp(app->name, APP_NAME_BT))) { //软关机
sys_enter_soft_poweroff(NULL);
} else {
power_set_soft_poweroff();
}
}
#endif
} else {
if (app && (!strcmp(app->name, APP_NAME_IDLE)) && (app_var.goto_poweroff_flag == 0)) {
#if TCFG_CHARGE_OFF_POWERON_NE
log_info("ldo5v off,task switch to BT\n");
app_var.play_poweron_tone = 0;
#if TCFG_SYS_LVD_EN
vbat_check_init();
#endif
#if TCFG_SYS_LVD_EN
if (get_vbat_need_shutdown() == FALSE) {
task_switch_to_bt();
} else {
log_info("ldo5v off,lowpower,need enter softpoweroff\n");
power_set_soft_poweroff();
}
#else
task_switch_to_bt();
#endif
#else
power_set_soft_poweroff();
#endif
}
}
#if TCFG_GSENSOR_ENABLE
//出舱使能gSensor
gSensor_wkupup_enable();
#endif
#if TCFG_LINEIN_ENABLE
//出舱开启linein检测
linein_det_enable();
#endif
#if TCFG_LP_TOUCH_KEY_ENABLE
extern void lp_touch_key_charge_mode_exit();
lp_touch_key_charge_mode_exit();
#endif /* #if TCFG_LP_TOUCH_KEY_ENABLE */
#if TCFG_TEST_BOX_ENABLE
if (testbox_get_ex_enter_storage_mode_flag()) {
power_set_vddio_keep(0);//关VDDIO KEEP
#if TCFG_LP_TOUCH_KEY_ENABLE
lp_touch_key_disable();//仓储模式关内置触摸
#else
external_touch_key_disable(); //仓储模式关外置触摸供电
#endif /* #if TCFG_LP_TOUCH_KEY_ENABLE */
//测试盒仓储模式使能后，断开测试盒直接关机
power_set_soft_poweroff();
}
#endif
#if TCFG_GX8002_NPU_ENABLE
extern void gx8002_module_resumed();
gx8002_module_resumed();
#endif /* #if TCFG_GX8002_NPU_ENABLE */
}
int app_charge_event_handler(struct device_event *dev)
{
int ret = false;
u8 otg_status = 0;
switch (dev->event) {
case CHARGE_EVENT_CHARGE_START:
#if NTC_DET_EN
ntc_det_start();
#endif
charge_start_deal();
break;
case CHARGE_EVENT_CHARGE_CLOSE:
#if NTC_DET_EN
ntc_det_stop();
#endif
charge_close_deal();
break;
case CHARGE_EVENT_CHARGE_FULL:
charge_full_deal();
break;
case CHARGE_EVENT_LDO5V_KEEP:
#if NTC_DET_EN
ntc_det_stop();
#endif
ldo5v_keep_deal();
break;
case CHARGE_EVENT_LDO5V_IN:
#if ((TCFG_OTG_MODE & OTG_SLAVE_MODE) && (TCFG_OTG_MODE & OTG_CHARGE_MODE))
while (1) {
otg_status = usb_otg_online(0);
if (otg_status != IDLE_MODE) {
break;
}
os_time_dly(2);
}
if (otg_status == SLAVE_MODE) {
set_charge_poweron_en(1);
}
#endif
if (get_charge_poweron_en() || (otg_status != SLAVE_MODE)) {
charge_ldo5v_in_deal();
}
break;
case CHARGE_EVENT_LDO5V_OFF:
#if ((TCFG_OTG_MODE & OTG_SLAVE_MODE) && (TCFG_OTG_MODE & OTG_CHARGE_MODE))
while (1) {
otg_status = usb_otg_online(0);
if (otg_status != IDLE_MODE) {
break;
}
os_time_dly(2);
}
#endif
if (get_charge_poweron_en() || (otg_status != SLAVE_MODE)) {
charge_ldo5v_off_deal();
}
break;
default:
break;
}
return ret;
}
#else
u8 get_charge_full_flag(void)
{
return 0;
}
#endif

859
apps/xtell_hide/power_manage/app_chargestore.c Normal file
View File

@ -0,0 +1,859 @@
#include "init.h"
#include "app_config.h"
#include "system/includes.h"
#include "asm/charge.h"
#include "asm/chargestore.h"
#include "user_cfg.h"
#include "app_chargestore.h"
#include "device/vm.h"
#include "btstack/avctp_user.h"
#include "app_power_manage.h"
#include "app_action.h"
#include "app_main.h"
#include "app_charge.h"
#include "app_testbox.h"
#include "classic/tws_api.h"
#include "update.h"
#include "bt_ble.h"
#include "bt_tws.h"
#include "app_action.h"
#include "bt_common.h"
#include "le_rcsp_adv_module.h"
#define LOG_TAG_CONST APP_CHARGESTORE
#define LOG_TAG "[APP_CHARGESTORE]"
#define LOG_ERROR_ENABLE
#define LOG_DEBUG_ENABLE
#define LOG_INFO_ENABLE
/* #define LOG_DUMP_ENABLE */
#define LOG_CLI_ENABLE
#include "debug.h"
extern void sys_enter_soft_poweroff(void *priv);
extern void tws_api_set_connect_aa_allways(u32 connect_aa);
extern u32 tws_le_get_pair_aa(void);
extern u32 tws_le_get_connect_aa(void);
extern u32 tws_le_get_search_aa(void);
extern void bt_get_vm_mac_addr(u8 *addr);
extern bool get_tws_sibling_connect_state(void);
extern bool get_tws_phone_connect_state(void);
extern void cpu_reset();
extern u32 dual_bank_update_exist_flag_get(void);
extern u32 classic_update_task_exist_flag_get(void);
extern char tws_api_get_local_channel();
extern u16 bt_get_tws_device_indicate(u8 *tws_device_indicate);
extern void bt_tws_remove_pairs();
extern const u8 *bt_get_mac_addr();
//-----------------------------------------------------------------------------------
//-----------以下配对相关的接口,提供充电舱和蓝牙测试盒-------------------------------
//-----------------------------------------------------------------------------------
#if (TCFG_CHARGESTORE_ENABLE || TCFG_TEST_BOX_ENABLE)
#if TCFG_USER_TWS_ENABLE
static void new_addr_generating_for_pair(u8 *addr)
{
u8 i;
for (i = 0; i < 6; i++) {
addr[i] = addr[i] + 1;
}
}
void chargestore_set_tws_channel_info(u8 channel)
{
if ((channel == 'L') || (channel == 'R')) {
syscfg_write(CFG_CHARGESTORE_TWS_CHANNEL, &channel, 1);
}
}
u8 chargestore_get_tws_channel_info(void)
{
u8 channel = 'U';
syscfg_read(CFG_CHARGESTORE_TWS_CHANNEL, &channel, 1);
return channel;
}
static u8 tws_paired_flag;
bool chargestore_set_tws_remote_info(u8 *data, u8 len)
{
u8 i;
bool ret = true;
int w_ret = 0;
u8 remote_addr[6];
u8 common_addr[6];
u8 local_addr[6];
CHARGE_STORE_INFO *charge_store_info = (CHARGE_STORE_INFO *)data;
if (len > sizeof(CHARGE_STORE_INFO)) {
log_error("len err\n");
return false;
}
//set remote addr
syscfg_read(CFG_TWS_REMOTE_ADDR, remote_addr, sizeof(remote_addr));
if (memcmp(remote_addr, charge_store_info->tws_local_addr, sizeof(remote_addr))) {
ret = false;
}
#if TCFG_TEST_BOX_ENABLE
if (testbox_get_status()) {
//using new remote addr generating;
new_addr_generating_for_pair(charge_store_info->tws_local_addr);
}
#endif
if (sizeof(remote_addr) != syscfg_write(CFG_TWS_REMOTE_ADDR, charge_store_info->tws_local_addr, sizeof(remote_addr))) {
w_ret = -1;
}
bt_get_tws_local_addr(local_addr);
#if TCFG_TEST_BOX_ENABLE
if (testbox_get_status()) {
new_addr_generating_for_pair(local_addr);
if (sizeof(local_addr) != syscfg_write(CFG_TWS_LOCAL_ADDR, local_addr, sizeof(local_addr))) {
w_ret = -2;
}
}
#endif
#if (CONFIG_TWS_COMMON_ADDR_SELECT != CONFIG_TWS_COMMON_ADDR_USED_LEFT)
//set common addr
syscfg_read(CFG_TWS_COMMON_ADDR, common_addr, sizeof(common_addr));
for (i = 0; i < sizeof(common_addr); i++) {
if (common_addr[i] != (u8)(local_addr[i] + charge_store_info->tws_local_addr[i])) {
ret = false;
}
common_addr[i] = local_addr[i] + charge_store_info->tws_local_addr[i];
}
if (sizeof(common_addr) != syscfg_write(CFG_TWS_COMMON_ADDR, common_addr, sizeof(common_addr))) {
w_ret = -3;
}
#endif
#ifndef CONFIG_NEW_BREDR_ENABLE
if (chargestore_get_tws_channel_info() == 'L') {
if (tws_le_get_connect_aa() != tws_le_get_pair_aa()) {
ret = false;
}
tws_api_set_connect_aa_allways(tws_le_get_pair_aa());
} else {
if (tws_le_get_connect_aa() != charge_store_info->pair_aa) {
ret = false;
}
tws_api_set_connect_aa_allways(charge_store_info->pair_aa);
}
#endif
#if TCFG_TEST_BOX_ENABLE
if (testbox_get_status() && (0 == w_ret)) {
u8 cmd = CMD_BOX_TWS_REMOTE_ADDR;
chargestore_api_write(&cmd, 1);
testbox_set_testbox_tws_paired(1);
}
#endif
return ret;
}
void chargestore_clean_tws_conn_info(u8 type)
{
CHARGE_STORE_INFO charge_store_info;
log_info("chargestore_clean_tws_conn_info=%d\n", type);
if (type == TWS_DEL_TWS_ADDR) {
log_info("TWS_DEL_TWS_ADDR\n");
} else if (type == TWS_DEL_PHONE_ADDR) {
log_info("TWS_DEL_PHONE_ADDR\n");
} else if (type == TWS_DEL_ALL_ADDR) {
log_info("TWS_DEL_ALL_ADDR\n");
}
memset(&charge_store_info, 0xff, sizeof(CHARGE_STORE_INFO));
syscfg_write(CFG_TWS_REMOTE_ADDR, charge_store_info.tws_remote_addr, sizeof(charge_store_info.tws_remote_addr));
}
#endif //TCFG_USER_TWS_ENABLE
u16 chargestore_get_tws_remote_info(u8 *data)
{
u16 ret_len = 0;
u16 device_ind;
CHARGE_STORE_INFO *charge_store_info = (CHARGE_STORE_INFO *)data;
#if TCFG_USER_TWS_ENABLE
bt_get_tws_local_addr(charge_store_info->tws_local_addr);
bt_get_vm_mac_addr(charge_store_info->tws_mac_addr);
#if TCFG_TEST_BOX_ENABLE
if (testbox_get_keep_tws_conn_flag()) {
memcpy(charge_store_info->tws_mac_addr, bt_get_mac_addr(), 6);
}
#endif
#ifndef CONFIG_NEW_BREDR_ENABLE
charge_store_info->search_aa = tws_le_get_search_aa();
charge_store_info->pair_aa = tws_le_get_pair_aa();
#endif
#if (CONFIG_TWS_CHANNEL_SELECT == CONFIG_TWS_AS_LEFT_CHANNEL) \
||(CONFIG_TWS_CHANNEL_SELECT == CONFIG_TWS_AS_RIGHT_CHANNEL) \
||(CONFIG_TWS_CHANNEL_SELECT == CONFIG_TWS_EXTERN_DOWN_AS_LEFT) \
||(CONFIG_TWS_CHANNEL_SELECT == CONFIG_TWS_EXTERN_UP_AS_LEFT)
charge_store_info->local_channel = tws_api_get_local_channel();
#else
charge_store_info->local_channel = 'U';
#endif
charge_store_info->device_ind = bt_get_tws_device_indicate(NULL);
charge_store_info->reserved_data = chargestore_api_crc8(data, sizeof(CHARGE_STORE_INFO) - 2);
#if TCFG_TEST_BOX_ENABLE
if (testbox_get_status()) {
charge_store_info->reserved_data = 0;
}
#endif
#else
bt_get_vm_mac_addr(charge_store_info->tws_mac_addr);
#endif
ret_len = sizeof(CHARGE_STORE_INFO);
return ret_len;
}
#endif //TCFG_CHARGESTORE_ENABLE || TCFG_TEST_BOX_ENABLE
//-----------------------------------------------------------------------------------
//-----------分割线---------以下是充电舱流程实现-------------------------------------
//-----------------------------------------------------------------------------------
#if TCFG_CHARGESTORE_ENABLE
struct chargestore_info {
int timer;
int shutdown_timer;
u8 version;
u8 chip_type;
u8 max_packet_size;//充电舱端一包的最大值
u8 bt_init_ok;//蓝牙协议栈初始化成功
u8 power_level;//本机记录的充电舱电量百分比
u8 pre_power_lvl;
u8 sibling_chg_lev;//对耳同步的充电舱电量
u8 power_status;//充电舱供电状态 0:断电 5V不在线 1:升压 5V在线
u8 cover_status;//充电舱盖子状态 0:合盖 1:开盖
u8 connect_status;//通信成功
u8 ear_number;//盒盖时耳机在线数
u8 channel;//左右
u8 tws_power;//对耳的电量
u8 power_sync;//第一次获取到充电舱电量时,同步到对耳
u8 pair_flag;//配对标记
u8 close_ing;//等待合窗超时
u8 active_disconnect;//主动断开连接
u8 switch2bt;
};
static struct chargestore_info info = {
.power_status = 1,
.ear_number = 1,
.tws_power = 0xff,
.power_level = 0xff,
.sibling_chg_lev = 0xff,
.max_packet_size = 32,
.channel = 'U',
};
#define __this (&info)
static u8 local_packet[36];
static CHARGE_STORE_INFO read_info, write_info;
static u8 read_index, write_index;
u8 chargestore_get_power_level(void)
{
if ((__this->power_level == 0xff) ||
((!get_charge_online_flag()) &&
(__this->sibling_chg_lev != 0xff))) {
return __this->sibling_chg_lev;
}
return __this->power_level;
}
u8 chargestore_get_power_status(void)
{
return __this->power_status;
}
u8 chargestore_get_cover_status(void)
{
return __this->cover_status;
}
u8 chargestore_get_earphone_online(void)
{
return __this->ear_number;
}
void chargestore_set_earphone_online(u8 ear_number)
{
__this->ear_number = ear_number;
}
void chargestore_set_pair_flag(u8 pair_flag)
{
__this->pair_flag = pair_flag;
}
void chargestore_set_active_disconnect(u8 active_disconnect)
{
__this->active_disconnect = active_disconnect;
}
u8 chargestore_get_earphone_pos(void)
{
u8 channel = 'U';
#if TCFG_USER_TWS_ENABLE
channel = chargestore_get_tws_channel_info();
#endif
log_info("get_ear_channel = %c\n", channel);
return channel;
}
u8 chargestore_get_sibling_power_level(void)
{
return __this->tws_power;
}
#if TCFG_USER_TWS_ENABLE
static void set_tws_sibling_charge_level(void *_data, u16 len, bool rx)
{
if (rx) {
u8 *data = (u8 *)_data;
chargestore_set_sibling_chg_lev(data[0]);
}
}
REGISTER_TWS_FUNC_STUB(charge_level_stub) = {
.func_id = TWS_FUNC_ID_CHARGE_SYNC,
.func = set_tws_sibling_charge_level,
};
#endif //TCFG_USER_TWS_ENABLE
int chargestore_sync_chg_level(void)
{
#if TCFG_USER_TWS_ENABLE
int err = -1;
struct application *app = get_current_app();
if (app && (!strcmp(app->name, "earphone")) && (!app_var.goto_poweroff_flag)) {
err = tws_api_send_data_to_sibling((u8 *)&__this->power_level, 1,
TWS_FUNC_ID_CHARGE_SYNC);
}
return err;
#else
return 0;
#endif
}
void chargestore_set_sibling_chg_lev(u8 chg_lev)
{
__this->sibling_chg_lev = chg_lev;
}
void chargestore_set_power_level(u8 power)
{
__this->power_level = power;
}
u8 chargestore_check_going_to_poweroff(void)
{
return __this->close_ing;
}
void chargestore_shutdown_reset(void)
{
if (__this->shutdown_timer) {
sys_timer_del(__this->shutdown_timer);
__this->shutdown_timer = 0;
}
}
void chargestore_set_bt_init_ok(u8 flag)
{
__this->bt_init_ok = flag;
}
void chargestore_shutdown_do(void *priv)
{
log_info("chargestore shutdown!\n");
power_set_soft_poweroff();
}
void chargestore_event_to_user(u8 *packet, u32 type, u8 event, u8 size)
{
struct sys_event e;
e.type = SYS_DEVICE_EVENT;
if (packet != NULL) {
if (size > sizeof(local_packet)) {
return;
}
e.u.chargestore.packet = local_packet;
memcpy(e.u.chargestore.packet, packet, size);
}
e.arg = (void *)type;
e.u.chargestore.event = event;
e.u.chargestore.size = size;
sys_event_notify(&e);
}
#if TCFG_USER_TWS_ENABLE
bool chargestore_check_data_succ(u8 *data, u8 len)
{
u16 crc;
u16 device_ind;
CHARGE_STORE_INFO *charge_store_info = (CHARGE_STORE_INFO *)data;
if (len > sizeof(CHARGE_STORE_INFO)) {
log_error("len err\n");
return false;
}
crc = chargestore_api_crc8(data, len - 2);
if (crc != charge_store_info->reserved_data) {
log_error("crc err\n");
return false;
}
device_ind = bt_get_tws_device_indicate(NULL);
if (device_ind != charge_store_info->device_ind) {
log_error("device_ind err\n");
return false;
}
return true;
}
u16 chargestore_f95_read_tws_remote_info(u8 *data, u8 flag)
{
u8 read_len;
u8 *pbuf = (u8 *)&read_info;
if (flag) {//first packet
read_index = 0;
chargestore_get_tws_remote_info((u8 *)&read_info);
}
read_len = sizeof(read_info) - read_index;
read_len = (read_len > (__this->max_packet_size - 1)) ? (__this->max_packet_size - 1) : read_len;
memcpy(data, pbuf + read_index, read_len);
read_index += read_len;
return read_len;
}
u16 chargestore_f95_write_tws_remote_info(u8 *data, u8 len, u8 flag)
{
u8 write_len;
u8 *pbuf = (u8 *)&write_info;
if (flag) {
write_index = 0;
memset(&write_info, 0, sizeof(write_info));
}
write_len = sizeof(write_info) - write_index;
write_len = (write_len >= len) ? len : write_len;
memcpy(pbuf + write_index, data, write_len);
write_index += write_len;
return write_len;
}
#endif
void chargestore_timeout_deal(void *priv)
{
__this->timer = 0;
__this->close_ing = 0;
if ((!__this->cover_status) || __this->active_disconnect) {//当前为合盖或者主动断开连接
struct application *app = get_current_app();
if (app && strcmp(app->name, "idle")) {
sys_enter_soft_poweroff((void *)1);
}
} else {
#if (TCFG_BLE_DEMO_SELECT == DEF_BLE_DEMO_ADV)
/* if ((!get_total_connect_dev()) && (tws_api_get_role() == TWS_ROLE_MASTER) && (get_bt_tws_connect_status())) { */
if (tws_api_get_role() == TWS_ROLE_MASTER) {
printf("charge_icon_ctl...\n");
bt_ble_icon_reset();
#if CONFIG_NO_DISPLAY_BUTTON_ICON
if (get_total_connect_dev()) {
//蓝牙未真正断开;重新广播
bt_ble_icon_open(ICON_TYPE_RECONNECT);
} else {
//蓝牙未连接，重新开可见性
bt_ble_icon_open(ICON_TYPE_INQUIRY);
}
#else
//不管蓝牙是否连接，默认打开
bt_ble_icon_open(ICON_TYPE_RECONNECT);
#endif
}
#elif (TCFG_BLE_DEMO_SELECT == DEF_BLE_DEMO_ADV_RCSP)
if (tws_api_get_role() == TWS_ROLE_MASTER) {
printf("charge_icon_ctl...\n");
#if CONFIG_NO_DISPLAY_BUTTON_ICON
if (get_total_connect_dev()) {
//蓝牙未真正断开;重新广播
bt_ble_adv_ioctl(BT_ADV_SET_EDR_CON_FLAG, SECNE_CONNECTED, 1);
} else {
//蓝牙未连接，重新开可见性
bt_ble_adv_ioctl(BT_ADV_SET_EDR_CON_FLAG, SECNE_UNCONNECTED, 1);
}
#else
//不管蓝牙是否连接，默认打开
bt_ble_adv_ioctl(BT_ADV_SET_EDR_CON_FLAG, SECNE_CONNECTED, 1);
#endif
}
#endif
}
__this->ear_number = 1;
}
void chargestore_set_phone_disconnect(void)
{
#if (TCFG_BLE_DEMO_SELECT == DEF_BLE_DEMO_ADV)
#if (!CONFIG_NO_DISPLAY_BUTTON_ICON)
if (__this->pair_flag && get_tws_sibling_connect_state()) {
//check ble inquiry
//printf("get box log_key...con_dev=%d\n",get_tws_phone_connect_state());
if ((bt_ble_icon_get_adv_state() == ADV_ST_RECONN)
|| (bt_ble_icon_get_adv_state() == ADV_ST_DISMISS)
|| (bt_ble_icon_get_adv_state() == ADV_ST_END)) {
bt_ble_icon_reset();
bt_ble_icon_open(ICON_TYPE_INQUIRY);
}
}
#endif
__this->pair_flag = 0;
#elif (TCFG_BLE_DEMO_SELECT == DEF_BLE_DEMO_ADV_RCSP)
#if (!CONFIG_NO_DISPLAY_BUTTON_ICON)
if (__this->pair_flag && get_tws_sibling_connect_state()) {
//check ble inquiry
bt_ble_adv_ioctl(BT_ADV_SET_EDR_CON_FLAG, SECNE_UNCONNECTED, 1);
}
#endif
__this->pair_flag = 0;
#endif
}
void chargestore_set_phone_connect(void)
{
__this->active_disconnect = 0;
}
int app_chargestore_event_handler(struct chargestore_event *chargestore_dev)
{
int ret = false;
struct application *app = get_current_app();
#if defined(TCFG_CHARGE_KEEP_UPDATA) && TCFG_CHARGE_KEEP_UPDATA
//在升级过程中,不响应智能充电舱app层消息
if (dual_bank_update_exist_flag_get() || classic_update_task_exist_flag_get()) {
return ret;
}
#endif
switch (chargestore_dev->event) {
case CMD_RESTORE_SYS:
#if TCFG_USER_TWS_ENABLE
bt_tws_remove_pairs();
#endif
user_send_cmd_prepare(USER_CTRL_DEL_ALL_REMOTE_INFO, 0, NULL);
cpu_reset();
break;
case CMD_TWS_CHANNEL_SET:
#if TCFG_USER_TWS_ENABLE
chargestore_set_tws_channel_info(__this->channel);
#endif
break;
#if TCFG_USER_TWS_ENABLE
case CMD_TWS_REMOTE_ADDR:
log_info("event_CMD_TWS_REMOTE_ADDR\n");
if (chargestore_set_tws_remote_info(chargestore_dev->packet, chargestore_dev->size) == false) {
//交换地址后,断开与手机连接,并删除所有连过的手机地址
user_send_cmd_prepare(USER_CTRL_DEL_ALL_REMOTE_INFO, 0, NULL);
__this->ear_number = 2;
sys_enter_soft_poweroff((void *)1);
} else {
__this->pair_flag = 1;
if (get_tws_phone_connect_state() == TRUE) {
__this->active_disconnect = 1;
user_send_cmd_prepare(USER_CTRL_DISCONNECTION_HCI, 0, NULL);
} else {
chargestore_set_phone_disconnect();
}
}
break;
case CMD_TWS_ADDR_DELETE:
log_info("event_CMD_TWS_ADDR_DELETE\n");
chargestore_clean_tws_conn_info(chargestore_dev->packet[0]);
break;
#endif
case CMD_POWER_LEVEL_OPEN:
log_info("event_CMD_POWER_LEVEL_OPEN\n");
//电压过低,不进响应开盖命令
#if TCFG_SYS_LVD_EN
if (get_vbat_need_shutdown() == TRUE) {
log_info(" lowpower deal!\n");
break;
}
#endif
if (__this->cover_status) {//当前为开盖
if (__this->power_sync) {
if (chargestore_sync_chg_level() == 0) {
__this->power_sync = 0;
}
}
if (app && strcmp(app->name, APP_NAME_BT) && (app_var.goto_poweroff_flag == 0)) {
/* app_var.play_poweron_tone = 1; */
app_var.play_poweron_tone = 0;
power_set_mode(TCFG_LOWPOWER_POWER_SEL);
__this->switch2bt = 1;
task_switch_to_bt();
__this->switch2bt = 0;
}
}
break;
case CMD_POWER_LEVEL_CLOSE:
log_info("event_CMD_POWER_LEVEL_CLOSE\n");
if (!__this->cover_status) {//当前为合盖
if (app && strcmp(app->name, "idle")) {
sys_enter_soft_poweroff((void *)1);
}
}
break;
case CMD_CLOSE_CID:
log_info("event_CMD_CLOSE_CID\n");
if (!__this->cover_status) {//当前为合盖
#if (TCFG_BLE_DEMO_SELECT == DEF_BLE_DEMO_ADV)
if ((__this->bt_init_ok) && (tws_api_get_role() == TWS_ROLE_MASTER)) {
bt_ble_icon_close(1);
}
#elif (TCFG_BLE_DEMO_SELECT == DEF_BLE_DEMO_ADV_RCSP)
if ((__this->bt_init_ok) && (tws_api_get_role() == TWS_ROLE_MASTER)) {
bt_ble_adv_ioctl(BT_ADV_SET_EDR_CON_FLAG, SECNE_DISMISS, 1);
}
#endif
if (!__this->timer) {
__this->timer = sys_timeout_add(NULL, chargestore_timeout_deal, 2000);
if (!__this->timer) {
log_error("timer alloc err!\n");
} else {
__this->close_ing = 1;
}
} else {
sys_timer_modify(__this->timer, 2000);
__this->close_ing = 1;
}
} else {
__this->ear_number = 1;
__this->close_ing = 0;
}
break;
case CMD_SHUT_DOWN:
log_info("event_CMD_SHUT_DOWN\n");
if (!__this->shutdown_timer) {
__this->shutdown_timer = sys_timer_add(NULL, chargestore_shutdown_do, 1000);
} else {
sys_timer_modify(__this->shutdown_timer, 1000);
}
break;
default:
break;
}
return ret;
}
u8 chargestore_get_vbat_percent(void)
{
u8 power;
#if CONFIG_DISPLAY_DETAIL_BAT
power = get_vbat_percent();//显示个位数的电量
#else
power = get_self_battery_level() * 10 + 10; //显示10%~100%
#endif
#if TCFG_CHARGE_ENABLE
if (get_charge_full_flag()) {
power = 100;
} else if (power == 100) {
power = 99;
}
if (get_charge_online_flag()) {
power |= BIT(7);
}
#endif
return power;
}
void chargestore_set_power_status(u8 *buf, u8 len)
{
__this->version = buf[0] & 0x0f;
__this->chip_type = (buf[0] >> 4) & 0x0f;
//f95可能传一个大于100的电量
if ((buf[1] & 0x7f) > 100) {
__this->power_level = (buf[1] & 0x80) | 100;
} else {
__this->power_level = buf[1];
}
if (len > 2) {
__this->max_packet_size = buf[2];
if (len > 3) {
__this->tws_power = buf[3];
}
}
}
static int app_chargestore_data_handler(u8 *buf, u8 len)
{
u8 send_buf[36];
/* log_info_hexdump(buf, len); */
chargestore_shutdown_reset();
send_buf[0] = buf[0];
#ifdef CONFIG_CHARGESTORE_REMAP_ENABLE
if (remap_app_chargestore_data_deal(buf, len)) {
return 1;
}
#endif
switch (buf[0]) {
case CMD_TWS_CHANNEL_SET:
__this->channel = (buf[1] == TWS_CHANNEL_LEFT) ? 'L' : 'R';
chargestore_event_to_user(NULL, DEVICE_EVENT_CHARGE_STORE, buf[0], 0);
if (__this->bt_init_ok) {
len = chargestore_get_tws_remote_info(&send_buf[1]);
chargestore_api_write(send_buf, len + 1);
} else {
send_buf[0] = CMD_UNDEFINE;
chargestore_api_write(send_buf, 1);
}
break;
case CMD_TWS_SET_CHANNEL:
__this->channel = (buf[1] == TWS_CHANNEL_LEFT) ? 'L' : 'R';
log_info("f95 set channel = %c\n", __this->channel);
chargestore_event_to_user(NULL, DEVICE_EVENT_CHARGE_STORE, CMD_TWS_CHANNEL_SET, 0);
if (__this->bt_init_ok) {
chargestore_api_write(send_buf, 1);
} else {
send_buf[0] = CMD_UNDEFINE;
chargestore_api_write(send_buf, 1);
}
break;
#if TCFG_USER_TWS_ENABLE
case CMD_TWS_REMOTE_ADDR:
__this->close_ing = 0;
if (chargestore_check_data_succ((u8 *)&buf[1], len - 1) == true) {
chargestore_event_to_user((u8 *)&buf[1], DEVICE_EVENT_CHARGE_STORE, buf[0], len - 1);
} else {
send_buf[0] = CMD_FAIL;
}
chargestore_api_write(send_buf, 1);
break;
case CMD_EX_FIRST_READ_INFO:
log_info("read first!\n");
__this->close_ing = 0;
len = chargestore_f95_read_tws_remote_info(&send_buf[1], 1);
chargestore_api_write(send_buf, len + 1);
break;
case CMD_EX_CONTINUE_READ_INFO:
log_info("read continue!\n");
__this->close_ing = 0;
len = chargestore_f95_read_tws_remote_info(&send_buf[1], 0);
chargestore_api_write(send_buf, len + 1);
break;
case CMD_EX_FIRST_WRITE_INFO:
log_info("write first!\n");
__this->close_ing = 0;
chargestore_f95_write_tws_remote_info(&buf[1], len - 1, 1);
chargestore_api_write(send_buf, 1);
break;
case CMD_EX_CONTINUE_WRITE_INFO:
log_info("write continue!\n");
__this->close_ing = 0;
chargestore_f95_write_tws_remote_info(&buf[1], len - 1, 0);
chargestore_api_write(send_buf, 1);
break;
case CMD_EX_INFO_COMPLETE:
log_info("ex complete!\n");
if (chargestore_check_data_succ((u8 *)&write_info, sizeof(write_info)) == true) {
chargestore_event_to_user((u8 *)&write_info, DEVICE_EVENT_CHARGE_STORE, CMD_TWS_REMOTE_ADDR, sizeof(write_info));
} else {
send_buf[0] = CMD_FAIL;
}
chargestore_api_write(send_buf, 1);
break;
#endif
case CMD_TWS_ADDR_DELETE:
__this->close_ing = 0;
chargestore_event_to_user(&buf[1], DEVICE_EVENT_CHARGE_STORE, CMD_TWS_ADDR_DELETE, len - 1);
chargestore_api_write(send_buf, 1);
break;
case CMD_POWER_LEVEL_OPEN:
__this->power_status = 1;
__this->cover_status = 1;
__this->close_ing = 0;
if (__this->power_level == 0xff) {
__this->power_sync = 1;
}
chargestore_set_power_status(&buf[1], len - 1);
if (__this->power_level != __this->pre_power_lvl) {
__this->power_sync = 1;
}
__this->pre_power_lvl = __this->power_level;
send_buf[1] = chargestore_get_vbat_percent();
send_buf[2] = chargestore_get_det_level(__this->chip_type);
chargestore_api_write(send_buf, 3);
//切模式过程中不发送消息,防止堆满消息
if (__this->switch2bt == 0) {
chargestore_event_to_user(NULL, DEVICE_EVENT_CHARGE_STORE, CMD_POWER_LEVEL_OPEN, 0);
}
break;
case CMD_POWER_LEVEL_CLOSE:
__this->power_status = 1;
__this->cover_status = 0;
__this->close_ing = 0;
chargestore_set_power_status(&buf[1], len - 1);
send_buf[1] = chargestore_get_vbat_percent();
send_buf[2] = chargestore_get_det_level(__this->chip_type);
chargestore_api_write(send_buf, 3);
chargestore_event_to_user(NULL, DEVICE_EVENT_CHARGE_STORE, CMD_POWER_LEVEL_CLOSE, 0);
break;
case CMD_SHUT_DOWN:
log_info("shut down\n");
__this->power_status = 0;
__this->cover_status = 0;
__this->close_ing = 0;
chargestore_api_write(send_buf, 1);
chargestore_event_to_user(NULL, DEVICE_EVENT_CHARGE_STORE, CMD_SHUT_DOWN, 0);
break;
case CMD_CLOSE_CID:
log_info("close cid\n");
__this->power_status = 1;
__this->cover_status = 0;
__this->ear_number = buf[1];
chargestore_api_write(send_buf, 1);
chargestore_event_to_user(NULL, DEVICE_EVENT_CHARGE_STORE, CMD_CLOSE_CID, 0);
break;
case CMD_RESTORE_SYS:
r_printf("restore sys\n");
__this->power_status = 1;
__this->cover_status = 1;
__this->close_ing = 0;
chargestore_api_write(send_buf, 1);
chargestore_event_to_user(NULL, DEVICE_EVENT_CHARGE_STORE, CMD_RESTORE_SYS, 0);
break;
//不是充电舱的指令,返回0
default:
return 0;
}
return 1;
}
CHARGESTORE_HANDLE_REG(chargestore, app_chargestore_data_handler);
#endif //TCFG_CHARGESTORE_ENABLE

475
apps/xtell_hide/power_manage/app_power_manage.c Normal file
View File

@ -0,0 +1,475 @@
#include "system/includes.h"
#include "app_power_manage.h"
#include "app_main.h"
#include "app_config.h"
#include "app_action.h"
#include "asm/charge.h"
#include "ui_manage.h"
#include "tone_player.h"
#include "asm/adc_api.h"
#include "btstack/avctp_user.h"
#include "user_cfg.h"
#include "asm/charge.h"
#if TCFG_USER_TWS_ENABLE
#include "bt_tws.h"
#endif
#define LOG_TAG_CONST APP_POWER
#define LOG_TAG "[APP_POWER]"
#define LOG_ERROR_ENABLE
#define LOG_DEBUG_ENABLE
#define LOG_INFO_ENABLE
/* #define LOG_DUMP_ENABLE */
#define LOG_CLI_ENABLE
#include "debug.h"
enum {
VBAT_NORMAL = 0,
VBAT_WARNING,
VBAT_LOWPOWER,
} VBAT_STATUS;
#define VBAT_DETECT_CNT 6
static int vbat_slow_timer = 0;
static int vbat_fast_timer = 0;
static int lowpower_timer = 0;
static u8 old_battery_level = 9;
static u16 bat_val = 0;
static volatile u8 cur_battery_level = 0;
static u16 battery_full_value = 0;
static u8 tws_sibling_bat_level = 0xff;
static u8 tws_sibling_bat_percent_level = 0xff;
static u8 cur_bat_st = VBAT_NORMAL;
void vbat_check(void *priv);
void sys_enter_soft_poweroff(void *priv);
void clr_wdt(void);
void power_event_to_user(u8 event);
u8 get_tws_sibling_bat_level(void)
{
#if TCFG_USER_TWS_ENABLE
/* log_info("***********get_tws_sibling_bat_level: %2x", tws_sibling_bat_percent_level); */
return tws_sibling_bat_level & 0x7f;
#endif
return 0xff;
}
u8 get_tws_sibling_bat_persent(void)
{
#if TCFG_USER_TWS_ENABLE
/* log_info("***********get_tws_sibling_bat_level: %2x", tws_sibling_bat_percent_level); */
return tws_sibling_bat_percent_level;
#endif
return 0xff;
}
void app_power_set_tws_sibling_bat_level(u8 vbat, u8 percent)
{
#if TCFG_USER_TWS_ENABLE
tws_sibling_bat_level = vbat;
tws_sibling_bat_percent_level = percent;
/*
** 发出电量同步事件进行进一步处理
**/
power_event_to_user(POWER_EVENT_SYNC_TWS_VBAT_LEVEL);
log_info("set_sibling_bat_level: %d, %d\n", vbat, percent);
#endif
}
static void set_tws_sibling_bat_level(void *_data, u16 len, bool rx)
{
u8 *data = (u8 *)_data;
if (rx) {
app_power_set_tws_sibling_bat_level(data[0], data[1]);
}
}
#if TCFG_USER_TWS_ENABLE
REGISTER_TWS_FUNC_STUB(vbat_sync_stub) = {
.func_id = TWS_FUNC_ID_VBAT_SYNC,
.func = set_tws_sibling_bat_level,
};
#endif
void tws_sync_bat_level(void)
{
#if (TCFG_USER_TWS_ENABLE && BT_SUPPORT_DISPLAY_BAT)
u8 battery_level = cur_battery_level;
#if CONFIG_DISPLAY_DETAIL_BAT
u8 percent_level = get_vbat_percent();
#else
u8 percent_level = get_self_battery_level() * 10 + 10;
#endif
if (get_charge_online_flag()) {
percent_level |= BIT(7);
}
u8 data[2];
data[0] = battery_level;
data[1] = percent_level;
tws_api_send_data_to_sibling(data, 2, TWS_FUNC_ID_VBAT_SYNC);
log_info("tws_sync_bat_level: %d,%d\n", battery_level, percent_level);
#endif
}
void power_event_to_user(u8 event)
{
struct sys_event e;
e.type = SYS_DEVICE_EVENT;
e.arg = (void *)DEVICE_EVENT_FROM_POWER;
e.u.dev.event = event;
e.u.dev.value = 0;
sys_event_notify(&e);
}
int app_power_event_handler(struct device_event *dev)
{
int ret = false;
#if(TCFG_SYS_LVD_EN == 1)
switch (dev->event) {
case POWER_EVENT_POWER_NORMAL:
ui_update_status(STATUS_EXIT_LOWPOWER);
break;
case POWER_EVENT_POWER_WARNING:
ui_update_status(STATUS_LOWPOWER);
/* tone_play(TONE_LOW_POWER); */
STATUS *p_tone = get_tone_config();
tone_play_index(p_tone->lowpower, 0);
if (lowpower_timer == 0) {
lowpower_timer = sys_timer_add((void *)POWER_EVENT_POWER_WARNING, (void (*)(void *))power_event_to_user, LOW_POWER_WARN_TIME);
}
break;
case POWER_EVENT_POWER_LOW:
r_printf(" POWER_EVENT_POWER_LOW");
vbat_timer_delete();
if (lowpower_timer) {
sys_timer_del(lowpower_timer);
lowpower_timer = 0 ;
}
#if TCFG_APP_BT_EN
#if (RCSP_ADV_EN)
extern u8 adv_tws_both_in_charge_box(u8 type);
adv_tws_both_in_charge_box(1);
#endif
sys_enter_soft_poweroff(NULL);
#else
void app_entry_idle() ;
app_entry_idle() ;
#endif
break;
#if TCFG_APP_BT_EN
#if TCFG_USER_TWS_ENABLE
case POWER_EVENT_SYNC_TWS_VBAT_LEVEL:
if (tws_api_get_role() == TWS_ROLE_MASTER) {
user_send_cmd_prepare(USER_CTRL_HFP_CMD_UPDATE_BATTARY, 0, NULL);
}
break;
#endif
case POWER_EVENT_POWER_CHANGE:
/* log_info("POWER_EVENT_POWER_CHANGE\n"); */
#if TCFG_USER_TWS_ENABLE
if (tws_api_get_tws_state() & TWS_STA_SIBLING_CONNECTED) {
if (tws_api_get_tws_state()&TWS_STA_ESCO_OPEN) {
break;
}
tws_sync_bat_level();
}
#endif
user_send_cmd_prepare(USER_CTRL_HFP_CMD_UPDATE_BATTARY, 0, NULL);
#endif
break;
case POWER_EVENT_POWER_CHARGE:
if (lowpower_timer) {
sys_timer_del(lowpower_timer);
lowpower_timer = 0 ;
}
break;
default:
break;
}
#endif
return ret;
}
u16 get_vbat_level(void)
{
//return 370; //debug
return (adc_get_voltage(AD_CH_VBAT) * 4 / 10);
}
__attribute__((weak)) u8 remap_calculate_vbat_percent(u16 bat_val)
{
return 0;
}
u16 get_vbat_value(void)
{
return bat_val;
}
u8 get_vbat_percent(void)
{
u16 tmp_bat_val;
u16 bat_val = get_vbat_level();
if (battery_full_value == 0) {
#if TCFG_CHARGE_ENABLE
battery_full_value = (get_charge_full_value() - 100) / 10; //防止部分电池充不了这么高电量，充满显示未满的情况
#else
battery_full_value = 420;
#endif
}
if (bat_val <= app_var.poweroff_tone_v) {
return 0;
}
tmp_bat_val = remap_calculate_vbat_percent(bat_val);
if (!tmp_bat_val) {
tmp_bat_val = ((u32)bat_val - app_var.poweroff_tone_v) * 100 / (battery_full_value - app_var.poweroff_tone_v);
if (tmp_bat_val > 100) {
tmp_bat_val = 100;
}
}
return (u8)tmp_bat_val;
}
bool get_vbat_need_shutdown(void)
{
if ((bat_val <= LOW_POWER_SHUTDOWN) || adc_check_vbat_lowpower()) {
return TRUE;
}
return FALSE;
}
//将当前电量转换为1~9级发送给手机同步电量
u8 battery_value_to_phone_level(u16 bat_val)
{
u8 battery_level = 0;
u8 vbat_percent = get_vbat_percent();
if (vbat_percent < 5) { //小于5%电量等级为0，显示10%
return 0;
}
battery_level = (vbat_percent - 5) / 10;
return battery_level;
}
//获取自身的电量
u8 get_self_battery_level(void)
{
return cur_battery_level;
}
u8 get_cur_battery_level(void)
{
u8 bat_lev = tws_sibling_bat_level & (~BIT(7));
#if TCFG_USER_TWS_ENABLE
if (bat_lev == 0x7f) {
return cur_battery_level;
}
#if (CONFIG_DISPLAY_TWS_BAT_TYPE == CONFIG_DISPLAY_TWS_BAT_LOWER)
return cur_battery_level < bat_lev ? cur_battery_level : bat_lev;
#elif (CONFIG_DISPLAY_TWS_BAT_TYPE == CONFIG_DISPLAY_TWS_BAT_HIGHER)
return cur_battery_level < bat_lev ? bat_lev : cur_battery_level;
#elif (CONFIG_DISPLAY_TWS_BAT_TYPE == CONFIG_DISPLAY_TWS_BAT_LEFT)
return tws_api_get_local_channel() == 'L' ? cur_battery_level : bat_lev;
#elif (CONFIG_DISPLAY_TWS_BAT_TYPE == CONFIG_DISPLAY_TWS_BAT_RIGHT)
return tws_api_get_local_channel() == 'R' ? cur_battery_level : bat_lev;
#else
return cur_battery_level;
#endif //END CONFIG_DISPLAY_TWS_BAT_TYPE
#else //TCFG_USER_TWS_ENABLE == 0
return cur_battery_level;
#endif
}
void vbat_check_slow(void *priv)
{
if (vbat_fast_timer == 0) {
vbat_fast_timer = usr_timer_add(NULL, vbat_check, 10, 1);
}
if (get_charge_online_flag()) {
sys_timer_modify(vbat_slow_timer, 60 * 1000);
} else {
sys_timer_modify(vbat_slow_timer, 10 * 1000);
}
}
void vbat_check_init(void)
{
if (vbat_slow_timer == 0) {
vbat_slow_timer = sys_timer_add(NULL, vbat_check_slow, 10 * 1000);
} else {
sys_timer_modify(vbat_slow_timer, 10 * 1000);
}
if (vbat_fast_timer == 0) {
vbat_fast_timer = usr_timer_add(NULL, vbat_check, 10, 1);
}
}
void vbat_timer_delete(void)
{
if (vbat_slow_timer) {
sys_timer_del(vbat_slow_timer);
vbat_slow_timer = 0;
}
if (vbat_fast_timer) {
usr_timer_del(vbat_fast_timer);
vbat_fast_timer = 0;
}
}
void vbat_check(void *priv)
{
static u8 unit_cnt = 0;
static u8 low_warn_cnt = 0;
static u8 low_off_cnt = 0;
static u8 low_voice_cnt = 0;
static u8 low_power_cnt = 0;
static u8 power_normal_cnt = 0;
static u8 charge_online_flag = 0;
static u8 low_voice_first_flag = 1;//进入低电后先提醒一次
if (!bat_val) {
bat_val = get_vbat_level();
} else {
bat_val = (get_vbat_level() + bat_val) / 2;
}
cur_battery_level = battery_value_to_phone_level(bat_val);
/* printf("bv:%d, bl:%d , check_vbat:%d\n", bat_val, cur_battery_level, adc_check_vbat_lowpower()); */
unit_cnt++;
/* if (bat_val < LOW_POWER_OFF_VAL) { */
if (adc_check_vbat_lowpower() || (bat_val <= app_var.poweroff_tone_v)) {
low_off_cnt++;
}
/* if (bat_val < LOW_POWER_WARN_VAL) { */
if (bat_val <= app_var.warning_tone_v) {
low_warn_cnt++;
}
/* log_info("unit_cnt:%d\n", unit_cnt); */
if (unit_cnt >= VBAT_DETECT_CNT) {
if (get_charge_online_flag() == 0) {
if (low_off_cnt > (VBAT_DETECT_CNT / 2)) { //低电关机
low_power_cnt++;
low_voice_cnt = 0;
power_normal_cnt = 0;
cur_bat_st = VBAT_LOWPOWER;
if (low_power_cnt > 6) {
log_info("\n*******Low Power,enter softpoweroff********\n");
low_power_cnt = 0;
power_event_to_user(POWER_EVENT_POWER_LOW);
usr_timer_del(vbat_fast_timer);
vbat_fast_timer = 0;
}
} else if (low_warn_cnt > (VBAT_DETECT_CNT / 2)) { //低电提醒
low_voice_cnt ++;
low_power_cnt = 0;
power_normal_cnt = 0;
cur_bat_st = VBAT_WARNING;
if ((low_voice_first_flag && low_voice_cnt > 1) || //第一次进低电10s后报一次
(!low_voice_first_flag && low_voice_cnt >= 5)) {
low_voice_first_flag = 0;
low_voice_cnt = 0;
if (!lowpower_timer) {
log_info("\n**Low Power,Please Charge Soon!!!**\n");
power_event_to_user(POWER_EVENT_POWER_WARNING);
}
}
} else {
power_normal_cnt++;
low_voice_cnt = 0;
low_power_cnt = 0;
if (power_normal_cnt > 2) {
if (cur_bat_st != VBAT_NORMAL) {
log_info("[Noraml power]\n");
cur_bat_st = VBAT_NORMAL;
power_event_to_user(POWER_EVENT_POWER_NORMAL);
}
}
}
} else {
power_event_to_user(POWER_EVENT_POWER_CHARGE);
}
unit_cnt = 0;
low_off_cnt = 0;
low_warn_cnt = 0;
if (cur_bat_st != VBAT_LOWPOWER) {
usr_timer_del(vbat_fast_timer);
vbat_fast_timer = 0;
cur_battery_level = battery_value_to_phone_level(bat_val);
if (cur_battery_level != old_battery_level) {
power_event_to_user(POWER_EVENT_POWER_CHANGE);
} else {
if (charge_online_flag != get_charge_online_flag()) {
//充电变化也要交换，确定是否在充电仓
power_event_to_user(POWER_EVENT_POWER_CHANGE);
}
}
charge_online_flag = get_charge_online_flag();
old_battery_level = cur_battery_level;
}
}
}
bool vbat_is_low_power(void)
{
return (cur_bat_st != VBAT_NORMAL);
}
void check_power_on_voltage(void)
{
#if(TCFG_SYS_LVD_EN == 1)
u16 val = 0;
u8 normal_power_cnt = 0;
u8 low_power_cnt = 0;
while (1) {
clr_wdt();
val = get_vbat_level();
printf("vbat: %d\n", val);
if ((val < app_var.poweroff_tone_v) || adc_check_vbat_lowpower()) {
low_power_cnt++;
normal_power_cnt = 0;
if (low_power_cnt > 10) {
ui_update_status(STATUS_POWERON_LOWPOWER);
os_time_dly(100);
log_info("power on low power , enter softpoweroff!\n");
power_set_soft_poweroff();
}
} else {
normal_power_cnt++;
low_power_cnt = 0;
if (normal_power_cnt > 10) {
vbat_check_init();
return;
}
}
}
#endif
}

549
apps/xtell_hide/power_manage/app_umidigi_chargestore.c Normal file
View File

@ -0,0 +1,549 @@
#include "app_umidigi_chargestore.h"
#include "init.h"
#include "app_config.h"
#include "system/includes.h"
#include "asm/charge.h"
#include "user_cfg.h"
#include "app_chargestore.h"
#include "device/vm.h"
#include "btstack/avctp_user.h"
#include "app_power_manage.h"
#include "app_action.h"
#include "app_main.h"
#include "app_charge.h"
#include "app_testbox.h"
#include "classic/tws_api.h"
#include "update.h"
#include "bt_ble.h"
#include "bt_tws.h"
#include "app_action.h"
#include "bt_common.h"
#include "le_rcsp_adv_module.h"
#include "tone_player.h"
#include "app_msg.h"
#include "key_event_deal.h"
#define LOG_TAG_CONST APP_UMIDIGI_CHARGESTORE
#define LOG_TAG "[APP_UMIDIGI_CHARGESTORE]"
#define LOG_ERROR_ENABLE
#define LOG_DEBUG_ENABLE
#define LOG_INFO_ENABLE
/* #define LOG_DUMP_ENABLE */
#define LOG_CLI_ENABLE
#include "debug.h"
extern void bt_tws_remove_pairs();
extern void cpu_reset();
#if TCFG_UMIDIGI_BOX_ENABLE
struct umidigi_chargestore_info {
int timer; //合盖之后定时进入休眠的句柄
u8 cover_status; //充电舱盖子状态 0: 合盖 1:开盖
u8 ear_number; //合盖时耳机在线数
u8 close_ing; //等待合窗超时
u8 bt_init_ok; //蓝牙协议栈初始化成功
u8 active_disconnect; //主动断开连接
u8 sibling_chg_lev; //对耳同步的充电舱电量
u8 pair_flag; //配对标记
u8 power_sync; //第一次获取到充电舱电量时,同步到对耳
u8 switch2bt; //开盖切换到蓝牙的标记位
u8 pre_power_lvl;
/*以下为充电舱发送CMD时携带的信息*/
u8 case_charger_state; //充电舱自身充电状态 0: 不在充电 1: 充电中
u8 case_battery_level; //充电舱电量百分比
u8 l_ear_whether_in_box; //左耳是否在舱 0: 左耳不在仓 1：左耳在仓
u8 r_ear_whether_in_box; //右耳是否在舱 0: 右耳不在仓 1：右耳在仓
u8 usb_state; //usb插入/拔出标志(本地播放专用) 0: USB OUT 1: USB IN
u16 open_case_timer; //延迟处理开盖命令定时器
u16 pair_timer; //延迟处理配对命令定时器
};
static struct umidigi_chargestore_info info = {
.case_charger_state = 1,
.ear_number = 1,
.case_battery_level = 0xff,
.sibling_chg_lev = 0xff,
};
#define __this (&info)
/*获取充电舱电池电量*/
u8 umidigi_chargestore_get_power_level(void)
{
if ((__this->case_battery_level == 0xff) ||
((!get_charge_online_flag()) &&
(__this->sibling_chg_lev != 0xff))) {
return __this->sibling_chg_lev;
}
return __this->case_battery_level;
}
/*获取充电舱充电状态*/
u8 umidigi_chargestore_get_power_status(void)
{
return __this->case_charger_state;
}
/*获取充电舱合盖或开盖状态*/
u8 umidigi_chargestore_get_cover_status(void)
{
return __this->cover_status;
}
/*获取合盖状态时耳机在仓数量*/
u8 umidigi_chargestore_get_earphone_online(void)
{
return __this->ear_number;
}
/*获取蓝牙初始化成功标志位*/
void umidigi_chargestore_set_bt_init_ok(u8 flag)
{
__this->bt_init_ok = flag;
}
#if TCFG_USER_TWS_ENABLE
static void umidigi_set_tws_sibling_charge_level(void *_data, u16 len, bool rx)
{
if (rx) {
u8 *data = (u8 *)_data;
umidigi_chargestore_set_sibling_chg_lev(data[0]);
}
}
REGISTER_TWS_FUNC_STUB(charge_level_stub) = {
.func_id = TWS_FUNC_ID_CHARGE_SYNC,
.func = umidigi_set_tws_sibling_charge_level,
};
#endif //TCFG_USER_TWS_ENABLE
int umidigi_chargestore_sync_chg_level(void)
{
#if TCFG_USER_TWS_ENABLE
int err = -1;
struct application *app = get_current_app();
if (app && (!strcmp(app->name, "earphone")) && (!app_var.goto_poweroff_flag)) {
err = tws_api_send_data_to_sibling((u8 *)&__this->case_battery_level, 1,
TWS_FUNC_ID_CHARGE_SYNC);
}
return err;
#else
return 0;
#endif
}
/*设置对耳同步的充电舱电量*/
void umidigi_chargestore_set_sibling_chg_lev(u8 chg_lev)
{
__this->sibling_chg_lev = chg_lev;
}
/*设置充电舱电池电量*/
void umidigi_chargestore_set_power_level(u8 power)
{
__this->case_battery_level = power;
}
/*获取允许poweroff标志位*/
u8 umidigi_chargestore_check_going_to_poweroff(void)
{
return __this->close_ing;
}
void umidigi_chargestore_set_phone_disconnect(void)
{
#if (TCFG_BLE_DEMO_SELECT == DEF_BLE_DEMO_ADV)
#if (!CONFIG_NO_DISPLAY_BUTTON_ICON)
if (__this->pair_flag && get_tws_sibling_connect_state()) {
//check ble inquiry
//printf("get box log_key...con_dev=%d\n",get_tws_phone_connect_state());
if ((bt_ble_icon_get_adv_state() == ADV_ST_RECONN)
|| (bt_ble_icon_get_adv_state() == ADV_ST_DISMISS)
|| (bt_ble_icon_get_adv_state() == ADV_ST_END)) {
bt_ble_icon_reset();
bt_ble_icon_open(ICON_TYPE_INQUIRY);
}
}
#endif
__this->pair_flag = 0;
#elif (TCFG_BLE_DEMO_SELECT == DEF_BLE_DEMO_ADV_RCSP)
#if (!CONFIG_NO_DISPLAY_BUTTON_ICON)
if (__this->pair_flag && get_tws_sibling_connect_state()) {
//check ble inquiry
bt_ble_adv_ioctl(BT_ADV_SET_EDR_CON_FLAG, SECNE_UNCONNECTED, 1);
}
#endif
__this->pair_flag = 0;
#endif
}
void umidigi_chargestore_set_phone_connect(void)
{
__this->active_disconnect = 0;
}
extern void sys_enter_soft_poweroff(void *priv);
void umidigi_chargestore_timeout_deal(void *priv)
{
__this->timer = 0;
__this->close_ing = 0;
//该类型的充电仓获取不到充电在线状态时,认为出仓了。
//避免盒盖马上开盖迅速拔出,收不到开盖消息,导致连上又复位系统。
if (get_charge_online_flag() == 0) {
__this->cover_status = 1;
}
if ((!__this->cover_status) || __this->active_disconnect) {//当前为合盖或者主动断开连接
struct application *app = get_current_app();
if (app && strcmp(app->name, "idle")) {
sys_enter_soft_poweroff((void *)1);
}
} else {
#if (TCFG_BLE_DEMO_SELECT == DEF_BLE_DEMO_ADV)
/* if ((!get_total_connect_dev()) && (tws_api_get_role() == TWS_ROLE_MASTER) && (get_bt_tws_connect_status())) { */
if (tws_api_get_role() == TWS_ROLE_MASTER) {
printf("charge_icon_ctl...\n");
bt_ble_icon_reset();
#if CONFIG_NO_DISPLAY_BUTTON_ICON
if (get_total_connect_dev()) {
//蓝牙未真正断开;重新广播
bt_ble_icon_open(ICON_TYPE_RECONNECT);
} else {
//蓝牙未连接，重新开可见性
bt_ble_icon_open(ICON_TYPE_INQUIRY);
}
#else
//不管蓝牙是否连接，默认打开
bt_ble_icon_open(ICON_TYPE_RECONNECT);
#endif
}
#elif (TCFG_BLE_DEMO_SELECT == DEF_BLE_DEMO_ADV_RCSP)
if (tws_api_get_role() == TWS_ROLE_MASTER) {
printf("charge_icon_ctl...\n");
#if CONFIG_NO_DISPLAY_BUTTON_ICON
if (get_total_connect_dev()) {
//蓝牙未真正断开;重新广播
bt_ble_adv_ioctl(BT_ADV_SET_EDR_CON_FLAG, SECNE_CONNECTED, 1);
} else {
//蓝牙未连接，重新开可见性
bt_ble_adv_ioctl(BT_ADV_SET_EDR_CON_FLAG, SECNE_UNCONNECTED, 1);
}
#else
//不管蓝牙是否连接，默认打开
bt_ble_adv_ioctl(BT_ADV_SET_EDR_CON_FLAG, SECNE_CONNECTED, 1);
#endif
}
#endif
}
__this->ear_number = 1;
}
/*开盖命令处理函数*/
static void open_case_callback(void *priv)
{
struct application *app = get_current_app();
if (__this->cover_status) {
//电压过低,不进响应开盖命令
#if TCFG_SYS_LVD_EN
if (get_vbat_need_shutdown() == TRUE) {
log_info(" lowpower deal!\n");
__this->open_case_timer = 0;
return;
}
#endif
if (__this->cover_status) {//当前为开盖
if (__this->power_sync) {
if (umidigi_chargestore_sync_chg_level() == 0) {
__this->power_sync = 0;
}
}
if (app && strcmp(app->name, APP_NAME_BT) && (app_var.goto_poweroff_flag == 0)) {
/* app_var.play_poweron_tone = 1; */
app_var.play_poweron_tone = 0;
power_set_mode(TCFG_LOWPOWER_POWER_SEL);
r_printf("switch to bt\n");
__this->switch2bt = 1;
#if TCFG_SYS_LVD_EN
vbat_check_init();
#endif
task_switch_to_bt();
__this->switch2bt = 0;
}
}
__this->open_case_timer = 0;
} else {
__this->open_case_timer = 0;
}
}
/*等待蓝牙初始化完成再进行对耳*/
static void tws_pair_wait_bt_init_callback(void *priv)
{
#if TCFG_USER_TWS_ENABLE
if (bt_tws_get_local_channel() == 'L') {
r_printf("L channel\n");
//充电仓不支持 双击回播电话,也不支持 双击配对和取消配对
#if (!TCFG_CHARGESTORE_ENABLE)
#if TCFG_USER_TWS_ENABLE
if (bt_tws_start_search_sibling()) {
tone_play_index(IDEX_TONE_NORMAL, 1);
}
#endif
#endif
if (bt_user_priv_var.last_call_type == BT_STATUS_PHONE_INCOME) {
user_send_cmd_prepare(USER_CTRL_DIAL_NUMBER, bt_user_priv_var.income_phone_len, bt_user_priv_var.income_phone_num);
} else {
user_send_cmd_prepare(USER_CTRL_HFP_CALL_LAST_NO, 0, NULL);
}
} else if (bt_tws_get_local_channel() == 'R') {
r_printf("R channel\n");
} else if (bt_tws_get_local_channel() == 'U') {
r_printf("U channel\n");
}
#endif
__this->pair_timer = 0;
}
/*配对命令处理函数*/
static void tws_pair_callback(void *priv)
{
struct application *app = get_current_app();
#if CONFIG_TWS_PAIR_MODE == CONFIG_TWS_PAIR_BY_CLICK
if (app && strcmp(app->name, APP_NAME_BT) && (app_var.goto_poweroff_flag == 0)) {
/* app_var.play_poweron_tone = 1; */
app_var.play_poweron_tone = 0;
power_set_mode(TCFG_LOWPOWER_POWER_SEL);
r_printf("switch to bt\n");
task_switch_to_bt();
}
sys_timeout_add(NULL, tws_pair_wait_bt_init_callback, 1000);
#endif
}
/*充电舱命令处理函数，所有命令携带8bit有效数据*/
int app_umidigi_chargestore_event_handler(struct umidigi_chargestore_event *umidigi_chargestore_dev)
{
int ret = false;
struct application *app = get_current_app();
#if defined(TCFG_CHARGE_KEEP_UPDATA) && TCFG_CHARGE_KEEP_UPDATA
//在升级过程中,不响应智能充电舱app层消息
if (dual_bank_update_exist_flag_get() || classic_update_task_exist_flag_get()) {
return ret;
}
#endif
switch (umidigi_chargestore_dev->event) {
case CMD_RESERVED_0:
log_info("event_CMD_RESERVED_0\n");
break;
case CMD_FACTORY_RESET:
log_info("event_CMD_FACTORY_RESET\n");
/*该命令携带固定数据0x55*/
if (umidigi_chargestore_dev->value != 0x55) {
break;
}
#if TCFG_USER_TWS_ENABLE
bt_tws_remove_pairs();
#endif
user_send_cmd_prepare(USER_CTRL_DEL_ALL_REMOTE_INFO, 0, NULL);
cpu_reset();
break;
case CMD_RESERVED_2:
log_info("event_CMD_RESERVED_2\n");
break;
case CMD_OPEN_CASE:
log_info("event_CMD_OPEN_CASE\n");
/*在收到其中一个开盖命令后，延迟2s进行耳机端开盖的相关操作*/
/*防止被其他开盖命令导致的通讯口电平变化所影响*/
if (!__this->open_case_timer) {
__this->open_case_timer = sys_timeout_add(NULL, open_case_callback, 2000);
}
if (__this->case_battery_level == 0xff) {
__this->power_sync = 1;
}
/*该命令携带的8bit data，BIT[7]为充电舱状态 BIT[6:0]为充电舱电量*/
__this->case_charger_state = umidigi_chargestore_dev->value >> 7;
__this->case_battery_level = umidigi_chargestore_dev->value & 0x7f;
if (__this->case_battery_level != __this->pre_power_lvl) {
__this->power_sync = 1;
}
__this->pre_power_lvl = __this->case_battery_level;
break;
case CMD_CLOSE_CASE:
log_info("event_CMD_CLOSE_CASE\n");
/*该命令携带的8bit data，BIT[7:2]为固定数据0x15*/
/*BIT[1]：1：右耳在仓 0：右耳不在仓, BIT[0]：1：左耳在仓 0：左耳不在仓*/
if ((umidigi_chargestore_dev->value >> 2) != 0x15) {
break;
}
__this->r_ear_whether_in_box = (umidigi_chargestore_dev->value & 0x02) >> 1;
__this->l_ear_whether_in_box = umidigi_chargestore_dev->value & 0x01;
__this->ear_number = __this->r_ear_whether_in_box + __this->l_ear_whether_in_box;
/* r_printf("r=%d l=%d\n", __this->r_ear_whether_in_box, __this->l_ear_whether_in_box); */
/* r_printf("ear_number = %d\n", __this->ear_number); */
if (!__this->cover_status) {//当前为合盖
#if (TCFG_BLE_DEMO_SELECT == DEF_BLE_DEMO_ADV)
if ((__this->bt_init_ok) && (tws_api_get_role() == TWS_ROLE_MASTER)) {
bt_ble_icon_close(1);
}
#elif (TCFG_BLE_DEMO_SELECT == DEF_BLE_DEMO_ADV_RCSP)
if ((__this->bt_init_ok) && (tws_api_get_role() == TWS_ROLE_MASTER)) {
bt_ble_adv_ioctl(BT_ADV_SET_EDR_CON_FLAG, SECNE_DISMISS, 1);
}
#endif
if (!__this->timer) {
__this->timer = sys_timeout_add(NULL, umidigi_chargestore_timeout_deal, 2000);
if (!__this->timer) {
log_error("timer alloc err!\n");
} else {
__this->close_ing = 1;
}
} else {
sys_timer_modify(__this->timer, 2000);
__this->close_ing = 1;
}
} else {
__this->ear_number = 1;
__this->close_ing = 0;
}
break;
case CMD_ENTER_PAIRING_MODE:
log_info("event_CMD_ENTER_PAIRING_MODE\n");
/*该命令携带固定数据0x55*/
if (umidigi_chargestore_dev->value != 0x55) {
break;
}
if (!__this->pair_timer) {
__this->pair_timer = sys_timeout_add(NULL, tws_pair_callback, 2000);
}
break;
case CMD_DUT_MODE_CMD:
log_info("event_CMD_DUT_MODE_CMD\n");
break;
case CMD_USB_STATE:
log_info("event_CMD_USB_STATE\n");
/*该命令携带固定数据0x05或0x70 0x05: USB IN, 0x70: USB OUT*/
if (umidigi_chargestore_dev->value == 0x05) {
__this->usb_state = 1;
} else if (umidigi_chargestore_dev->value == 0x70) {
__this->usb_state = 0;
}
break;
case CMD_RESERVED_B:
log_info("event_CMD_RESERVED_B\n");
break;
case CMD_SEND_CASE_BATTERY:
log_info("event_CMD_SEND_CASE_BATTERY\n");
/*该命令携带的8bit data，BIT[7]为充电舱状态 BIT[6:0]为充电舱电量*/
__this->case_charger_state = umidigi_chargestore_dev->value >> 7;
__this->case_battery_level = umidigi_chargestore_dev->value & 0x7f;
break;
default:
break;
}
}
void umidigi_chargestore_event_to_user(u32 type, u8 event, u8 data)
{
struct sys_event e;
e.type = SYS_DEVICE_EVENT;
e.arg = (void *)type;
e.u.umidigi_chargestore.event = event;
e.u.umidigi_chargestore.value = data;
sys_event_notify(&e);
}
/*umidigi充电舱消息处理*/
void app_umidigi_chargetore_message_deal(u16 message)
{
u8 cmd, data;
cmd = (message & CMD_IN_MESSAGE) >> 10;
data = (message & DATA_IN_MESSAGE) >> 2;
#if TCFG_TEST_BOX_ENABLE
//测试盒在线时,不解码数据
if (testbox_get_status()) {
return;
}
#endif
switch (cmd) {
case CMD_RESERVED_0:
log_info("reserved0\n");
umidigi_chargestore_event_to_user(DEVICE_EVENT_UMIDIGI_CHARGE_STORE, CMD_RESERVED_0, data);
break;
case CMD_FACTORY_RESET:
//充电仓不删除配对信息
break;
__this->cover_status = 1;
__this->close_ing = 0;
r_printf("factory reset\n");
umidigi_chargestore_event_to_user(DEVICE_EVENT_UMIDIGI_CHARGE_STORE, CMD_FACTORY_RESET, data);
break;
case CMD_RESERVED_2:
log_info("reserved2\n");
umidigi_chargestore_event_to_user(DEVICE_EVENT_UMIDIGI_CHARGE_STORE, CMD_RESERVED_2, data);
break;
case CMD_OPEN_CASE:
__this->cover_status = 1;
__this->close_ing = 0;
log_info("open case\n");
//切模式过程中不发送消息,防止堆满消息
if (__this->switch2bt == 0) {
umidigi_chargestore_event_to_user(DEVICE_EVENT_UMIDIGI_CHARGE_STORE, CMD_OPEN_CASE, data);
}
break;
case CMD_CLOSE_CASE:
__this->cover_status = 0;
log_info("close case\n");
umidigi_chargestore_event_to_user(DEVICE_EVENT_UMIDIGI_CHARGE_STORE, CMD_CLOSE_CASE, data);
break;
case CMD_ENTER_PAIRING_MODE:
__this->cover_status = 1;
log_info("enter pairing mode\n");
umidigi_chargestore_event_to_user(DEVICE_EVENT_UMIDIGI_CHARGE_STORE, CMD_ENTER_PAIRING_MODE, data);
break;
case CMD_DUT_MODE_CMD:
log_info("dut mode\n");
umidigi_chargestore_event_to_user(DEVICE_EVENT_UMIDIGI_CHARGE_STORE, CMD_DUT_MODE_CMD, data);
break;
case CMD_USB_STATE:
log_info("usb state\n");
umidigi_chargestore_event_to_user(DEVICE_EVENT_UMIDIGI_CHARGE_STORE, CMD_USB_STATE, data);
break;
case CMD_RESERVED_B:
log_info("reservedB\n");
umidigi_chargestore_event_to_user(DEVICE_EVENT_UMIDIGI_CHARGE_STORE, CMD_RESERVED_B, data);
break;
case CMD_SEND_CASE_BATTERY:
log_info("received case battery\n");
umidigi_chargestore_event_to_user(DEVICE_EVENT_UMIDIGI_CHARGE_STORE, CMD_SEND_CASE_BATTERY, data);
break;
default:
log_info("received an invalid message!\n");
break;
}
}
#endif

4
apps/xtell_hide/sdk_version.z.S Normal file
View File

@ -0,0 +1,4 @@
.section .sys.version, "ax"
.long 254991771
.asciz "JL701N_V1.6.1-@20240130-$8f8f3995"