/*
****************************************************************************************
* @brief ble_adv
* @param[in] pcCommandString ÃüÁîºÍ²ÎÊý´æ·ÅµØÖ·
* @param[in] pcWriteBuffer дÈë´ËÊý×éµÄÃüÁ±»·¢Ë͵½´®¿Ú
* @param[in] commpare_length ÃüÁîËùÕ¼³¤¶È
* @return None
* @description ¿ªÆô»òÕ߹رչ㲥£¬ÃüÁî¸ñʽ£ºAT+ADV=0 ¿ªÆô¹ã²¥ AT+ADV=1 ¹Ø±Õ¹ã²¥
*****************************************************************************************/
int ble_adv( const uint8_t * const pcCommandString,uint8_t* pcWriteBuffer,uint32_t commpare_length)
{
const int8_t *pcom;
int32_t arg1;
uint32_t pxParameterStringLength;
pcom = at_get_parameter((const int8_t*)pcCommandString + commpare_length + 1, 0, &pxParameterStringLength);
arg1 = at_HEXstringToNum((const uint8_t *)pcom, pxParameterStringLength);
if(arg1 == 0)
{
usr_led1_set(LED_ON_DUR_IDLE,LED_OFF_DUR_IDLE);
app_gap_adv_stop_req();
}
else if(arg1 == 1)
{
usr_led1_set(LED_ON_DUR_ADV_FAST,LED_ON_DUR_ADV_FAST);
app_gap_adv_start_req(GAP_GEN_DISCOVERABLE|GAP_UND_CONNECTABLE,
app_env.adv_data, app_set_adv_data(GAP_GEN_DISCOVERABLE),
app_env.scanrsp_data, app_set_scan_rsp_data(app_get_local_service_flag()),
GAP_ADV_FAST_INTV1, GAP_ADV_FAST_INTV2);
ke_timer_set(APP_ADV_INTV_UPDATE_TIMER,TASK_APP,30);
}
else
{
return sprintf((char*)pcWriteBuffer,"ERR\r\n");
}
return sprintf((char*)pcWriteBuffer,"OK\r\n");
}
/**
****************************************************************************************
* @brief Handles button press after cancel the jitter.
*
* @param[in] msgid Id of the message received
* @param[in] param None
* @param[in] dest_id TASK_APP
* @param[in] src_id TASK_APP
*
* @return If the message was consumed or not.
****************************************************************************************
*/
int app_button_timer_handler(ke_msg_id_t const msgid, void const *param,
ke_task_id_t const dest_id, ke_task_id_t const src_id)
{
switch(msgid)
{
case APP_SYS_BUTTON_1_TIMER:
// make sure the button is pressed
if(gpio_read_pin(BUTTON1_PIN) == GPIO_LOW)
{
if(APP_IDLE == ke_state_get(TASK_APP))
{
struct app_proxr_env_tag *app_proxr_env = &app_env.proxr_ev;
if(!app_proxr_env->enabled)
{
// start adv
app_gap_adv_start_req(GAP_GEN_DISCOVERABLE|GAP_UND_CONNECTABLE,
app_env.adv_data, app_set_adv_data(GAP_GEN_DISCOVERABLE),
app_env.scanrsp_data, app_set_scan_rsp_data(app_get_local_service_flag()),
GAP_ADV_FAST_INTV1, GAP_ADV_FAST_INTV2);
#if (QN_DEEP_SLEEP_EN)
// prevent entering into deep sleep mode
sleep_set_pm(PM_SLEEP);
#endif
#if (FB_OLED)
ke_timer_set(APP_OLED_STATE_DISPlAY_TIMER,TASK_APP,20);
#endif
}
}
else if(APP_ADV == ke_state_get(TASK_APP))
{
// stop adv
app_gap_adv_stop_req();
#if (QN_DEEP_SLEEP_EN)
// allow entering into deep sleep mode
sleep_set_pm(PM_DEEP_SLEEP);
#endif
#if (FB_OLED)
ke_timer_set(APP_OLED_STATE_DISPlAY_TIMER,TASK_APP,20);
#endif
}
}
break;
case APP_SYS_BUTTON_2_TIMER:
if(gpio_read_pin(BUTTON2_PIN) == GPIO_LOW)
{
buzzer_off();
}
break;
default:
ASSERT_ERR(0);
break;
}
return (KE_MSG_CONSUMED);
}
static void adv_wdt_to_handler(void)
{
ke_state_set(TASK_APP, APP_IDLE);
// start adv
app_gap_adv_start_req(GAP_GEN_DISCOVERABLE|GAP_UND_CONNECTABLE,
app_env.adv_data, app_set_adv_data(GAP_GEN_DISCOVERABLE),
app_env.scanrsp_data, app_set_scan_rsp_data(app_get_local_service_flag()),
GAP_ADV_FAST_INTV1, GAP_ADV_FAST_INTV2);
}
void app_init_func(void)
{
#if (BLE_SPOTA_RECEIVER)
app_spotar_init();
#endif
app_dis_init();
app_set_adv_data();
}
/**
****************************************************************************************
* @brief Start the device to advertising process.
****************************************************************************************
*/
void app_start_adv(void)
{
if(! app_htpt_env->enabled)
{
if(APP_IDLE == ke_state_get(TASK_APP))
{
app_gap_adv_start_req(GAP_GEN_DISCOVERABLE|GAP_UND_CONNECTABLE,
app_env.adv_data, app_set_adv_data(GAP_GEN_DISCOVERABLE),
app_env.scanrsp_data, app_set_scan_rsp_data(app_get_local_service_flag()),
GAP_ADV_FAST_INTV1, GAP_ADV_FAST_INTV2);
}
}
}
/**
****************************************************************************************
* @brief Handles advertising mode timer event.
*
* @param[in] msgid APP_ADV_INTV_UPDATE_TIMER
* @param[in] param None
* @param[in] dest_id TASK_APP
* @param[in] src_id TASK_APP
*
* @return If the message was consumed or not.
* @description
*
* This handler is used to inform the application that first phase of adversting mode is timeout.
****************************************************************************************
*/
int app_gap_adv_intv_update_timer_handler(ke_msg_id_t const msgid, void const *param,
ke_task_id_t const dest_id, ke_task_id_t const src_id)
{
if(APP_ADV == ke_state_get(TASK_APP))
{
usr_led1_set(LED_ON_DUR_IDLE, LED_OFF_DUR_IDLE);
// Update Advertising Parameters
app_gap_adv_start_req(GAP_GEN_DISCOVERABLE|GAP_UND_CONNECTABLE,
app_env.adv_data, app_set_adv_data(GAP_GEN_DISCOVERABLE),
app_env.scanrsp_data, app_set_scan_rsp_data(app_get_local_service_flag()),
GAP_ADV_SLOW_INTV, GAP_ADV_SLOW_INTV);
}
return (KE_MSG_CONSUMED);
}
void app_init_func(void)
{
app_task_custom_init();
//app_accel_init();
app_set_adv_data();
#if 0
#if SLEEP_ENABLED
#if DEEP_SLEEP_ENABLED
app_set_deep_sleep();
#else
app_set_extended_sleep(false);
#endif
#else
app_disable_sleep();
#endif // SLEEP_ENABLED
#endif
}
/**
****************************************************************************************
* @brief Application task message handler
****************************************************************************************
*/
void app_task_msg_hdl(ke_msg_id_t const msgid, void const *param)
{
switch(msgid)
{
case GAP_SET_MODE_REQ_CMP_EVT:
if(APP_IDLE == ke_state_get(TASK_APP))
{
usr_led1_set(LED_ON_DUR_ADV_FAST, LED_OFF_DUR_ADV_FAST);
ke_timer_set(APP_ADV_INTV_UPDATE_TIMER, TASK_APP, 30 * 100);
}
else if(APP_ADV == ke_state_get(TASK_APP))
{
usr_led1_set(LED_ON_DUR_ADV_SLOW, LED_OFF_DUR_ADV_SLOW);
}
break;
case GAP_ADV_REQ_CMP_EVT:
usr_led1_set(LED_ON_DUR_IDLE, LED_OFF_DUR_IDLE);
ke_timer_clear(APP_ADV_INTV_UPDATE_TIMER, TASK_APP);
break;
case GAP_DISCON_CMP_EVT:
usr_led1_set(LED_ON_DUR_IDLE, LED_OFF_DUR_IDLE);
// start adv
app_gap_adv_start_req(GAP_GEN_DISCOVERABLE|GAP_UND_CONNECTABLE,
app_env.adv_data, app_set_adv_data(GAP_GEN_DISCOVERABLE),
app_env.scanrsp_data, app_set_scan_rsp_data(app_get_local_service_flag()),
GAP_ADV_FAST_INTV1, GAP_ADV_FAST_INTV2);
break;
case GAP_LE_CREATE_CONN_REQ_CMP_EVT:
if(((struct gap_le_create_conn_req_cmp_evt *)param)->conn_info.status == CO_ERROR_NO_ERROR)
{
if(GAP_PERIPHERAL_SLV == app_get_role())
{
ke_timer_clear(APP_ADV_INTV_UPDATE_TIMER, TASK_APP);
usr_led1_set(LED_ON_DUR_CON, LED_OFF_DUR_CON);
// Update cnx parameters
if (((struct gap_le_create_conn_req_cmp_evt *)param)->conn_info.con_interval < GAP_PPCP_CONN_INTV_MIN)
{
// Update connection parameters here
struct gap_conn_param_update conn_par;
/// Connection interval minimum
conn_par.intv_min = GAP_PPCP_CONN_INTV_MIN;
/// Connection interval maximum
conn_par.intv_max = GAP_PPCP_CONN_INTV_MAX;
/// Latency
conn_par.latency = GAP_PPCP_SLAVE_LATENCY;
/// Supervision timeout, Time = N * 10 msec
conn_par.time_out = GAP_PPCP_STO_MULT;
app_gap_param_update_req(((struct gap_le_create_conn_req_cmp_evt *)param)->conn_info.conhdl, &conn_par);
}
}
}
break;
case GLPS_DISABLE_IND:
ke_timer_clear(APP_GLPS_MEAS_SEND_TIMER, TASK_APP);
break;
case GLPS_CFG_INDNTF_IND:
if (app_glps_env->evt_cfg & GLPS_MEAS_NTF_CFG && !(((struct glps_cfg_indntf_ind *)param)->evt_cfg & GLPS_MEAS_NTF_CFG))
{
ke_timer_clear(APP_GLPS_MEAS_SEND_TIMER, TASK_APP);
}
if (app_glps_env->evt_cfg & GLPS_MEAS_CTX_NTF_CFG && !(((struct glps_cfg_indntf_ind *)param)->evt_cfg & GLPS_MEAS_CTX_NTF_CFG))
{
ke_timer_clear(APP_GLPS_MEAS_SEND_TIMER, TASK_APP);
}
break;
case GLPS_RACP_REQ_IND:
{
uint8_t res;
switch (((struct glps_racp_req_ind *)param)->racp_req.op_code)
{
case GLP_REQ_REP_STRD_RECS: // Report stored records (Operator: Value from Operator Table)
res = app_glps_racp_procedure_handle(&app_glps_env->racp_req);
if (res == GLP_RSP_SUCCESS)
{
ke_timer_set(APP_GLPS_MEAS_SEND_TIMER, TASK_APP, APP_GLPS_MEAS_SEND_TO);
}
else
{
app_glps_racp_rsp_req_send(app_glps_env->conhdl, 0, GLP_REQ_REP_STRD_RECS, res);
}
break;
case GLP_REQ_DEL_STRD_RECS: // Delete stored records (Operator: Value from Operator Table)
app_glps_racp_rsp_req_send(app_glps_env->conhdl, 0, GLP_REQ_DEL_STRD_RECS, GLP_RSP_SUCCESS);
break;
case GLP_REQ_ABORT_OP: // Abort operation (Operator: Null 'value of 0x00 from Operator Table')
ke_timer_clear(APP_GLPS_MEAS_SEND_TIMER, TASK_APP);
app_glps_racp_rsp_req_send(app_glps_env->conhdl, 0, GLP_REQ_ABORT_OP, GLP_RSP_SUCCESS);
break;
case GLP_REQ_REP_NUM_OF_STRD_RECS: // Report number of stored records (Operator: Value from Operator Table)
res = app_glps_racp_procedure_handle(&app_glps_env->racp_req);
app_glps_racp_rsp_req_send(app_glps_env->conhdl, APP_GLPS_STROED_RECORDS_NUM, GLP_REQ_REP_NUM_OF_STRD_RECS, res);
break;
default:
app_glps_racp_rsp_req_send(app_glps_env->conhdl, 0, ((struct glps_racp_req_ind *)param)->racp_req.op_code, GLP_RSP_OP_CODE_NOT_SUP);
break;
}
break;
}
default:
break;
}
}
/**
****************************************************************************************
* @brief Application task message handler
****************************************************************************************
*/
void app_task_msg_hdl(ke_msg_id_t const msgid, void const *param)
{
switch(msgid)
{
case GAP_SET_MODE_REQ_CMP_EVT:
if(APP_IDLE == ke_state_get(TASK_APP))
{
usr_led1_set(LED_ON_DUR_ADV_FAST, LED_OFF_DUR_ADV_FAST);
//delay some time let adv slow
ke_timer_set(APP_ADV_INTV_UPDATE_TIMER, TASK_APP, 30 * 100);
}
else if(APP_ADV == ke_state_get(TASK_APP))
{
usr_led1_set(LED_ON_DUR_ADV_SLOW, LED_OFF_DUR_ADV_SLOW);
}
break;
case GAP_ADV_REQ_CMP_EVT:
usr_led1_set(LED_ON_DUR_IDLE, LED_OFF_DUR_IDLE);
ke_timer_clear(APP_ADV_INTV_UPDATE_TIMER, TASK_APP);
break;
case GAP_DISCON_CMP_EVT:
usr_led1_set(LED_ON_DUR_IDLE, LED_OFF_DUR_IDLE);
// start adv
app_gap_adv_start_req(GAP_GEN_DISCOVERABLE|GAP_UND_CONNECTABLE,
app_env.adv_data, app_set_adv_data(GAP_GEN_DISCOVERABLE),
app_env.scanrsp_data, app_set_scan_rsp_data(app_get_local_service_flag()),
GAP_ADV_FAST_INTV1, GAP_ADV_FAST_INTV2);
break;
case GAP_LE_CREATE_CONN_REQ_CMP_EVT:
if(((struct gap_le_create_conn_req_cmp_evt *)param)->conn_info.status == CO_ERROR_NO_ERROR)
{
if(GAP_PERIPHERAL_SLV == app_get_role())
{
ke_timer_clear(APP_ADV_INTV_UPDATE_TIMER, TASK_APP);
usr_led1_set(LED_ON_DUR_CON, LED_OFF_DUR_CON);
// Update cnx parameters
//if (((struct gap_le_create_conn_req_cmp_evt *)param)->conn_info.con_interval > IOS_CONN_INTV_MAX)
{
// Update connection parameters here
struct gap_conn_param_update conn_par;
/// Connection interval minimum
conn_par.intv_min = IOS_CONN_INTV_MIN;
/// Connection interval maximum
conn_par.intv_max = IOS_CONN_INTV_MAX;
/// Latency
conn_par.latency = IOS_SLAVE_LATENCY;
/// Supervision timeout, Time = N * 10 msec
conn_par.time_out = IOS_STO_MULT;
app_gap_param_update_req(((struct gap_le_create_conn_req_cmp_evt *)param)->conn_info.conhdl, &conn_par);
}
}
}
break;
case QPPS_DISABLE_IND:
break;
case QPPS_CFG_INDNTF_IND:
break;
default:
break;
}
}
int app_accel_adv_timer_handler(ke_msg_id_t const msgid,
void const *param,
ke_task_id_t const dest_id,
ke_task_id_t const src_id)
{
//GZ
app_set_adv_data();
// Shedule interval is: adv starts with APP_ADV_INT_MIN, then after 500ms goes to 200ms,
// then after 3 mins goes to 1sec, then after 3 mins goes to 2 sec
// Check if we need to change Advertising interval
if( accel_adv_count == 0 )
{
// First schedule for advertising interval has been reached. Move to the next schedule
accel_adv_interval = 0x140; // 200ms (200ms/0.625)
// Increment counter in retension memory
//accel_adv_count += 1;
// ke_timer_set(APP_ACCEL_ADV_TIMER, TASK_APP, 18000);
if(accel_adv_interval1 < 10)
accel_adv_interval1 = 10;
ke_timer_set(APP_ACCEL_ADV_TIMER, TASK_APP, accel_adv_interval1*100);
//stop Accelerometer
acc_stop();
rwip_env.sleep_enable = true;
}
else if( accel_adv_count == 1 )
{
accel_adv_interval = 0x640; // 1sec (1000ms/0.625)
// Increment counter in retension memory
//accel_adv_count += 1;
// ke_timer_set(APP_ACCEL_ADV_TIMER, TASK_APP, 18000);
ke_timer_set(APP_ACCEL_ADV_TIMER, TASK_APP, accel_adv_interval2*100);
}
else if( accel_adv_count == 2 )
{
accel_adv_interval = 0xc80; // 2sec (2000ms/0.625)
// Increment counter in retension memory
//accel_adv_count += 1;
// ke_timer_set(APP_ACCEL_ADV_TIMER, TASK_APP, 18000);
ke_timer_set(APP_ACCEL_ADV_TIMER, TASK_APP, accel_adv_interval3*100);
}
if( accel_adv_count >= 3 )
{
accel_adv_count = 0;
accel_adv_interval = APP_ADV_INT_MIN;
// Max schedule for advertising interval has been reached. Stop timer
ke_timer_clear(APP_ACCEL_ADV_TIMER, TASK_APP);
// Stop Advertising
app_adv_stop();
// Update APP State
ke_state_set(TASK_APP, APP_CONNECTABLE);
// Activate Accelerometer
//GZ set_accel_freefall();
if(accel_mode == 0)
set_accel_freefall();
else
set_accel_click();
//acc_int_restart();
acc_enable_wakeup_irq();
rwip_env.sleep_enable = true;
}
else
{
accel_adv_count += 1;
app_adv_start();
}
return (KE_MSG_CONSUMED);
}
/**
****************************************************************************************
* @brief BLE main function.
*
* This function is called right after the booting process has completed.
****************************************************************************************
*/
int main(void)
{
int ble_sleep_st, usr_sleep_st;
// DC-DC
dc_dc_enable(QN_DC_DC_ENABLE);
// QN platform initialization
#if QN_NVDS_WRITE
plf_init(QN_POWER_MODE, __XTAL, QN_32K_RCO, nvds_tmp_buf, NVDS_TMP_BUF_SIZE);
#else
plf_init(QN_POWER_MODE, __XTAL, QN_32K_RCO, NULL, 0);
#endif
#if (defined(QN_9020_B1) && (!QN_PMU_VOLTAGE))
disable_patch_b1();
#endif
// System initialization, user configuration
SystemInit();
// Profiles register
#if (QN_WORK_MODE != WORK_MODE_HCI)
prf_register();
#endif
// BLE stack initialization
// Notes:
// 1. When the chip works on Network Processor Mode, UART flow control signal is used to implement sleep mode.
// UART 's flow control feature shall be enabled. Enable this feature in the uart.c file.
// 2. Controller mode does not support sleep mode.
// 3. So far client example project does not support sleep mode. It will be implemented later.
// Check to go normal work mode or test mode.
// If the input of test control pin is low level, the program will enter into test mode, otherwise the program will
// enter into work mode which is defined in the user configuration file.
#if (defined(QN_TEST_CTRL_PIN))
if(gpio_read_pin(QN_TEST_CTRL_PIN) == GPIO_HIGH)
{
#endif
// Work mode defined in the usr_config.h
ble_init((enum WORK_MODE)QN_WORK_MODE, QN_HCI_PORT, QN_HCI_RD, QN_HCI_WR, ble_heap, BLE_HEAP_SIZE, QN_BLE_SLEEP);
#if (defined(QN_TEST_CTRL_PIN))
}
else
{
// Test mode (controller mode)
ble_init((enum WORK_MODE)WORK_MODE_HCI, QN_HCI_PORT, QN_HCI_RD, QN_HCI_WR, ble_heap, BLE_HEAP_SIZE, false);
// In the test mode, the program moniter test control pin. If the input of test control ping changes to low level,
// it means work mode should be switched to the mode defined in the user configuration file.
gpio_set_interrupt(QN_TEST_CTRL_PIN, GPIO_INT_HIGH_LEVEL);
gpio_enable_interrupt(QN_TEST_CTRL_PIN);
}
#endif
set_max_sleep_duration(QN_BLE_MAX_SLEEP_DUR);
// If QN902x works on wireless SoC mode, initialize APP task
#if (QN_WORK_MODE == WORK_MODE_SOC)
app_init();
#endif
usr_init();
sleep_init();
wakeup_by_sleep_timer(__32K_TYPE);
GLOBAL_INT_START();
ke_schedule();
//ke_timer_set(APP_SYS_SLEEP_TIMER, TASK_APP, 300);
// start advertizing as soon as power is gained.
// start adv
app_gap_adv_start_req(GAP_GEN_DISCOVERABLE|GAP_UND_CONNECTABLE,
app_env.adv_data, app_set_adv_data(GAP_GEN_DISCOVERABLE),
app_env.scanrsp_data, app_set_scan_rsp_data(app_get_local_service_flag()),
GAP_ADV_FAST_INTV1, GAP_ADV_FAST_INTV2);
// prevent entering into deep sleep mode
sleep_set_pm(PM_SLEEP);
while(1)
{
ke_schedule();
// Checks for sleep have to be done with interrupt disabled
GLOBAL_INT_DISABLE_WITHOUT_TUNER();
// Check whether the chip can enters sleep mode
//
// Chip enter sleep condition:
// +--------+--------+--------+--------+--------+
// | USR | | | | |
// | BLE | ACTIVE | IDLE | SLEEP | DEEP |
// +--------+--------+--------+--------+--------+
// | ACTIVE | active | active | active | active |
// | IDLE | active | idle | idle | idle |
// | SLEEP | active | idle | sleep | deep |
// +--------+--------+--------+--------+--------+
// Obtain the status of the user program
usr_sleep_st = usr_sleep();
// If the user program can be sleep or deep sleep then check ble status
if(usr_sleep_st != PM_ACTIVE)
{
// Obtain the status of ble sleep mode
ble_sleep_st = ble_sleep(usr_sleep_st);
// Check if the processor clock can be gated
if(((ble_sleep_st == PM_IDLE) || (usr_sleep_st == PM_IDLE))
&& (ble_sleep_st != PM_ACTIVE))
{
// Debug
led_set(5, LED_OFF);
led_set(4, LED_ON); // led4 is on when enter into gating mode
enter_sleep(SLEEP_CPU_CLK_OFF,
WAKEUP_BY_ALL_IRQ_SOURCE,
NULL);
// Debug
led_set(4, LED_OFF);
led_set(5, LED_ON); // led5 is on when enter into active mode
}
// Check if the processor can be power down
else if((ble_sleep_st == PM_SLEEP) && (usr_sleep_st == PM_SLEEP))
{
// Debug
led_set(5, LED_OFF);
led_set(3, LED_ON); // led3 is on when enter into sleep mode
enter_sleep(SLEEP_NORMAL,
(WAKEUP_BY_OSC_EN | WAKEUP_BY_GPIO),
sleep_cb);
// Debug
led_set(3, LED_OFF);
led_set(5, LED_ON); // led5 is on when enter into active mode
}
// Check if the system can be deep sleep
else if((ble_sleep_st == PM_SLEEP) && (usr_sleep_st == PM_DEEP_SLEEP))
{
// Debug
led_set(5, LED_OFF);
led_set(2, LED_ON); // led2 is on when enter into deep sleep mode
enter_sleep(SLEEP_DEEP,
WAKEUP_BY_GPIO,
sleep_cb);
// Debug
led_set(2, LED_OFF);
led_set(5, LED_ON); // led5 is on when enter into active mode
}
}
// Checks for sleep have to be done with interrupt disabled
GLOBAL_INT_RESTORE_WITHOUT_TUNER();
}
}
/**
****************************************************************************************
* @brief Application task message handler
****************************************************************************************
*/
void app_task_msg_hdl(ke_msg_id_t const msgid, void const *param)
{
switch(msgid)
{
case GAP_SET_MODE_REQ_CMP_EVT:
if(APP_IDLE == ke_state_get(TASK_APP))
{
usr_led1_set(LED_ON_DUR_ADV_FAST, LED_OFF_DUR_ADV_FAST);
ke_timer_set(APP_ADV_INTV_UPDATE_TIMER, TASK_APP, 30 * 100);
}
else if(APP_ADV == ke_state_get(TASK_APP))
{
usr_led1_set(LED_ON_DUR_ADV_SLOW, LED_OFF_DUR_ADV_SLOW);
}
break;
case GAP_ADV_REQ_CMP_EVT:
usr_led1_set(LED_ON_DUR_IDLE, LED_OFF_DUR_IDLE);
ke_timer_clear(APP_ADV_INTV_UPDATE_TIMER, TASK_APP);
break;
case GAP_DISCON_CMP_EVT:
usr_led1_set(LED_ON_DUR_IDLE, LED_OFF_DUR_IDLE);
ke_timer_clear(APP_BASS_BATT_LEVEL_TIMER, TASK_APP);
// start adv
app_gap_adv_start_req(GAP_GEN_DISCOVERABLE|GAP_UND_CONNECTABLE,
app_env.adv_data, app_set_adv_data(GAP_GEN_DISCOVERABLE),
app_env.scanrsp_data, app_set_scan_rsp_data(app_get_local_service_flag()),
GAP_ADV_FAST_INTV1, GAP_ADV_FAST_INTV2);
break;
case GAP_LE_CREATE_CONN_REQ_CMP_EVT:
if(((struct gap_le_create_conn_req_cmp_evt *)param)->conn_info.status == CO_ERROR_NO_ERROR)
{
if(GAP_PERIPHERAL_SLV == app_get_role())
{
ke_timer_clear(APP_ADV_INTV_UPDATE_TIMER, TASK_APP);
usr_led1_set(LED_ON_DUR_CON, LED_OFF_DUR_CON);
// Update cnx parameters
if (((struct gap_le_create_conn_req_cmp_evt *)param)->conn_info.con_interval < GAP_PPCP_CONN_INTV_MIN)
{
// Update connection parameters here
struct gap_conn_param_update conn_par;
/// Connection interval minimum
conn_par.intv_min = GAP_PPCP_CONN_INTV_MIN;
/// Connection interval maximum
conn_par.intv_max = GAP_PPCP_CONN_INTV_MAX;
/// Latency
conn_par.latency = GAP_PPCP_SLAVE_LATENCY;
/// Supervision timeout, Time = N * 10 msec
conn_par.time_out = GAP_PPCP_STO_MULT;
app_gap_param_update_req(((struct gap_le_create_conn_req_cmp_evt *)param)->conn_info.conhdl, &conn_par);
}
}
//Force immediately update the battery voltage
app_bass_batt_level_timer_handler(APP_BASS_BATT_LEVEL_TIMER, NULL, TASK_APP, TASK_APP);
}
break;
case BASS_DISABLE_IND:
ke_timer_clear(APP_BASS_BATT_LEVEL_TIMER, TASK_APP);
break;
case BASS_BATT_LEVEL_NTF_CFG_IND:
if (((struct bass_batt_level_ntf_cfg_ind *)param)->ntf_cfg == PRF_CLI_START_NTF)
{
// Start update timer
ke_timer_set(APP_BASS_BATT_LEVEL_TIMER, TASK_APP, APP_BASS_BATT_LEVEL_TO);
}
else
{
// Stop update timer
ke_timer_clear(APP_BASS_BATT_LEVEL_TIMER, TASK_APP);
}
break;
default:
break;
}
}
/**
****************************************************************************************
* @brief Application task message handler
****************************************************************************************
*/
void app_task_msg_hdl(ke_msg_id_t const msgid, void const *param)
{
switch(msgid)
{
case GAP_SET_MODE_REQ_CMP_EVT:
if(APP_IDLE == ke_state_get(TASK_APP))
{
usr_led1_set(LED_ON_DUR_ADV_FAST, LED_OFF_DUR_ADV_FAST);
ke_timer_set(APP_ADV_INTV_UPDATE_TIMER, TASK_APP, 30 * 100);
#if (defined(QN_ADV_WDT))
usr_env.adv_wdt_enable = true;
#endif
}
else if(APP_ADV == ke_state_get(TASK_APP))
{
usr_led1_set(LED_ON_DUR_ADV_SLOW, LED_OFF_DUR_ADV_SLOW);
#if (defined(QN_ADV_WDT))
usr_env.adv_wdt_enable = true;
#endif
}
#if (FB_OLED)
ke_timer_set(APP_OLED_DISPLAY_TIMER,TASK_APP,20);
#endif
break;
case GAP_ADV_REQ_CMP_EVT:
usr_led1_set(LED_ON_DUR_IDLE, LED_OFF_DUR_IDLE);
ke_timer_clear(APP_ADV_INTV_UPDATE_TIMER, TASK_APP);
break;
case GAP_DISCON_CMP_EVT:
usr_led1_set(LED_ON_DUR_IDLE, LED_OFF_DUR_IDLE);
// start adv
app_gap_adv_start_req(GAP_GEN_DISCOVERABLE|GAP_UND_CONNECTABLE,
app_env.adv_data, app_set_adv_data(GAP_GEN_DISCOVERABLE),
app_env.scanrsp_data, app_set_scan_rsp_data(app_get_local_service_flag()),
GAP_ADV_FAST_INTV1, GAP_ADV_FAST_INTV2);
break;
case GAP_LE_CREATE_CONN_REQ_CMP_EVT:
if(((struct gap_le_create_conn_req_cmp_evt *)param)->conn_info.status == CO_ERROR_NO_ERROR)
{
if(GAP_PERIPHERAL_SLV == app_get_role())
{
ke_timer_clear(APP_ADV_INTV_UPDATE_TIMER, TASK_APP);
usr_led1_set(LED_ON_DUR_CON, LED_OFF_DUR_CON);
#if (defined(QN_ADV_WDT))
usr_env.adv_wdt_enable = false;
#endif
// Update cnx parameters
if (((struct gap_le_create_conn_req_cmp_evt *)param)->conn_info.con_interval < GAP_PPCP_CONN_INTV_MIN)
{
// Update connection parameters here
struct gap_conn_param_update conn_par;
/// Connection interval minimum
conn_par.intv_min = GAP_PPCP_CONN_INTV_MIN;
/// Connection interval maximum
conn_par.intv_max = GAP_PPCP_CONN_INTV_MAX;
/// Latency
conn_par.latency = GAP_PPCP_SLAVE_LATENCY;
/// Supervision timeout, Time = N * 10 msec
conn_par.time_out = GAP_PPCP_STO_MULT;
app_gap_param_update_req(((struct gap_le_create_conn_req_cmp_evt *)param)->conn_info.conhdl, &conn_par);
}
}
}
break;
case PROXR_ALERT_IND:
{
usr_proxr_alert((struct proxr_alert_ind*)param);
}
break;
#if (BLE_OTA_SERVER)
case OTAS_TRANSIMIT_STATUS_IND:
QPRINTF(" APP get OTA transmit status = %d , describe = %d \r\n" , ((struct otas_transimit_status_ind*)param)->status,
((struct otas_transimit_status_ind*)param)->status_des);
//only need response once when ota status is in ota status start request
if(((struct otas_transimit_status_ind*)param)->status == OTA_STATUS_START_REQ)
{
app_ota_ctrl_resp(START_OTA);
}
break;
//end
#endif
case QPPS_DAVA_VAL_IND:
{
}
break;
default:
break;
}
#if (FB_OLED)
ke_timer_set(APP_OLED_STATE_DISPlAY_TIMER,TASK_APP,20);
#endif
}
/**
****************************************************************************************
* @brief Application task message handler
****************************************************************************************
*/
void app_task_msg_hdl(ke_msg_id_t const msgid, void const *param)
{
switch(msgid)
{
case GAP_SET_MODE_REQ_CMP_EVT:
if(APP_IDLE == ke_state_get(TASK_APP))
{
usr_led1_set(LED_ON_DUR_ADV_FAST, LED_OFF_DUR_ADV_FAST);
ke_timer_set(APP_ADV_INTV_UPDATE_TIMER, TASK_APP, 30 * 100);
#if (defined(QN_ADV_WDT))
usr_env.adv_wdt_enable = true;
#endif
}
else if(APP_ADV == ke_state_get(TASK_APP))
{
usr_led1_set(LED_ON_DUR_ADV_SLOW, LED_OFF_DUR_ADV_SLOW);
#if (defined(QN_ADV_WDT))
usr_env.adv_wdt_enable = true;
#endif
}
break;
case GAP_ADV_REQ_CMP_EVT:
usr_led1_set(LED_ON_DUR_IDLE, LED_OFF_DUR_IDLE);
ke_timer_clear(APP_ADV_INTV_UPDATE_TIMER, TASK_APP);
break;
case GAP_DISCON_CMP_EVT:
usr_led1_set(LED_ON_DUR_IDLE, LED_OFF_DUR_IDLE);
// start adv
app_gap_adv_start_req(GAP_GEN_DISCOVERABLE|GAP_UND_CONNECTABLE,
app_env.adv_data, app_set_adv_data(GAP_GEN_DISCOVERABLE),
app_env.scanrsp_data, app_set_scan_rsp_data(app_get_local_service_flag()),
GAP_ADV_FAST_INTV1, GAP_ADV_FAST_INTV2);
break;
case GAP_LE_CREATE_CONN_REQ_CMP_EVT:
if(((struct gap_le_create_conn_req_cmp_evt *)param)->conn_info.status == CO_ERROR_NO_ERROR)
{
if(GAP_PERIPHERAL_SLV == app_get_role())
{
ke_timer_clear(APP_ADV_INTV_UPDATE_TIMER, TASK_APP);
usr_led1_set(LED_ON_DUR_CON, LED_OFF_DUR_CON);
#if (defined(QN_ADV_WDT))
usr_env.adv_wdt_enable = false;
#endif
// Update cnx parameters
if (((struct gap_le_create_conn_req_cmp_evt *)param)->conn_info.con_interval < GAP_PPCP_CONN_INTV_MIN)
{
// Update connection parameters here
struct gap_conn_param_update conn_par;
/// Connection interval minimum
conn_par.intv_min = GAP_PPCP_CONN_INTV_MIN;
/// Connection interval maximum
conn_par.intv_max = GAP_PPCP_CONN_INTV_MAX;
/// Latency
conn_par.latency = GAP_PPCP_SLAVE_LATENCY;
/// Supervision timeout, Time = N * 10 msec
conn_par.time_out = GAP_PPCP_STO_MULT;
app_gap_param_update_req(((struct gap_le_create_conn_req_cmp_evt *)param)->conn_info.conhdl, &conn_par);
}
}
}
break;
case RSCPS_DISABLE_IND:
ke_timer_clear(APP_RSCPS_MEAS_SEND_TIMER, TASK_APP);
break;
case RSCPS_NTF_IND_CFG_IND:
{
struct rscps_ntf_ind_cfg_ind *cfg = (struct rscps_ntf_ind_cfg_ind *)param;
if (cfg->char_code == RSCP_RSCS_RSC_MEAS_CHAR)
{
if (app_rscps_env->app_cfg & RSCP_PRF_CFG_FLAG_RSC_MEAS_NTF)
{
app_rscps_env->ntf_sending = false;
ke_timer_set(APP_RSCPS_MEAS_SEND_TIMER, TASK_APP, APP_RSCPS_MEAS_SEND_TO);
}
else
{
ke_timer_clear(APP_RSCPS_MEAS_SEND_TIMER, TASK_APP);
}
}
else if (cfg->char_code == RSCP_RSCS_SC_CTNL_PT_CHAR)
{
;
}
break;
}
case RSCPS_SC_CTNL_PT_REQ_IND:
{
struct rscps_sc_ctnl_pt_req_ind *cfg = (struct rscps_sc_ctnl_pt_req_ind *)param;
union rscps_sc_ctnl_pt_cfm_value value;
switch (cfg->op_code)
{
case RSCP_CTNL_PT_OP_SET_CUMUL_VAL:
app_rscps_sc_ctnl_pt_cfm(app_rscps_env->conhdl, PRF_ERR_OK, &value);
break;
case RSCP_CTNL_PT_OP_START_CALIB:
app_rscps_sc_ctnl_pt_cfm(app_rscps_env->conhdl, PRF_ERR_OK, &value);
break;
case RSCP_CTNL_PT_OP_UPD_LOC:
value.sensor_loc = cfg->value.sensor_loc;
app_rscps_sc_ctnl_pt_cfm(app_rscps_env->conhdl, PRF_ERR_OK, &value);
break;
case RSCP_CTNL_PT_OP_REQ_SUPP_LOC:
value.supp_sensor_loc = 0x001f;
app_rscps_sc_ctnl_pt_cfm(app_rscps_env->conhdl, PRF_ERR_OK, &value);
break;
}
break;
}
default:
break;
}
}
/**
****************************************************************************************
* @brief Application task message handler
****************************************************************************************
*/
void app_task_msg_hdl(ke_msg_id_t const msgid, void const *param)
{
switch(msgid)
{
case GAP_SET_MODE_REQ_CMP_EVT:
if(APP_IDLE == ke_state_get(TASK_APP))
{
usr_led1_set(LED_ON_DUR_ADV_FAST, LED_OFF_DUR_ADV_FAST);
ke_timer_set(APP_ADV_INTV_UPDATE_TIMER, TASK_APP, 30 * 100);
}
else if(APP_ADV == ke_state_get(TASK_APP))
{
usr_led1_set(LED_ON_DUR_ADV_SLOW, LED_OFF_DUR_ADV_SLOW);
}
break;
case GAP_ADV_REQ_CMP_EVT:
usr_led1_set(LED_ON_DUR_IDLE, LED_OFF_DUR_IDLE);
ke_timer_clear(APP_ADV_INTV_UPDATE_TIMER, TASK_APP);
break;
case GAP_DISCON_CMP_EVT:
usr_led1_set(LED_ON_DUR_IDLE, LED_OFF_DUR_IDLE);
// start adv
app_gap_adv_start_req(GAP_GEN_DISCOVERABLE|GAP_UND_CONNECTABLE,
app_env.adv_data, app_set_adv_data(GAP_GEN_DISCOVERABLE),
app_env.scanrsp_data, app_set_scan_rsp_data(app_get_local_service_flag()),
GAP_ADV_FAST_INTV1, GAP_ADV_FAST_INTV2);
break;
case GAP_LE_CREATE_CONN_REQ_CMP_EVT:
if(((struct gap_le_create_conn_req_cmp_evt *)param)->conn_info.status == CO_ERROR_NO_ERROR)
{
if(GAP_PERIPHERAL_SLV == app_get_role())
{
ke_timer_clear(APP_ADV_INTV_UPDATE_TIMER, TASK_APP);
usr_led1_set(LED_ON_DUR_CON, LED_OFF_DUR_CON);
// Update cnx parameters
if (((struct gap_le_create_conn_req_cmp_evt *)param)->conn_info.con_interval < GAP_PPCP_CONN_INTV_MIN)
{
// Update connection parameters here
struct gap_conn_param_update conn_par;
/// Connection interval minimum
conn_par.intv_min = IOS_MIN_PARAM_INTV_MIN;
/// Connection interval maximum
conn_par.intv_max = IOS_MIN_PARAM_IMTV_MAX;
/// Latency
conn_par.latency = IOS_MIN_PARAM_LATENCY;
/// Supervision timeout, Time = N * 10 msec
conn_par.time_out = IOS_MIN_PARAM_TIME_OUT;
app_gap_param_update_req(((struct gap_le_create_conn_req_cmp_evt *)param)->conn_info.conhdl, &conn_par);
}
}
}
break;
case PROXR_ALERT_IND:
usr_proxr_alert((struct proxr_alert_ind*)param);
break;
case OTAS_TRANSIMIT_STATUS_IND:
#ifdef ENAB_OTAS_APP_CTRL
//only need response once when ota status is in ota status start request
if(((struct otas_transimit_status_ind*)param)->status == OTA_STATUS_START_REQ)
{
app_ota_ctrl_resp(START_OTA);
}
#endif
break;
default:
break;
}
}
/**
****************************************************************************************
* @brief Application task message handler
****************************************************************************************
*/
void app_task_msg_hdl(ke_msg_id_t const msgid, void const *param)
{
switch(msgid)
{
case GAP_SET_MODE_REQ_CMP_EVT:
if(APP_IDLE == ke_state_get(TASK_APP))
{
usr_led1_set(LED_ON_DUR_ADV_FAST, LED_OFF_DUR_ADV_FAST);
ke_timer_set(APP_ADV_INTV_UPDATE_TIMER, TASK_APP, 30 * 100);
#if (defined(QN_ADV_WDT))
usr_env.adv_wdt_enable = true;
#endif
}
else if(APP_ADV == ke_state_get(TASK_APP))
{
usr_led1_set(LED_ON_DUR_ADV_SLOW, LED_OFF_DUR_ADV_SLOW);
#if (defined(QN_ADV_WDT))
usr_env.adv_wdt_enable = true;
#endif
}
break;
case GAP_ADV_REQ_CMP_EVT:
usr_led1_set(LED_ON_DUR_IDLE, LED_OFF_DUR_IDLE);
ke_timer_clear(APP_ADV_INTV_UPDATE_TIMER, TASK_APP);
break;
case GAP_DISCON_CMP_EVT:
usr_led1_set(LED_ON_DUR_IDLE, LED_OFF_DUR_IDLE);
// start adv
app_gap_adv_start_req(GAP_GEN_DISCOVERABLE|GAP_UND_CONNECTABLE,
app_env.adv_data, app_set_adv_data(GAP_GEN_DISCOVERABLE),
app_env.scanrsp_data, app_set_scan_rsp_data(app_get_local_service_flag()),
GAP_ADV_FAST_INTV1, GAP_ADV_FAST_INTV2);
break;
case GAP_LE_CREATE_CONN_REQ_CMP_EVT:
if(((struct gap_le_create_conn_req_cmp_evt *)param)->conn_info.status == CO_ERROR_NO_ERROR)
{
if(GAP_PERIPHERAL_SLV == app_get_role())
{
ke_timer_clear(APP_ADV_INTV_UPDATE_TIMER, TASK_APP);
usr_led1_set(LED_ON_DUR_CON, LED_OFF_DUR_CON);
#if (defined(QN_ADV_WDT))
usr_env.adv_wdt_enable = false;
#endif
// Update cnx parameters
if (((struct gap_le_create_conn_req_cmp_evt *)param)->conn_info.con_interval < GAP_PPCP_CONN_INTV_MIN)
{
// Update connection parameters here
struct gap_conn_param_update conn_par;
/// Connection interval minimum
conn_par.intv_min = IOS_CONN_INTV_MIN;
/// Connection interval maximum
conn_par.intv_max = IOS_CONN_INTV_MAX;
/// Latency
conn_par.latency = IOS_SLAVE_LATENCY;
/// Supervision timeout, Time = N * 10 msec
conn_par.time_out = IOS_STO_MULT;
app_gap_param_update_req(((struct gap_le_create_conn_req_cmp_evt *)param)->conn_info.conhdl, &conn_par);
}
}
}
break;
case HRPS_DISABLE_IND:
ke_timer_clear(APP_HRPS_TIMER, TASK_APP);
break;
case HRPS_CFG_INDNTF_IND:
if (((struct hrps_cfg_indntf_ind *)param)->cfg_val == PRF_CLI_START_NTF)
{
app_hrps_env->ntf_sending = false;
ke_timer_set(APP_HRPS_TIMER, TASK_APP, APP_HEART_RATE_MEASUREMENT_TO);
}
else
{
ke_timer_clear(APP_HRPS_TIMER, TASK_APP);
}
break;
default:
break;
}
}
