Dynamically updating Advertising data in SDK 15

Question

(side note : it would have been handy if the migration guide mentioned that the advertising timeout configs have changed from seconds to 10's of ms) 
 It seems to have become harder to dynamically update the advertising packet in SDK15. In SDK14, using ble_advertising, I could just update the manufacturer data used by my instance of ble_advertising_t and call ble_advdata_set and be done. Then whenever ble_advertising did something later, it would continue with the latest data (eg auto restart advertising, change speed etc). Advertising would not be restarted and if you use fast and slow advertising, then that timing and transition would not be affected if you changed the manufacturer data. 
 Now, we need to use sd_ble_gap_adv_set_configure instead of ble_advdata_set, but the new call wont allow changing the encoded data contents and using the same buffer. You need to provide a new buffer if its busy advertising. Providing a new long lived buffer for each update causes many other issues. One way to deal with this is to stop and restart advertising with the same but updated buffer. But that affects the fast to slow advertising timing and transitions : say you update the data every 1 minute, and your fast advertising goes slow after 2 minutes, then you'll always be in fast mode. 
 Is there an easy and minimally impactful way to update just the manufacturer data in SDK15 ?

Josh West · Accepted Answer

I was beginning to have the same sentiments as you, regarding the need to provide a new buffer to update the advertising data while advertising, until I read through the s140_nrf52_6.0.0_migration_document.pdf. You should be able to find this in your <sdk>/components/softdevice/s140/doc folder. 
 It seems that you are to be expected to have 2 sets of buffers allocated in order to update your advertising data on-the-fly. 
 Here is the code snippet from the migration doc... 
 static uint8_t raw_adv_data_buffer1[BLE_GAP_ADV_SET_DATA_SIZE_MAX];
static uint8_t raw_scan_rsp_data_buffer1[BLE_GAP_ADV_SET_DATA_SIZE_MAX];
static ble_gap_adv_data_t adv_data1 = {
 .adv_data.p_data = raw_adv_data_buffer1,
 .adv_data.len = sizeof(raw_adv_data_buffer1),
 .scan_rsp_data.p_data = raw_scan_rsp_data_buffer1,
 .scan_rsp_data.len = sizeof(raw_scan_rsp_data_buffer1)
};

/* A second advertising data buffer for later updating advertising data while advertising */
static uint8_t raw_adv_data_buffer2[BLE_GAP_ADV_SET_DATA_SIZE_MAX];
static uint8_t raw_scan_rsp_data_buffer2[BLE_GAP_ADV_SET_DATA_SIZE_MAX];
static ble_gap_adv_data_t adv_data2 = {
 .adv_data.p_data = raw_adv_data_buffer2,
 .adv_data.len = sizeof(raw_adv_data_buffer2),
 .scan_rsp_data.p_data = raw_scan_rsp_data_buffer2,
 .scan_rsp_data.len = sizeof(raw_scan_rsp_data_buffer2)
};

int main(void)
{
 uint8_t adv_handle = BLE_GAP_ADV_SET_HANDLE_NOT_SET;
 ble_gap_adv_params_t adv_params = {
 .properties = {
 .type = BLE_GAP_ADV_TYPE_CONNECTABLE_SCANNABLE_UNDIRECTED
 },
 .interval = BLE_GAP_ADV_INTERVAL_MAX,
 .duration = BLE_GAP_ADV_TIMEOUT_LIMITED_MAX,
 .channel_mask = {0}, /* Advertising on all the primary channels */
 .max_adv_evts = 0,
 .filter_policy = BLE_GAP_ADV_FP_ANY,
 .primary_phy = BLE_GAP_PHY_AUTO,
 .scan_req_notification = 1
 };
 /* Enable the BLE Stack */
 sd_ble_enable(...);
 [...]
 sd_ble_gap_adv_set_configure(&adv_handle, &adv_data1, &adv_params);
 /* Start advertising */
 sd_ble_gap_adv_start(adv_handle, BLE_CONN_CFG_TAG_DEFAULT);
 [...]
 /* Update advertising data while advertising */
 sd_ble_gap_adv_set_configure(&adv_handle, &adv_data2, NULL);
 [...]
 /* Stop advertising */
 sd_ble_gap_adv_stop(adv_handle);
 [...]
} 
 
 I am still in the middle of migrating so I have not had a chance to implement this solution and try it out.

MDougherty · Answer

While the original poster has likely moved on, I am posting for others who come here with a similar issue.

My team also wanted to update the advertising data of a device dynamically. Stripping away any details that are beyond the scope of the question, our use case was a sensor which would advertise 1 when sensing an event and advertise 0 when not sensing an event.

We ran into the same problems using the SDK and API to dynamically update the advertising data as others here and in other forum posts.

We did find a working and efficient solution, however, and it is as follows:

Note the ble_gap_adv_data_t struct which holds the advertising data. When initialized it would look something like:

static uint8_t m_adv_handle = BLE_GAP_ADV_SET_HANDLE_NOT_SET;                   /**< Advertising handle used to identify an advertising set. */
static uint8_t m_enc_advdata[BLE_GAP_ADV_SET_DATA_SIZE_MAX];                    /**< Buffer for storing an encoded advertising set. */
static uint8_t m_enc_scan_response_data[BLE_GAP_ADV_SET_DATA_SIZE_MAX];         /**< Buffer for storing an encoded scan data. */

/**@brief Struct that contains pointers to the encoded advertising data. */
static ble_gap_adv_data_t m_adv_data =
{
    .adv_data =
    {
        .p_data = m_enc_advdata,
        .len    = BLE_GAP_ADV_SET_DATA_SIZE_MAX
    },
    .scan_rsp_data =
    {
        .p_data = m_enc_scan_response_data,
        .len    = BLE_GAP_ADV_SET_DATA_SIZE_MAX

    }
};

The .adv_data.p_data data field is the right place to be looking. So let's follow .adv_data.p_data through the code and see what happens...

First, let's look at the relevant bits of advertising_init()

static void advertising_init(void)
{
    .
    .
    .

    // Build and set advertising data.
    ble_advdata_t advdata;
    memset(&advdata, 0, sizeof(advdata));
    
    uint8_t data[]                      = {0xDE, 0xAD, 0xBE, 0xEF};
    manuf_data.company_identifier       = 0x0059;
    manuf_data.data.p_data              = data;
    manuf_data.data.size                = sizeof(data);
    advdata.p_manuf_specific_data       = &manuf_data;

    advdata.name_type          = BLE_ADVDATA_FULL_NAME;
    advdata.include_appearance = true;
    advdata.flags              = BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE;

    err_code = ble_advdata_encode(&advdata, m_adv_data.adv_data.p_data, &m_adv_data.adv_data.len);
    APP_ERROR_CHECK(err_code);
    
    NRF_LOG_INFO("m_adv_data.adv_data.p_data address %p", m_adv_data.adv_data.p_data);
    
    // Build and set scan response data.
    .
    .
    .

    // Build and set advertising parameters.
    ble_gap_adv_params_t adv_params;
    .
    .
    .

    err_code = sd_ble_gap_adv_set_configure(&m_adv_handle, &m_adv_data, &adv_params);
    APP_ERROR_CHECK(err_code);
}

Of important note here is that, to keep with Bluetooth standards, the ble_advdata_encode() function is used. This is because, from Source:

"...the term advertising data refers to the 0..31 byte long payload that is available for application use. (In Bluetooth Core specification this field is referred to as AdvData).

Advertising data consists of one or more Advertising Data (AD) elements. Each element is formatted as follows:

1st byte: length of the element (excluding the length byte itself)
2nd byte: AD type – specifies what data is included in the element
AD data – one or more bytes - the meaning is defined by AD type"

Which is why our dynamic advertising data is in the manufacturer-specific data field.

So we don't want to simply override the entire .adv_data.p_data or we will not be in compliance with Bluetooth standards (unless you take care to format your payload yourself).

The last call in the advertising_init() snippet was:

err_code = sd_ble_gap_adv_set_configure(&m_adv_handle, &m_adv_data, &adv_params);

which is a Soft Device call so all we can look at is the declaration of that function which can be found in ble_gap.h:

SVCALL(SD_BLE_GAP_ADV_SET_CONFIGURE, uint32_t, sd_ble_gap_adv_set_configure(uint8_t *p_adv_handle, ble_gap_adv_data_t const *p_adv_data, ble_gap_adv_params_t const *p_adv_params));

...noting that SVCALL is a macro defined in nrf_svc.h and that this whole thing really does turn into a function definition. So why did we come all this way to look at a messy function declaration? We came so we could see the parameter ble_gap_adv_data_t const *p_adv_data, and in particular note that the pointer it is looking for is a constant. Therefore, while we can't know what sd_ble_gap_adv_set_configure(...) is doing since the soft device is proprietary, we can know that it expects the pointer to the advertising data to never change, which suggests the soft device will keep looking in the same location for advertising data (testing have verified this).

And that brings us to our solution, because we defined m_adv_data, so we can directly write to its address in memory. Writing to it is easy, we just use memcpy() or something like:

m_adv_data.adv_data.p_data[your_offset] = 0x01;

The only thing you need to do is determine your_offset, which is the where in p_data we want to put our dynamically updated payload, as it is going to be different depending on what fields you have in your advertising payload. Remember, we can't just write anywhere in p_data because the format is standardized, and only certain fields are meant to convey arbitrary data.

And now you may realize why

NRF_LOG_INFO("m_adv_data.adv_data.p_data address %p", m_adv_data.adv_data.p_data);

was in the advertising_init() function, and why the manuf_data.data.p_data was set to 0xDEADBEEF... it was so we could run the debugger to find the offset we need to write directly to the manufacturer-specific data section of m_adv_data.adv_data.p_data.

Now, if we ran the debugger and look at the logs we would see the address of m_adv_data.adv_data.p_data printed. Then, we would go to the view->debug->memory option in Segger Embedded Studio and go to that address and look for 0xDEADBEEF. You count the bytes from the address of m_adv_data.adv_data.p_data to the first D in 0xDEADBEEF to get your offset.

As for my team's use case, we can now dynamically update the advertising data by writing

m_adv_data.adv_data.p_data[11] = 0x01;

when the sensor picks up an event and

m_adv_data.adv_data.p_data[11] = 0x00;

when it does not. This is a simple solution that bypasses using the advertising update functions of the SDK, and avoids other complex solutions like double buffering. It is just one line to change the advertising data dynamically.

Just be mindful, as since you are writing directly to memory nothing is error checking what you are writing. You need to make sure that you don't write more characters than your field allows, that you update the offset if you change the number of fields in the advertising payload, and that you don't write anything which breaks the Bluetooth standard (such as writing over length fields, etc).

Hope that helps.

Dynamically updating Advertising data in SDK 15

Top Replies