void streamdatad_streamonoff(void)
{
uint16_t len = 0;
uint8_t* streamdatad_en = NULL;
attmdb_att_get_value(STREAMDATAD_HANDLE(STREAMDATAD_IDX_ENABLE_VAL), &(len), &(streamdatad_en));
// Indicate to the application the state of the profile
int on = ((len == 2) && (streamdatad_en && (*streamdatad_en))) ? 1 : 0;
if (on)
{
// Allocate the start indication message
struct streamdatad_start_ind *ind = KE_MSG_ALLOC(STREAMDATAD_START_IND,
streamdatad_env.appid, TASK_STREAMDATAD,
streamdatad_start_ind);
streamdatad_env.stream_enabled = (*streamdatad_en);
ind->status = PRF_ERR_OK;
// Send the message
ke_msg_send(ind);
}
else
{
streamdatad_env.next_attribute_idx = 0;
streamdatad_env.stream_enabled = 0;
// Send the stop indication
ke_msg_send_basic(STREAMDATAD_STOP_IND, streamdatad_env.appid, TASK_STREAMDATAD);
}
uint16_t enable_val = streamdatad_en?(*streamdatad_en):0;
// Enable or disable all data notifications
streamdatad_env.nr_enabled_attributes = 0;
int lastattr = enable_val?((STREAMDATAD_MAX>MAX_TRANSMIT_BUFFER_PACKETS)?MAX_TRANSMIT_BUFFER_PACKETS:STREAMDATAD_MAX):STREAMDATAD_MAX;
attmdb_att_set_value(STREAMDATAD_IDX_ENABLE_EN, sizeof(uint16_t),(uint8_t*) &(enable_val));
for (int i = 0; i < lastattr; i++)
{
attmdb_att_set_value(STREAMDATAD_DIR_EN_HANDLE(i), sizeof(uint16_t),(uint8_t*) &(enable_val));
streamdatad_env.nr_enabled_attributes++;
}
if (!enable_val) streamdatad_env.nr_enabled_attributes = 0;
}
void app_disconnect_func(struct gapc_disconnect_ind const *param)
{
#if BLE_ACCEL
//Stop the accelerometer
acc_stop();
// Disable accelerometer profile
ke_msg_send_basic(ACCEL_DISABLE_REQ, TASK_ACCEL, TASK_APP);
// Stop the accelerometer timer
update_conn_params = 0;
ke_timer_clear(APP_ACCEL_TIMER, TASK_APP);
// Set accel advertising interval to initial value
accel_adv_interval = APP_ADV_INT_MIN;
accel_adv_count = 0;
rwip_env.sleep_enable = true;
#endif //(BLE_ACCEL)
}
/**
****************************************************************************************
* @brief Handles reception of the @ref GL2C_CODE_ATT_WR_CMD_IND message.
* The handler compares the new values with current ones and notifies them if they changed.
* @param[in] msgid Id of the message received (probably unused).
* @param[in] param Pointer to the parameters of the message.
* @param[in] dest_id ID of the receiving task instance (probably unused).
* @param[in] src_id ID of the sending task instance.
* @return If the message was consumed or not.
****************************************************************************************
*/
static int gattc_write_cmd_ind_handler(ke_msg_id_t const msgid,
struct gattc_write_cmd_ind const *param,
ke_task_id_t const dest_id,
ke_task_id_t const src_id)
{
// Update the attribute value
attmdb_att_update_value(param->handle, param->length, param->offset,
(uint8_t*)&(param->value[0]));
switch (ACCEL_IDX(param->handle))
{
case ACCEL_IDX_ENABLE_VAL:
{
uint16_t len;
uint8_t* accel_en;
uint8_t* axis_en;
uint8_t* range;
if(*(uint8_t*)&(param->value[0]) > 1)
accel_threshold = *(uint8_t*)&(param->value[0]) - 2;
// set_accel_thr();
attmdb_att_get_value(ACCEL_HANDLE(ACCEL_IDX_ENABLE_VAL), &(len), &(accel_en));
// Indicate to the application the state of the profile
if (accel_en)
{
// Allocate the start indication message
struct accel_start_ind *ind = KE_MSG_ALLOC(ACCEL_START_IND,
accel_env.con_info.appid, dest_id,
accel_start_ind);
// Fill in the parameter structure
for (int i = 0; i < ACCEL_MAX; i++)
{
attmdb_att_get_value(ACCEL_DIR_VAL_HANDLE(i), &(len), &(axis_en));
ind->accel_en[i] = *axis_en;
}
attmdb_att_get_value(ACCEL_HANDLE(ACCEL_IDX_RANGE_VAL), &(len), &(range));
ind->range = *range;
// Send the message
ke_msg_send(ind);
}
else
{
// Send the stop indication
ke_msg_send_basic(ACCEL_STOP_IND, accel_env.con_info.appid, TASK_ACCEL);
}
}
break;
case ACCEL_IDX_ACCEL_DISPLAY1_VAL:
case ACCEL_IDX_ACCEL_DISPLAY2_VAL:
if(*(uint8_t*)&(param->value[0]) == 0xFF)
{
if(param->length > 1 && *(uint8_t*)&(param->value[1]) > 1)
accel_con_interval = *(uint8_t*)&(param->value[1]);
if(param->length > 2 && *(uint8_t*)&(param->value[2]) > 1)
accel_mode = *(uint8_t*)&(param->value[2])-2;
if(param->length > 3 && *(uint8_t*)&(param->value[3]) > 1)
accel_latency = *(uint8_t*)&(param->value[3])-2;
if(param->length > 4 && *(uint8_t*)&(param->value[4]) > 1)
accel_window = *(uint8_t*)&(param->value[4]);
}
{
uint8_t line;
uint16_t len;
uint8_t* display;
struct accel_write_line_ind *ind = KE_MSG_ALLOC(ACCEL_WRITE_LINE_IND,
accel_env.con_info.appid, TASK_ACCEL,
accel_write_line_ind);
line = (param->handle == ACCEL_HANDLE(ACCEL_IDX_ACCEL_DISPLAY1_VAL))?0:1;
attmdb_att_get_value(param->handle, &(len), &(display));
// Fill in the parameter structure
memcpy(ind->text, display, len);
ind->line = line;
// Send the message
ke_msg_send(ind);
}
atts_write_rsp_send(accel_env.con_info.conidx, param->handle, PRF_ERR_OK);
break;
case ACCEL_IDX_ACCEL_X_VAL:
case ACCEL_IDX_ACCEL_X_EN:
if(*(uint8_t*)&(param->value[0]) > 1)
accel_adv_interval1 = *(uint8_t*)&(param->value[0]);
atts_write_rsp_send(accel_env.con_info.conidx, param->handle, PRF_ERR_OK);
break;
case ACCEL_IDX_ACCEL_Y_VAL:
case ACCEL_IDX_ACCEL_Y_EN:
if(*(uint8_t*)&(param->value[0]) > 1)
accel_adv_interval2 = *(uint8_t*)&(param->value[0]);
if(*(uint8_t*)&(param->value[0]) == 255)
accel_adv_interval2 = 0;
atts_write_rsp_send(accel_env.con_info.conidx, param->handle, PRF_ERR_OK);
break;
case ACCEL_IDX_ACCEL_Z_VAL:
case ACCEL_IDX_ACCEL_Z_EN:
if(*(uint8_t*)&(param->value[0]) > 1)
accel_adv_interval3 = *(uint8_t*)&(param->value[0]);
if(*(uint8_t*)&(param->value[0]) == 255)
accel_adv_interval3 = 0;
atts_write_rsp_send(accel_env.con_info.conidx, param->handle, PRF_ERR_OK);
break;
default:
atts_write_rsp_send(accel_env.con_info.conidx, param->handle, PRF_ERR_OK);
break;
}
return (KE_MSG_CONSUMED);
}
