measure_service.c

static uint32_t measure_value_char_add(ble_mus_t * p_mus, const ble_mus_init_t * p_mus_init)
{
    uint32_t            err_code;
    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;

    // Add Measure Value characteristic
    memset(&cccd_md, 0, sizeof(cccd_md));

    //  Read  operation on cccd should be possible without authentication.
    BLE_GAP_CONN_SEC_MODE_SET_OPEN(&cccd_md.read_perm);
    //BLE_GAP_CONN_SEC_MODE_SET_OPEN(&cccd_md.write_perm);
    
    cccd_md.write_perm = p_mus_init->measure_value_char_attr_md.cccd_write_perm;
    cccd_md.vloc       = BLE_GATTS_VLOC_STACK;

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

    char_md.char_props.read   = 1;
    char_md.char_props.write  = 0;
    char_md.char_props.notify = 1; 
    char_md.p_char_user_desc  = (uint8_t *)measure_value_char_user_desc;
    char_md.char_user_desc_max_size = sizeof(measure_value_char_user_desc) - 1;
    char_md.char_user_desc_size = sizeof(measure_value_char_user_desc) - 1;
    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.type = p_mus->uuid_type;
    ble_uuid.uuid = MEASURE_VALUE_CHAR_UUID;

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

    attr_md.read_perm  = p_mus_init->measure_value_char_attr_md.read_perm;
    attr_md.write_perm = p_mus_init->measure_value_char_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));

    attr_char_value.p_uuid    = &ble_uuid;
    attr_char_value.p_attr_md = &attr_md;
    attr_char_value.init_len  = sizeof(uint8_t)*1;
    attr_char_value.init_offs = 0;
    attr_char_value.max_len   = sizeof(uint8_t)*1;

    err_code = sd_ble_gatts_characteristic_add(p_mus->service_handle, &char_md,
                                               &attr_char_value,
                                               &p_mus->measure_value_handles);
    if (err_code != NRF_SUCCESS)
    {
        return err_code;
    }

    return NRF_SUCCESS;
}

uint32_t ble_mus_init(ble_mus_t * p_mus, const ble_mus_init_t * p_mus_init)
{
    if (p_mus == NULL || p_mus_init == NULL)
    {
        return NRF_ERROR_NULL;
    }

    uint32_t   err_code;
    ble_uuid_t ble_uuid;

    // Initialize service structure
    p_mus->evt_handler               = p_mus_init->evt_handler;
    p_mus->conn_handle               = BLE_CONN_HANDLE_INVALID;

    // Add Measure Service UUID
    ble_uuid128_t base_uuid = {MEASURE_SERVICE_UUID_BASE};
    err_code =  sd_ble_uuid_vs_add(&base_uuid, &p_mus->uuid_type);
    VERIFY_SUCCESS(err_code);
    
    ble_uuid.type = p_mus->uuid_type;
    ble_uuid.uuid = MEASURE_SERVICE_UUID;

    // Add the Measure Service
    err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY, &ble_uuid, &p_mus->service_handle);
    if (err_code != NRF_SUCCESS)
    {
        return err_code;
    }

    // Add Measure Value characteristic
    err_code = measure_value_char_add(p_mus, p_mus_init);
    return err_code;
    if (err_code != NRF_SUCCESS)
    {
        return err_code;
    }    
}

uint32_t err_spl;
uint32_t err_spl_2;
uint32_t ble_mus_measure_value_update(ble_mus_t * p_mus, uint8_t measure_value, uint8_t LEN)
{
    if (p_mus == NULL)
    {
        return NRF_ERROR_NULL;
    }

    // Convert measure_value to big-endian
    //uint16_t measure_value_be = __builtin_bswap16(measure_value);

    uint32_t err_code = NRF_SUCCESS;
    ble_gatts_value_t gatts_value;

    // Initialize value struct.
    memset(&gatts_value, 0, sizeof(gatts_value));

    gatts_value.len     = sizeof(uint8_t)*LEN;
    gatts_value.offset  = 0;
    gatts_value.p_value = measure_value;

    // Update database.
    err_code = sd_ble_gatts_value_set(p_mus->conn_handle,
                                      p_mus->measure_value_handles.value_handle,
                                      &gatts_value);
    err_spl_2 = err_code;
    if (err_code != NRF_SUCCESS)
    {
        return err_code;
    }

    // Send value if connected and notifying.
    if ((p_mus->conn_handle != BLE_CONN_HANDLE_INVALID)) 
    {
        ble_gatts_hvx_params_t hvx_params;

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

        hvx_params.handle = p_mus->measure_value_handles.value_handle;
        hvx_params.type   = BLE_GATT_HVX_NOTIFICATION;
        hvx_params.offset = gatts_value.offset;
        hvx_params.p_len  = &gatts_value.len;
        hvx_params.p_data = gatts_value.p_value;

        err_code = sd_ble_gatts_hvx(p_mus->conn_handle, &hvx_params);
        err_spl = err_code;
        NRF_LOG_INFO("sd_ble_gatts_hvx result: %x. \r\n", err_code); 
    }
    else
    {
        err_code = NRF_ERROR_INVALID_STATE;
        NRF_LOG_INFO("sd_ble_gatts_hvx result: NRF_ERROR_INVALID_STATE. \r\n"); 
    }


    return err_code;
}


// this to send notification
#define BATTERY_NOTIFICATION_INTERVAL APP_TIMER_TICKS(5000)

uint8_t inc_num = 0;
uint32_t e_code = NRF_SUCCESS;
static void notification_timeout_handler(void * p_context)
{
    UNUSED_PARAMETER(p_context);
    ret_code_t err_code;

    //err_code = ble_pus_battery_value_update(&m_pus, battery);

    inc_num++;

    e_code = ble_mus_measure_value_update(&m_mus, inc_num, 1);
    // APP_ERROR_CHECK(err_code); // this is crashing the app. to be find out why
}