Questions about implementing BLE bonding with NUS

RE: Questions about implementing BLE bonding with NUS

Edvin — Fri, 10 Jul 2020 11:50:18 GMT

Hello Joe,

Thank you for sharing, and I am glad to hear that it worked out.

Have a nice weekend.

Best regards,

Edvin

RE: Questions about implementing BLE bonding with NUS

sdtjoe — Fri, 10 Jul 2020 02:44:45 GMT

Hi Edvin,

Thank you very much for your help so far.
Finally I have get my device working correctly.

My purpose is 1-to-1 connection, so I just followed your suggestion.
What I do is add a disconnect process and wait for the disconnect event before deleting the bonding.

Here is my code for reference, in case someone need it in the future.

static void button_handler(uint8_t pin_no, uint8_t button_action)
{
    uint32_t err_code;
    //NRF_LOG_INFO("button_handler");
    if(button_action == APP_BUTTON_PUSH)
    {
        NRF_LOG_INFO("APP_BUTTON_PUSH (pin_no = %d)", pin_no);
        switch(pin_no)
        {
            case DELETE_BUTTON_PIN:
                  if (m_is_connected) {
                      m_delete_bond_after_disconnect = true;
                      err_code = sd_ble_gap_disconnect(m_conn_handle, BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
                      if (err_code != NRF_ERROR_INVALID_STATE)
                      {
                          APP_ERROR_CHECK(err_code);
                      }
                  } else {
                      advertising_start(true);
                  }
                break;
            default:
                break;
        }
    }
}

static void ble_evt_handler(ble_evt_t const * p_ble_evt, void * p_context)
{
    uint32_t err_code;

    switch (p_ble_evt->header.evt_id)
    {
        // ...
        case BLE_GAP_EVT_DISCONNECTED:
            NRF_LOG_INFO("Disconnected");
            // ...
            advertising_start(m_delete_bond_after_disconnect);
            m_delete_bond_after_disconnect = false;
        break;
    // ...
}

Best Regards,
Joe

RE: Questions about implementing BLE bonding with NUS

Edvin — Wed, 08 Jul 2020 09:11:45 GMT

Hello,

Thanks for sharing your progress. It is very useful for other users who encounter similar problems.

The softdevice can only have a certain number of connections (declared in the application). If you are in a connection, and you have set the maximum number of connections to 1, then sd_ble_gap_adv_start() will return NRF_ERROR_CONN_COUNT. So in your case, you are probably still connected, and you start advertising again.

If you only intend to support one connection at the time, you need to disconnect before you start advertising. Deleting the bonds will not disconnect your current connections, so you need to do this "manually".

Perhaps your button handler can disconnect from the central before it deletes the bonds. Remember that disconnecting can take some time, especially if you have a long connection interval. If so, perhaps you should set a flag (a local variable), and disconnect. When you get the disconnected event, you can check this flag, and call advertising_start(true) if the flag is set, and advertising_start(false) if the flag is not set (just a normal disconnect).

If you intend to support more than one connection, you need to increase the connection count. Please refer to the multilink examples. ble_app_multilink_central for multilink central, and ble_app_multiperipheral for multiperipheral.

Best regards,

Edvin

RE: Questions about implementing BLE bonding with NUS

sdtjoe — Wed, 08 Jul 2020 03:53:30 GMT

Hi Edvin,

I have solved the problem finally. It is because I missed the whitelist in the Peripheral side.
After integrating the whitelist by referencing example ble_app_hids_keyboard, the Problem #2 is fixed.
After some simple tests, bonded device will only connect to each other correctly.

And I found a new problem about advertising on Peripheral.

Background:
There is a button on Peripheral, the button will erase the the saved bonding information on Peripheral. And the same for Central.
After erasing, I want the device to restart scan for Central and advertising for Peripheral.

Scenario:
(Code sample are below)
1. Peripheral and Central are bonded and connected.
2. On Peripheral, press on the button to call advertising_start(true), which will call delete_bond().
3. pm_peers_delete() will trigger event PM_EVT_PEERS_DELETE_SUCCEEDED in pm_evt_handler.
4. PM_EVT_PEERS_DELETE_SUCCEEDED event will call advertising_start(false)
5. When ble_advertising_start is called, the error NRF_ERROR_CONN_COUNT is returned.

static void advertising_start(bool erase_bonds)
{
    NRF_LOG_INFO("advertising_start(%d)", erase_bonds);
    if (erase_bonds == true)
    {
        delete_bonds();
        // Advertising is started by PM_EVT_PEERS_DELETE_SUCCEEDED event.
    }
    else
    {
        whitelist_set(PM_PEER_ID_LIST_SKIP_NO_ID_ADDR);

        ret_code_t err_code = ble_advertising_start(&m_advertising, BLE_ADV_MODE_FAST);
        APP_ERROR_CHECK(err_code);	// Line 1180

        m_is_advertising = true;
        NRF_LOG_INFO("Advertising start");
    }
}

static void delete_bonds(void)
{
    ret_code_t err_code;

    NRF_LOG_INFO("Erase bonds");

    err_code = pm_peers_delete();
    APP_ERROR_CHECK(err_code);
}

static void pm_evt_handler(pm_evt_t const * p_evt)
{
    pm_handler_on_pm_evt(p_evt);
    pm_handler_flash_clean(p_evt);

    switch (p_evt->evt_id)
    {
        case PM_EVT_PEERS_DELETE_SUCCEEDED:
            NRF_LOG_INFO("PM_EVT_PEERS_DELETE_SUCCEEDED");
            advertising_start(false);
            break;
		//...
}

I found that the error is from sd_ble_gap_adv_start(...), line 653 of ble_advertising.c

if (p_advertising->adv_mode_current != BLE_ADV_MODE_IDLE)
{

	ret = sd_ble_gap_adv_set_configure(&p_advertising->adv_handle, p_advertising->p_adv_data, &p_advertising->adv_params);
	if (ret != NRF_SUCCESS)
	{
		return ret;
	}
	ret = sd_ble_gap_adv_start(p_advertising->adv_handle, p_advertising->conn_cfg_tag);		// Line 653

	if (ret != NRF_SUCCESS)
	{
		return ret;
	}
}

According to nrf_error.h:

#define NRF_ERROR_CONN_COUNT (NRF_ERROR_BASE_NUM + 18) ///< Maximum connection count exceeded.

Does it mean that I cannot advertise when there is an active connection?
If so, does it mean that I have to disconnect from Central before start to advertise?

Best Regards,
Joe

RE: Questions about implementing BLE bonding with NUS

sdtjoe — Tue, 07 Jul 2020 00:48:13 GMT

Hi Edvin,

Thank you for your reply.
May be I have do something wrong when integrating my project code from the sample code.
Let me try to figure it out why PM_EVT_CONN_SEC_CONFIG_REQ does not appear first.
And I will use manually erasing as you suggested for testing.

Best Regards,

Joe

RE: Questions about implementing BLE bonding with NUS

Edvin — Mon, 06 Jul 2020 09:12:48 GMT

I don't think I follow what you are doing anymore. If one of the devices still has bonding information and the other one doesn't, I believe you should get an event to which you should call a reply with .allow_repairing = true or false. I believe this event is the PM_EVT_CONN_SEC_CONFIG_REQ event.

If you are not sure how whether your bonds are deleted, I suggest you work with manually erasing the chip for now, until you figure out how to handle the different setups (one device having the bonding information, while the other doesn't).

Best regards,

Edvin

RE: Questions about implementing BLE bonding with NUS

sdtjoe — Fri, 03 Jul 2020 02:29:26 GMT

Hello Edvin,

Just like some additional observation.

Instead of deleting bond by pressing button to call delete_bond from the problem, I tried Target > Erase All to remove the whole device memory by J-Link.

(The observed result is same as previous.)
Scenario 1:
If I perform remove all to the Peripheral, the Central can no longer connect due to PM_CONN_SEC_ERROR_PIN_OR_KEY_MISSING.
Scenario 2:
On the otherhand, if I perform remove all to the Central, the Peripheral still can connect again.

According to the observation, I understand the situation as follow:
Scenario 1 proved that the Central is actually remembering the Peripheral, because when the Peripheral device is cleared the key is also lost, therefore, the "old" Central rejects the connection of the "new" Peripheral?
Scenario 2 proved that the Peripheral is not remembering the Central, because the Peripheral can connect to a "new" Central, even it has been bonded with the "old" Central.

So I guess the problem is due to some security or bonding setting?
I think should look for the problem from the code on Peripheral side rather than on Central side.

Best Regards,
Joe

RE: Questions about implementing BLE bonding with NUS

sdtjoe — Thu, 02 Jul 2020 08:34:20 GMT

Hello Edvin,

I don't have pm_conn_sec_params_reply at all in my code.
I the only similar one is pm_conn_sec_config_reply.
But I believe this event has never been fired, as it didn't shown in the log.

Here is my pm_evt_handler function of the Central device.

static void pm_evt_handler(pm_evt_t const * p_evt)
{
    pm_handler_on_pm_evt(p_evt);
    pm_handler_flash_clean(p_evt);

    switch (p_evt->evt_id)
    {
        case PM_EVT_PEERS_DELETE_SUCCEEDED:
            // Bonds are deleted. Start scanning.
            NRF_LOG_INFO("PM_EVT_PEERS_DELETE_SUCCEEDED");
            scan_start();
            break;

        case PM_EVT_CONN_SEC_CONFIG_REQ:
            NRF_LOG_INFO("PM_EVT_CONN_SEC_CONFIG_REQ");
            pm_conn_sec_config_t conn_sec_config = {.allow_repairing = true};
            pm_conn_sec_config_reply(p_evt->conn_handle, &conn_sec_config);
            break;

        case PM_EVT_BONDED_PEER_CONNECTED: // 0
            NRF_LOG_INFO("PM_EVT_BONDED_PEER_CONNECTED");
            break;

        case PM_EVT_CONN_SEC_START: // 1
            NRF_LOG_INFO("PM_EVT_CONN_SEC_START");
            break;

        case PM_EVT_CONN_SEC_SUCCEEDED: // 2
            NRF_LOG_INFO("PM_EVT_CONN_SEC_SUCCEEDED");
            break;

        case PM_EVT_CONN_SEC_FAILED: // 3
            NRF_LOG_INFO("PM_EVT_CONN_SEC_FAILED");
            break;

        case PM_EVT_CONN_SEC_PARAMS_REQ: // 5
            NRF_LOG_INFO("PM_EVT_CONN_SEC_PARAMS_REQ");
            break;

        case PM_EVT_PEER_DATA_UPDATE_SUCCEEDED: // 8
            NRF_LOG_INFO("PM_EVT_PEER_DATA_UPDATE_SUCCEEDED");
            break;

        case PM_EVT_LOCAL_DB_CACHE_APPLIED: // 14
            NRF_LOG_INFO("PM_EVT_LOCAL_DB_CACHE_APPLIED");
            break;

        case PM_EVT_SLAVE_SECURITY_REQ: // 18
            NRF_LOG_INFO("PM_EVT_SLAVE_SECURITY_REQ");
            break;

        default:
            NRF_LOG_INFO("p_evt->evt_id = %d", p_evt->evt_id);
            break;
    }
}

If response to the pm_conn_sec_params_reply is needed, shall I just response the same setting as param_sec?

case PM_EVT_CONN_SEC_PARAMS_REQ: // 5
	NRF_LOG_INFO("PM_EVT_CONN_SEC_PARAMS_REQ");
	ble_gap_sec_params_t sec_param;

	memset(&sec_param, 0, sizeof(ble_gap_sec_params_t));

	// Security parameters to be used for all security procedures.
	sec_param.bond           = 1;
	sec_param.mitm           = 0;
	sec_param.lesc           = 0;
	sec_param.keypress       = 0;
	sec_param.io_caps        = BLE_GAP_IO_CAPS_NONE;
	sec_param.oob            = 0;
	sec_param.min_key_size   = 7;
	sec_param.max_key_size   = 16;
	sec_param.kdist_own.enc  = 1;
	sec_param.kdist_own.id   = 1;
	sec_param.kdist_peer.enc = 1;
	sec_param.kdist_peer.id  = 1;
	pm_conn_sec_params_reply(p_evt->conn_handle, &sec_param, NULL);
	break;

Best Regards,
Joe

RE: Questions about implementing BLE bonding with NUS

Edvin — Thu, 02 Jul 2020 07:32:07 GMT

Hello Joe,

I am a bit confused:

[quote user="sdtjoe"]However neither Central or Peripheral the event PM_EVT_CONN_SEC_CONFIG_REQ is not being fired.[/quote]

But from the latest screenshot of the log, the line before "Unexpected Behavior" says:

"PM_EVT_CONN_SEC_PARAMS_REQ" (not the same, but similar). From peer_manager_types.h:

/**< @brief Security parameters (@ref ble_gap_sec_params_t) are needed for an ongoing security procedure. Reply with @ref pm_conn_sec_params_reply before the event handler returns. If no reply is sent, the parameters given in @ref pm_sec_params_set are used. If a peripheral connection, the central's sec_params will be available in the event. */

Do you reply with pm_conn_sec_params_reply? Do you get any events on the peripheral at this point in time?

Where did you set .allow_repairing = true in the central?

BR,

Edvin

RE: Questions about implementing BLE bonding with NUS

sdtjoe — Thu, 02 Jul 2020 03:50:24 GMT

Hello Edvin,

Thank you for your reply.

For Problem #1 (Solved):
I have followed your suggestion and ignore the COMMUNICATION_ERROR unless the device is connected.
It works correctly and I applied this solution as I believe this is a better workaround.

For Problem #2:
I have added a log to print when PM_EVT_CONN_SEC_CONFIG_REQ is being called in pm_evt_handler.
However neither Central or Peripheral the event PM_EVT_CONN_SEC_CONFIG_REQ is not being fired.
So I think the allow_pairing did not set at all.

case PM_EVT_CONN_SEC_CONFIG_REQ:
NRF_LOG_INFO("PM_EVT_CONN_SEC_CONFIG_REQ");
pm_conn_sec_config_t conn_sec_config = {.allow_repairing = true};
pm_conn_sec_config_reply(p_evt->conn_handle, &conn_sec_config);
break;

Here is additional information that may help.
I think I am using a Just Work Bonding. My sec_param is set as follow:

sec_param.bond = 1;
sec_param.mitm = 0;
sec_param.lesc = 0;
sec_param.keypress = 0;
sec_param.io_caps = BLE_GAP_IO_CAPS_NONE;
sec_param.oob = 0;
sec_param.min_key_size = 7;
sec_param.max_key_size = 16;
sec_param.kdist_own.enc = 1;
sec_param.kdist_own.id = 1;
sec_param.kdist_peer.enc = 1;
sec_param.kdist_peer.id = 1;

In addition, I call delete_bonds() function for both Central and Peripheral.
It will call pm_peer_delete() same as sample code.

static void delete_bonds(void)
{
ret_code_t err_code;

NRF_LOG_INFO("Erase bonds");

err_code = pm_peers_delete();
APP_ERROR_CHECK(err_code);
}

Here is my steps and observation:
Scenario 1 (No problem at all):
1. Turn on both devices which are never connected.
2. They will bond.
3. Turn off either Central / Peripheral and they will connect again.
4. Press delete button on Peripheral side, PM_EVT_PEERS_DELETE_SUCCEEDED event is fired.
5. Try to connect again, PM_CONN_SEC_ERROR_PIN_OR_KEY_MISSING, which is my expected behavior.

Scenario 2 (Unexpected behavior):
1. Turn on both devices which are never connected.
2. They will bond.
3. Turn off either Central / Peripheral and they will connect again.
4. Press delete button on Central side, PM_EVT_PEERS_DELETE_SUCCEEDED event is fired.
5. Try to connect again, the devices connected successfully. But I expect it should be rejected as I have deleted the Central bonding in step 4.

Maybe I have missed some setting on either side?

Best Regards,
Joe

RE: Questions about implementing BLE bonding with NUS

Edvin — Tue, 30 Jun 2020 14:09:14 GMT

[quote user="sdtjoe"]Thank you for your suggestion.
I have moved the uart_init() from main to the event handler of event BLE_GAP_EVT_CONNECTED, so the UART will only init after BLE is connected. And also I have created a flag to make sure it run only once.
And the problem seems to be fixed. I will do further test on this later on.[/quote]

Good! An alternative is to just ignore the COMMUNICATION_ERROR event unless the device is connected. You can experiment with different workarounds.

Make sure the allow_repairing is set to true in the device that did not lose the bonding information. Or set it in both devices, if there is a chance that they both lose it.

Does the PM_EVT_CONN_SEC_CONFIG_REQ event occur in any of the devices?

BR,

Edvin

RE: Questions about implementing BLE bonding with NUS

sdtjoe — Tue, 30 Jun 2020 08:38:33 GMT

Hello Edvin,

Thank you for your reply.

Actually the Central device is a USB dongle.
What my project do is:
Peripheral will send data through BLE NUS, and the Central device will receive the data and transfer it through UART to PC.

For Problem #1:
Thank you for your suggestion.
I have moved the uart_init() from main to the event handler of event BLE_GAP_EVT_CONNECTED, so the UART will only init after BLE is connected. And also I have created a flag to make sure it run only once.
And the problem seems to be fixed. I will do further test on this later on.

For Problem #2:
Would the following description be one of the possibility of this problem?
At first devices bonding are done, so the key is establish and shared.
But either one of them does not save permanently in flash storage, so after power off, one of them has lost the key?
If so, is there anyway I can check if the device has stored the key?

Actually in pm_evt_handler, I have added allow_repairing for both Peripheral and Central.

case PM_EVT_CONN_SEC_CONFIG_REQ:
NRF_LOG_INFO("PM_EVT_CONN_SEC_CONFIG_REQ");
pm_conn_sec_config_t conn_sec_config = {.allow_repairing = true};
pm_conn_sec_config_reply(p_evt->conn_handle, &conn_sec_config);
break;

But from the log, I did not see any log message "PM_EVT_CONN_SEC_CONFIG_REQ".
So maybe this part of code is not being called?

Best Regards,
Joe

RE: Questions about implementing BLE bonding with NUS

Edvin — Mon, 29 Jun 2020 11:55:59 GMT

Hello Joe,

Problem #1:

The value in p_evt->data.error_communication refers to the errorsrc register on the UART peripheral:

https://infocenter.nordicsemi.com/topic/com.nordic.infocenter.nrf52832.ps.v1.1/uarte.html?cp=4_2_0_34_9_4#register.ERRORSRC

When this is 12, it means you have a framing error. Are your UART pins connected to anything? If not, perhaps you should skip the uart_init(), if you are not using it.

Problem #2:

At this point, does one of the devices contain bonding information, while the other doesn't?

RE: Questions about implementing BLE bonding with NUS

sdtjoe — Mon, 29 Jun 2020 08:29:56 GMT

Hello

Sorry I was busy on other project so I was unable to update the progress.

After referencing the examples, looks like I am able to bond two nRF52 devices.
According to the log, the peer data was updated in flash.

If I just turn the Peripheral device off and on again, the Central remain on, the devices reconnected successfully and no change is made in flash.

Problem #1:
However, if I turn the Central off, and turn it on again, it shows the following error:
ERROR 12 [NRF_ERROR_DATA_SIZE]
(The error is occurred on Central side, not Peripheral side)
(The Central program is based on the example ble_uart_c)

case APP_UART_COMMUNICATION_ERROR:
NRF_LOG_ERROR("Communication error occurred while handling UART.");
APP_ERROR_HANDLER(p_event->data.error_communication); // Line 1006
break;

And I can only erase the Central and re-download the program again.
I have read several posts talking about this.
Most are on Peripheral side, but mine is on Central side.

Problem #2:
After problem #1 occured, the pairing no long success.
When trying to connect, the error of 4102 is returned.
4102 => 0x1006 => PM_CONN_SEC_ERROR_PIN_OR_KEY_MISSING

Is there any hint on the above two problems?

Best Regards
Joe

RE: Questions about implementing BLE bonding with NUS

Edvin — Fri, 12 Jun 2020 10:12:50 GMT

Hello,

When you see the "fatal error" in the log, define DEBUG in your preprocessor definitions, and the log should point to where the error is coming from.

For the bonding questions, I suggest you look into some of the examples that use bonding. A peripheral that use this is the ble_app_gls, and a central project that use it is the ble_app_hrs_c.

[quote user="sdtjoe"]To create a bonding, do I need to implement on both side (Peripheral and Central)? Or i just have to implement on one side, say the Central device?[/quote]

Both sides. If not, then the devices without the whitelist will always accept connections from other devices.

Best regards,

Edvin

RE: Questions about implementing BLE bonding with NUS

sdtjoe — Fri, 12 Jun 2020 08:58:23 GMT

Hi Edvin

Thank you for your reply.

Looks like the connection is disconnected due to fatal error on Peripheral.
Here is the RTT log of Peripheral.

I cannot figure it out where did it come from yet. When I try to debug, it always jump to NRF_BREAKPOINT_COND.

And some supplementary about the devices behavior:
Both Peripheral and Central are nRF52 devices. If Central is not paired, it keeps scanning for Peripheral. On the other hand, when Peripheral is not paired, it keeps advertising until it is connected. So basically when both are power on, it should be connected immediately.

That mean to archive my goal, I have to:
Once the bonding is completed, I can "add it to whitelist".
So it will always only connect to each other, unless I clear the bonding (the devices become a unpaired "new device")

To create a bonding, do I need to implement on both side (Peripheral and Central)? Or i just have to implement on one side, say the Central device?

Best Regards
Joe

RE: Questions about implementing BLE bonding with NUS

Edvin — Thu, 11 Jun 2020 13:06:03 GMT

Hello,

You can see where this error is printed:

It is from the PM_EVT_CONN_SEC_FAILED event in pm_handler_pm_evt_log() from peer_manager_handler.c:

            NRF_LOG_INFO("Connection security failed: role: %s, conn_handle: 0x%x, procedure: %s, error: %d",
                         m_roles_str[ble_conn_state_role(p_pm_evt->conn_handle)],
                         p_pm_evt->conn_handle,
                         m_sec_procedure_str[p_pm_evt->params.conn_sec_start.procedure],
                         p_pm_evt->params.conn_sec_failed.error);

You can see that the error number is printed as a decimal value (%d), so this means that the decimal value is 0x1100. So what does that mean?

Looking at the type of the p_pm_evt->params.conn_sec_failed.error, which is an pm_sec_error_code_t, you can see from the description that it is:

/**@brief Errors from security procedures in Peer Manager.
 *
 * @details Possible values are defined in @ref PM_SEC_ERRORS and @ref BLE_GAP_SEC_STATUS.
 */
typedef uint16_t pm_sec_error_code_t;

(from peer_manager_types.h, line 74-78)

So from @defgroup PM_SEC_ERRORS:

#define PM_CONN_SEC_ERROR_DISCONNECT (PM_CONN_SEC_ERROR_BASE + 0x100) /**< @brief Pairing or encryption did not finish before the link disconnected for an unrelated reason. */

(PM_CONN_SEC_ERROR_BASE is 0x1000)

So the error you receive is because of the disconnect.

Are you prompted with any pairing questions when connecting with nRF Connect for Desktop? Did you try to click the settings icon of the connection and click pair (and check of "bond")?

[quote user=""]2. Actually what I would like to archive is that I want the previously paired devices remember each other. Just like our earphone always connect to our smartphone when both power on. Therefore even if there are multiple peripherals and centrals are power on, the devices will not paired to a device that is not paired before.
As far as my understanding, the original example of NUS, Central will search for any Peripheral device with NUS UUID. So I cannot guarantee which device connect to which if I have multiple Peripheral advertising and Central scanning at the same time. So I googled and found bonding seems to be the solution. Is my understanding correct? Please correct me if I am wrong.[/quote]

That is almost correct. Bonding means that you store the encryption keys of the connection. After you have bonded, either your central or peripheral (or both) may use something called a whitelist when it is scanning/advertising. If you do this, it will only accept connections to that device.

That being said. Even if you bond with a phone, it doesn't mean that this phone will try to connect to the peripheral whenever it is advertising. I don't know the exact details about earphones, because that is not BLE, but Classic Bluetooth. However, I suspect that it is similar to HID devices. You will see that if you try to flash the ble_app_hids_keyboard example, the phone will automatically reconnect to that device. The reason for this is that it is a HID [device] (Human Interface Device), and the phone's OS finds it useful. However, if you use most other examples, the phone will not automatically connect even though they are bonded. If you want something custom to automatically connect to your phone, you must write an application on the phone that will scan for and connect to your peripheral.

Back to whitelists: The main purpose of whitelists is to look for specific devices, and deny connection from others. One example that uses a whitelist is the ble_app_gls, and the ble_app_hrs_c.

Best regards,

Edvin