自学教程：C++ tx_buf_alloc函数代码示例

uint32_t sd_ble_uuid_encode(ble_uuid_t const * const p_uuid,                            uint8_t * const          p_uuid_le_len,                            uint8_t * const          p_uuid_le){    uint8_t * p_buffer;    uint32_t  buffer_length;    tx_buf_alloc(&p_buffer, &buffer_length);    m_output_params.ble_uuid_encode_out_params.p_uuid_le_len = p_uuid_le_len;    m_output_params.ble_uuid_encode_out_params.p_uuid_le     = p_uuid_le;    uint32_t err_code = ble_uuid_encode_req_enc(p_uuid,                                                p_uuid_le_len,                                                p_uuid_le,                                                &(p_buffer[1]),                                                &buffer_length);    //@note: Should never fail.    APP_ERROR_CHECK(err_code);    //@note: Increment buffer length as internally managed packet type field must be included.    return ser_sd_transport_cmd_write(p_buffer,                                      (++buffer_length),                                      uuid_encode_rsp_dec);}

uint32_t sd_ble_gap_sec_params_reply(uint16_t                     conn_handle,                                     uint8_t                      sec_status,                                     ble_gap_sec_params_t const * p_sec_params,                                     ble_gap_sec_keyset_t const * p_sec_keyset){    uint8_t * p_buffer;    uint32_t  buffer_length = 0;    uint32_t  sec_tab_index = 0;    uint32_t  err_code      = NRF_SUCCESS;    tx_buf_alloc(&p_buffer, (uint16_t *)&buffer_length);    m_output_params.gap_sec_params_reply_out_params.p_sec_keyset = p_sec_keyset;    m_output_params.gap_sec_params_reply_out_params.conn_handle = conn_handle;    // First allocate security context for serialization    if (p_sec_keyset)    {        err_code = app_ble_gap_sec_context_create(conn_handle, &sec_tab_index);        SER_ASSERT(err_code == NRF_SUCCESS, err_code);        memcpy(&(m_app_keys_table[sec_tab_index].keyset), p_sec_keyset, sizeof(ble_gap_sec_keyset_t));    }    err_code = ble_gap_sec_params_reply_req_enc(conn_handle,                                                               sec_status,                                                               p_sec_params,                                                               p_sec_keyset,                                                               &(p_buffer[1]),                                                               &buffer_length);    APP_ERROR_CHECK(err_code);    //@note: Increment buffer length as internally managed packet type field must be included.    return ser_sd_transport_cmd_write(p_buffer,                                      (++buffer_length),                                      gap_sec_params_reply_rsp_dec);}

uint32_t sd_ble_gatts_value_get(uint16_t         handle,                                uint16_t         offset,                                uint16_t * const p_len,                                uint8_t * const  p_data){    uint8_t * p_buffer;    uint32_t  buffer_length = 0;    tx_buf_alloc(&p_buffer, (uint16_t *)&buffer_length);    mp_out_params[0] = p_len;    mp_out_params[1] = p_data;    const uint32_t err_code = ble_gatts_value_get_req_enc(handle,                                                          offset,                                                          p_len,                                                          p_data,                                                          &(p_buffer[1]),                                                          &buffer_length);    APP_ERROR_CHECK(err_code);    //@note: Increment buffer length as internally managed packet type field must be included.    return ser_sd_transport_cmd_write(p_buffer,                                      (++buffer_length),                                      gatts_value_get_rsp_dec);}

uint32_t sd_ble_gatts_sys_attr_get(uint16_t         conn_handle,                                   uint8_t * const  p_sys_attr_data,                                   uint16_t * const p_len,                                   uint32_t         flags){    uint8_t * p_buffer;    uint32_t  buffer_length = 0;    tx_buf_alloc(&p_buffer, (uint16_t *)&buffer_length);    mp_out_params[0] = p_sys_attr_data;    mp_out_params[1] = p_len;    const uint32_t err_code = ble_gatts_sys_attr_get_req_enc(conn_handle,                              p_sys_attr_data,                              p_len,                              flags,                              &(p_buffer[1]),                              &buffer_length);    //@note: Should never fail.    APP_ERROR_CHECK(err_code);    //@note: Increment buffer length as internally managed packet type field must be included.    return ser_sd_transport_cmd_write(p_buffer,                                      (++buffer_length),                                      gatts_sys_attr_get_rsp_dec);}

uint32_t sd_power_system_off(void){    uint8_t * p_buffer;    uint32_t  buffer_length = 0;    tx_buf_alloc(&p_buffer, (uint16_t *)&buffer_length);    const uint32_t err_code = power_system_off_req_enc(&(p_buffer[1]), &buffer_length);    APP_ERROR_CHECK(err_code);    ser_app_power_system_off_set();    //@note: Increment buffer length as internally managed packet type field must be included.    return ser_sd_transport_cmd_write(p_buffer,                                      (++buffer_length),                                      NULL);}

uint32_t sd_ble_gap_rssi_stop(uint16_t conn_handle){    uint8_t * p_buffer;    uint32_t  buffer_length = 0;    tx_buf_alloc(&p_buffer, (uint16_t *)&buffer_length);    const uint32_t err_code = ble_gap_rssi_stop_req_enc(conn_handle,                                                        &(p_buffer[1]), &buffer_length);    //@note: Should never fail.    APP_ERROR_CHECK(err_code);    //@note: Increment buffer length as internally managed packet type field must be included.    return ser_sd_transport_cmd_write(p_buffer,                                      (++buffer_length),                                      gap_rssi_stop_rsp_dec);}

uint32_t sd_ble_gap_adv_start(ble_gap_adv_params_t const * const p_adv_params){    uint8_t * p_buffer;    uint32_t  buffer_length = 0;    tx_buf_alloc(&p_buffer, (uint16_t *)&buffer_length);    const uint32_t err_code = ble_gap_adv_start_req_enc(p_adv_params,                                                        &(p_buffer[1]),                                                        &buffer_length);    APP_ERROR_CHECK(err_code);    //@note: Increment buffer length as internally managed packet type field must be included.    return ser_sd_transport_cmd_write(p_buffer,                                      (++buffer_length),                                      gap_adv_start_rsp_dec);}

uint32_t sd_ble_gap_address_set(uint8_t addr_cycle_mode, ble_gap_addr_t const * const p_addr){    uint8_t * p_buffer;    uint32_t  buffer_length = 0;    tx_buf_alloc(&p_buffer, (uint16_t *)&buffer_length);    const uint32_t err_code = ble_gap_address_set_req_enc(addr_cycle_mode,                                                          p_addr,                                                          &(p_buffer[1]),                                                          &buffer_length);    //@note: Should never fail.    APP_ERROR_CHECK(err_code);    //@note: Increment buffer length as internally managed packet type field must be included.    return ser_sd_transport_cmd_write(p_buffer,                                      (++buffer_length),                                      gap_address_set_rsp_dec);}

uint32_t sd_ble_uuid_vs_add(ble_uuid128_t const * const p_vs_uuid, uint8_t * const p_uuid_type){    uint8_t * p_buffer;    uint32_t  buffer_length;    tx_buf_alloc(&p_buffer, &buffer_length);    mp_out_params[0] = p_uuid_type;    const uint32_t err_code = ble_uuid_vs_add_req_enc(p_vs_uuid, p_uuid_type,                                                      &(p_buffer[1]),                                                      &buffer_length);    APP_ERROR_CHECK(err_code);    //@note: Increment buffer length as internally managed packet type field must be included.    return ser_sd_transport_cmd_write(p_buffer,                                      (++buffer_length),                                      uuid_vs_add_rsp_dec);}

uint32_t _sd_ble_gattc_attr_info_discover(uint16_t                               conn_handle,                                        ble_gattc_handle_range_t const * const p_handle_range){    uint8_t * p_buffer;    uint32_t  buffer_length = 0;    tx_buf_alloc(&p_buffer, (uint16_t *)&buffer_length);    const uint32_t err_code = ble_gattc_attr_info_discover_req_enc(conn_handle,                                                                   p_handle_range,                                                                   &(p_buffer[1]),                                                                   &buffer_length);    APP_ERROR_CHECK(err_code);    //@note: Increment buffer length as internally managed packet type field must be included.    return ser_sd_transport_cmd_write(p_buffer,                                      (++buffer_length),                                      gattc_attr_info_discover_rsp_dec);}

uint32_t sd_ble_gatts_hvx(uint16_t conn_handle, ble_gatts_hvx_params_t const * const p_hvx_params){    uint8_t * p_buffer;    uint32_t  buffer_length = 0;    tx_buf_alloc(&p_buffer, (uint16_t *)&buffer_length);    mp_out_params[0] = (p_hvx_params) ? p_hvx_params->p_len : NULL;    const uint32_t err_code = ble_gatts_hvx_req_enc(conn_handle,                              p_hvx_params,                              &(p_buffer[1]),                              &buffer_length);    APP_ERROR_CHECK(err_code);    //@note: Increment buffer length as internally managed packet type field must be included.    return ser_sd_transport_cmd_write(p_buffer,                                      (++buffer_length),                                      gatts_hvx_rsp_dec);}

uint32_t sd_ble_enable(ble_enable_params_t * p_params){    uint8_t * p_buffer;    uint32_t  buffer_length;    tx_buf_alloc(&p_buffer, &buffer_length);    mp_out_params[0] = p_params;    const uint32_t err_code = ble_enable_req_enc(p_params,                                                 &(p_buffer[1]),                                                 &buffer_length);    APP_ERROR_CHECK(err_code);    //@note: Increment buffer length as internally managed packet type field must be included.    return ser_sd_transport_cmd_write(p_buffer,                                      (++buffer_length),                                      enable_rsp_dec);}

uint32_t sd_ble_opt_set(uint32_t opt_id, ble_opt_t const *p_opt){    uint8_t * p_buffer;    uint32_t  buffer_length;    tx_buf_alloc(&p_buffer, &buffer_length);    const uint32_t err_code = ble_opt_set_req_enc(opt_id,                                                  p_opt,                                                  &(p_buffer[1]),                                                  &buffer_length);    APP_ERROR_CHECK(err_code);    //@note: Increment buffer length as internally managed packet type field must be included.    return ser_sd_transport_cmd_write(p_buffer,                                      (++buffer_length),                                      opt_set_rsp_dec);}

uint32_t _sd_ble_gattc_exchange_mtu_request(uint16_t conn_handle,                                           uint16_t client_rx_mtu){    uint8_t * p_buffer;    uint32_t  buffer_length = 0;    tx_buf_alloc(&p_buffer, (uint16_t *)&buffer_length);    const uint32_t err_code = ble_gattc_exchange_mtu_request_req_enc(conn_handle,                                                                     client_rx_mtu,                                                                     &(p_buffer[1]),                                                                     &buffer_length);    APP_ERROR_CHECK(err_code);    //@note: Increment buffer length as internally managed packet type field must be included.    return ser_sd_transport_cmd_write(p_buffer,                                      (++buffer_length),                                      gattc_exchange_mtu_request_rsp_dec);}

uint32_t sd_temp_get(int32_t * p_temp){    uint8_t * p_buffer;    uint32_t  buffer_length = 0;    tx_buf_alloc(&p_buffer, (uint16_t *)&buffer_length);    mp_out_param = p_temp;    const uint32_t err_code = temp_get_req_enc(p_temp,                                               &(p_buffer[1]),                                               &buffer_length);    APP_ERROR_CHECK(err_code);    //@note: Increment buffer length as internally managed packet type field must be included.    return ser_sd_transport_cmd_write(p_buffer,                                      (++buffer_length),                                      mw_temp_get_rsp_dec);}

uint32_t sd_ble_gap_ppcp_get(ble_gap_conn_params_t * const p_conn_params){    uint8_t * p_buffer;    uint32_t  buffer_length = 0;    tx_buf_alloc(&p_buffer, (uint16_t *)&buffer_length);    m_output_params.gap_ppcp_get_out_params.p_conn_params = p_conn_params;    const uint32_t err_code = ble_gap_ppcp_get_req_enc(p_conn_params,                                                       &(p_buffer[1]),                                                       &buffer_length);    //@note: Should never fail.    APP_ERROR_CHECK(err_code);    //@note: Increment buffer length as internally managed packet type field must be included.    return ser_sd_transport_cmd_write(p_buffer,                                      (++buffer_length),                                      gap_ppcp_get_reply_rsp_dec);}

uint32_t sd_ble_gatts_sys_attr_set(uint16_t              conn_handle,                                   uint8_t const * const p_sys_attr_data,                                   uint16_t              len){    uint8_t * p_buffer;    uint32_t  buffer_length = 0;    tx_buf_alloc(&p_buffer, (uint16_t *)&buffer_length);    const uint32_t err_code = ble_gatts_sys_attr_set_req_enc(conn_handle,                                                             p_sys_attr_data,                                                             len,                                                             &(p_buffer[1]),                                                             &buffer_length);    APP_ERROR_CHECK(err_code);    //@note: Increment buffer length as internally managed packet type field must be included.    return ser_sd_transport_cmd_write(p_buffer,                                      (++buffer_length),                                      gatts_sys_attr_set_rsp_dec);}

uint32_t sd_ble_gap_device_name_set(ble_gap_conn_sec_mode_t const * const p_write_perm,                                    uint8_t const * const                 p_dev_name,                                    uint16_t                              len){    uint8_t * p_buffer;    uint32_t  buffer_length = 0;    tx_buf_alloc(&p_buffer, (uint16_t *)&buffer_length);    const uint32_t err_code = ble_gap_device_name_set_req_enc(p_write_perm,                                                              p_dev_name,                                                              len,                                                              &(p_buffer[1]),                                                              &buffer_length);    //@note: Should never fail.    APP_ERROR_CHECK(err_code);    //@note: Increment buffer length as internally managed packet type field must be included.    return ser_sd_transport_cmd_write(p_buffer,                                      (++buffer_length),                                      gap_device_name_set_rsp_dec);}

uint32_t _sd_ble_gattc_char_values_read(uint16_t               conn_handle,                                       uint16_t const * const p_handles,                                       uint16_t               handle_count){    uint8_t * p_buffer;    uint32_t  buffer_length = 0;    tx_buf_alloc(&p_buffer, (uint16_t *)&buffer_length);    const uint32_t err_code = ble_gattc_char_values_read_req_enc(conn_handle,                                                                 p_handles,                                                                 handle_count,                                                                 &(p_buffer[1]),                                                                 &buffer_length);    APP_ERROR_CHECK(err_code);    //@note: Increment buffer length as internally managed packet type field must be included.    return ser_sd_transport_cmd_write(p_buffer,                                      (++buffer_length),                                      gattc_char_values_read_rsp_dec);}

uint32_t sd_ble_gap_sec_info_reply(uint16_t                    conn_handle,                                   ble_gap_enc_info_t  const * p_enc_info,                                   ble_gap_irk_t       const * p_id_info,                                   ble_gap_sign_info_t const * p_sign_info){    uint8_t * p_buffer;    uint32_t  buffer_length = 0;    tx_buf_alloc(&p_buffer, (uint16_t *)&buffer_length);    const uint32_t err_code = ble_gap_sec_info_reply_req_enc(conn_handle,                                                             p_enc_info,                                                             p_id_info,                                                             p_sign_info,                                                             &(p_buffer[1]),                                                             &buffer_length);    APP_ERROR_CHECK(err_code);    //@note: Increment buffer length as internally managed packet type field must be included.    return ser_sd_transport_cmd_write(p_buffer,                                      (++buffer_length),                                      gap_sec_info_reply_rsp_dec);}

uint32_t sd_ble_gatts_descriptor_add(uint16_t                       char_handle,                                     ble_gatts_attr_t const * const p_attr,                                     uint16_t * const               p_handle){    uint8_t * p_buffer;    uint32_t  buffer_length = 0;    tx_buf_alloc(&p_buffer, (uint16_t *)&buffer_length);    mp_out_params[0] = p_handle;    const uint32_t err_code = ble_gatts_descriptor_add_req_enc(char_handle,                              p_attr,                              p_handle,                              &(p_buffer[1]),                              &buffer_length);    APP_ERROR_CHECK(err_code);    //@note: Increment buffer length as internally managed packet type field must be included.    return ser_sd_transport_cmd_write(p_buffer,                                      (++buffer_length),                                      gatts_descriptor_add_rsp_dec);}

uint32_t sd_ble_user_mem_reply(uint16_t conn_handle, ble_user_mem_block_t const *p_block){    uint8_t * p_buffer;    uint32_t  buffer_length, user_mem_table_index;    uint32_t  err_code = NRF_SUCCESS;    tx_buf_alloc(&p_buffer, &buffer_length);    // Prepare User Memory Block context for later synchronization when SoftDevice updates     // the data in the memory block    if(p_block != NULL)    {        err_code = app_ble_user_mem_context_create(conn_handle, &user_mem_table_index);        SER_ASSERT(err_code == NRF_SUCCESS, err_code);        m_app_user_mem_table[user_mem_table_index].mem_block.len   = p_block->len;        m_app_user_mem_table[user_mem_table_index].mem_block.p_mem = p_block->p_mem;        // Save connection handle and context allocation flag for case if context destroy was needed        m_output_params.ble_user_mem_reply_out_params.conn_handle       = conn_handle;        m_output_params.ble_user_mem_reply_out_params.context_allocated = 1;    }    else    {        m_output_params.ble_user_mem_reply_out_params.context_allocated = 0;    }    err_code = ble_user_mem_reply_req_enc(conn_handle,                                          p_block,                                             &(p_buffer[1]),                                          &buffer_length);    APP_ERROR_CHECK(err_code);    //@note: Increment buffer length as internally managed packet type field must be included.    return ser_sd_transport_cmd_write(p_buffer,                                      (++buffer_length),                                      user_mem_reply_rsp_dec);}