/**
****************************************************************************************
* @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 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
}
else if(APP_INIT == ke_state_get(TASK_APP))
{
const qn_tm_t time = {2013,8,20,14,40,00};
// initialize ble time
qn_time_init();
// Set a real time, this is only a example.
// User should use this function in other condition.
qn_time_set(&time);
}
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);
usr_env.is_idle_connection_overtime = false;
ke_timer_clear(APP_HTPT_IDLE_CONNECTION_TIMEOUT_TIMER, TASK_APP);
break;
case GAP_LE_CREATE_CONN_REQ_CMP_EVT:
{
const struct gap_le_create_conn_req_cmp_evt * const pconnect = param;
if(pconnect->conn_info.status == CO_ERROR_NO_ERROR)
{
if(GAP_PERIPHERAL_SLV == app_get_role())
{
// Update cnx parameters
app_param_update(pconnect);
// set idle connection timeout event
app_set_idle_connection();
#if (defined(QN_ADV_WDT))
usr_env.adv_wdt_enable = false;
#endif
}
}
}
break;
case HTPT_DISABLE_IND:
if(! usr_env.is_temp_meas_config)
{
usr_env.is_meas_running = false;
//always stop intermediate timer
ke_timer_clear(APP_HTPT_PERIOD_MEAS_TIMER, TASK_APP);
}
break;
case HTPT_CFG_INDNTF_IND:
app_char_config_desc_change(param);
break;
case HTPT_TEMP_SEND_CFM:
QPRINTF("Temperature send confirm: %d\r\n", ((struct gatt_notify_cmp_evt const *)param)->status);
app_send_stored_meas();
break;
case HTPT_MEAS_INTV_CHG_IND:
if(usr_env.is_temp_meas_config)
{
if(app_htpt_env->meas_intv != 0)
{
ke_timer_set(APP_HTPT_PERIOD_MEAS_TIMER, TASK_APP,
app_htpt_env->meas_intv * 100); // trans unit from 1sec to 10ms
}
else
{
ke_timer_clear(APP_HTPT_PERIOD_MEAS_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);
}
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;
}
}
