How to Resubscribe to Old BLE Handles Upon Reconnection

RE: How to Resubscribe to Old BLE Handles Upon Reconnection

LeviRand — Tue, 22 Jul 2025 23:57:41 GMT

Thank you for the direction and insights.

After going over your description and the example you suggested, I believe I know where I am going wrong with bonding. I was confused by the bt_conn_set_bondable( ) function which doesn't actually initiate the bond and instead should be using bt_conn_set_security to triggers the bond (like you suggested). I added this call at BT_SECURITY_L2 (since BT_SECURITY_L1 is the default and won't trigger) and this seems to be working.

I need to do more architectural changes to accomplish my goal of skipping discovery, but this is the solution I needed.

Thanks for all your help, Susheel!

RE: How to Resubscribe to Old BLE Handles Upon Reconnection

Susheel Nuguru — Tue, 22 Jul 2025 10:57:40 GMT

Most of the central samples in the NCS SDK have this feature already and show you how to trigger bonding.. For example if you look into central_bas it shows how to discover the battery service and use bt_conn_set_security in your connected() callback to trigger bonding. It also shows how to use bt_gatt_bas_c_subscribe in your security_changed callback handler once the link is encrypted. You can also see central_hids sample for the same reference.

RE: How to Resubscribe to Old BLE Handles Upon Reconnection

LeviRand — Fri, 18 Jul 2025 21:24:13 GMT

To complete my thought, are there any good examples how to perform bonding?

RE: How to Resubscribe to Old BLE Handles Upon Reconnection

LeviRand — Fri, 18 Jul 2025 21:23:14 GMT

Hello again,

I spent some time trying a few different tactics as well as the example code you have provided. No attempt has worked.

Despite me re-initializing the structure like your example code above, the last notification will always fail to subscribe with an error code (-12 ---> ENOMEM). Why am I receiving this error code when trying to subscribe outside of the discovery process? This error code seems to suggest that I am running out of memory for this operation.

// Create fresh structure for fast subscription
struct bt_gatt_subscribe_params fresh = {
    .notify       = notifyStructBackup[handle].notify,
    .value_handle = notifyStructBackup[handle].value_handle,
    .ccc_handle   = notifyStructBackup[handle].ccc_handle,
    .value        = BT_GATT_CCC_NOTIFY,
};
notifyStruct[handle] = fresh;

int err = bt_gatt_subscribe(conn, &notifyStruct[handle]);

I am also using the memset in the notify callback as you suggested, but that did not change anything unfortunately.

uint8_t genericNotifyCollect(volatile uint8_t* storageArr, volatile bool* storageFlag, void (*codeInject)(uint8_t*),
    struct bt_gatt_subscribe_params *params, const void *data) {
    if ((uint8_t*)data) {
        uint8_t* myData = (uint8_t*)data;

        // Optionally Collect the Data
        if (storageArr != NULL && storageFlag != NULL) {
            *storageFlag = true;
		    oa_memcpy((uint8_t*)storageArr, myData, VND_MAX_LEN);
        }

        // Optionally, Perform Code Injection
        // This drastically reduces the code for some files
        if (codeInject != NULL) {
            codeInject(myData);
        }
    } else {
          printk("[BLE] UNSUBSCRIBING: Notify Returned Null: %d\n", params->value_handle);

        // Delete Parameters and Unsubscribe
		memset(params, 0, sizeof(*params));
        return BT_GATT_ITER_STOP;
    }

	// Continue Receiving Notification
    return BT_GATT_ITER_CONTINUE;
}

Researching this a bit more, it seems bonding is the proper way to do this. I haven't any good examples of how to do this online. I saw 2 examples on the Nordic Academy for enabling bonding on the peripheral but not the central.

RE: How to Resubscribe to Old BLE Handles Upon Reconnection

Susheel Nuguru — Mon, 14 Jul 2025 06:32:46 GMT

You’re seeing the “-128” errors because once the ATT channel is torn down there’s no socket left to drive the write-of-“0” to the CCCD. In other words, calling bt_gatt_unsubscribe() inside your disconnected() handler is too late. the GATT bearer is already gone, so the unsubscribe write fails with ENOTCONN. Instead, let Zephyr tell you when it’s done (it will invoke your notify callback with data==NULL to signal that unsubscribe has completed) and then just clear out your params struct. Something like this:

static uint8_t genericNotifyCollect(struct bt_gatt_subscribe_params *params,
                                    const void *data, uint16_t length)
{
    if (!data) {
        // completed the CCCD-write
        memset(params, 0, sizeof(*params));
        return BT_GATT_ITER_STOP;
    }
    
    return BT_GATT_ITER_CONTINUE;
}

When subscriptions are removed notify callback is called with the data set to NULL according to the documentation here.

You need to then build a fresh bt_gatt_subscribe_params (i.e. zero-initialized) on every new connect , fill in only:

p.value_handle = stored_handle;
p.ccc_handle   = stored_ccc;
p.value        = BT_GATT_CCC_NOTIFY;
p.notify       = your_notify_cb;

and then call 

bt_gatt_subscribe(conn, &p);

To kick of bonding (SMP pairing) from your master side you need to register your authentication callbacks using bt_conn_auth_cb_register and also set the security level once you are connected using bt_conn_set_security to say BT_SECUTIRY_L2 for example.

RE: How to Resubscribe to Old BLE Handles Upon Reconnection

LeviRand — Fri, 11 Jul 2025 22:40:25 GMT

Hi Susheel,

I have tested your initial response for resetting the subscribe params and found this yields the same result as before. Additionally, I tried unsubscribing during the disconnected() callback and found that the unsubscribing fails, providing a (-128) socket not connected error. See updated code below with log output. Thoughts?

Code:

void subscribeToStoredHandles(struct bt_conn *conn, char* addr) {
    bool subscribe;

    for (NOTIFY_CHAR_HANDLES_T handle = NOTIFY_FS_STATUS; handle < NUM_OF_NOTIFY_CHARS; handle++) {
        // Reset Subscribe Status
        subscribe = false;

        // Check if Handle is Valid
        if (notifyStruct[handle].ccc_handle != 0) {
            // Determine if Current Connection Matches Handle
            switch(handle) {
                case NOTIFY_FS_STATUS:
                case NOTIFY_FS_QUAT:
                case NOTIFY_FS_LOG:
                case NOTIFY_FS_RAW:
                    if (conn == *ptrFSConn) {
                        subscribe = true;
                    }
                    break;
                case NOTIFY_GL_VALUE:
                    if (conn == *ptrGLConn) {
                        subscribe = true;
                    }
                    break;
                case NOTIFY_TB_CMD:
                case NOTIFY_FWU_INFO:
                case NOTIFY_FWU_DATA:
                    if (conn == *ptrTBConn) {
                        subscribe = true;
                    }
                    break;
                default:
                    break;
            }

            // Perform Subscribe
            if (subscribe) {
                // Create fresh structure for fast subscription
                struct bt_gatt_subscribe_params fresh = {
                    .notify       = notifyStruct[handle].notify,
                    .value_handle = notifyStruct[handle].value_handle,
                    .ccc_handle   = notifyStruct[handle].ccc_handle,
                    .value        = BT_GATT_CCC_NOTIFY,
                };
                notifyStruct[handle] = fresh;

                int err = bt_gatt_subscribe(conn, &notifyStruct[handle]);
                // int err = bt_gatt_resubscribe(BT_ID_DEFAULT, addr, &notifyStruct[handle]);
                if (err) {
                    printk("[BLE] FAILURE: Subscribe failed (err %d). value=%d, value_handle=%d, ccc_handle=%d, notify=%d, subscribe=%d, node=%d, flags=%d, handle=%d\n",
                        err,
                        notifyStruct[handle].value,
                        notifyStruct[handle].value_handle,
                        notifyStruct[handle].ccc_handle,
                        notifyStruct[handle].notify,
                        notifyStruct[handle].subscribe,
                        notifyStruct[handle].node,
                        notifyStruct[handle].flags,
                        handle);
                } else {
                    printk("      - - Subscribed to value=%d, value_handle=%d, ccc_handle=%d, notify=%d, subscribe=%d, node=%d, flags=%d, handle=%d\n",
                        notifyStruct[handle].value,
                        notifyStruct[handle].value_handle,
                        notifyStruct[handle].ccc_handle,
                        notifyStruct[handle].notify,
                        notifyStruct[handle].subscribe,
                        notifyStruct[handle].node,
                        notifyStruct[handle].flags,
                        handle);

                }
            }
        }
    }

Log:

00> [BLE] Primary Service Discovered. Val = 0x1855, Handle = 41, End Handle = 55
00>       - 16-Bit Characteristic Discovered. Val = 0x2b26, Handle = 42
00>       - 16-Bit Characteristic Discovered. Val = 0x2b29, Handle = 44
00>       - - Looking for Notify Descriptor...
00>       - - Descriptor Discovered. Val = 0x2902, Handle = 46
00>       - - Subscribed to value=1, value_handle=45, ccc_handle=46, notify=176809, subscribe=0, node=0, flags=536904920, handle=0
00>       - 16-Bit Characteristic Discovered. Val = 0x2b2a, Handle = 47
00>       - - Looking for Notify Descriptor...
00>       - - Descriptor Discovered. Val = 0x2902, Handle = 49
00>       - - Subscribed to value=1, value_handle=48, ccc_handle=49, notify=176845, subscribe=0, node=536904924, flags=536904944, handle=1
00>       - 16-Bit Characteristic Discovered. Val = 0x2b2c, Handle = 50
00>       - - Looking for Notify Descriptor...
00>       - - Descriptor Discovered. Val = 0x2902, Handle = 52
00>       - - Subscribed to value=1, value_handle=51, ccc_handle=52, notify=176881, subscribe=0, node=536904948, flags=536904968, handle=2
00>       - 16-Bit Characteristic Discovered. Val = 0x2b2d, Handle = 53
00>       - - Looking for Notify Descriptor...
00>       - - Descriptor Discovered. Val = 0x2902, Handle = 55
00>       - - Subscribed to value=1, value_handle=54, ccc_handle=55, notify=176913, subscribe=0, node=536904972, flags=536904992, handle=3
00> [BLE] Looking for Next Service...
00> [BLE] Bluetooth Discovery: Complete


00> [BLE] UNSUBSCRIBING: Notify Returned Null: 54
00> [BLE] UNSUBSCRIBING: Notify Returned Null: 51
00> [BLE] UNSUBSCRIBING: Notify Returned Null: 48
00> [BLE] UNSUBSCRIBING: Notify Returned Null: 45
00> [BLE] FAILURE: Unsubscribe failed (err -128). value=0, value_handle=45, ccc_handle=46, notify=176809, subscribe=0, node=0, flags=536904920, handle=0
00> [BLE] FAILURE: Unsubscribe failed (err -128). value=0, value_handle=48, ccc_handle=49, notify=176845, subscribe=0, node=0, flags=536904944, handle=1
00> [BLE] FAILURE: Unsubscribe failed (err -128). value=0, value_handle=51, ccc_handle=52, notify=176881, subscribe=0, node=0, flags=536904968, handle=2
00> [BLE] FAILURE: Unsubscribe failed (err -128). value=0, value_handle=54, ccc_handle=55, notify=176913, subscribe=0, node=0, flags=536904992, handle=3
00> [BLE] Device Status: Disconnected 0x8


00> [BLE] Device Status: Connected
00> [BLE] Using Cached Handles
00>       - - Subscribed to value=1, value_handle=45, ccc_handle=46, notify=176809, subscribe=0, node=0, flags=536904920, handle=0
00>       - - Subscribed to value=1, value_handle=48, ccc_handle=49, notify=176845, subscribe=0, node=536904924, flags=536904944, handle=1
00>       - - Subscribed to value=1, value_handle=51, ccc_handle=52, notify=176881, subscribe=0, node=536904948, flags=536904968, handle=2
00> [BLE] FAILURE: Subscribe failed (err -12). value=1, value_handle=54, ccc_handle=55, notify=176913, subscribe=0, node=0, flags=536904992, handle=3

I am not bonded with my device, but I also tried using bt_gatt_resubscribe(). Predictably, this does not work either. I did some quick searching for the bonding API but did not find anything. What function must be called to initiate bonding with my peripheral?

RE: How to Resubscribe to Old BLE Handles Upon Reconnection

Susheel Nuguru — Fri, 11 Jul 2025 06:57:26 GMT

It looks like you are re-using the structures from the previous connection. Do not reuse bt_gatt_subscribe_params structures from a previous connection. Reinitialize these structures before resubscribing. Use bt_gatt_resubscribe() if you are bonded and the server supports persistent subscriptions, but still ensure the parameters are valid and reinitialized. Always set all required fields before calling bt_gatt_subscribe() or bt_gatt_resubscribe().

RE: How to Resubscribe to Old BLE Handles Upon Reconnection

LeviRand — Thu, 10 Jul 2025 23:39:51 GMT

Hi Susheel,

I appreciate your response. It is clear from what you are saying that my approach is incorrect. Thank you for providing an example using the resubscribe method. I will fully evaluate your response and get back soon. Work is busy, so hopefully early next week.

Thanks,

Levi

RE: How to Resubscribe to Old BLE Handles Upon Reconnection

Susheel Nuguru — Wed, 09 Jul 2025 07:09:32 GMT

Zephyr ties each bt_gatt_subscribe_params to internal state; you can’t just reuse it after a disconnect without resetting it. If your device is bonded and the server persists CCC, call bt_gatt_resubscribe() on reconnect and I think there no discovery needed.

Otherwise, explicitly call bt_gatt_unsubscribe() on disconnect, memset your params to zero, repopulate handle/callback fields, then bt_gatt_subscribe() again.

Something like this (not tested)

@@ void subscribeToStoredHandles(struct bt_conn *conn) {
-        // Perform Subscribe
-        if (subscribe) {
-            int err = bt_gatt_subscribe(conn, &notifyStruct[handle]);
-            if (err) {
-                printk("[BLE] FAILURE: Subscribe failed (err %d)\n", err);
-            } else {
-                printk("      - - Subscribed to Handle = %d, Notify = %d\n",
-                       notifyStruct[handle].ccc_handle, handle);
-            }
-        }
+        // Susheel changes: Perform Subscribe (re‐init struct so internal .node is cleared)
+        if (subscribe) {
+            struct bt_gatt_subscribe_params fresh = {
+                .notify       = notifyStruct[handle].notify,
+                .value_handle = notifyStruct[handle].value_handle,
+                .ccc_handle   = notifyStruct[handle].ccc_handle,
+                .value        = BT_GATT_CCC_NOTIFY,
+            };
+            /* overwrite the old one (zeroes out .node, .handle, .flags, etc) */
+            notifyStruct[handle] = fresh;
+
+            int err = bt_gatt_subscribe(conn, &notifyStruct[handle]);
+            if (err) {
+                printk("[BLE] FAILURE: Subscribe failed (err %d)\n", err);
+            } else {
+                printk("      - - Subscribed to Handle = %d, Notify = %d\n",
+                       notifyStruct[handle].ccc_handle, handle);
+            }
+        }