/* **************************************************************************************** * @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); }
/** **************************************************************************************** * @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); }
/** **************************************************************************************** * @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)) { // start adv app_gap_adv_start_req(GAP_GEN_DISCOVERABLE, adv_data, sizeof(adv_data), scan_data, sizeof(scan_data), GAP_ADV_INTV1, GAP_ADV_INTV2); ke_state_set(TASK_APP, APP_ADV); #if (QN_DEEP_SLEEP_EN) // prevent entering into deep sleep mode sleep_set_pm(PM_SLEEP); #endif } else if (APP_ADV == ke_state_get(TASK_APP)) { // stop adv app_gap_adv_stop_req(); ke_state_set(TASK_APP, APP_IDLE); #if (QN_DEEP_SLEEP_EN) // allow entering into deep sleep mode sleep_set_pm(PM_DEEP_SLEEP); #endif } } break; default: ASSERT_ERR(0); break; } return (KE_MSG_CONSUMED); }
/** **************************************************************************************** * @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; } }
/** **************************************************************************************** * @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; } }