Problems with function for handling ble events

[Laerte Junior]

Hi,

I'm using ble_app_template to implement my custom solution. I can read battery values, but I can't read custom values.

As a reference, I'm using ble_app_cscs, and the function below works fine.

ble_cscs.c

void ble_cscs_on_ble_evt(ble_evt_t const * p_ble_evt, void * p_context)
{
    ble_cscs_t * p_cscs = (ble_cscs_t *)p_context;

    if (p_cscs == NULL || p_ble_evt == NULL)
    {
        return;
    }

    ble_sc_ctrlpt_on_ble_evt(&(p_cscs->ctrl_pt), p_ble_evt);
    switch (p_ble_evt->header.evt_id)
    {
        case BLE_GAP_EVT_CONNECTED:
            on_connect(p_cscs, p_ble_evt);
            break;

        case BLE_GAP_EVT_DISCONNECTED:
            on_disconnect(p_cscs, p_ble_evt);
            break;

        case BLE_GATTS_EVT_WRITE:
            on_write(p_cscs, p_ble_evt);
            break;

        default:
            // No implementation needed.
            break;
    }
}

In my code, I made the same function, but the value of machine state is 0 and never enter in the first case to send data do my application.

void ble_cps_on_ble_evt(ble_cps_t * p_cps, ble_evt_t * p_ble_evt)
{
 
    switch (p_ble_evt->header.evt_id)
    {
    case BLE_GAP_EVT_CONNECTED:
        on_connect(p_cps, p_ble_evt);
        break;

    case BLE_GAP_EVT_DISCONNECTED:
        on_disconnect(p_cps, p_ble_evt);
        break;

    case BLE_GATTS_EVT_WRITE:
        on_write(p_cps, p_ble_evt);
        break;

    default:
        // No implementation needed.
        break;
    }
}

I using nrf52 pca10040 dev board and sdk 17.0.2.

Can you help me to solve this?

Regards

[Jared]

Hi there,

Can you set a breakpoint at the beginning of ble_cps_on_ble_evt() before the case BLE_GAP_EVT_CONNECTED line and confirm that the ble event handler is called. 

regards

Jared 

[Laerte Junior]

Hi Jared,

I set the breakpoint and modified my code to debug and the event handler was called, but the evt_id return 0.

void ble_cps_on_ble_evt(ble_cps_t * p_cps, ble_evt_t * p_ble_evt)
{
    
    NRF_LOG_INFO("ble_cps_on_ble_evt!! valor de p_ble_evt->header.evt_id =%u, ", p_ble_evt->header.evt_id);//todo debug
    
    switch (p_ble_evt->header.evt_id)
    {
    case BLE_GAP_EVT_CONNECTED:
        on_connect(p_cps, p_ble_evt);
        NRF_LOG_INFO("ble_cps_on_ble_evt: BLE_GAP_EVT_CONNECTED ");//todo debug
        break;

    case BLE_GAP_EVT_DISCONNECTED:
        on_disconnect(p_cps, p_ble_evt);
        NRF_LOG_INFO("ble_cps_on_ble_evt: BLE_GAP_EVT_DISCONNECTED ");//todo debug
        break;

    case BLE_GATTS_EVT_WRITE:
        on_write(p_cps, p_ble_evt);
        NRF_LOG_INFO("ble_cps_on_ble_evt: BLE_GATTS_EVT_WRITE ");//todo debug
        break;

    default:
        // No implementation needed.
         NRF_LOG_INFO("ble_cps_on_ble_evt: NENHUM!!! ");//todo debug
        break;
    }
}

I cannot idenfitify wich part of the code the this value is changed, because the ble_evt_handler function in main.c works fine to connect and I can see the services in nrf connect app without values

[Laerte Junior]

Hi Jared,

I tried it several times finding the point of my code that set this value. I ran the code again to show you with the breakpoint inside the case and never entered.

Regards

Laerte

[Jared]

Hi,

Ok, so most likely the device never connects. You''ve probably put the UUID of your custom service inside the advertising packet which explains why you are able to see it. What are you using on the other side to scan the advertising packets? A mobile phone?

regards

Jared 

[Laerte Junior]

Hi Jared

My custom service connect, because I put the correct UUID.

I'm using nrf connect app to see the services.

I can't read the measurement values of my service. Analyzing my code, the function  ble_cps_measurement_send below was never called.

uint32_t ble_cps_measurement_send(ble_cps_t * p_cps, ble_cps_meas_t * p_measurement)
{
    uint32_t err_code;
    //NRF_LOG_INFO("Entrou no ble_cps_measurement_send ");//todo debug
    //NRF_LOG_INFO("Valor de p_cps->conn_handle = %u ", p_cps->conn_handle);//todo debug
    // Send value if connected and notifying
    if (p_cps->conn_handle != BLE_CONN_HANDLE_INVALID)
    {
        uint8_t                encoded_cp_meas[MAX_CPM_LEN];
        uint16_t               len;
        uint16_t               hvx_len;
        ble_gatts_hvx_params_t hvx_params;

        len     = cp_measurement_encode(p_cps, p_measurement, encoded_cp_meas);
        hvx_len = len;        // Length = 20 Bytes!!!!

        memset(&hvx_params, 0, sizeof(hvx_params));

        hvx_params.handle   = p_cps->meas_handles.value_handle;
        hvx_params.type     = BLE_GATT_HVX_NOTIFICATION;
        hvx_params.offset   = 0;
        hvx_params.p_len    = &hvx_len;
        hvx_params.p_data   = encoded_cp_meas;

        err_code = sd_ble_gatts_hvx(p_cps->conn_handle, &hvx_params);
        if ((err_code == NRF_SUCCESS) && (hvx_len != len))
        {
            err_code = NRF_ERROR_DATA_SIZE;
        }
        //NRF_LOG_INFO("ble_cps_measurement_send ");//todo debug
        //NRF_LOG_INFO("O que foi enviado no bluetooth = %u ", hvx_params.p_data);//todo debug
        
    }
    else
    {
        err_code = NRF_ERROR_INVALID_STATE;
    }
    //NRF_LOG_FLUSH();
    return err_code;
}

I made my code comparing with cscs service in ble_cscs.c and the measures was showed correctly in nrf connect app

uint32_t ble_cscs_measurement_send(ble_cscs_t * p_cscs, ble_cscs_meas_t * p_measurement)
{
    if (p_cscs == NULL || p_measurement == NULL)
    {
        return NRF_ERROR_NULL;
    }

    uint32_t err_code;
    NRF_LOG_INFO("Valor de p_cscs->conn_handle = %u ", p_cscs->conn_handle);//todo debug
    //NRF_LOG_INFO("Entrou no ble_cps_measurement_send ");//todo debug
    // Send value if connected and notifying
    if (p_cscs->conn_handle != BLE_CONN_HANDLE_INVALID)
    {
        uint8_t                encoded_csc_meas[MAX_CSCM_LEN];
        uint16_t               len;
        uint16_t               hvx_len;
        ble_gatts_hvx_params_t hvx_params;

        len     = csc_measurement_encode(p_cscs, p_measurement, encoded_csc_meas);
        hvx_len = len;

        memset(&hvx_params, 0, sizeof(hvx_params));

        hvx_params.handle = p_cscs->meas_handles.value_handle;
        hvx_params.type   = BLE_GATT_HVX_NOTIFICATION;
        hvx_params.offset = 0;
        hvx_params.p_len  = &hvx_len;
        hvx_params.p_data = encoded_csc_meas;

        err_code = sd_ble_gatts_hvx(p_cscs->conn_handle, &hvx_params);
        if ((err_code == NRF_SUCCESS) && (hvx_len != len))
        {
            err_code = NRF_ERROR_DATA_SIZE;
        }
        NRF_LOG_INFO("O que foi enviado no bluetooth = %u ", &hvx_params.p_data);//todo debug
    }
    else
    {
        err_code = NRF_ERROR_INVALID_STATE;
    }

    return err_code;
}

Regards

Laerte

[Jared]

Hi,

What parameters are you passing to NRF_SDH_BLE_OBSERVER() when you are registering the event handler ?

 

regards

Jared 

[Laerte Junior]

Hi,

I'm passing the parameters according the function below

static void ble_stack_init(void)
{
    ret_code_t err_code;

    err_code = nrf_sdh_enable_request();
    APP_ERROR_CHECK(err_code);

    // Configure the BLE stack using the default settings.
    // Fetch the start address of the application RAM.
    uint32_t ram_start = 0;
    err_code = nrf_sdh_ble_default_cfg_set(APP_BLE_CONN_CFG_TAG, &ram_start);
    APP_ERROR_CHECK(err_code);

    // Enable BLE stack.
    err_code = nrf_sdh_ble_enable(&ram_start);
    APP_ERROR_CHECK(err_code);

    // Register a handler for BLE events.
    NRF_SDH_BLE_OBSERVER(m_ble_observer, APP_BLE_OBSERVER_PRIO, ble_evt_handler, NULL);
}

Regards

Laerte

[Jared]

Hi,

Can you share a project that would reproduce this on the nRF52 development kit?

regards

Jared 

[Laerte Junior]

I using files that I found on internet to create this project. I run the project inside the examples folder:

E:\nRF5_SDK_17.0.2_d674dde\components\ble\ble_services\ble_cps

6014.ble_app_template.zip

for cps files, I create folder inside the ble_services folder

E:\nRF5_SDK_17.0.2_d674dde\components\ble\ble_services\ble_cpsble_cps.h

Fullscreen ble_cps.c Download

/* Copyright (c) 2012 Nordic Semiconductor. All Rights Reserved.
 *
 * The information contained herein is property of Nordic Semiconductor ASA.
 * Terms and conditions of usage are described in detail in NORDIC
 * SEMICONDUCTOR STANDARD SOFTWARE LICENSE AGREEMENT.
 *
 * Licensees are granted free, non-transferable use of the information. NO
 * WARRANTY of ANY KIND is provided. This heading must NOT be removed from
 * the file.
 *
 */

/* Attention!
*  To maintain compliance with Nordic Semiconductor ASA?s Bluetooth profile
*  qualification listings, this section of source code must not be modified.
*/

#include "ble_cps.h"
#include <string.h>
#include "nordic_common.h"
#include "ble_l2cap.h"
#include "ble_srv_common.h"
#include "app_util.h"
#include "nrf_log.h"

#define OPCODE_LENGTH  1                                                    /**< Length of opcode inside Cycling Power Measurement packet. */
#define HANDLE_LENGTH  2                                                    /**< Length of handle inside Cycling Power Measurement packet. */
//#define BLE_L2CAP_MTU_DEF           (23)    

#define MAX_CPM_LEN   (BLE_GATT_ATT_MTU_DEFAULT - OPCODE_LENGTH - HANDLE_LENGTH)  /**< Maximum size of a transmitted Cycling Power Measurement. */

// Cycling Power Measurement flag bits
#define CP_MEAS_FLAG_MASK_WHEEL_REV_DATA_PRESENT   (0x01 << 0)             /**< Wheel revolution data present flag bit. */
#define CP_MEAS_FLAG_MASK_CRANK_REV_DATA_PRESENT   (0x01 << 1)             /**< Crank revolution data present flag bit. */


/**@brief Function for handling the Connect event.
 *
 * @param[in]   p_cps      Cycling Power Service structure.
 * @param[in]   p_ble_evt   Event received from the BLE stack.
 */
static void on_connect(ble_cps_t * p_cps, ble_evt_t * p_ble_evt)
{
    p_cps->conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
     //NRF_LOG_INFO("Valor de p_ble_evt->evt.gap_evt.conn_handle = %u ", p_ble_evt->evt.gap_evt.conn_handle);//todo debug
}


/**@brief Function for handling the Disconnect event.
 *
 * @param[in]   p_cps      Cycling Power Service structure.
 * @param[in]   p_ble_evt   Event received from the BLE stack.
 */
static void on_disconnect(ble_cps_t * p_cps, ble_evt_t * p_ble_evt)
{
    UNUSED_PARAMETER(p_ble_evt);
    p_cps->conn_handle = BLE_CONN_HANDLE_INVALID;
}

/**@brief Function for handling write events to the cpS Measurement characteristic.
 *
 * @param[in]   p_cps        Cycling Power Service structure.
 * @param[in]   p_evt_write   Write event received from the BLE stack.
 */
static void on_meas_cccd_write(ble_cps_t * p_cps, ble_gatts_evt_write_t * p_evt_write)
{
    if (p_evt_write->len == 2)
    {
        // CCCD written, update notification state
        if (p_cps->evt_handler != NULL)
        {
            ble_cps_evt_t evt;

            if (ble_srv_is_notification_enabled(p_evt_write->data))
            {
                evt.evt_type = BLE_cpS_EVT_NOTIFICATION_ENABLED;
            }
            else
            {
                evt.evt_type = BLE_cpS_EVT_NOTIFICATION_DISABLED;
            }

            p_cps->evt_handler(p_cps, &evt);
        }
    }
}


/**@brief Function for handling the Write event.
 *
 * @param[in]   p_cps      Cycling Power Service structure.
 * @param[in]   p_ble_evt   Event received from the BLE stack.
 */
static void on_write(ble_cps_t * p_cps, ble_evt_t * p_ble_evt)
{
    ble_gatts_evt_write_t * p_evt_write = &p_ble_evt->evt.gatts_evt.params.write;

    if (p_evt_write->handle == p_cps->meas_handles.cccd_handle)
    {
        on_meas_cccd_write(p_cps, p_evt_write);
    }
}

void ble_cps_on_ble_evt(ble_cps_t * p_cps, ble_evt_t * p_ble_evt)
{
    
    NRF_LOG_INFO("ble_cps_on_ble_evt!! valor de p_ble_evt->header.evt_id =%u, ", p_ble_evt->header.evt_id);//todo debug
    
    switch (p_ble_evt->header.evt_id)
    {
    case BLE_GAP_EVT_CONNECTED:
        on_connect(p_cps, p_ble_evt);
        //NRF_LOG_INFO("ble_cps_on_ble_evt: BLE_GAP_EVT_CONNECTED ");//todo debug
        break;

    case BLE_GAP_EVT_DISCONNECTED:
        on_disconnect(p_cps, p_ble_evt);
        //NRF_LOG_INFO("ble_cps_on_ble_evt: BLE_GAP_EVT_DISCONNECTED ");//todo debug
        break;

    case BLE_GATTS_EVT_WRITE:
        on_write(p_cps, p_ble_evt);
        //NRF_LOG_INFO("ble_cps_on_ble_evt: BLE_GATTS_EVT_WRITE ");//todo debug
        break;

    default:
        // No implementation needed.
        // NRF_LOG_INFO("ble_cps_on_ble_evt: NENHUM!!! ");//todo debug
        break;
    }
}

/**@brief Function for encoding a cpS Measurement.
 *
 * @param[in]   p_cps              Cycling Power Service structure.
 * @param[in]   p_cp_measurement   Measurement to be encoded.
 * @param[out]  p_encoded_buffer    Buffer where the encoded data will be written.
 *
 * @return      Size of encoded data.
 */
static uint8_t cp_measurement_encode(ble_cps_t *       p_cps,
                                     ble_cps_meas_t *  p_cp_measurement,
                                     uint8_t *          p_encoded_buffer)
{
    uint16_t flags = 0;
    uint8_t len   = 2;

    flags = 0x01;
    len += uint16_encode(p_cp_measurement->power_measurement, &p_encoded_buffer[len]);
		len = 20;
    // Flags Field
    p_encoded_buffer[0] = (uint8_t) ((flags >> 8) & 0x00FF);
    p_encoded_buffer[1] = (uint8_t) (flags & 0x00FF);

    return len;
}


/**@brief Function for adding cp Measurement characteristics.
 *
 * @param[in]   p_cps        Cycling Power Service structure.
 * @param[in]   p_cps_init   Information needed to initialize the service.
 *
 * @return      NRF_SUCCESS on success, otherwise an error code.
 */
static uint32_t cp_measurement_char_add(ble_cps_t * p_cps, const ble_cps_init_t * p_cps_init)
{
    ble_gatts_char_md_t char_md;
    ble_gatts_attr_md_t cccd_md;
    ble_gatts_attr_t    attr_char_value;
    ble_uuid_t          ble_uuid;
    ble_gatts_attr_md_t attr_md;
    ble_cps_meas_t      initial_scm;
    uint8_t             encoded_scm[MAX_CPM_LEN];

    memset(&cccd_md, 0, sizeof(cccd_md));

    BLE_GAP_CONN_SEC_MODE_SET_OPEN(&cccd_md.read_perm);
    cccd_md.write_perm = p_cps_init->cp_meas_attr_md.cccd_write_perm;
    cccd_md.vloc = BLE_GATTS_VLOC_STACK;

    memset(&char_md, 0, sizeof(char_md));

    char_md.char_props.notify = 1;
    char_md.p_char_user_desc  = NULL;
    char_md.p_char_pf         = NULL;
    char_md.p_user_desc_md    = NULL;
    char_md.p_cccd_md         = &cccd_md;
    char_md.p_sccd_md         = NULL;

    BLE_UUID_BLE_ASSIGN(ble_uuid, BLE_UUID_CYCLING_POWER_MEASUREMENT_CHAR);

    memset(&attr_md, 0, sizeof(attr_md));

    BLE_GAP_CONN_SEC_MODE_SET_NO_ACCESS(&attr_md.read_perm );
    BLE_GAP_CONN_SEC_MODE_SET_NO_ACCESS(&attr_md.write_perm);
    attr_md.vloc       = BLE_GATTS_VLOC_STACK;
    attr_md.rd_auth    = 0;
    attr_md.wr_auth    = 0;
    attr_md.vlen       = 1;

    memset(&attr_char_value, 0, sizeof(attr_char_value));

    attr_char_value.p_uuid       = &ble_uuid;
    attr_char_value.p_attr_md    = &attr_md;
    attr_char_value.init_len     = cp_measurement_encode(p_cps, &initial_scm, encoded_scm);
    attr_char_value.init_offs    = 0;
    attr_char_value.max_len      = MAX_CPM_LEN;
    attr_char_value.p_value      = encoded_scm;

    return sd_ble_gatts_characteristic_add(p_cps->service_handle,
                                           &char_md,
                                           &attr_char_value,
                                           &p_cps->meas_handles);
}


/**@brief Function for adding cp Feature characteristics.
 *
 * @param[in]   p_cps        Cycling Power Service structure.
 * @param[in]   p_cps_init   Information needed to initialize the service.
 *
 * @return      NRF_SUCCESS on success, otherwise an error code.
 */
static uint32_t cp_feature_char_add(ble_cps_t * p_cps, const ble_cps_init_t * p_cps_init)
{
    ble_gatts_char_md_t char_md;
    ble_gatts_attr_t    attr_char_value;
    ble_uuid_t          ble_uuid;
    ble_gatts_attr_md_t attr_md;
    uint8_t             init_value_encoded[4];
    uint8_t             init_value_len;

    memset(&char_md, 0, sizeof(char_md));

    char_md.char_props.read  = 1;
    char_md.p_char_user_desc = NULL;
    char_md.p_char_pf        = NULL;
    char_md.p_user_desc_md   = NULL;
    char_md.p_cccd_md        = NULL;
    char_md.p_sccd_md        = NULL;

    BLE_UUID_BLE_ASSIGN(ble_uuid, BLE_UUID_CYCLING_POWER_FEATURE_CHAR);

    memset(&attr_md, 0, sizeof(attr_md));

    attr_md.read_perm  = p_cps_init->cp_feature_attr_md.read_perm;
    BLE_GAP_CONN_SEC_MODE_SET_NO_ACCESS(&attr_md.write_perm);
    attr_md.vloc       = BLE_GATTS_VLOC_STACK;
    attr_md.rd_auth    = 0;
    attr_md.wr_auth    = 0;
    attr_md.vlen       = 0;

    memset(&attr_char_value, 0, sizeof(attr_char_value));

    init_value_len = uint32_encode(p_cps_init->feature, &init_value_encoded[0]);

    attr_char_value.p_uuid       = &ble_uuid;
    attr_char_value.p_attr_md    = &attr_md;
    attr_char_value.init_len     = init_value_len;
    attr_char_value.init_offs    = 0;
    attr_char_value.max_len      = init_value_len;
    attr_char_value.p_value      = init_value_encoded;

    return sd_ble_gatts_characteristic_add(p_cps->service_handle,
                                           &char_md,
                                           &attr_char_value,
                                           &p_cps->feature_handles);
}


/**@brief Function for adding cp Sensor Location characteristic.
 *
 * @param[in]   p_cps        Cycling Power Service structure.
 * @param[in]   p_cps_init   Information needed to initialize the service.
 *
 * @return      NRF_SUCCESS on success, otherwise an error code.
 */
static uint32_t cp_sensor_loc_char_add(ble_cps_t * p_cps, const ble_cps_init_t * p_cps_init)
{
    ble_gatts_char_md_t char_md;
    ble_gatts_attr_t    attr_char_value;
    ble_uuid_t          ble_uuid;
    ble_gatts_attr_md_t attr_md;
    uint8_t             init_value_len;
    uint8_t             encoded_init_value[1];

    memset(&char_md, 0, sizeof(char_md));

    char_md.char_props.read  = 1;
    char_md.p_char_user_desc = NULL;
    char_md.p_char_pf        = NULL;
    char_md.p_user_desc_md   = NULL;
    char_md.p_cccd_md        = NULL;
    char_md.p_sccd_md        = NULL;

    BLE_UUID_BLE_ASSIGN(ble_uuid, BLE_UUID_SENSOR_LOCATION_CHAR);

    memset(&attr_md, 0, sizeof(attr_md));

    attr_md.read_perm  = p_cps_init->cp_sensor_loc_attr_md.read_perm;
    BLE_GAP_CONN_SEC_MODE_SET_NO_ACCESS(&attr_md.write_perm);
    attr_md.vloc       = BLE_GATTS_VLOC_STACK;
    attr_md.rd_auth    = 0;
    attr_md.wr_auth    = 0;
    attr_md.vlen       = 0;

    memset(&attr_char_value, 0, sizeof(attr_char_value));

    init_value_len        = sizeof(uint8_t);
    if (p_cps_init->sensor_location != NULL)
    {
        encoded_init_value[0] = *p_cps_init->sensor_location;
    }

    attr_char_value.p_uuid       = &ble_uuid;
    attr_char_value.p_attr_md    = &attr_md;
    attr_char_value.init_len     = init_value_len;
    attr_char_value.init_offs    = 0;
    attr_char_value.max_len      = init_value_len;
    attr_char_value.p_value      = encoded_init_value;

    return sd_ble_gatts_characteristic_add(p_cps->service_handle,
                                           &char_md,
                                           &attr_char_value,
                                           &p_cps->sensor_loc_handles);
}


uint32_t ble_cps_init(ble_cps_t * p_cps, const ble_cps_init_t * p_cps_init)
{
    uint32_t   err_code;
    ble_uuid_t ble_uuid;
    //ble_cs_ctrlpt_init_t sc_ctrlpt_init;

    // Initialize service structure
    p_cps->evt_handler = p_cps_init->evt_handler;
    p_cps->conn_handle = BLE_CONN_HANDLE_INVALID;
    p_cps->feature     = p_cps_init->feature;

    // Add service
    BLE_UUID_BLE_ASSIGN(ble_uuid, BLE_UUID_CYCLING_POWER);

    err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY,
                                        &ble_uuid,
                                        &p_cps->service_handle);
    if (err_code != NRF_SUCCESS)
    {
        return err_code;
    }

    // Add Cycling Power measurement characteristic
    err_code = cp_measurement_char_add(p_cps, p_cps_init);
    if (err_code != NRF_SUCCESS)
    {
        return err_code;
    }

    // Add Cycling Power feature characteristic
    err_code = cp_feature_char_add(p_cps, p_cps_init);
    if (err_code != NRF_SUCCESS)
    {
        return err_code;
    }

    // Add Power Sensor Location characteristic
    if (p_cps_init->sensor_location != NULL)
    {
        err_code = cp_sensor_loc_char_add(p_cps, p_cps_init);
        if (err_code != NRF_SUCCESS)
        {
            return err_code;
        }
    }

    return err_code;
}


uint32_t ble_cps_measurement_send(ble_cps_t * p_cps, ble_cps_meas_t * p_measurement)
{
    uint32_t err_code;
    //NRF_LOG_INFO("Entrou no ble_cps_measurement_send ");//todo debug
    //NRF_LOG_INFO("Valor de p_cps->conn_handle = %u ", p_cps->conn_handle);//todo debug
    // Send value if connected and notifying
    if (p_cps->conn_handle != BLE_CONN_HANDLE_INVALID)
    {
        uint8_t                encoded_cp_meas[MAX_CPM_LEN];
        uint16_t               len;
        uint16_t               hvx_len;
        ble_gatts_hvx_params_t hvx_params;

        len     = cp_measurement_encode(p_cps, p_measurement, encoded_cp_meas);
        hvx_len = len;		// Length = 20 Bytes!!!!

        memset(&hvx_params, 0, sizeof(hvx_params));

        hvx_params.handle   = p_cps->meas_handles.value_handle;
        hvx_params.type     = BLE_GATT_HVX_NOTIFICATION;
        hvx_params.offset   = 0;
        hvx_params.p_len    = &hvx_len;
        hvx_params.p_data   = encoded_cp_meas;

        err_code = sd_ble_gatts_hvx(p_cps->conn_handle, &hvx_params);
        if ((err_code == NRF_SUCCESS) && (hvx_len != len))
        {
            err_code = NRF_ERROR_DATA_SIZE;
        }
        //NRF_LOG_INFO("ble_cps_measurement_send ");//todo debug
        //NRF_LOG_INFO("O que foi enviado no bluetooth = %u ", hvx_params.p_data);//todo debug
        
    }
    else
    {
        err_code = NRF_ERROR_INVALID_STATE;
    }
    //NRF_LOG_FLUSH();
    return err_code;
}

//uint32_t ble_cps_sensor_location_set(ble_cps_t * p_cps, uint8_t sensor_location)
//{
//    uint16_t len = sizeof(uint8_t);
//    return sd_ble_gatts_value_set(p_cps->sensor_loc_handles.value_handle, 0, &len, &sensor_location);
//}

Regards

Laerte

[Jared]

Hi,

I added your project to the ble peripeheral examples folder and added your custom service header and source file to the ble services folder. But your project isn't building successfully. Have you modified any other file? I'm getting missing definitions such as BLE_UUID_CYCLING_POWER. Where have you defined that in your project?

regards

Jared 

[Laerte Junior]

Hi Jared,

I added this definition inside the ble_srv_common.h

ble_srv_common.h

Regards

Laerte

[Laerte Junior]

Hi Jared,

I Solve the problem...

I was passing wrong parameters inside the ble_cps_on_ble_evt function.

Now, works fine...

thanks for your help