service data advertisement and 128 uuid

RE: service data advertisement and 128 uuid

FormerMember — Fri, 09 Jan 2015 08:17:35 GMT

Good that it works! No, unfortunately, it's not a general solution, I just wanted to show how "service data" with 128 bit UUID can be added. It shouldn't be too hard to make a general solution. Yes, a memcpy in uint128_encode is a nicer solution!

RE: service data advertisement and 128 uuid

Marcel Mulder — Fri, 09 Jan 2015 07:57:06 GMT

Hi Kristin,

I can confirm your solution works! It is however not a general solution ;-) I have one question. Why using 16 assign statements in stead of a memcpy in uint128_encode? Thanks for the quick fix.

Regards, Marcel

RE: service data advertisement and 128 uuid

Marcel Mulder — Thu, 08 Jan 2015 15:22:22 GMT

Hi Kristin,

Thank you! I hope I can test it tomorrow, but I will let you know if it works for me. We do not advertise a name, so there is no problem with the limited space. The name is only send in a scan response.

RE: service data advertisement and 128 uuid

FormerMember — Thu, 08 Jan 2015 14:51:17 GMT

In order to add "Service data" with 128 bit UUID to the advertising data, a few modifications to the code in the SDK has to be made. Below are the modifications I did. I used SDK 7.1.0, and tested with ble_app_hrs.

Note 1: This is not a general solution, it just shows how "service data" with a 128 bit UUID can be added.

Note 2: remember that 31 bytes is the maximum payload in an advertising packet.

ble_advdata.h: ble_advdata_service_data_t has to be modified to handle 128 bit UUID:

/**@brief Service data structure. */
typedef struct
{
    ble_uuid128_t                  service_uuid;                  /**< Service UUID. */ 
    uint8_array_t                  data;                          /**< Additional service data. */
} ble_advdata_service_data_t;

app_util.h: An encoding function for a 128 bit UUID has to be added:

/**@brief Function for encoding a 128 bit UUID value.
 *
 * @param[in]   value            Value to be encoded.
 * @param[out]  p_encoded_data   Buffer where the encoded data is to be written.
 *
 * @return      Number of bytes written.
 */

static __INLINE uint8_t uint128_encode(ble_uuid128_t value, uint8_t * p_encoded_data)
{
    p_encoded_data[0] =  (uint8_t) value.uuid128[0];
    p_encoded_data[1] =  (uint8_t) value.uuid128[1];
    p_encoded_data[2] =  (uint8_t) value.uuid128[2];
    p_encoded_data[3] =  (uint8_t) value.uuid128[3];
    p_encoded_data[4] =  (uint8_t) value.uuid128[4];
    p_encoded_data[5] =  (uint8_t) value.uuid128[5];
    p_encoded_data[6] =  (uint8_t) value.uuid128[6];
    p_encoded_data[7] =  (uint8_t) value.uuid128[7];
    p_encoded_data[8] =  (uint8_t) value.uuid128[8];
    p_encoded_data[9] =  (uint8_t) value.uuid128[9];
    p_encoded_data[10] = (uint8_t) value.uuid128[10];
    p_encoded_data[11] = (uint8_t) value.uuid128[11];
    p_encoded_data[12] = (uint8_t) value.uuid128[12];
    p_encoded_data[13] = (uint8_t) value.uuid128[13];
    p_encoded_data[14] = (uint8_t) value.uuid128[14];
    p_encoded_data[15] = (uint8_t) value.uuid128[15];

    return 16;
}

ble_advdata.c: The service_data_encode(..) function has to be modified to encode the 128 bit UUID.

 static uint32_t service_data_encode(const ble_advdata_t * p_advdata,
                                    uint8_t             * p_encoded_data,
                                    uint8_t             * p_len)
{
    uint8_t i;

    // Check parameter consistency.
    if (p_advdata->p_service_data_array == NULL)
    {
        return NRF_ERROR_INVALID_PARAM;
    }

    for (i = 0; i < p_advdata->service_data_count; i++)
    {
        ble_advdata_service_data_t * p_service_data;
        uint8_t                      data_size;

        p_service_data = &p_advdata->p_service_data_array[i];
        data_size      = 16 + p_service_data->data.size; // sizeof(uint16_le_t) + p_service_data->data.size;

        // Encode Length and AD Type.
        p_encoded_data[(*p_len)++] = 1 + data_size;
        p_encoded_data[(*p_len)++] = BLE_GAP_AD_TYPE_SERVICE_DATA_128BIT_UUID; //BLE_GAP_AD_TYPE_SERVICE_DATA;

        // Encode service UUID.
        //(*p_len) += uint16_encode(p_service_data->service_uuid, &p_encoded_data[*p_len]);
    
        (*p_len) += uint128_encode(p_service_data->service_uuid, &p_encoded_data[*p_len]); // added for encoding of 128 bit uuid.
    
        // Encode additional service data.
        if (p_service_data->data.size > 0)
        {
            if (p_service_data->data.p_data == NULL)
            {
                return NRF_ERROR_INVALID_PARAM;
            }
            memcpy(&p_encoded_data[*p_len], p_service_data->data.p_data, p_service_data->data.size);
            (*p_len) += p_service_data->data.size;
        }
    }

    return NRF_SUCCESS;
}

main.c: I made the device name short and added "service data" in advertising_init(..):

In order to make sure that the advertising data didn't exceed 31 bytes, I change the device name to something short:

#define DEVICE_NAME                          "H"

I changed advertising_init(..) to the following:

/**@brief Function for initializing the Advertising functionality.
 *
 * @details Encodes the required advertising data and passes it to the stack.
 *          Also builds a structure to be passed to the stack when starting advertising.
 */
static void advertising_init(void)
{
    uint32_t      err_code;
    ble_advdata_t advdata;
    uint8_t       flags = BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE;

    uint8_t       service_data[3] = {1,2,3};
    uint8_t       service_data_len = sizeof(service_data)/sizeof(service_data[0]);

 
     ble_uuid128_t   service128bit_uuid = {{0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, 0x00, 0x11,
                                 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99}};                                 
                                 
    ble_advdata_service_data_t service_data_struct;

    ble_uuid_t adv_uuids[] =
    {
        {BLE_UUID_HEART_RATE_SERVICE,         BLE_UUID_TYPE_BLE},
        {BLE_UUID_BATTERY_SERVICE,            BLE_UUID_TYPE_BLE},
        {BLE_UUID_DEVICE_INFORMATION_SERVICE, BLE_UUID_TYPE_BLE}
    };

    // Build and set advertising data.
    memset(&advdata, 0, sizeof(advdata));

    advdata.name_type               = BLE_ADVDATA_FULL_NAME;
    advdata.include_appearance      = true;
    advdata.flags.size              = sizeof(flags);
    advdata.flags.p_data            = &flags;
    //advdata.uuids_complete.uuid_cnt = sizeof(adv_uuids) / sizeof(adv_uuids[0]);
    //advdata.uuids_complete.p_uuids  = adv_uuids;

    advdata.p_service_data_array = &service_data_struct;    
    advdata.p_service_data_array->service_uuid = service128bit_uuid;
    advdata.p_service_data_array->data.p_data = service_data;
    advdata.p_service_data_array->data.size   = service_data_len;
    advdata.service_data_count = 1;

    err_code = ble_advdata_set(&advdata, NULL);
    APP_ERROR_CHECK(err_code);

    // Initialize advertising parameters (used when starting advertising).
    memset(&m_adv_params, 0, sizeof(m_adv_params));

    m_adv_params.type        = BLE_GAP_ADV_TYPE_ADV_IND;
    m_adv_params.p_peer_addr = NULL;                           // Undirected advertisement.
    m_adv_params.fp          = BLE_GAP_ADV_FP_ANY;
    m_adv_params.interval    = APP_ADV_INTERVAL;
    m_adv_params.timeout     = APP_ADV_TIMEOUT_IN_SECONDS;
}

RE: service data advertisement and 128 uuid

Marcel Mulder — Wed, 07 Jan 2015 15:20:56 GMT

But this is not what I need... I need service DATA advertisement.... I talked about this issue with another Nordic employee. He confirmed that this is not supported in current SDK en that they will look into it. Case closed... but not solved ;-)

RE: service data advertisement and 128 uuid

Nguyen Hoan Hoang — Wed, 07 Jan 2015 15:17:19 GMT

That is exactly what I did in my example code.

RE: service data advertisement and 128 uuid

Nguyen Hoan Hoang — Wed, 07 Jan 2015 15:16:18 GMT

The answer given by Petter Myhre is exactly what I did in my example code.

RE: service data advertisement and 128 uuid

Petter Myhre — Wed, 07 Jan 2015 12:35:54 GMT

Please have a look at experimental_ble_app_uart, it includes a 128 bit UUID in the scan response.

It is not included in the advertising packet, because it would become to big with both a device name and a 128 bit UUID in it.

However, you can easily remove the device name (use BLE_ADVDATA_NO_NAME), and add the UUID to the advertising packet by replacing:

scanrsp.uuids_complete.uuid_cnt = sizeof(adv_uuids) / sizeof(adv_uuids[0]);
scanrsp.uuids_complete.p_uuids  = adv_uuids;

with:

advdata.uuids_complete.uuid_cnt = sizeof(adv_uuids) / sizeof(adv_uuids[0]);
advdata.uuids_complete.p_uuids  = adv_uuids;

RE: service data advertisement and 128 uuid

Marcel Mulder — Sun, 21 Dec 2014 11:00:04 GMT

Thank you for bearing with me. The problem is there is already an implementation using a different vendor and there is already an iOS app in the field. That 's why I have to use this type: BLE_GAP_AD_TYPE_SERVICE_DATA_128BIT_UUID of advertisement. I think I can solve te problem by extending service_data_encode function or create my own encoder but I did not tried that yet. I personally find it strange how Nordic implemented it and deals with 128 uuid's. Most people, I think, wil not make products which already have a Bluetooth SIG profile and therefore must use 128 uuid's. You are right that the Nordic SDK may have different ways and that only the transmitted packet is important. But sadly enough the forgot to implement 128 uuid service data type of advertisement. I will make a case out of this because Nordic is not responding here. It would be really nice if it is added to the SDK

RE: service data advertisement and 128 uuid

Nguyen Hoan Hoang — Sun, 21 Dec 2014 04:24:09 GMT

Ok, then you can use the le_advdata_service_data_t for your uuid. The code is an example demo code not production. It does not matter whether I use illegal manufacturer id or not. My iOS counter part demo code still can read it. I do have a real ID which I do not provide with demo code. The info I transmit over manufacturer data is the 64bits chip unique ID. I use it as serial number so i can connected to multiple boards. In the Scan, I list them with the serial # so the user can select what that need. In another app (private one) I send both the 64bits serial # plus 3 x 16 bits values for model #, Hw rev #, fw rev #. Total of 112 bits + 16 bits manufac Id = 128bits. The p_data can be whatever you want to put in there. If you don't like using manufacturer data, you can use the ble_advdata_service_data_t instead. I've never tried that one though. Plus I still get my full 128bits service uuid transmitted with it so the total is 256bits. My be you can take a sniffer and compare the packets. Nordic SDK may have a different way to do thing than what you used to have but the transmitted packet should be very similar

RE: service data advertisement and 128 uuid

Marcel Mulder — Sat, 20 Dec 2014 17:02:16 GMT

The advertisement init at line 222 uses the 128 uuid (g_BlinkyServ.uuid_type) for service advertisement. I need to do service DATA advertisement (using ble_advdata_service_data_t) with a 128 bit uuid. This is different from service advertisement. Still you are using a illegal manufacturer id. This is alway a 16 bit uuid. A 128 bit uuid is not possible with manufacturer data.

RE: service data advertisement and 128 uuid

Nguyen Hoan Hoang — Sat, 20 Dec 2014 14:56:08 GMT

File BlinkyBleService.c at line 174 in the function ble_blinkys_init. That is where the base 128bits UUID gets encoded. It returns an index handle called uuid_type. The UUID is defined by a macro in the file BlinkyBleService.h.
Then the file BlinkyBleMain.c in function advertising_init at line 222. This is where the all the advertising data gets encoded. The 16bit part get encoded with the base 128bits part (g_BlinkyServ.uuid_type) to make the full 128 bits UUID of the service.

RE: service data advertisement and 128 uuid

Marcel Mulder — Sat, 20 Dec 2014 14:25:46 GMT

I think we don't understand each other. Could you please give the filename and line number or function name where you use a 128 bit uuid for advertisement?

RE: service data advertisement and 128 uuid

Nguyen Hoan Hoang — Thu, 18 Dec 2014 11:44:06 GMT

It is not a valid Bluetooth company ID. The UUID I used is 128 bits. The base part was encoded with sd_ble_uuid_vs_add prior calling advertising_init. The 16bit bottom part of of the UUID is encoded in the advertising_init for each service.

RE: service data advertisement and 128 uuid

Marcel Mulder — Thu, 18 Dec 2014 06:46:33 GMT

You are using manufacturer data. I need to use service data. The reason for wanting to use service data is that we don't have a company identifier. You use 0x2082 but I can't find it in the list of company identifiers on www.bluetooth.org/.../company-identifiers. So is it a valid one? Anyway, you have or use a 16 bit uuid. I need to use (according to the specification) a 128 bit uuid. Therefore I need to use service data advertisement with 128 uuid. This is specified but not implemented by Nordic.

RE: service data advertisement and 128 uuid

Nguyen Hoan Hoang — Thu, 18 Dec 2014 04:51:33 GMT

I am not sure to fully understand what you need. Have you looked at the function advertising_init() where the UUID along with manufacturer data be encoded for advertisement. I sent a serial number with the advertisement packet where I can read it from iOS without needing to connect to the device. In a customer project, I sent model number and rev number as well as serial #.

RE: service data advertisement and 128 uuid

Marcel Mulder — Wed, 17 Dec 2014 12:07:03 GMT

No, this is not what I need. I know how to add custom uuid as I mentioned in my post using sd_ble_uuid_vs_add. Again I am talking about "Service DATA Advertisement" using ble_advdata_service_data_t structure. Also look to the additional info I posted below. My conclusion for now is that Nordic did not implement 128 uuid service data advertisement. At least not in ble_advdata.c.

RE: service data advertisement and 128 uuid

Nguyen Hoan Hoang — Wed, 17 Dec 2014 10:40:58 GMT

The custom service requires advertising 128 custom UUID. Isn't that what you need ?

ble_uuid128_t base_uuid = {BLINKY_UUID_BASE};

err_code = sd_ble_uuid_vs_add(&base_uuid, &p_blinkys->uuid_type);

RE: service data advertisement and 128 uuid

Marcel Mulder — Wed, 17 Dec 2014 07:16:18 GMT

Some additional info...

When I dig into the code I end up at service_data_encode in ble_advdata.c. Here the advertise data is constructed. The only type of service data I see is BLE_GAP_AD_TYPE_SERVICE_DATA where I need to use BLE_GAP_AD_TYPE_SERVICE_DATA_128BIT_UUID.

RE: service data advertisement and 128 uuid

Marcel Mulder — Wed, 17 Dec 2014 06:38:49 GMT

Thank you for your reply, but my question is about service data advertisement according to Supplement to the Bluetooth Core Specification with a 128 bit uuid. It is not about using custom or vendor specific service.

RE: service data advertisement and 128 uuid

Nguyen Hoan Hoang — Tue, 16 Dec 2014 22:23:15 GMT

There are examples code from this blog use custom UUID. You can see how it's done. embeddedsoftdev.blogspot.ca/.../ehal-nrf51.html