uint32_t ble_gap_evt_auth_status_enc(ble_evt_t const * const p_event,
uint32_t event_len,
uint8_t * const p_buf,
uint32_t * const p_buf_len)
{
uint32_t index = 0;
uint16_t evt_header = BLE_GAP_EVT_AUTH_STATUS;
uint32_t total_len;
uint32_t err_code = NRF_SUCCESS;
SER_ASSERT_NOT_NULL(p_event);
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_buf_len);
total_len = *p_buf_len;
err_code = uint16_t_enc(&evt_header, p_buf, total_len, &index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = uint16_t_enc(&p_event->evt.gap_evt.conn_handle, p_buf, total_len, &index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = ble_gap_evt_auth_status_t_enc(&p_event->evt.gap_evt.params.auth_status,
p_buf,
total_len,
&index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
*p_buf_len = index;
return err_code;
}
uint32_t ANT_ENABLE_enc(void const * const p_void_enable_params,
uint8_t * const p_buf,
uint32_t buf_len,
uint32_t * const p_index)
{
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_index);
SER_ASSERT_NOT_NULL(p_void_enable_params);
ANT_ENABLE * p_enable_params = (ANT_ENABLE *)p_void_enable_params;
uint32_t err_code = NRF_SUCCESS;
err_code = uint8_t_enc(&p_enable_params->ucTotalNumberOfChannels, p_buf, buf_len, p_index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = uint8_t_enc(&p_enable_params->ucNumberOfEncryptedChannels, p_buf, buf_len, p_index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = uint16_t_enc(&p_enable_params->usNumberOfEvents, p_buf, buf_len, p_index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = uint32_t_enc(&p_enable_params->pucMemoryBlockStartLocation, p_buf, buf_len, p_index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = uint16_t_enc(&p_enable_params->usMemoryBlockByteSize, p_buf, buf_len, p_index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
return err_code;
}
uint32_t ble_gatts_include_add_req_enc(uint16_t service_handle,
uint16_t inc_srvc_handle,
uint16_t * const p_include_handle,
uint8_t * const p_buf,
uint32_t * const p_buf_len)
{
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_buf_len);
SER_ASSERT_LENGTH_LEQ(6, *p_buf_len);
uint32_t index = 0;
uint32_t buf_len = *p_buf_len;
uint32_t err_code;
uint8_t opCode = SD_BLE_GATTS_INCLUDE_ADD;
uint8_t presenceFlag;
err_code = uint8_t_enc(&opCode, p_buf, *p_buf_len, &index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = uint16_t_enc(&service_handle, p_buf, buf_len, &index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = uint16_t_enc(&inc_srvc_handle, p_buf, buf_len, &index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
presenceFlag = (p_include_handle != NULL) ? SER_FIELD_PRESENT : SER_FIELD_NOT_PRESENT;
err_code = uint8_t_enc(&presenceFlag, p_buf, *p_buf_len, &index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
*p_buf_len = index;
return err_code;
}
uint32_t ble_gatts_evt_write_t_enc(void const * const p_void_write,
uint8_t * const p_buf,
uint32_t buf_len,
uint32_t * const p_index)
{
ble_gatts_evt_write_t * p_write = (ble_gatts_evt_write_t *) p_void_write;
uint32_t error_code = NRF_SUCCESS;
error_code = uint16_t_enc(&(p_write->handle), p_buf, buf_len, p_index);
SER_ASSERT(error_code == NRF_SUCCESS, error_code);
error_code = uint8_t_enc(&(p_write->op), p_buf, buf_len, p_index);
SER_ASSERT(error_code == NRF_SUCCESS, error_code);
error_code = ble_gatts_attr_context_t_enc(&(p_write->context), p_buf, buf_len, p_index);
SER_ASSERT(error_code == NRF_SUCCESS, error_code);
error_code = uint16_t_enc(&(p_write->offset), p_buf, buf_len, p_index);
SER_ASSERT(error_code == NRF_SUCCESS, error_code);
uint16_t data_len = p_write->len;
error_code = uint16_t_enc(&data_len, p_buf, buf_len, p_index);
SER_ASSERT(error_code == NRF_SUCCESS, error_code);
SER_ASSERT_LENGTH_LEQ(data_len, buf_len - *p_index);
memcpy(&p_buf[*p_index], p_write->data, data_len);
*p_index += data_len;
return error_code;
}
uint32_t ble_gattc_evt_rel_disc_rsp_enc(ble_evt_t const * const p_event,
uint32_t event_len,
uint8_t * const p_buf,
uint32_t * const p_buf_len)
{
uint32_t index = 0;
uint32_t error_code = NRF_SUCCESS;
uint16_t evt_header = BLE_GATTC_EVT_REL_DISC_RSP;
SER_ASSERT_NOT_NULL(p_event);
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_buf_len);
uint32_t total_len = *p_buf_len;
error_code = uint16_t_enc(&evt_header, p_buf, total_len, &index);
SER_ASSERT(error_code == NRF_SUCCESS, error_code);
error_code = uint16_t_enc(&p_event->evt.gattc_evt.conn_handle, p_buf, total_len, &index);
SER_ASSERT(error_code == NRF_SUCCESS, error_code);
error_code = uint16_t_enc(&p_event->evt.gattc_evt.gatt_status, p_buf, total_len, &index);
SER_ASSERT(error_code == NRF_SUCCESS, error_code);
error_code = uint16_t_enc(&p_event->evt.gattc_evt.error_handle, p_buf, total_len, &index);
SER_ASSERT(error_code == NRF_SUCCESS, error_code);
error_code = ble_gattc_evt_rel_disc_rsp_t_enc(&p_event->evt.gattc_evt.params.rel_disc_rsp,
p_buf,
total_len,
&index);
SER_ASSERT(error_code == NRF_SUCCESS, error_code);
*p_buf_len = index;
return error_code;
}
uint32_t ble_gatts_evt_write_enc(ble_evt_t const * const p_event,
uint32_t event_len,
uint8_t * const p_buf,
uint32_t * const p_buf_len)
{
uint32_t err_code = NRF_SUCCESS;
SER_ASSERT_NOT_NULL(p_event);
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_buf_len);
uint32_t index = 0;
uint32_t total_len = *p_buf_len;
uint16_t evt_header = BLE_GATTS_EVT_WRITE;
err_code = uint16_t_enc(&evt_header, p_buf, total_len, &index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = uint16_t_enc(&(p_event->evt.gatts_evt.conn_handle), p_buf, total_len, &index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = ble_gatts_evt_write_t_enc(&(p_event->evt.gatts_evt.params.write),
p_buf,
total_len,
&index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
*p_buf_len = index;
return err_code;
}
uint32_t ble_gap_evt_disconnected_enc(ble_evt_t const * const p_event,
uint32_t event_len,
uint8_t * const p_buf,
uint32_t * const p_buf_len)
{
SER_ASSERT_NOT_NULL(p_event);
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_buf_len);
uint32_t index = 0;
uint32_t total_len = *p_buf_len;
uint32_t err_code;
uint16_t evt_header = BLE_GAP_EVT_DISCONNECTED;
err_code = uint16_t_enc(&evt_header, p_buf, total_len, &index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = uint16_t_enc((void *)&(p_event->evt.gap_evt.conn_handle), p_buf, total_len, &index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = ble_gap_evt_disconnected_t_enc((void *)&(p_event->evt.gap_evt.params.disconnected),
p_buf,
total_len,
&index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
*p_buf_len = index;
return err_code;
}
uint32_t ble_gap_evt_conn_param_update_enc(ble_evt_t const * const p_event,
uint32_t event_len,
uint8_t * const p_buf,
uint32_t * const p_buf_len)
{
SER_ASSERT_NOT_NULL(p_event);
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_buf_len);
SER_ASSERT(p_event->header.evt_id == BLE_GAP_EVT_CONN_PARAM_UPDATE, NRF_ERROR_INVALID_PARAM);
uint32_t index = 0;
uint32_t total_len = *p_buf_len;
uint32_t err_code = NRF_SUCCESS;
err_code = uint16_t_enc(&p_event->header.evt_id, p_buf, total_len, &index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = uint16_t_enc(&p_event->evt.gap_evt.conn_handle, p_buf, total_len, &index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = ble_gap_evt_conn_param_update_t_enc(&p_event->evt.gap_evt.params.conn_param_update,
p_buf,
total_len,
&index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
*p_buf_len = index;
return err_code;
}
uint32_t ble_gatts_attr_enc(void const * const p_void_gatts_attr,
uint8_t * const p_buf,
uint32_t buf_len,
uint32_t * const p_index)
{
uint32_t err_code = NRF_SUCCESS;
ble_gatts_attr_t * p_gatts_attr = (ble_gatts_attr_t *)p_void_gatts_attr;
err_code = cond_field_enc((void *)p_gatts_attr->p_uuid, p_buf, buf_len, p_index, ble_uuid_t_enc);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = cond_field_enc((void *)p_gatts_attr->p_attr_md,
p_buf,
buf_len,
p_index,
ble_gatts_attr_md_enc);
SER_ERROR_CHECK(err_code == NRF_SUCCESS, err_code);
err_code = uint16_t_enc(&p_gatts_attr->init_offs, p_buf, buf_len, p_index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = uint16_t_enc(&p_gatts_attr->max_len, p_buf, buf_len, p_index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
SER_ERROR_CHECK(p_gatts_attr->init_len <= BLE_GATTS_VAR_ATTR_LEN_MAX, NRF_ERROR_INVALID_PARAM);
//init len move just before p_data to be able to use len16data decoder.
err_code = len16data_enc(p_gatts_attr->p_value, p_gatts_attr->init_len, p_buf, buf_len, p_index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
return err_code;
}
uint32_t ble_gatts_evt_rw_authorize_request_enc(ble_evt_t const * const p_event,
uint32_t event_len,
uint8_t * const p_buf,
uint32_t * const p_buf_len)
{
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_buf_len);
SER_ASSERT_NOT_NULL(p_event);
uint32_t index = 0;
uint32_t total_len = *p_buf_len;
uint32_t err_code = NRF_SUCCESS;
err_code = uint16_t_enc(&p_event->header.evt_id, p_buf, total_len, &index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = uint16_t_enc(&(p_event->evt.gatts_evt.conn_handle), p_buf, total_len, &index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = ble_gatts_evt_rw_authorize_request_t_enc(
&(p_event->evt.gatts_evt.params.authorize_request),
p_buf, total_len, &index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
*p_buf_len = index;
return err_code;
}
uint32_t ble_gattc_write_params_t_enc(void const * const p_void_write,
uint8_t * const p_buf,
uint32_t buf_len,
uint32_t * const p_index)
{
SER_ASSERT_NOT_NULL(p_void_write);
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_index);
uint32_t err_code = NRF_SUCCESS;
ble_gattc_write_params_t * p_write = (ble_gattc_write_params_t *)p_void_write;
err_code = uint8_t_enc(&(p_write->write_op), p_buf, buf_len, p_index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = uint8_t_enc(&(p_write->flags), p_buf, buf_len, p_index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = uint16_t_enc(&(p_write->handle), p_buf, buf_len, p_index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = uint16_t_enc(&(p_write->offset), p_buf, buf_len, p_index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = len16data_enc(p_write->p_value, p_write->len, p_buf, buf_len, p_index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
return err_code;
}
uint32_t ble_gattc_hv_confirm_req_enc(uint16_t conn_handle,
uint16_t handle,
uint8_t * const p_buf,
uint32_t * const p_buf_len)
{
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_buf_len);
uint8_t op_code = SD_BLE_GATTC_HV_CONFIRM;
uint32_t err_code = NRF_SUCCESS;
uint32_t buf_len = *p_buf_len;
uint32_t index = 0;
err_code = uint8_t_enc(&op_code, p_buf, buf_len, &index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = uint16_t_enc(&conn_handle, p_buf, buf_len, &index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = uint16_t_enc(&handle, p_buf, buf_len, &index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
*p_buf_len = index;
return NRF_SUCCESS;
}
uint32_t ble_gattc_evt_char_val_by_uuid_read_rsp_t_enc(void const * const p_void_struct,
uint8_t * const p_buf,
uint32_t buf_len,
uint32_t * const p_index)
{
ble_gattc_evt_char_val_by_uuid_read_rsp_t * p_read =
(ble_gattc_evt_char_val_by_uuid_read_rsp_t *) p_void_struct;
uint32_t err_code = NRF_SUCCESS;
err_code = uint16_t_enc(&(p_read->count), p_buf, buf_len, p_index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = uint16_t_enc(&(p_read->value_len), p_buf, buf_len, p_index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
uint32_t i;
ble_gattc_handle_value_t * p_handle_value = &p_read->handle_value[0];
for (i = 0; i < p_read->count; i++)
{
err_code = uint16_t_enc(&(p_handle_value->handle), p_buf, buf_len, p_index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
SER_ASSERT_LENGTH_LEQ(p_read->value_len, buf_len - *p_index);
memcpy(&p_buf[*p_index], p_handle_value->p_value, p_read->value_len);
*p_index += p_read->value_len;
p_handle_value++;
}
return err_code;
}
uint32_t ble_gap_evt_scan_req_report_enc(ble_evt_t const * const p_event,
uint32_t event_len,
uint8_t * const p_buf,
uint32_t * const p_buf_len)
{
SER_ASSERT_NOT_NULL(p_event);
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_buf_len);
uint32_t index = 0;
uint32_t total_len = *p_buf_len;
uint32_t err_code = NRF_SUCCESS;
const uint16_t evt_header = BLE_GAP_EVT_SCAN_REQ_REPORT;
err_code = uint16_t_enc((void *)&evt_header, p_buf, total_len, &index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = uint16_t_enc((void *)&p_event->evt.gap_evt.conn_handle, p_buf, total_len, &index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = ble_gap_addr_enc((void *)&(p_event->evt.gap_evt.params.scan_req_report.peer_addr), p_buf, total_len, &index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = uint8_t_enc((void *)&(p_event->evt.gap_evt.params.scan_req_report.rssi), p_buf, total_len, &index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
*p_buf_len = index;
return err_code;
}
uint32_t ble_gap_evt_sec_info_request_enc(ble_evt_t const * const p_event,
uint32_t event_len,
uint8_t * const p_buf,
uint32_t * const p_buf_len)
{
SER_ASSERT_NOT_NULL(p_event);
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_buf_len);
uint32_t index = 0;
uint32_t total_len = *p_buf_len;
uint32_t err_code = NRF_SUCCESS;
const uint16_t evt_header = BLE_GAP_EVT_SEC_INFO_REQUEST;
err_code = uint16_t_enc((void *)&evt_header, p_buf, total_len, &index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = uint16_t_enc((void *)&p_event->evt.gap_evt.conn_handle, p_buf, total_len, &index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = ble_gap_evt_sec_info_request_t_enc(
(void *)&p_event->evt.gap_evt.params.sec_info_request,
p_buf,
total_len,
&index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
*p_buf_len = index;
return err_code;
}
uint32_t ser_ble_gatts_char_pf_enc(void const * const p_void_char_pf,
uint8_t * const p_buf,
uint32_t buf_len,
uint32_t * const p_index)
{
ble_gatts_char_pf_t * p_char_pf = (ble_gatts_char_pf_t *)p_void_char_pf;
uint32_t err_code = NRF_SUCCESS;
err_code = uint8_t_enc(&p_char_pf->format, p_buf, buf_len, p_index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = uint8_t_enc(&p_char_pf->exponent, p_buf, buf_len, p_index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = uint16_t_enc(&p_char_pf->unit, p_buf, buf_len, p_index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = uint8_t_enc(&p_char_pf->name_space, p_buf, buf_len, p_index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = uint16_t_enc(&p_char_pf->desc, p_buf, buf_len, p_index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
return err_code;
}
uint32_t ble_gap_lesc_dhkey_reply_req_enc(uint16_t conn_handle,
ble_gap_lesc_dhkey_t const *p_dhkey,
uint8_t * const p_buf,
uint32_t * const p_buf_len)
{
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_buf_len);
uint8_t op_code = SD_BLE_GAP_LESC_DHKEY_REPLY;
uint32_t err_code = NRF_SUCCESS;
uint32_t buf_len = *p_buf_len;
uint32_t index = 0;
err_code = uint8_t_enc(&op_code, p_buf, buf_len, &index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = uint16_t_enc(&conn_handle, p_buf, buf_len, &index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = cond_field_enc(p_dhkey, p_buf, buf_len, &index, ble_gap_lesc_dhkey_t_enc);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
*p_buf_len = index;
return err_code;
}
uint32_t ble_gap_sec_params_reply_req_enc(uint16_t conn_handle,
uint8_t sec_status,
ble_gap_sec_params_t const * const p_sec_params,
ble_gap_sec_keyset_t const * const p_sec_keyset,
uint8_t * const p_buf,
uint32_t * const p_buf_len)
{
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_buf_len);
uint8_t op_code = SD_BLE_GAP_SEC_PARAMS_REPLY;
uint32_t err_code = NRF_SUCCESS;
uint32_t buf_len = *p_buf_len;
uint32_t index = 0;
err_code = uint8_t_enc(&op_code, p_buf, buf_len, &index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = uint16_t_enc(&conn_handle, p_buf, buf_len, &index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = uint8_t_enc(&sec_status, p_buf, buf_len, &index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = cond_field_enc(p_sec_params, p_buf, buf_len, &index, ble_gap_sec_params_t_enc);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = cond_field_enc(p_sec_keyset, p_buf, buf_len, &index, ble_gap_sec_keyset_t_enc);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
*p_buf_len = index;
return err_code;
}
uint32_t ble_gattc_handle_range_t_enc(void const * const p_void_struct,
uint8_t * const p_buf,
uint32_t buf_len,
uint32_t * const p_index)
{
ble_gattc_handle_range_t * p_range = (ble_gattc_handle_range_t *) p_void_struct;
uint32_t err_code = NRF_SUCCESS;
err_code = uint16_t_enc(&(p_range->start_handle), p_buf, buf_len, p_index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = uint16_t_enc(&(p_range->end_handle), p_buf, buf_len, p_index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
return err_code;
}
uint32_t ble_gap_rssi_start_req_enc(uint16_t conn_handle,
uint8_t threshold_dbm,
uint8_t skip_count,
uint8_t * const p_buf,
uint32_t * const p_buf_len)
{
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_buf_len);
uint8_t op_code = SD_BLE_GAP_RSSI_START;
uint32_t err_code = NRF_SUCCESS;
uint32_t buf_len = *p_buf_len;
uint32_t index = 0;
err_code = uint8_t_enc(&op_code, p_buf, buf_len, &index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = uint16_t_enc(&conn_handle, p_buf, buf_len, &index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = uint8_t_enc(&threshold_dbm, p_buf, buf_len, &index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = uint8_t_enc(&skip_count, p_buf, buf_len, &index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
*p_buf_len = index;
return err_code;
}
uint32_t ble_gatts_service_add_rsp_enc(uint32_t return_code,
uint8_t * const p_buf,
uint32_t * const p_buf_len,
uint16_t const * const p_handle)
{
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_buf_len);
uint32_t buf_len = *p_buf_len;
uint32_t index = 0;
uint32_t err_code;
err_code = op_status_enc(SD_BLE_GATTS_SERVICE_ADD, return_code, p_buf, p_buf_len, &index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
if (return_code != NRF_SUCCESS)
{
return NRF_SUCCESS; //this seems silly but it is not
}
SER_ASSERT_NOT_NULL(p_handle);
err_code = uint16_t_enc(p_handle, p_buf, buf_len, &index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
*p_buf_len = index; //update change made by op_status_enc
return err_code;
}
uint32_t ble_l2cap_tx_req_enc(uint16_t conn_handle,
ble_l2cap_header_t const * const p_l2cap_header,
uint8_t const * const p_data,
uint8_t * const p_buf,
uint32_t * const p_buf_len)
{
uint32_t index = 0;
uint32_t err_code = NRF_SUCCESS;
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_buf_len);
SER_ASSERT_LENGTH_LEQ(1, *p_buf_len);
p_buf[index++] = SD_BLE_L2CAP_TX;
err_code = uint16_t_enc(&conn_handle, p_buf, *p_buf_len, &index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = cond_field_enc(p_l2cap_header, p_buf, *p_buf_len, &index, ble_l2cap_header_t_enc);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
if (p_l2cap_header != NULL)
{
err_code = buf_enc(p_data, p_l2cap_header->len, p_buf, *p_buf_len, &index);
}
else
{
err_code = buf_enc(NULL, 0, p_buf, *p_buf_len, &index);
}
*p_buf_len = index;
return err_code;
}
uint32_t ble_gatts_rw_authorize_reply_req_enc(
uint16_t conn_handle,
ble_gatts_rw_authorize_reply_params_t const * const
p_reply_params,
uint8_t * const
p_buf,
uint32_t * const
p_buf_len)
{
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_buf_len);
uint32_t index = 0;
uint32_t buf_len = *p_buf_len;
uint8_t opcode = SD_BLE_GATTS_RW_AUTHORIZE_REPLY;
uint32_t err_code = NRF_SUCCESS;
err_code = uint8_t_enc(&opcode, p_buf, buf_len, &index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = uint16_t_enc(&conn_handle, p_buf, buf_len, &index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = cond_field_enc(p_reply_params, p_buf, buf_len, &index,
ble_gatts_rw_authorize_reply_params_t_enc);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
*p_buf_len = index;
return err_code;
}
uint32_t ble_gatts_attr_get_req_enc(uint16_t handle,
ble_uuid_t * p_uuid,
ble_gatts_attr_md_t * p_md,
uint8_t * const p_buf,
uint32_t * p_buf_len)
{
uint32_t index = 0;
uint32_t err_code = NRF_SUCCESS;
uint32_t total_len = *p_buf_len;
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_buf_len);
p_buf[index++] = SD_BLE_GATTS_ATTR_GET;
err_code = uint16_t_enc(&handle, p_buf, total_len, &index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = cond_field_enc(p_uuid, p_buf, total_len, &index, ble_uuid_t_enc);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = cond_field_enc(p_md, p_buf, total_len, &index, NULL);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
*p_buf_len = index;
return NRF_SUCCESS;
}
uint32_t ble_gatts_char_md_enc(void const * const p_void_char_md,
uint8_t * const p_buf,
uint32_t buf_len,
uint32_t * const p_index)
{
uint32_t err_code = NRF_SUCCESS;
ble_gatts_char_md_t * p_char_md = (ble_gatts_char_md_t *)p_void_char_md;
uint8_t temp8;
temp8 = p_char_md->char_props.broadcast |
(p_char_md->char_props.read << 1) |
(p_char_md->char_props.write_wo_resp << 2) |
(p_char_md->char_props.write << 3) |
(p_char_md->char_props.notify << 4) |
(p_char_md->char_props.indicate << 5) |
(p_char_md->char_props.auth_signed_wr << 6);
err_code = uint8_t_enc(&temp8, p_buf, buf_len, p_index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
temp8 = p_char_md->char_ext_props.reliable_wr |
(p_char_md->char_ext_props.wr_aux << 1);
err_code = uint8_t_enc(&temp8, p_buf, buf_len, p_index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = uint16_t_enc(&p_char_md->char_user_desc_max_size, p_buf, buf_len, p_index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
SER_ERROR_CHECK(p_char_md->char_user_desc_size <= BLE_GATTS_VAR_ATTR_LEN_MAX,
NRF_ERROR_INVALID_PARAM);
err_code = len16data_enc(p_char_md->p_char_user_desc, p_char_md->char_user_desc_size, p_buf,
buf_len, p_index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = cond_field_enc(p_char_md->p_char_pf,
p_buf,
buf_len,
p_index,
ser_ble_gatts_char_pf_enc);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = cond_field_enc(p_char_md->p_user_desc_md,
p_buf,
buf_len,
p_index,
ble_gatts_attr_md_enc);
SER_ERROR_CHECK(err_code == NRF_SUCCESS, err_code);
err_code = cond_field_enc(p_char_md->p_cccd_md, p_buf, buf_len, p_index, ble_gatts_attr_md_enc);
SER_ERROR_CHECK(err_code == NRF_SUCCESS, err_code);
err_code = cond_field_enc(p_char_md->p_sccd_md, p_buf, buf_len, p_index, ble_gatts_attr_md_enc);
SER_ERROR_CHECK(err_code == NRF_SUCCESS, err_code);
return err_code;
}
uint32_t ble_gap_adv_start_req_enc(ble_gap_adv_params_t const * const p_adv_params,
uint8_t * const p_buf,
uint32_t * const p_buf_len)
{
uint32_t index = 0;
uint32_t err_code = NRF_SUCCESS;
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_buf_len);
uint32_t total_len = *p_buf_len;
SER_ASSERT_LENGTH_LEQ(index + 2, total_len);
p_buf[index++] = SD_BLE_GAP_ADV_START;
p_buf[index++] = (p_adv_params == NULL) ? SER_FIELD_NOT_PRESENT : SER_FIELD_PRESENT;
if (p_adv_params != NULL)
{
err_code = uint8_t_enc(&(p_adv_params->type), p_buf, total_len, &index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = cond_field_enc(p_adv_params->p_peer_addr, p_buf, total_len, &index, ble_gap_addr_enc);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = uint8_t_enc(&(p_adv_params->fp), p_buf, total_len, &index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = cond_field_enc(p_adv_params->p_whitelist, p_buf, total_len, &index, ble_gap_whitelist_t_enc);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = uint16_t_enc(&(p_adv_params->interval), p_buf, total_len, &index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = uint16_t_enc(&(p_adv_params->timeout), p_buf, total_len, &index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = ble_gap_adv_ch_mask_t_enc(&(p_adv_params->channel_mask), p_buf, total_len, &index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
}
*p_buf_len = index;
return err_code;
}
uint32_t ble_gatts_evt_write_enc(ble_evt_t const * const p_event,
uint32_t event_len,
uint8_t * const p_buf,
uint32_t * const p_buf_len)
{
uint32_t err_code = NRF_SUCCESS;
SER_ASSERT_NOT_NULL(p_event);
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_buf_len);
uint32_t index = 0;
uint32_t total_len = *p_buf_len;
uint16_t evt_header = BLE_GATTS_EVT_WRITE;
err_code = uint16_t_enc(&evt_header, p_buf, total_len, &index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = uint16_t_enc(&(p_event->evt.gatts_evt.conn_handle), p_buf, total_len, &index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = ble_gatts_evt_write_t_enc(&(p_event->evt.gatts_evt.params.write),
p_buf,
total_len,
&index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
if(p_event->evt.gatts_evt.params.write.op == BLE_GATTS_OP_EXEC_WRITE_REQ_NOW)
{
uint32_t conn_index;
if(conn_ble_user_mem_context_find(p_event->evt.gatts_evt.conn_handle, &conn_index) != NRF_ERROR_NOT_FOUND)
{
err_code = len16data_enc(m_conn_user_mem_table[conn_index].mem_block.p_mem, m_conn_user_mem_table[conn_index].mem_block.len, p_buf, *p_buf_len, &index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
}
}
*p_buf_len = index;
return err_code;
}
uint32_t ble_gatts_value_t_enc(void const * const p_void_struct,
uint8_t * const p_buf,
uint32_t buf_len,
uint32_t * const p_index)
{
ble_gatts_value_t * p_value = (ble_gatts_value_t *)p_void_struct;
uint32_t err_code = NRF_SUCCESS;
err_code = uint16_t_enc((void *) &(p_value->len), p_buf, buf_len, p_index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = uint16_t_enc((void *) &(p_value->offset), p_buf, buf_len, p_index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = buf_enc(p_value->p_value, p_value->len, p_buf, buf_len, p_index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
return err_code;
}
uint32_t ble_l2cap_header_t_enc(void const * const p_void_header,
uint8_t * const p_buf,
uint32_t buf_len,
uint32_t * const p_index)
{
SER_ASSERT_NOT_NULL(p_buf);
SER_ASSERT_NOT_NULL(p_index);
SER_ASSERT_NOT_NULL(p_void_header);
ble_l2cap_header_t * p_header = (ble_l2cap_header_t *)p_void_header;
uint32_t err_code = NRF_SUCCESS;
err_code = uint16_t_enc(&(p_header->len), p_buf, buf_len, p_index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = uint16_t_enc(&(p_header->cid), p_buf, buf_len, p_index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
return err_code;
}
uint32_t ble_gatts_hvx_params_t_enc(void const * const p_void_hvx_params,
uint8_t * const p_buf,
uint32_t buf_len,
uint32_t * const p_index)
{
ble_gatts_hvx_params_t * p_hvx_params = (ble_gatts_hvx_params_t *)p_void_hvx_params;
uint32_t err_code = NRF_SUCCESS;
SER_ASSERT_LENGTH_LEQ(2 + 1 + 2, buf_len - *p_index);
err_code = uint16_t_enc(&p_hvx_params->handle, p_buf, buf_len, p_index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = uint8_t_enc(&p_hvx_params->type, p_buf, buf_len, p_index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
err_code = uint16_t_enc(&p_hvx_params->offset, p_buf, buf_len, p_index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
if (p_hvx_params->p_len != NULL)
{
SER_ASSERT_LENGTH_LEQ(1, buf_len - *p_index);
p_buf[(*p_index)++] = SER_FIELD_PRESENT;
err_code = uint16_t_enc(p_hvx_params->p_len, p_buf, buf_len, p_index);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
}
if (p_hvx_params->p_data != NULL)
{
SER_ASSERT_LENGTH_LEQ(1, buf_len - *p_index);
p_buf[(*p_index)++] = SER_FIELD_PRESENT;
SER_ASSERT_LENGTH_LEQ(*p_hvx_params->p_len, buf_len - *p_index);
memcpy(&p_buf[*p_index], p_hvx_params->p_data, *p_hvx_params->p_len);
*p_index += *p_hvx_params->p_len;
}
return err_code;
}
