/**
****************************************************************************************
* @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);
}
void app_neb_msg_rx_resp_cycle_dur(struct app_neb_msg_resp_cycle_dur* msg)
{
uint8_t status = NEB_ERR_SUCCESS;
if(msg->duration != 0 && (ke_state_get(TASK_APP_NEB) == APP_NEB_CONNECTED))
{
// Allocate message to profile
struct nbps_neb_record_send_req *req = KE_MSG_ALLOC(NBPS_NEB_RECORD_SEND_REQ,
TASK_NBPS, TASK_APP_NEB,
nbps_neb_record_send_req);
req->conhdl = app_neb_env.conhdl;
req->neb_rec.neb_id = app_neb_env.curr_neb_id;
req->neb_rec.rec_id = app_neb_env.next_rec_id;
req->neb_rec.flags = NEB_REC_RESP_DUR_FLAG;
// Parameters
req->neb_rec.resp_cycle_dur = msg->duration;
ke_msg_send(req);
// Increment record ID
app_neb_env.next_rec_id++;
}
// Confirm the message
app_neb_msg_tx_confirm_basic(NEB_MSG_ID_RESP_CYCLE_DUR, status);
}
void prf_client_disable_ind_send(prf_env_struct ***p_envs, ke_msg_id_t msg_id,
ke_task_id_t task_id, uint8_t state, uint16_t conhdl)
{
// retrieve current state
uint8_t cur_state = ke_state_get(task_id);
// prevent doing freeing structure if state already of profile is already free.
if(cur_state != state)
{
// Get the address of the environment
prf_env_struct *env = prf_client_get_env(*p_envs, task_id);
ASSERT_WARN(env != NULL);
if (env != NULL)
{
struct prf_client_disable_ind *ind = KE_MSG_ALLOC(msg_id,
env->con_info.appid, env->con_info.prf_id,
prf_client_disable_ind);
ind->conhdl = conhdl;
ind->status = prf_client_disable(p_envs, KE_IDX_GET(env->con_info.prf_id));
// Send the message
ke_msg_send(ind);
// Go to idle state
ke_state_set(task_id, state);
}
}
}
void rscpc_send_cmp_evt(struct rscpc_env_tag *rscpc_env, uint8_t operation, uint8_t status)
{
// Free the stored operation if needed
if (rscpc_env->operation != NULL)
{
ke_msg_free(ke_param2msg(rscpc_env->operation));
rscpc_env->operation = NULL;
}
// Go back to the CONNECTED state if the state is busy
if (ke_state_get(rscpc_env->con_info.prf_id) == RSCPC_BUSY)
{
ke_state_set(rscpc_env->con_info.prf_id, RSCPC_CONNECTED);
}
// Send the message
struct rscpc_cmp_evt *evt = KE_MSG_ALLOC(RSCPC_CMP_EVT,
rscpc_env->con_info.appid, rscpc_env->con_info.prf_id,
rscpc_cmp_evt);
evt->conhdl = gapc_get_conhdl(rscpc_env->con_info.conidx);
evt->operation = operation;
evt->status = status;
ke_msg_send(evt);
}
/**
****************************************************************************************
* @brief Handles reception of the APP_MODULE_INIT_CMP_EVT messgage
* @param[in] msgid Id of the message received.
* @param[in] param Pointer to the parameters of the message.
* @param[in] dest_id ID of the receiving task instance
* @param[in] src_id ID of the sending task instance.
*
* @return If the message was consumed or not.
****************************************************************************************
*/
int app_module_init_cmp_evt_handler(ke_msg_id_t const msgid,
const struct app_module_init_cmp_evt *param,
ke_task_id_t const dest_id,
ke_task_id_t const src_id)
{
if (ke_state_get(dest_id) == APP_DB_INIT)
{
if (param->status == CO_ERROR_NO_ERROR)
{
// Add next required service in the database
if (app_db_init())
{
// No more service to add in the database, start application
app_db_init_complete_func();
}
}
else
{
// An error has occurred during database creation
ASSERT_ERR(0);
}
}
else
{
// APP_DB_INIT state is used to wait the APP_MODULE_INIT_CMP_EVT message
ASSERT_ERR(0);
}
return (KE_MSG_CONSUMED);
}
void app_disconnect_func(ke_task_id_t task_id, struct gapc_disconnect_ind const *param)
{
uint8_t state = ke_state_get(task_id);
#if BLE_BATT_SERVER
app_batt_poll_stop();
#endif // BLE_BATT_SERVER
if ((state == APP_SECURITY) || (state == APP_CONNECTED) || (state == APP_PARAM_UPD))
{
/**************************************************
Handle disconnection event
***************************************************/
// Restart Advertising
//app_adv_start();
}
else
{
// We are not in a Connected State
ASSERT_ERR(0);
}
}
static int htpt_create_db_cfm_handler(ke_msg_id_t const msgid,
struct htpt_create_db_cfm const *param,
ke_task_id_t const dest_id,
ke_task_id_t const src_id)
{
if (ke_state_get(dest_id) == APP_HT_DISABLED)
{
if (param->status == PRF_ERR_OK)
{
// Go to Idle state
ke_state_set(TASK_APP_HT, APP_HT_IDLE);
}
// Inform the Application Manager
struct app_module_init_cmp_evt *cfm = KE_MSG_ALLOC(APP_MODULE_INIT_CMP_EVT,
TASK_APP, TASK_APP_HT,
app_module_init_cmp_evt);
cfm->status = param->status;
ke_msg_send(cfm);
}
return (KE_MSG_CONSUMED);
}
/**
****************************************************************************************
* @brief Handles GAP controller command complete events.
*
* @param[in] msgid Id of the message received.
* @param[in] param Pointer to the parameters of the message.
* @param[in] dest_id ID of the receiving task instance (TASK_GAP).
* @param[in] src_id ID of the sending task instance.
*
* @return If the message was consumed or not.
****************************************************************************************
*/
int gapc_cmp_evt_handler(ke_msg_id_t const msgid,
struct gapc_cmp_evt const *param,
ke_task_id_t const dest_id,
ke_task_id_t const src_id)
{
switch(param->operation) {
// reset completed
case GAPC_UPDATE_PARAMS:
if (ke_state_get(dest_id) == APP_PARAM_UPD) {
if ((param->status != CO_ERROR_NO_ERROR)) {
// it's application specific what to do when the Param Upd request is rejected
app_update_params_rejected_func(param->status);
}
else {
// Go to Connected State
ke_state_set(dest_id, APP_CONNECTED);
// if state is APP_CONNECTED then the request was accepted
app_update_params_complete_func();
}
}
break;
default:
if(param->status != GAP_ERR_NO_ERROR) {
ASSERT_ERR(0); // unexpected error
}
break;
}
return (KE_MSG_CONSUMED);
}
/**
****************************************************************************************
* @brief Function called to send a message through UART.
*
* @param[in] msgid U16 message id from ke_msg.
* @param[in] *param Pointer to parameters of the message in ke_msg.
* @param[in] dest_id Destination task id.
* @param[in] src_id Source task ID.
*
* @return Kernel message state, must be KE_MSG_NO_FREE.
*****************************************************************************************
*/
static int my_gtl_msg_send_handler (ke_msg_id_t const msgid,
void *param,
ke_task_id_t const dest_id,
ke_task_id_t const src_id)
{
//extract the ke_msg pointer from the param passed and push it in GTL queue
struct ke_msg *msg = ke_param2msg(param);
// Check if there is no transmission ongoing
if (ke_state_get(TASK_GTL) != GTL_TX_IDLE)
{
if(gtl_env.tx_queue.tx_data_packet > MAX_GTL_PENDING_PACKETS_ADV)
{
if(msgid == GAPM_ADV_REPORT_IND || gtl_env.tx_queue.tx_data_packet > MAX_GTL_PENDING_PACKETS)
return KE_MSG_CONSUMED;
}
co_list_push_back(>l_env.tx_queue, &(msg->hdr));
}
else
{
// send the message
gtl_send_msg(msg);
// Set GTL task to TX ONGOING state
ke_state_set(TASK_GTL, GTL_TX_ONGOING);
}
//return NO_FREE always since gtl_eif_write handles the freeing
return KE_MSG_NO_FREE;
}
/**
****************************************************************************************
* @brief Handles UART data indication.
*
* @param[in] msgid APP_SYS_UART_DATA_IND
* @param[in] param Pointer to struct app_uart_data_ind
* @param[in] dest_id TASK_APP
* @param[in] src_id TASK_APP
*
* @return If the message was consumed or not.
****************************************************************************************
*/
static int app_uart_data_ind_handler(ke_msg_id_t const msgid, struct app_uart_data_ind const *ind,
ke_task_id_t const dest_id, ke_task_id_t const src_id)
{
switch (ke_state_get(dest_id))
{
case APP_INIT:
break;
case APP_IDLE:
default:
#if QN_EACI
app_eaci_msg_hdl((src_id >> 8) & 0xFF,
src_id & 0xFF,
ind->len,
ind->data);
#elif QN_DEMO_MENU
if (ind->len != 0)
{
memcpy(app_env.input, ind->data, ind->len);
app_menu_hdl();
}
#endif
break;
}
#if (QN_EACI&&(EACI_MSG_BUFFER_EN==TRUE))
return (KE_MSG_NO_FREE);
#else
return (KE_MSG_CONSUMED);
#endif
}
bool check_gtl_state(void)
{
uint8_t ret = true;
#if BLE_HOST_PRESENT
if ((ke_state_get(TASK_GTL) != GTL_TX_IDLE) ||
((gtl_env.rx_state != GTL_STATE_RX_START) &&
(gtl_env.rx_state != GTL_STATE_RX_OUT_OF_SYNC)) )
ret = false;
#else
if ((ke_state_get(TASK_HCI) != HCI_STATE_TX_IDLE) ||
((hci_env.rx_state != HCI_STATE_RX_START) &&
(hci_env.rx_state != HCI_STATE_RX_OUT_OF_SYNC)) )
ret = false;
#endif
return ret;
}
/**
****************************************************************************************
* @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);
}
void app_neb_msg_rx_start(struct app_neb_msg_start* msg)
{
uint8_t status = NEB_ERR_SUCCESS;
// Check parameters
switch (msg->reason)
{
case NEB_MSG_START_REASON_START:
{
// Increment nebulizer ID
app_neb_env.curr_neb_id++;
#if (NVDS_SUPPORT)
// Put the current nebulizer ID into storage
nvds_put(NVDS_TAG_NEB_ID, NVDS_LEN_NEB_ID, (uint8_t *)&app_neb_env.curr_neb_id);
#endif // NVDS_SUPPORT
// Clear record ID
app_neb_env.next_rec_id = 0;
}
break;
case NEB_MSG_START_REASON_RESTART:
break;
default:
{
status = NEB_ERR_INVALID_PARAMS;
}
break;
}
if ((status == NEB_ERR_SUCCESS) && (ke_state_get(TASK_APP_NEB) == APP_NEB_CONNECTED))
{
// Allocate message to profile
struct nbps_neb_record_send_req *req = KE_MSG_ALLOC(NBPS_NEB_RECORD_SEND_REQ,
TASK_NBPS, TASK_APP_NEB,
nbps_neb_record_send_req);
req->conhdl = app_neb_env.conhdl;
req->neb_rec.neb_id = app_neb_env.curr_neb_id;
req->neb_rec.rec_id = app_neb_env.next_rec_id;
req->neb_rec.flags = NEB_REC_START_FLAG;
// Parameters
req->neb_rec.reason = msg->reason;
// Get absolute time stamp
app_neb_insert_abs_time(req);
ke_msg_send(req);
// Increment record ID
app_neb_env.next_rec_id++;
}
// Confirm the message
app_neb_msg_tx_confirm_basic(NEB_MSG_ID_START, status);
}
/**
****************************************************************************************
* @brief Handles accelerometer start advertising request from the Wakeup ISR.
*
* @param[in] msgid Id of the message received.
* @param[in] param Pointer to the parameters of the message.
* @param[in] dest_id ID of the receiving task instance (TASK_GAP).
* @param[in] src_id ID of the sending task instance.
*
* @return If the message was consumed or not.
****************************************************************************************
*/
int accel_msg_handler(ke_msg_id_t const msgid,
struct accel_create_db_cfm const *param,
ke_task_id_t const dest_id,
ke_task_id_t const src_id)
{
// If state is not idle, ignore the message
if (ke_state_get(dest_id) == APP_CONNECTABLE)
app_adv_start();
return (KE_MSG_CONSUMED);
}
/**
****************************************************************************************
* @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);
}
}
}
void cpps_send_cmp_evt(uint8_t src_id, uint8_t dest_id, uint16_t conhdl,
uint8_t operation, uint8_t status)
{
// Go back to the Connected state if the state is busy
if ((ke_state_get(src_id) == CPPS_BUSY)
|| (ke_state_get(src_id) == CPPS_WAIT_FOR_CFM))
{
ke_state_set(src_id, CPPS_CONNECTED);
}
// Set the operation code
cpps_env.operation = CPPS_RESERVED_OP_CODE;
// Send the message
struct cpps_cmp_evt *evt = KE_MSG_ALLOC(CPPS_CMP_EVT,
dest_id, src_id,
cpps_cmp_evt);
evt->conhdl = conhdl;
evt->operation = operation;
evt->status = status;
ke_msg_send(evt);
}
/**
****************************************************************************************
* @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 Sample128 profile database creation confirmation.
*
* @param[in] msgid Id of the message received.
* @param[in] param Pointer to the parameters of the message.
* @param[in] dest_id ID of the receiving task instance .
* @param[in] src_id ID of the sending task instance.
*
* @return If the message was consumed or not.
****************************************************************************************
*/
int sample128_create_db_cfm_handler(ke_msg_id_t const msgid,
struct sample128_create_db_cfm const *param,
ke_task_id_t const dest_id,
ke_task_id_t const src_id)
{
// If state is not idle, ignore the message
if (ke_state_get(dest_id) == APP_DB_INIT)
{
// Inform the Application Manager
struct app_module_init_cmp_evt *cfm = KE_MSG_ALLOC(APP_MODULE_INIT_CMP_EVT,
TASK_APP, TASK_APP,
app_module_init_cmp_evt);
cfm->status = param->status;
ke_msg_send(cfm);
}
return (KE_MSG_CONSUMED);
}
/**
****************************************************************************************
* @brief Handles connection complete event from the GAP. Will enable profile.
*
* @param[in] msgid Id of the message received.
* @param[in] param Pointer to the parameters of the message.
* @param[in] dest_id ID of the receiving task instance (TASK_GAP).
* @param[in] src_id ID of the sending task instance.
*
* @return If the message was consumed or not.
****************************************************************************************
*/
int gapc_connection_req_ind_handler(ke_msg_id_t const msgid,
struct gapc_connection_req_ind const *param,
ke_task_id_t const dest_id,
ke_task_id_t const src_id)
{
// Connection Index
if (ke_state_get(dest_id) == APP_CONNECTABLE)
{
app_env.conidx = KE_IDX_GET(src_id);
if (app_env.conidx != GAP_INVALID_CONIDX)
{
//Disable timer of the establishment of the connection
ke_timer_clear(APP_CONN_TIMER, TASK_APP);
ke_state_set(dest_id, APP_CONNECTED);
app_connection_func(param);
// Retrieve the connection info from the parameters
app_env.conhdl = param->conhdl;
app_env.peer_addr_type = param->peer_addr_type;
memcpy(app_env.peer_addr.addr, param->peer_addr.addr, BD_ADDR_LEN);
// send connection confirmation // 发送连接确认aiwesky 20151004
app_connect_confirm(GAP_AUTH_REQ_NO_MITM_NO_BOND);
// Start param update
app_param_update_start(); // 此时，就可以进行profile读取了 aiwesky 20151004
}
else
{
// No connection has been establish, restart advertising
app_adv_start(); // 如果没有连接，则继续进行广播 aiwesky 20151005
}
}
else
{
// APP_CONNECTABLE state is used to wait the GAP_LE_CREATE_CONN_REQ_CMP_EVT message
ASSERT_ERR(0);
}
return (KE_MSG_CONSUMED);
}
/**
****************************************************************************************
* @brief Handles connection complete event from the GAP. Will enable profile.
*
* @param[in] msgid Id of the message received.
* @param[in] param Pointer to the parameters of the message.
* @param[in] dest_id ID of the receiving task instance (TASK_GAP).
* @param[in] src_id ID of the sending task instance.
*
* @return If the message was consumed or not.
****************************************************************************************
*/
int gapc_connection_req_ind_handler(ke_msg_id_t const msgid,
struct gapc_connection_req_ind const *param,
ke_task_id_t const dest_id,
ke_task_id_t const src_id)
{
// Connection Index
if (ke_state_get(dest_id) == APP_CONNECTABLE) {
app_env.conidx = KE_IDX_GET(src_id);
app_connection_func(param);
}
else {
// APP_CONNECTABLE state is used to wait the GAP_LE_CREATE_CONN_REQ_CMP_EVT message
ASSERT_ERR(0);
}
return (KE_MSG_CONSUMED);
}
/**
****************************************************************************************
* @brief This function handles the disconnection and also restarts the advertising or scanning
*
* @param[in] task_id Destination task id.
* @param[in] param Pointer to the parameters of the message.
*
* @return void
****************************************************************************************
*/
void app_disconnect_func(ke_task_id_t task_id, struct gapc_disconnect_ind const *param)
{
uint8_t state = ke_state_get(task_id);
if ((param->reason != CO_ERROR_REMOTE_USER_TERM_CON) && (param->reason != CO_ERROR_CON_TERM_BY_LOCAL_HOST))
{
app_reset_app(); // link loss (timer timeout) //reset higher layers
// Reset the environment **this is important because otherwise the profile att database will not be re-initiated**
memset(&app_env, 0, sizeof(app_env));
// Initialize next_prf_init value for first service to add in the database
app_env.next_prf_init = APP_PRF_LIST_START + 1;
}
else
{
app_scanning(); // both devices are disconnected correctly
}
}
void app_neb_msg_rx_stop(struct app_neb_msg_stop* msg)
{
uint8_t status = NEB_ERR_SUCCESS;
// Check parameters
switch (msg->reason)
{
case NEB_MSG_STOP_REASON_USER:
case NEB_MSG_STOP_REASON_LOW_BATT:
case NEB_MSG_STOP_REASON_AUTO:
break;
default:
{
status = NEB_ERR_INVALID_PARAMS;
}
break;
}
if ((status == NEB_ERR_SUCCESS) && (ke_state_get(TASK_APP_NEB) == APP_NEB_CONNECTED))
{
// Allocate message to profile
struct nbps_neb_record_send_req *req = KE_MSG_ALLOC(NBPS_NEB_RECORD_SEND_REQ,
TASK_NBPS, TASK_APP_NEB,
nbps_neb_record_send_req);
req->conhdl = app_neb_env.conhdl;
req->neb_rec.neb_id = app_neb_env.curr_neb_id;
req->neb_rec.rec_id = app_neb_env.next_rec_id;
req->neb_rec.flags = NEB_REC_STOP_FLAG;
// Parameters
req->neb_rec.reason = msg->reason;
// Get absolute time stamp
app_neb_insert_abs_time(req);
ke_msg_send(req);
// Increment record ID
app_neb_env.next_rec_id++;
}
// Confirm the message
app_neb_msg_tx_confirm_basic(NEB_MSG_ID_STOP, status);
}
void prf_client_enable_error(prf_env_struct ***p_envs, ke_task_id_t prf_task_id,
ke_state_t disc_state, ke_state_t idle_state)
{
/* An error has been raised, three possibilities:
* - Either the state is IDLE, no environment has been created, nothing to do,
* - Or the state is DISCOVERING, we need to come back to the IDLE state and to remove the
* environment,
* - Or the state is CONNECTED, the profile was already connected for the provided connection,
* nothing to do
*/
if (ke_state_get(prf_task_id) == disc_state)
{
// Come back to IDLE State
ke_state_set(prf_task_id, idle_state);
// Remove the allocated environment
prf_client_disable(p_envs, KE_IDX_GET(prf_task_id));
}
}
/**
****************************************************************************************
* @brief Handles measurement interval start indication from the Health Thermometer
* profile.
* Start or stop a timer following the value of the param intv.
*
* @param[in] msgid Id of the message received.
* @param[in] param Pointer to the parameters of the message.
* @param[in] dest_id ID of the receiving task instance (TASK_GAP).
* @param[in] src_id ID of the sending task instance.
*
* @return If the message was consumed or not.
****************************************************************************************
*/
static int htpt_meas_intv_chg_ind_handler(ke_msg_id_t const msgid,
struct htpt_meas_intv_chg_ind const *param,
ke_task_id_t const dest_id,
ke_task_id_t const src_id)
{
if (ke_state_get(dest_id) == APP_HT_CONNECTED)
{
// Store the received Measurement Interval value
app_ht_env.htpt_meas_intv = param->intv;
// Check the new Measurement Interval Value
if (app_ht_env.htpt_meas_intv != 0)
{
// Check if a Timer already exists
if (!app_ht_env.timer_enable)
{
// Set a Timer
ke_timer_set(APP_HT_TIMER, TASK_APP_HT, app_ht_env.htpt_meas_intv*100);
app_ht_env.timer_enable = true;
}
else
{
// Clear the previous timer
ke_timer_clear(APP_HT_TIMER, TASK_APP_HT);
// Create a new timer with the received measurement interval
ke_timer_set(APP_HT_TIMER, TASK_APP_HT, app_ht_env.htpt_meas_intv*100);
}
}
else
{
// Check if a Timer exists
if (app_ht_env.timer_enable)
{
// Measurement Interval is 0, clear the timer
ke_timer_clear(APP_HT_TIMER, TASK_APP_HT);
app_ht_env.timer_enable = false;
}
}
}
return (KE_MSG_CONSUMED);
}
/*
* Name : app_hid_timer_handler - Handler of the HID Timer
*
* Scope : PUBLIC
*
* Arguments : <various>
*
* Description : Sends a Connection Parameters Update Request to the Host
*
* Returns : KE_MSG_CONSUMED
*
*/
int app_hid_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)
{
// arch_puts("app_hid_timer_handler()\r\n");
ke_state_t app_state = ke_state_get(TASK_APP);
// Modify Conn Params
if (app_state == APP_SECURITY || app_state == APP_PARAM_UPD || app_state == APP_CONNECTED)
{
struct gapc_param_update_cmd * req = KE_MSG_ALLOC(GAPC_PARAM_UPDATE_CMD, TASK_GAPC, TASK_APP, gapc_param_update_cmd);
req->operation = GAPC_UPDATE_PARAMS;
// Fill in the parameter structure
req->params.intv_min = 8; // N * 1.25ms
req->params.intv_max = 8; // N * 1.25ms
req->params.latency = 23; // Conn Events skipped
req->params.time_out = 200; // N * 10ms
arch_puts("Send GAP_PARAM_UPDATE_REQ\r\n");
ke_msg_send(req);
ke_state_set(TASK_APP, APP_PARAM_UPD);
}
// Keyboard test can start here!
uint32_t press = 100000; // 100 msec
uint32_t release = 235000; // 235 msec
uint32_t press_incr = 0; // 0 usec
uint32_t release_incr = 10; // 10 usec
uint32_t limit = 275000; // 275 msec
if ( !start_kbd_single_test(press, press_incr, release, release_incr, limit) ) {
arch_puts("### Failed to start test!\r\n");
} else {
arch_printf("### Started test (press: %d, incr: %d, release: %d, incr: %d, limit: %d)\r\n",
press, press_incr, release, release_incr, limit);
}
return (KE_MSG_CONSUMED);
}
/**
****************************************************************************************
* @brief Handles ready indication from the GAP. - Reset the stack
*
* @param[in] msgid Id of the message received.
* @param[in] param Pointer to the parameters of the message.
* @param[in] dest_id ID of the receiving task instance (TASK_GAP).
* @param[in] src_id ID of the sending task instance.
*
* @return If the message was consumed or not.
****************************************************************************************
*/
int gapm_device_ready_ind_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 (ke_state_get(dest_id) == APP_DISABLED) {
// reset the lower layers.
struct gapm_reset_cmd* cmd = KE_MSG_ALLOC(GAPM_RESET_CMD, TASK_GAPM, TASK_APP,
gapm_reset_cmd);
cmd->operation = GAPM_RESET;
ke_msg_send(cmd);
}
else {
// APP_DISABLED state is used to wait the GAP_READY_EVT message
ASSERT_ERR(0);
}
return (KE_MSG_CONSUMED);
}
static int htpt_disable_ind_handler(ke_msg_id_t const msgid,
struct htpt_disable_ind const *param,
ke_task_id_t const dest_id,
ke_task_id_t const src_id)
{
if (ke_state_get(dest_id) == APP_HT_CONNECTED)
{
// Stop the Health Thermometer timer if enabled
if (app_ht_env.timer_enable)
{
ke_timer_clear(APP_HT_TIMER, TASK_APP_HT);
app_ht_env.timer_enable = false;
}
// Go to Idle state
ke_state_set(TASK_APP_HT, APP_HT_IDLE);
}
return (KE_MSG_CONSUMED);
}
void pasps_send_cmp_evt(ke_task_id_t src_id, ke_task_id_t dest_id, uint16_t conhdl,
uint8_t operation, uint8_t status)
{
// Come back to the Connected state if the state was busy.
if (ke_state_get(src_id) == PASPS_BUSY)
{
ke_state_set(src_id, PASPS_CONNECTED);
}
// Send the message to the application
struct pasps_cmp_evt *evt = KE_MSG_ALLOC(PASPS_CMP_EVT,
dest_id, src_id,
pasps_cmp_evt);
evt->conhdl = conhdl;
evt->operation = operation;
evt->status = status;
ke_msg_send(evt);
}
void app_neb_msg_rx_resp_flow(struct app_neb_msg_resp_flow* msg)
{
uint8_t status = NEB_ERR_SUCCESS;
if(ke_state_get(TASK_APP_NEB) == APP_NEB_CONNECTED)
{
ASSERT_INFO(app_neb_env.resp_flow_sample_nb < NEB_RESP_FLOW_PCK_NB, app_neb_env.resp_flow_sample_nb, NEB_RESP_FLOW_PCK_NB);
// Store sample
app_neb_env.resp_flow_sample_buf[app_neb_env.resp_flow_sample_nb++] = msg->flow;
// Check the buffer size
if(app_neb_env.resp_flow_sample_nb == NEB_RESP_FLOW_PCK_NB)
{
// Allocate message to profile
struct nbps_neb_record_send_req *req = KE_MSG_ALLOC(NBPS_NEB_RECORD_SEND_REQ,
TASK_NBPS, TASK_APP_NEB,
nbps_neb_record_send_req);
req->conhdl = app_neb_env.conhdl;
req->neb_rec.neb_id = app_neb_env.curr_neb_id;
req->neb_rec.rec_id = app_neb_env.next_rec_id;
req->neb_rec.flags = NEB_REC_RESP_RATE_FLAG;
// Parameters
req->neb_rec.nb_resp_rate = NEB_RESP_FLOW_PCK_NB;
memcpy(&req->neb_rec.resp_rate[0], &app_neb_env.resp_flow_sample_buf[0], NEB_RESP_FLOW_PCK_NB * sizeof(uint16_t));
ke_msg_send(req);
// Clear number of samples
app_neb_env.resp_flow_sample_nb = 0;
// Increment record ID
app_neb_env.next_rec_id++;
}
}
// Confirm the message
app_neb_msg_tx_confirm_basic(NEB_MSG_ID_RESP_FLOW, status);
}
/**
****************************************************************************************
* @brief Handles oled display status.
*
* @param[in] msgid APP_OLED_STATE_DISPlAY_TIMER
* @param[in] param Null
* @param[in] dest_id TASK_APP
* @param[in] src_id TASK_NONE
*
* @return If the message was consumed or not.
****************************************************************************************
*/
int app_oled_state_display_timer_handler(ke_msg_id_t const msgid,
void *param,
ke_task_id_t const dest_id,
ke_task_id_t const src_id)
{
// Stop proxr alert
switch(ke_state_get(TASK_APP))
{
case APP_ADV :
{
OLED_ShowString(0,2, (uint8_t *)" ");
OLED_ShowString(0,2,(uint8_t *)" Advertising ");
}break;
case APP_IDLE :
{
if(app_proxr_env->enabled)
{
OLED_ShowString(0,2, (uint8_t *)" ");
OLED_ShowString(0,2,(uint8_t *)" Connected ");
}
else
{
OLED_ShowString(0,2, (uint8_t *)" ");
OLED_ShowString(0,2,(uint8_t *)" unConected ");
}
}break;
case APP_INIT :
{
OLED_ShowString(0,2, (uint8_t *)" ");
OLED_ShowString(0,2,(uint8_t *)" Init! ");
}break;
default :
{
OLED_ShowString(0,2, (uint8_t *)" ");
OLED_ShowString(0,2,(uint8_t *)" Init! ");
}break;
}
return (KE_MSG_CONSUMED);
}
