Problems while discovering services on a multilink central

RE: Problems while discovering services on a multilink central

sne_333 — Tue, 11 Jul 2023 04:26:00 GMT

Hi Hung Bui JCombes I am facing the same issue in my central device. Can you please help me sharing how to created a table to keep a track of conn_handle and how to keep it updated?

Regards,

Snehal

RE: Problems while discovering services on a multilink central

Hung Bui — Wed, 03 Jul 2019 11:56:55 GMT

Hi Jules,

Glad that the issue is now fixed :D Sorry that the case has been dragging for some time. It's a bit hard to catch the bug :D

RE: Problems while discovering services on a multilink central

JCombes — Wed, 03 Jul 2019 09:00:33 GMT

Hi Hung Bui,

I missed this and the error was due to this, thank you for your help.

Now I have a table containing the types (RFID_TYPE our RELAY_TYPE) of devices for each conn_handle which is updated on DISCOVERY_COMPLETE and BLE_GAP_EVT_DISCONNECTED.

I can count the RFID devices to know which instance of m_rfid_c I have to call in db_disc_handler.

For the relay, since I always use one relay, I define only one instance of relay client and call this one in db_disc_handler.

RE: Problems while discovering services on a multilink central

Hung Bui — Tue, 02 Jul 2019 14:19:17 GMT

Hi Jules,

I think I found something wrong here.

As you can see in the log, the p_relay_c->uuid_type showing quite strange value (21, 178).

I think it was because of this function:

static void db_disc_handler(ble_db_discovery_evt_t * p_evt)
{
rfid_on_db_disc_evt(&m_rfid_c[p_evt->conn_handle], p_evt);
relay_on_db_disc_evt(&m_relay_c[p_evt->conn_handle], p_evt);
}

In our multilink example this work because we only have one service lbs and there can be a simple match between the index of the m_lbs_c array and the index of connection handle. When it's not the case with your application.

You are declaring m_rfid_c array with the size of 7 and m_relay_c with size of 1. Calling a function using m_relay_c[p_evt->conn_handle] will cause trouble if the conn_handle is not equal to 0.

And since you don't know which one will be the first one to connect you can't be sure that the conn_handle = 0 will be always be the relay.

So you need to define a table that keep track of the connection handle that match with the relay and the list of active RFID node in an array. And keep that table (array) up to date on each CONNECTED/DISCONNECTED event. (You can detect if a device is a relay or a RFID by the if check inside rfid_on_db_disc_evt() and relay_on_db_disc_evt() )

RE: Problems while discovering services on a multilink central

JCombes — Tue, 02 Jul 2019 12:39:19 GMT

Hi Hung Bui,

I added logs so we can see the parameters inside the checks in rfid_on_db_disc_evt() and in relay_on_db_disc_evt() when the event is BLE_DB_DISCOVERY_COMPLETE :

void rfid_on_db_disc_evt(rfid_c_t * p_rfid_c, ble_db_discovery_evt_t const * p_evt)
{
    if(p_evt->evt_type == 0)
    {
        NRF_LOG_INFO("rfid_on_db_disc_evt :");
        NRF_LOG_INFO("\tp_evt->evt_type == BLE_DB_DISCOVERY_COMPLETE : %d",p_evt->evt_type == BLE_DB_DISCOVERY_COMPLETE);
        NRF_LOG_INFO("\tp_evt->params.discovered_db.srv_uuid.uuid == RFID_UUID : %d",p_evt->params.discovered_db.srv_uuid.uuid == RFID_UUID);
        NRF_LOG_INFO("\tp_evt->params.discovered_db.srv_uuid.type : %d\t\t\tp_rfid_c->uuid_type : %d",p_evt->params.discovered_db.srv_uuid.type,p_rfid_c->uuid_type);
    } 

    // Check if the Led Button Service was discovered.
    if (p_evt->evt_type == BLE_DB_DISCOVERY_COMPLETE &&
        p_evt->params.discovered_db.srv_uuid.uuid == RFID_UUID &&
        p_evt->params.discovered_db.srv_uuid.type == p_rfid_c->uuid_type)
    {
        rfid_c_evt_t evt;

        evt.evt_type    = RFID_C_EVT_DISCOVERY_COMPLETE;
        evt.conn_handle = p_evt->conn_handle;

        for (uint32_t i = 0; i < p_evt->params.discovered_db.char_count; i++)
        {
            //NRF_LOG_INFO("Discovering characteristics.");
            const ble_gatt_db_char_t * p_char = &(p_evt->params.discovered_db.charateristics[i]);
            switch (p_char->characteristic.uuid.uuid)
            {
                case SENSORS_FRAME_CHAR_UUID:
                    evt.params.peer_db.sensors_frame_handle      = p_char->characteristic.handle_value;
                    evt.params.peer_db.sensors_frame_cccd_handle = p_char->cccd_handle;
                    break;
                
                case MEASURE_REQUEST_CHAR_UUID:
                    evt.params.peer_db.measure_request_handle     = p_char->characteristic.handle_value;
                    break;

                default:
                    break;
            }
        }

        //NRF_LOG_INFO("RFID Service discovered at peer.");
        //If the instance has been assigned prior to db_discovery, assign the db_handles
        if (p_rfid_c->conn_handle != BLE_CONN_HANDLE_INVALID)
        {
            if ((p_rfid_c->peer_rfid_db.sensors_frame_handle      == BLE_GATT_HANDLE_INVALID)&&
                (p_rfid_c->peer_rfid_db.sensors_frame_cccd_handle == BLE_GATT_HANDLE_INVALID))
            {
                p_rfid_c->peer_rfid_db = evt.params.peer_db;
            }
        }

        p_rfid_c->evt_handler(p_rfid_c, &evt);

    }
}

void relay_on_db_disc_evt(relay_c_t * p_relay_c, ble_db_discovery_evt_t const * p_evt)
{
    if(p_evt->evt_type == 0)
    {
        NRF_LOG_INFO("relay_on_db_disc_evt :");
        NRF_LOG_INFO("\tp_evt->evt_type == BLE_DB_DISCOVERY_COMPLETE : %d",p_evt->evt_type == BLE_DB_DISCOVERY_COMPLETE);
        NRF_LOG_INFO("\tp_evt->params.discovered_db.srv_uuid.uuid == RELAY_UUID : %d",p_evt->params.discovered_db.srv_uuid.uuid == RELAY_UUID);
        NRF_LOG_INFO("\tp_evt->params.discovered_db.srv_uuid.type : %d\t\t\tp_relay_c->uuid_type : %d",p_evt->params.discovered_db.srv_uuid.type,p_relay_c->uuid_type);
    }    

    // Check if the Led Button Service was discovered.
    if (p_evt->evt_type == BLE_DB_DISCOVERY_COMPLETE &&
        p_evt->params.discovered_db.srv_uuid.uuid == RELAY_UUID &&
        p_evt->params.discovered_db.srv_uuid.type == p_relay_c->uuid_type)
    {
        relay_c_evt_t evt;

        evt.evt_type    = RELAY_C_EVT_DISCOVERY_COMPLETE;
        evt.conn_handle = p_evt->conn_handle;

        for (uint32_t i = 0; i < p_evt->params.discovered_db.char_count; i++)
        {
            //NRF_LOG_INFO("Discovering characteristics.");
            const ble_gatt_db_char_t * p_char = &(p_evt->params.discovered_db.charateristics[i]);
            switch (p_char->characteristic.uuid.uuid)
            {
                case BLACKLIST_CHAR_UUID:
                    evt.params.peer_db.blacklist_handle      = p_char->characteristic.handle_value;
                    evt.params.peer_db.blacklist_cccd_handle = p_char->cccd_handle;
                    break;
                case TRAME_CONCENTRATEUR_CHAR_UUID:
                    evt.params.peer_db.trame_concentrateur_handle     = p_char->characteristic.handle_value;
                    break;
                default:
                    break;
            }
        }
        //NRF_LOG_INFO("RELAY Service discovered at peer.");
        //If the instance has been assigned prior to db_discovery, assign the db_handles
        if (p_relay_c->conn_handle != BLE_CONN_HANDLE_INVALID)
        {
            if ((p_relay_c->peer_relay_db.blacklist_handle      == BLE_GATT_HANDLE_INVALID)&&
                (p_relay_c->peer_relay_db.blacklist_cccd_handle == BLE_GATT_HANDLE_INVALID))
            {
                p_relay_c->peer_relay_db = evt.params.peer_db;
            }
        }
        p_relay_c->evt_handler(p_relay_c, &evt);
    }
}

You were right, it seems like the problem is coming from the uuid_type, I get this :

<info> app: ------------------------------------------------------------------------------------------
<info> app: -------------------------------------Concentrator-----------------------------------------
<info> app: ------------------------------------------------------------------------------------------
<info> app: Scanning for RFID and RELAY.
<info> app: >>>>>RFID found<<<<<
<info> app: Connection 0x0 established, attempt to find RFID or RELAY
<info> app: rfid_on_db_disc_evt :
<info> app: 	p_evt->evt_type == BLE_DB_DISCOVERY_COMPLETE : 1
<info> app: 	p_evt->params.discovered_db.srv_uuid.uuid == RFID_UUID : 1
<info> app: 	p_evt->params.discovered_db.srv_uuid.type : 2			p_rfid_c->uuid_type : 2
<info> app: **********RFID service discovered on conn_handle 0x0**********
<info> app: Scanning for RFID and RELAY.
<info> app: relay_on_db_disc_evt :
<info> app: 	p_evt->evt_type == BLE_DB_DISCOVERY_COMPLETE : 1
<info> app: 	p_evt->params.discovered_db.srv_uuid.uuid == RELAY_UUID : 1
<info> app: 	p_evt->params.discovered_db.srv_uuid.type : 2			p_relay_c->uuid_type : 3
<info> app: >>>>>RFID found<<<<<
<info> app: Connection 0x1 established, attempt to find RFID or RELAY
<info> app: rfid_on_db_disc_evt :
<info> app: 	p_evt->evt_type == BLE_DB_DISCOVERY_COMPLETE : 1
<info> app: 	p_evt->params.discovered_db.srv_uuid.uuid == RFID_UUID : 1
<info> app: 	p_evt->params.discovered_db.srv_uuid.type : 2			p_rfid_c->uuid_type : 2
<info> app: **********RFID service discovered on conn_handle 0x1**********
<info> app: Scanning for RFID and RELAY.
<info> app: relay_on_db_disc_evt :
<info> app: 	p_evt->evt_type == BLE_DB_DISCOVERY_COMPLETE : 1
<info> app: 	p_evt->params.discovered_db.srv_uuid.uuid == RELAY_UUID : 1
<info> app: 	p_evt->params.discovered_db.srv_uuid.type : 2			p_relay_c->uuid_type : 21
<info> app: >>>>>RELAY found<<<<<
<info> app: Connection 0x2 established, attempt to find RFID or RELAY
<info> app: rfid_on_db_disc_evt :
<info> app: 	p_evt->evt_type == BLE_DB_DISCOVERY_COMPLETE : 1
<info> app: 	p_evt->params.discovered_db.srv_uuid.uuid == RFID_UUID : 1
<info> app: 	p_evt->params.discovered_db.srv_uuid.type : 3			p_rfid_c->uuid_type : 2
<info> app: relay_on_db_disc_evt :
<info> app: 	p_evt->evt_type == BLE_DB_DISCOVERY_COMPLETE : 1
<info> app: 	p_evt->params.discovered_db.srv_uuid.uuid == RELAY_UUID : 1
<info> app: 	p_evt->params.discovered_db.srv_uuid.type : 3			p_relay_c->uuid_type : 178

I will send you my source code in a private message.

(P:\Nordic\) was the folder where I put SDK 15 and SDK 15.3. (Now it is C:/Dev/nordic/)

You have to put these two SDK in the folder of your choice and replace the path by the path of the folder you choosed.

I use SDK 15 but there is a exception. Only for the ble_db_discovery module, I use the SDK 15.3

I did this in my .emProject file :

...

c_user_include_directories= "... ;C:/Dev/nordic/nRF5_SDK_15.3.0_59ac345/components/ble/ble_db_discovery; ... "
...
<folder Name="nRF_BLE">
<file file_name="C:/Dev/nordic/nRF5_SDK_15.0.0_a53641a/components/ble/common/ble_advdata.c" />
<file file_name="C:/Dev/nordic/nRF5_SDK_15.0.0_a53641a/components/ble/ble_advertising/ble_advertising.c" />
<file file_name="C:/Dev/nordic/nRF5_SDK_15.0.0_a53641a/components/ble/common/ble_conn_state.c" />
<file file_name="C:/Dev/nordic/nRF5_SDK_15.3.0_59ac345/components/ble/ble_db_discovery/ble_db_discovery.c" />
<file file_name="C:/Dev/nordic/nRF5_SDK_15.0.0_a53641a/components/ble/common/ble_srv_common.c" />
<file file_name="C:/Dev/nordic/nRF5_SDK_15.0.0_a53641a/components/ble/nrf_ble_gatt/nrf_ble_gatt.c" />
</folder>
...

RE: Problems while discovering services on a multilink central

Hung Bui — Mon, 01 Jul 2019 09:11:11 GMT

Hi Jules,

I think we are getting close, now the problem is around why relay_on_db_disc_evt() (or rfid_on_db_disc_evt() ) wouldn't detect when there is an UUID match (evt_type = 0 ).

There is a following check:

if (p_evt->evt_type == BLE_DB_DISCOVERY_COMPLETE &&
p_evt->params.discovered_db.srv_uuid.uuid == RELAY_UUID &&
p_evt->params.discovered_db.srv_uuid.type == p_relay_c->uuid_type)

I suspect it could be something wrong with the uuid_type. If you can print out those values in the log, we may be able to find why the function is called but not executing anything.

We can try to test here and debug your application as well. But it doesn't built here. There is some absolute path you set (P:\Nordic\)

If possible please send the latest source code. Are you still on SDK v15.0 or you moved to SDK v15.3 ?

RE: Problems while discovering services on a multilink central

JCombes — Fri, 28 Jun 2019 14:29:11 GMT

Hi Hung Bui,

Thank you for your help.

For the ble_app_hrs_rscs_relay example :

I have tried to start scanning after the discovery is complete and it works. I can’t find the issue anymore.

For my code :

The two custom services have the same 16 bits UUID but not the same base UUID.

I was thinking it was possible to do this but maybe it’s a misunderstanding?

This is the definition of the UUIDs for my custom service “RELAY” :

This is the definition of the UUIDs for my custom service “RFID” :

These are the structures I use in my main.c :

This is in my sdk_config.h :

I added NRF_LOG_DEBUG() in discovery_complete_evt_trigger() :

/**@brief     Function for triggering a Discovery Complete or Service Not Found event to the
 *            application.
 *
 * @details   This function will fetch the event handler based on the UUID of the service being
 *            discovered. (The event handler is registered by the application beforehand).
 *            It then triggers an event indicating the completion of the service discovery.
 *            If no event handler was found, then this function will do nothing.
 *
 * @param[in] p_db_discovery Pointer to the DB discovery structure.
 * @param[in] is_srv_found   Variable to indicate if the service was found at the peer.
 * @param[in] conn_handle    Connection Handle.
 */
static void discovery_complete_evt_trigger(ble_db_discovery_t * p_db_discovery,
                                           bool                 is_srv_found,
                                           uint16_t             conn_handle)
{
    ble_db_discovery_evt_handler_t   p_evt_handler;
    ble_gatt_db_srv_t              * p_srv_being_discovered;

    p_srv_being_discovered = &(p_db_discovery->services[p_db_discovery->curr_srv_ind]);

    NRF_LOG_DEBUG("m_num_of_handlers_reg = %d",m_num_of_handlers_reg);
    NRF_LOG_DEBUG("m_pending_usr_evt_index = %d",m_pending_usr_evt_index);

    p_evt_handler = registered_handler_get(&(p_srv_being_discovered->srv_uuid));

    if (p_evt_handler != NULL)
    {
        if (m_pending_usr_evt_index < DB_DISCOVERY_MAX_USERS)
        {
            // Insert an event into the pending event list.
            m_pending_user_evts[m_pending_usr_evt_index].evt.conn_handle = conn_handle;
            m_pending_user_evts[m_pending_usr_evt_index].evt.params.discovered_db =
                *p_srv_being_discovered;

            if (is_srv_found)
            {
                m_pending_user_evts[m_pending_usr_evt_index].evt.evt_type =
                    BLE_DB_DISCOVERY_COMPLETE;
            }
            else
            {
                m_pending_user_evts[m_pending_usr_evt_index].evt.evt_type =
                    BLE_DB_DISCOVERY_SRV_NOT_FOUND;
            }

            m_pending_user_evts[m_pending_usr_evt_index].evt_handler = p_evt_handler;
            m_pending_usr_evt_index++;

            NRF_LOG_DEBUG("m_pending_usr_evt_index = %d",m_pending_usr_evt_index);

            if (m_pending_usr_evt_index == m_num_of_handlers_reg)
            {
                // All registered modules have pending events. Send all pending events to the user
                // modules.
                pending_user_evts_send();
            }
            else
            {
                // Too many events pending. Do nothing. (Ideally this should not happen.)
            }
        }
    }
}

Now we will see m_num_of_handlers_reg and m_pending_usr_evt_index in the logs.

I observed that even for the last service discovery which don't work, m_num_of_handlers_reg is equal to m_pending_usr_evt_index so the function pending_user_evts_send() should be called.

I added NRF_LOG_DEBUG() in pending_user_evts_send() to see which event type is passed to the event handler :

/**@brief Function for sending all pending discovery events to the corresponding user modules.
 */
static void pending_user_evts_send(void)
{
    for (uint32_t i = 0; i < m_num_of_handlers_reg; i++)
    {
        
        NRF_LOG_DEBUG("m_pending_user_evts[i].evt = %d",m_pending_user_evts[i].evt.evt_type);

        // Pass the event to the corresponding event handler.
        m_pending_user_evts[i].evt_handler(&(m_pending_user_evts[i].evt));
    }

    m_pending_usr_evt_index = 0;
}

Here is an example of the logs when I don't get the event EVT_DISCOVERY_COMPLETE :

<info> app: ------------------------------------------------------------------------------------------
<info> app: -------------------------------------Concentrator-----------------------------------------
<info> app: ------------------------------------------------------------------------------------------
<info> app: Scanning for RFID and RELAY.
<info> app: >>>>>RFID found<<<<<
<info> app: Connection 0x0 established, attempt to find RFID or RELAY
<debug> ble_db_disc: Starting discovery of service with UUID 0x1 on connection handle 0x0.
<debug> ble_db_disc: Found service UUID 0x1.
<debug> ble_db_disc: Discovery of service with UUID 0x1 completed with success on connection handle 0x0.
<debug> ble_db_disc: m_num_of_handlers_reg = 2
<debug> ble_db_disc: m_pending_usr_evt_index = 0
<debug> ble_db_disc: m_pending_usr_evt_index = 1
<debug> ble_db_disc: Starting discovery of service with UUID 0x1 on connection handle 0x0.
<debug> ble_db_disc: Service UUID 0x1 not found.
<debug> ble_db_disc: m_num_of_handlers_reg = 2
<debug> ble_db_disc: m_pending_usr_evt_index = 1
<debug> ble_db_disc: m_pending_usr_evt_index = 2
<debug> ble_db_disc: m_pending_user_evts[i].evt.evt_type = 0
<info> app: **********RFID service discovered on conn_handle 0x0**********
<info> app: Scanning for RFID and RELAY.
<debug> ble_db_disc: m_pending_user_evts[i].evt.evt_type = 2
<info> app: >>>>>RFID found<<<<<
<info> app: Connection 0x1 established, attempt to find RFID or RELAY
<debug> ble_db_disc: Starting discovery of service with UUID 0x1 on connection handle 0x1.
<debug> ble_db_disc: Found service UUID 0x1.
<debug> ble_db_disc: Discovery of service with UUID 0x1 completed with success on connection handle 0x1.
<debug> ble_db_disc: m_num_of_handlers_reg = 2
<debug> ble_db_disc: m_pending_usr_evt_index = 0
<debug> ble_db_disc: m_pending_usr_evt_index = 1
<debug> ble_db_disc: Starting discovery of service with UUID 0x1 on connection handle 0x1.
<debug> ble_db_disc: Service UUID 0x1 not found.
<debug> ble_db_disc: m_num_of_handlers_reg = 2
<debug> ble_db_disc: m_pending_usr_evt_index = 1
<debug> ble_db_disc: m_pending_usr_evt_index = 2
<debug> ble_db_disc: m_pending_user_evts[i].evt.evt_type = 0
<info> app: **********RFID service discovered on conn_handle 0x1**********
<info> app: Scanning for RFID and RELAY.
<debug> ble_db_disc: m_pending_user_evts[i].evt.evt_type = 2
<info> app: >>>>>RELAY found<<<<<
<info> app: Connection 0x2 established, attempt to find RFID or RELAY
<debug> ble_db_disc: Starting discovery of service with UUID 0x1 on connection handle 0x2.
<debug> ble_db_disc: Service UUID 0x1 not found.
<debug> ble_db_disc: m_num_of_handlers_reg = 2
<debug> ble_db_disc: m_pending_usr_evt_index = 0
<debug> ble_db_disc: m_pending_usr_evt_index = 1
<debug> ble_db_disc: Starting discovery of service with UUID 0x1 on connection handle 0x2.
<debug> ble_db_disc: Found service UUID 0x1.
<debug> ble_db_disc: Discovery of service with UUID 0x1 completed with success on connection handle 0x2.
<debug> ble_db_disc: m_num_of_handlers_reg = 2
<debug> ble_db_disc: m_pending_usr_evt_index = 1
<debug> ble_db_disc: m_pending_usr_evt_index = 2
<debug> ble_db_disc: m_pending_user_evts[i].evt.evt_type = 2
<debug> ble_db_disc: m_pending_user_evts[i].evt.evt_type = 0

Now, I don't really understand what is going wrong.

RE: Problems while discovering services on a multilink central

Hung Bui — Thu, 27 Jun 2019 15:30:47 GMT

Hi Jules,

I believe the issue of the ble_app_hrs_rscs_relay can be solved by starting scan after the service has been discovered (like in your code) it must be related to the issue when 2 service discovery was performed at the same time. I attached the main.c that i modified to do what similar to your code. Could you have a quick test to see if you have the same issue ?

devzone.nordicsemi.com/.../main.c

In your code, you already fixed the issue. So there could be a different bug.

First could you explain why in your log, both of the service was with "UUID 0x1" ?

As you already noticed, from the log we can see that the service and characteristic discovery was finished but you didn't get the EVT_DISCOVERY_COMPLETE event in the the handler in main.c

We need to debug this.

We print "Discovery of service with UUID 0x%x completed with success" inside on_descriptor_discovery_rsp() and then we call discovery_complete_evt_trigger()

Inside discovery_complete_evt_trigger(), we will collect the events until they match with the number of handler (m_num_of_handlers_reg) and then we will send out to each handlers in main.c

We will not send the event(s) out if the number of queued event is still lower than the m_num_of_handlers_reg.

Could you try printing out some debug log inside discovery_complete_evt_trigger() ? I suspect that pending_user_evts_send() is not called when it should be called.

RE: Problems while discovering services on a multilink central

JCombes — Wed, 26 Jun 2019 14:28:54 GMT

Hi, thank you for your answer.

I don't know if this info can be useful but for my hardware I use 2 nRF52840DK and 2 BMD-340-EVAL.

My code :

I use now the db_discovery library from SDK v15.3.

I did the following tests with one central and 2 RFID peripheral and 1 RELAY peripheral.

With my code I get the issue 1 time for 2 try.

This is an example of when it works :

The discovery works and then I get the event “RFID_C_EVT_DISCOVERY_COMPLETE” and start scanning again.

This is an example of when it doesn’t work :

According to the DEBUG logs, it seems that the discovery is successful. But I don’t get the event “RELAY_C_EVT_DISCOVERY_COMPLETE”.

I can’t reproduce the issue when I use only one peripheral.

Example code (SDK 15.3) :

For the following test I use 1 ble_app_hrs_rscs_relay, 1 ble_app_hrs and 1 ble_app_rscs.

I had to try at least 15 time to reproduce the issue.

Example of only the HRS service has been discovered :

Here we have the connection handle 0x0 and 0x1 but only one service is discovered.

I can’t reproduce the issue when I use only one peripheral.

RE: Problems while discovering services on a multilink central

Hung Bui — Wed, 26 Jun 2019 11:42:16 GMT

Hi JCombes,

I'm testing here with the ble_app_hrs_rcsc_relay and couldn't reproduce the issue. How often do you see the issue ?
Could you increase the log level to DEBUG level so we can see more information ?

I suspect it's the issue when you connect 2 device at the same time and before the service can be found on one device the other device start new service discovery. But it should not be the case if you wait until the first device finish and start the second one.

Could you check if you can reproduce the issue either on ble_app_hrs_rcsc_relay or in your code if you test with only one peripheral ?

In addition, I would strongly suggest to use the db_discovery library from SDK v15.3 we fixed an issue with characteristic discovery inside the db_discovery module. You don't have to move to SDK v15.3 , just need to use the db_discovery library in SDK v15.3

RE: Problems while discovering services on a multilink central

JCombes — Tue, 18 Jun 2019 14:03:54 GMT

I looked at the ble_app_hrs_rscs_relay exemple but for SDK 15.0 beacause it is the SDK I was using for my project. The service discovery look similar to my projects.

I used this project with the ble_app_hrs and ble_app_rscs examples to test the following scenario :

Peripherals Relay (central)
+----------+ +-------------+
| Heart | | Heart |
| Rate | -----> | Rate |
| Sensor | | Collector |
+----------+ +-------------+
| Running |
+-----------+ | Speed |
| Running| ------>| Collector |
| Speed | +-------------+
| Sensor |
+-----------+

I found that there are some case with this example where it don't work neither. It is less frequent but sometimes the relay does not discover the HRS or the RSCS service.

For example, in this case the relay discovered only the HRS service :

Edit : I tried with the example ble_app_hrs_rcsc_relay of the SDK 15.3 too and I found the same problem. Sometimes one service is not discovered during the service discovery, did you found this too? Do you have other suggestions? Did you saw my private ticket?

RE: Problems while discovering services on a multilink central

JCombes — Mon, 17 Jun 2019 12:34:45 GMT

Hi, I just created a private ticket with a link to download the whole project.

I'm going to look at ble_app_hrs_rscs_relay, thank you for the advice.

RE: Problems while discovering services on a multilink central

run_ar — Fri, 14 Jun 2019 14:12:23 GMT

Hi,

Sorry for the late answer. You can create a private ticket and upload your project there.

Edit: I am afraid I cannot really see what you are doing wrong based on main.c. Have you tried to compare your solution against the nRF5_SDK_15.3.0_59ac345\examples\ble_central_and_peripheral\experimental\ble_app_hrs_rscs_relay example? this example is a client to both HRS and RSCS so it should handle discovery in the same way you application has to do it.

RE: Problems while discovering services on a multilink central

JCombes — Mon, 03 Jun 2019 14:56:57 GMT

Hi,

I have 4 discovery module instances, 1 relay instance and 3 rfid instance.

I use "ble_db_discovery_start()" on one instance of the discovery module "&m_db_disc[p_gap_evt->conn_handle]" in the BLE event handler in case BLE_GAP_EVT_CONNECTED (line313).

This is the main.c of my central :

#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include "nordic_common.h"
#include "nrf_sdh.h"
#include "nrf_sdh_ble.h"
#include "app_timer.h"
#include "bsp_btn_ble.h"
#include "ble.h"
#include "ble_hci.h"
#include "ble_advdata.h"
#include "ble_advertising.h"
#include "ble_conn_params.h"
#include "ble_db_discovery.h"
#include "ble_conn_state.h"
#include "nrf_ble_gatt.h"
#include "nrf_pwr_mgmt.h"

#include "peer_manager.h"
#include "fds.h"

#include "rfid_c.h"
#include "relay_c.h"

#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.h"


#define APP_BLE_CONN_CFG_TAG      1                                     /**< A tag that refers to the BLE stack configuration we set with @ref sd_ble_cfg_set. Default tag is @ref APP_BLE_CONN_CFG_TAG. */
#define APP_BLE_OBSERVER_PRIO     3                                     /**< Application's BLE observer priority. You shouldn't need to modify this value. */

#define SEC_PARAM_BOND              1                                   /**< Perform bonding. */
#define SEC_PARAM_MITM              0                                   /**< Man In The Middle protection not required. */
#define SEC_PARAM_LESC              0                                   /**< LE Secure Connections not enabled. */
#define SEC_PARAM_KEYPRESS          0                                   /**< Keypress notifications not enabled. */
#define SEC_PARAM_IO_CAPABILITIES   BLE_GAP_IO_CAPS_NONE                /**< No I/O capabilities. */
#define SEC_PARAM_OOB               0                                   /**< Out Of Band data not available. */
#define SEC_PARAM_MIN_KEY_SIZE      7                                   /**< Minimum encryption key size in octets. */
#define SEC_PARAM_MAX_KEY_SIZE      16                                  /**< Maximum encryption key size in octets. */

#define CENTRAL_SCANNING_LED      BSP_BOARD_LED_0
#define CENTRAL_CONNECTED_LED     BSP_BOARD_LED_1
#define LEDBUTTON_LED             BSP_BOARD_LED_2                       /**< LED to indicate a change of state of the the Button characteristic on the peer. */

#define MEASURE_REQUEST_1_BUTTON     BSP_BUTTON_0//we will not need these buttons for the final version
#define MEASURE_REQUEST_2_BUTTON     BSP_BUTTON_1
#define MEASURE_REQUEST_3_BUTTON     BSP_BUTTON_2

#define LEDBUTTON_BUTTON          BSP_BUTTON_0                          /**< Button that will write to the LED characteristic of the peer. */
#define BUTTON_DETECTION_DELAY    APP_TIMER_TICKS(50)                   /**< Delay from a GPIOTE event until a button is reported as pushed (in number of timer ticks). */

#define SCAN_INTERVAL             0x00A0                                /**< Determines scan interval in units of 0.625 millisecond. */
#define SCAN_WINDOW               0x00A0                                /**< Determines scan window in units of 0.625 millisecond. */
#define SCAN_DURATION             0x0000                                /**< Duration of the scanning in units of 10 milliseconds. If set to 0x0000, scanning will continue until it is explicitly disabled. */

#define MIN_CONNECTION_INTERVAL   MSEC_TO_UNITS(99, UNIT_1_25_MS)       /**< Determines minimum connection interval in milliseconds. */
#define MAX_CONNECTION_INTERVAL   MSEC_TO_UNITS(100, UNIT_1_25_MS)      /**< Determines maximum connection interval in milliseconds. */
#define SLAVE_LATENCY             0                                     /**< Determines slave latency in terms of connection events. */
#define SUPERVISION_TIMEOUT       MSEC_TO_UNITS(4000, UNIT_10_MS)       /**< Determines supervision time-out in units of 10 milliseconds. */

#define RFID_COUNT                3                                     //number of relay clients
#define RELAY_COUNT               1                                     //number of RFID clients
#define DB_DISC_COUNT             4                                     //number of discovery module, 1 for each peripheral

NRF_BLE_GATT_DEF(m_gatt);                                               /**< GATT module instance. */
RFID_C_ARRAY_DEF(m_rfid_c, RFID_COUNT);                                 /**< RFID service client instances. */
RELAY_C_ARRAY_DEF(m_relay_c, RELAY_COUNT);                              /**< RELAY service client instance. */
BLE_DB_DISCOVERY_ARRAY_DEF(m_db_disc, DB_DISC_COUNT);                   /**< Database discovery module instances. */ 

/**< Name of the devices we try to connect to. These names are searched for in the scan report data*/
static char const m_target_periph_RFID_name[] = "RFID";             
static char const m_target_IHMI_relay_name[] = "RELAY";

static uint8_t m_scan_buffer_data[BLE_GAP_SCAN_BUFFER_MIN]; /**< buffer where advertising reports will be stored by the SoftDevice. */

uint8_t cptButtonEvent=0;
uint8_t measure_request[2]={0xFF,0xFF};

//Pour les UUID custom, faire bien attetntion au quel on a déclaré en premier pour savoir si il s'agit de BEGIN ou BEGIN+1
ble_uuid_t rfid_uuid = {RFID_UUID, BLE_UUID_TYPE_VENDOR_BEGIN};
ble_uuid_t relay_uuid = {RELAY_UUID, BLE_UUID_TYPE_VENDOR_BEGIN+1};

/**@brief Pointer to the buffer where advertising reports will be stored by the SoftDevice. */
static ble_data_t m_scan_buffer =
{
    m_scan_buffer_data,
    BLE_GAP_SCAN_BUFFER_MIN
};

/**@brief Scan parameters requested for scanning and connection. */
static ble_gap_scan_params_t const m_scan_params =
{
    .active   = 0,
    .interval = SCAN_INTERVAL,
    .window   = SCAN_WINDOW,

    .timeout           = SCAN_DURATION,
    .scan_phys         = BLE_GAP_PHY_1MBPS,
    .filter_policy     = BLE_GAP_SCAN_FP_ACCEPT_ALL,

};

/**@brief Connection parameters requested for connection. */
static ble_gap_conn_params_t const m_connection_param =
{
    (uint16_t)MIN_CONNECTION_INTERVAL,
    (uint16_t)MAX_CONNECTION_INTERVAL,
    (uint16_t)SLAVE_LATENCY,
    (uint16_t)SUPERVISION_TIMEOUT
};

static void scan_start(void);

/**@brief Function to handle asserts in the SoftDevice.
 *
 * @details This function will be called in case of an assert in the SoftDevice.
 *
 * @warning This handler is an example only and does not fit a final product. You need to analyze
 *          how your product is supposed to react in case of Assert.
 * @warning On assert from the SoftDevice, the system can only recover on reset.
 *
 * @param[in] line_num     Line number of the failing ASSERT call.
 * @param[in] p_file_name  File name of the failing ASSERT call.
 */
void assert_nrf_callback(uint16_t line_num, const uint8_t * p_file_name)
{
    app_error_handler(0xDEADBEEF, line_num, p_file_name);
}


/**@brief Function for handling database discovery events.
 *
 * @details This function is callback function to handle events from the database discovery module.
 *          Depending on the UUIDs that are discovered, this function should forward the events
 *          to their respective services.
 *
 * @param[in] p_event  Pointer to the database discovery event.
 */
static void db_disc_handler(ble_db_discovery_evt_t * p_evt)
{
    NRF_LOG_INFO("Discovery handler for conn_handle 0x%x\tp_evt->evt-type : %d", p_evt->conn_handle, p_evt->evt_type);
    rfid_on_db_disc_evt(&m_rfid_c[p_evt->conn_handle], p_evt);
    relay_on_db_disc_evt(&m_relay_c[p_evt->conn_handle], p_evt);
}


/**@brief Function for handling Peer Manager events.
 *
 * @param[in] p_evt  Peer Manager event.
 */
/*
static void pm_evt_handler(pm_evt_t const * p_evt)
{
    ret_code_t err_code;

    switch (p_evt->evt_id)
    {
        case PM_EVT_BONDED_PEER_CONNECTED:
        {
            NRF_LOG_INFO("Connected to a previously bonded device.");
        } break;

        case PM_EVT_CONN_SEC_SUCCEEDED:
        {
            NRF_LOG_INFO("Connection secured: role: %d, conn_handle: 0x%x, procedure: %d.",
                         ble_conn_state_role(p_evt->conn_handle),
                         p_evt->conn_handle,
                         p_evt->params.conn_sec_succeeded.procedure);
        } break;

        case PM_EVT_CONN_SEC_FAILED:
        {
*/
            /* Often, when securing fails, it shouldn't be restarted, for security reasons.
             * Other times, it can be restarted directly.
             * Sometimes it can be restarted, but only after changing some Security Parameters.
             * Sometimes, it cannot be restarted until the link is disconnected and reconnected.
             * Sometimes it is impossible, to secure the link, or the peer device does not support it.
             * How to handle this error is highly application dependent. */
/*
        } break;

        case PM_EVT_CONN_SEC_CONFIG_REQ:
        {
            // Reject pairing request from an already bonded peer.
            pm_conn_sec_config_t conn_sec_config = {.allow_repairing = false};
            pm_conn_sec_config_reply(p_evt->conn_handle, &conn_sec_config);
        } break;

        case PM_EVT_STORAGE_FULL:
        {
            // Run garbage collection on the flash.
            err_code = fds_gc();
            if (err_code == FDS_ERR_NO_SPACE_IN_QUEUES)
            {
                // Retry.
            }
            else
            {
                APP_ERROR_CHECK(err_code);
            }
        } break;

        case PM_EVT_PEERS_DELETE_SUCCEEDED:
        {
            // Bonds are deleted. Start scanning.
            scan_start();
        } break;

        case PM_EVT_PEER_DATA_UPDATE_FAILED:
        {
            // Assert.
            APP_ERROR_CHECK(p_evt->params.peer_data_update_failed.error);
        } break;

        case PM_EVT_PEER_DELETE_FAILED:
        {
            // Assert.
            APP_ERROR_CHECK(p_evt->params.peer_delete_failed.error);
        } break;

        case PM_EVT_PEERS_DELETE_FAILED:
        {
            // Assert.
            APP_ERROR_CHECK(p_evt->params.peers_delete_failed_evt.error);
        } break;

        case PM_EVT_ERROR_UNEXPECTED:
        {
            // Assert.
            APP_ERROR_CHECK(p_evt->params.error_unexpected.error);
        } break;

        case PM_EVT_CONN_SEC_START:
        case PM_EVT_PEER_DATA_UPDATE_SUCCEEDED:
        case PM_EVT_PEER_DELETE_SUCCEEDED:
        case PM_EVT_LOCAL_DB_CACHE_APPLIED:
        case PM_EVT_LOCAL_DB_CACHE_APPLY_FAILED:
            // This can happen when the local DB has changed.
        case PM_EVT_SERVICE_CHANGED_IND_SENT:
        case PM_EVT_SERVICE_CHANGED_IND_CONFIRMED:
        default:
            break;
    }
}
*/


/**@brief Function for handling the advertising report BLE event.
 *
 * @param[in] p_adv_report  Advertising report from the SoftDevice.
 */
static void on_adv_report(ble_gap_evt_adv_report_t const * p_adv_report)
{
    ret_code_t err_code;
    
    if (ble_advdata_name_find(p_adv_report->data.p_data, p_adv_report->data.len, m_target_periph_RFID_name)&&ble_advdata_uuid_find(p_adv_report->data.p_data, p_adv_report->data.len, &rfid_uuid))
    {//name found
        if(ble_advdata_uuid_find(p_adv_report->data.p_data, p_adv_report->data.len, &rfid_uuid))
        {//custom uuid found
            NRF_LOG_INFO("RFID peripheral found");
            err_code = sd_ble_gap_connect(&p_adv_report->peer_addr, &m_scan_params, &m_connection_param,APP_BLE_CONN_CFG_TAG);
            if (err_code != NRF_SUCCESS)
            {
                NRF_LOG_ERROR("Connection Request Failed, reason %d", err_code);
            }
        }
    }
    else if(ble_advdata_name_find(p_adv_report->data.p_data, p_adv_report->data.len, m_target_IHMI_relay_name)&&ble_advdata_uuid_find(p_adv_report->data.p_data, p_adv_report->data.len, &relay_uuid))
    {//name found
        if(ble_advdata_uuid_find(p_adv_report->data.p_data, p_adv_report->data.len, &relay_uuid))
        {//custom uuid found
            NRF_LOG_INFO("IHMI relay found");
            err_code = sd_ble_gap_connect(&p_adv_report->peer_addr, &m_scan_params, &m_connection_param,APP_BLE_CONN_CFG_TAG);
            if (err_code != NRF_SUCCESS)
            {
                NRF_LOG_ERROR("Connection Request Failed, reason %d", err_code);
            }
        }
    }
    else
    {
        //NRF_LOG_INFO("No connection established, scan starts again");
        err_code = sd_ble_gap_scan_start(NULL, &m_scan_buffer);
        APP_ERROR_CHECK(err_code);
    }
}


/**@brief Function for handling BLE events.
 *
 * @param[in]   p_ble_evt   Bluetooth stack event.
 * @param[in]   p_context   Unused.
 */
static void ble_evt_handler(ble_evt_t const * p_ble_evt, void * p_context)
{
    ret_code_t err_code;

    // For readability.
    ble_gap_evt_t const * p_gap_evt = &p_ble_evt->evt.gap_evt;

    switch (p_ble_evt->header.evt_id)
    {
        // Upon connection, check which peripheral has connected, initiate DB
        // discovery, update LEDs status and resume scanning if necessary.
        case BLE_GAP_EVT_CONNECTED:
        {
            NRF_LOG_INFO("\tConnection 0x%x established, starting DB discovery.", p_gap_evt->conn_handle);

            APP_ERROR_CHECK_BOOL(p_gap_evt->conn_handle < NRF_SDH_BLE_CENTRAL_LINK_COUNT);

            err_code = ble_db_discovery_start(&m_db_disc[p_gap_evt->conn_handle], p_gap_evt->conn_handle);
            APP_ERROR_CHECK(err_code);
            if (err_code != NRF_ERROR_BUSY)
            {
                APP_ERROR_CHECK(err_code);
            }

            // Update LEDs status, and check if we should be looking for more
            // peripherals to connect to.
            bsp_board_led_on(CENTRAL_CONNECTED_LED);

            /*//il faut attendre que le service soit découvert avant de relancer le start
            if (ble_conn_state_central_conn_count() == NRF_SDH_BLE_CENTRAL_LINK_COUNT)
            {
                bsp_board_led_off(CENTRAL_SCANNING_LED);
            }
            else
            {
                // Resume scanning.
                bsp_board_led_on(CENTRAL_SCANNING_LED);
                scan_start();
            }
            */
        } break; // BLE_GAP_EVT_CONNECTED

        // Upon disconnection, reset the connection handle of the peer which disconnected, update
        // the LEDs status and start scanning again.
        case BLE_GAP_EVT_DISCONNECTED:
        {
            NRF_LOG_INFO("Central link 0x%x disconnected (reason: 0x%x)",
                         p_gap_evt->conn_handle,
                         p_gap_evt->params.disconnected.reason);

            if (ble_conn_state_central_conn_count() == 0)
            {
                // Turn off connection indication LED
                bsp_board_led_off(CENTRAL_CONNECTED_LED);
            }

            // Start scanning
            scan_start();

            // Turn on LED for indicating scanning
            bsp_board_led_on(CENTRAL_SCANNING_LED);

        } break;

        case BLE_GAP_EVT_ADV_REPORT:
            on_adv_report(&p_gap_evt->params.adv_report);
            break;

        case BLE_GAP_EVT_TIMEOUT:
        {
            // We have not specified a timeout for scanning, so only connection attemps can timeout.
            if (p_gap_evt->params.timeout.src == BLE_GAP_TIMEOUT_SRC_CONN)
            {
                NRF_LOG_INFO("Connection request timed out.");
            }
        } break;

        case BLE_GAP_EVT_CONN_PARAM_UPDATE_REQUEST:
        {
            NRF_LOG_INFO("BLE_GAP_EVT_CONN_PARAM_UPDATE_REQUEST.");
            // Accept parameters requested by peer.
            err_code = sd_ble_gap_conn_param_update(p_gap_evt->conn_handle,
                                        &p_gap_evt->params.conn_param_update_request.conn_params);
            APP_ERROR_CHECK(err_code);
        } break;

        case BLE_GAP_EVT_PHY_UPDATE_REQUEST:
        {
            NRF_LOG_INFO("PHY update request.");
            ble_gap_phys_t const phys =
            {
                .rx_phys = BLE_GAP_PHY_AUTO,
                .tx_phys = BLE_GAP_PHY_AUTO,
            };
            err_code = sd_ble_gap_phy_update(p_ble_evt->evt.gap_evt.conn_handle, &phys);
            APP_ERROR_CHECK(err_code);
        } break;

        case BLE_GATTC_EVT_TIMEOUT:
        {
            // Disconnect on GATT Client timeout event.
            NRF_LOG_INFO("GATT Client Timeout.");
            err_code = sd_ble_gap_disconnect(p_ble_evt->evt.gattc_evt.conn_handle,
                                             BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
            APP_ERROR_CHECK(err_code);
        } break;

        case BLE_GATTS_EVT_TIMEOUT:
        {
            // Disconnect on GATT Server timeout event.
            NRF_LOG_INFO("GATT Server Timeout.");
            err_code = sd_ble_gap_disconnect(p_ble_evt->evt.gatts_evt.conn_handle,
                                             BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
            APP_ERROR_CHECK(err_code);
        } break;

        default:
            // No implementation needed.
            break;
    }
}


/**@brief Function for initializing the BLE stack.
 *
 * @details Initializes the SoftDevice and the BLE event interrupts.
 */
static void ble_stack_init(void)
{
    ret_code_t err_code;

    err_code = nrf_sdh_enable_request();
    APP_ERROR_CHECK(err_code);

    // Configure the BLE stack using the default settings.
    // Fetch the start address of the application RAM.
    uint32_t ram_start = 0;
    err_code = nrf_sdh_ble_default_cfg_set(APP_BLE_CONN_CFG_TAG, &ram_start);
    APP_ERROR_CHECK(err_code);

    // Enable BLE stack.
    err_code = nrf_sdh_ble_enable(&ram_start);
    APP_ERROR_CHECK(err_code);

    // Register a handler for BLE events.
    NRF_SDH_BLE_OBSERVER(m_ble_observer, APP_BLE_OBSERVER_PRIO, ble_evt_handler, NULL);
}


/**@brief Function for the Peer Manager initialization.
 */
/*
static void peer_manager_init(void)
{
    ble_gap_sec_params_t sec_param;
    ret_code_t err_code;

    err_code = pm_init();
    APP_ERROR_CHECK(err_code);

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

    // Security parameters to be used for all security procedures.
    sec_param.bond           = SEC_PARAM_BOND;
    sec_param.mitm           = SEC_PARAM_MITM;
    sec_param.lesc           = SEC_PARAM_LESC;
    sec_param.keypress       = SEC_PARAM_KEYPRESS;
    sec_param.io_caps        = SEC_PARAM_IO_CAPABILITIES;
    sec_param.oob            = SEC_PARAM_OOB;
    sec_param.min_key_size   = SEC_PARAM_MIN_KEY_SIZE;
    sec_param.max_key_size   = SEC_PARAM_MAX_KEY_SIZE;
    sec_param.kdist_own.enc  = 1;
    sec_param.kdist_own.id   = 1;
    sec_param.kdist_peer.enc = 1;
    sec_param.kdist_peer.id  = 1;

    err_code = pm_sec_params_set(&sec_param);
    APP_ERROR_CHECK(err_code);

    err_code = pm_register(pm_evt_handler);
    APP_ERROR_CHECK(err_code);
}
*/


/** @brief Clear bonding information from persistent storage
 */
/*
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);
}
*/


/**@brief Handles events coming from the RFID central module.
 */
static void rfid_c_evt_handler(rfid_c_t * p_rfid_c, rfid_c_evt_t * p_rfid_c_evt)
{
    switch (p_rfid_c_evt->evt_type)
    {
        case RFID_C_EVT_DISCOVERY_COMPLETE:
        {
            ret_code_t err_code;

            NRF_LOG_INFO("\t\tRFID SERVICE DISCOVERED on conn_handle 0x%x", p_rfid_c_evt->conn_handle);
            
            err_code = rfid_c_handles_assign( p_rfid_c, p_rfid_c_evt->conn_handle, &p_rfid_c_evt->params.peer_db);
            APP_ERROR_CHECK(err_code);

            // Initiate bonding.
            /*
            err_code = pm_conn_secure(p_bas_c_evt->conn_handle, false);
            */
          
            //RFID service discovered. Enable notification of sensors_frame.
            err_code = rfid_c_sensors_frame_notif_and_indic_enable(p_rfid_c);
            APP_ERROR_CHECK(err_code);

            ///
            if (ble_conn_state_central_conn_count() == NRF_SDH_BLE_CENTRAL_LINK_COUNT)
            {
                bsp_board_led_off(CENTRAL_SCANNING_LED);
            }
            else
            {
                // Resume scanning.
                bsp_board_led_on(CENTRAL_SCANNING_LED);
                scan_start();
            }
            ///
        
        } break; // BLE_LBS_C_EVT_DISCOVERY_COMPLETE

        case RFID_C_EVT_SENSORS_FRAME_RECEIVED:
        {
            //we have to send sensors_frame to the relay
            //it's here that we put functions to execute in case of receiving notifications, not in
            //rfic_c -> BLE_GATTC-EVT_HVX because it can come from another ble service
                  
        } break; // RFID_C_EVT_SENSORS_FRAME_RECEIVED

        default:
            // No implementation needed.
            break;
    }
}


/**@brief Handles events coming from the RELAY central module.
 */
static void relay_c_evt_handler(relay_c_t * p_relay_c, relay_c_evt_t * p_relay_c_evt)
{
    switch (p_relay_c_evt->evt_type)
    {
        case RELAY_C_EVT_DISCOVERY_COMPLETE:
        {
            ret_code_t err_code;

            NRF_LOG_INFO("\t\tRELAY SERVICE DISCOVERED on conn_handle 0x%x", p_relay_c_evt->conn_handle);

            err_code = relay_c_handles_assign( p_relay_c, p_relay_c_evt->conn_handle, &p_relay_c_evt->params.peer_db);
            APP_ERROR_CHECK(err_code);

            // Initiate bonding.
            /*
            err_code = pm_conn_secure(p_bas_c_evt->conn_handle, false);
            */
            
            //RELAY service discovered. Enable notification of blacklist.
            err_code = relay_c_blacklist_notif_and_indic_enable(p_relay_c);
            APP_ERROR_CHECK(err_code);

            ///
            if (ble_conn_state_central_conn_count() == NRF_SDH_BLE_CENTRAL_LINK_COUNT)
            {
                bsp_board_led_off(CENTRAL_SCANNING_LED);
            }
            else
            {
                // Resume scanning.
                bsp_board_led_on(CENTRAL_SCANNING_LED);
                scan_start();
            }
            ///

        } break; // RELAY_C_EVT_DISCOVERY_COMPLETE

        case RELAY_C_EVT_BLACKLIST_RECEIVED:
        {
            //we have to save the blacklist
                  
        } break; // RELAY_C_EVT_BLACKLIST_RECEIVED

        default:
            // No implementation needed.
            break;
    }
}


/**@brief rfid client initialization.
 */
static void main_rfid_c_init(void)
{
    ret_code_t       err_code;
    rfid_c_init_t rfid_c_init_obj;

    rfid_c_init_obj.evt_handler = rfid_c_evt_handler;

    for (uint32_t i = 0; i < RFID_COUNT; i++)
    {
      err_code = rfid_c_init(&m_rfid_c[i], &rfid_c_init_obj);
      APP_ERROR_CHECK(err_code);
    }
}


/**@brief relay client initialization.
 */
static void main_relay_c_init(void)
{
    ret_code_t       err_code;
    relay_c_init_t relay_c_init_obj;

    relay_c_init_obj.evt_handler = relay_c_evt_handler;

    for (uint32_t i = 0; i < RELAY_COUNT; i++)
    {
        err_code = relay_c_init(&m_relay_c[i], &relay_c_init_obj);
        APP_ERROR_CHECK(err_code);
    }
}


/** @brief Database discovery initialization.
 */
static void db_discovery_init(void)
{
    ret_code_t err_code = ble_db_discovery_init(db_disc_handler);
    APP_ERROR_CHECK(err_code);
}


/**@brief Function to start scanning. */
static void scan_start(void)
{
    ret_code_t ret;

    (void) sd_ble_gap_scan_stop();

    NRF_LOG_INFO("Scanning for %s and %s peripherals.", (uint32_t)m_target_periph_RFID_name,(uint32_t)m_target_IHMI_relay_name);
    ret = sd_ble_gap_scan_start(&m_scan_params, &m_scan_buffer);
    APP_ERROR_CHECK(ret);
    // Turn on the LED to signal scanning.
    bsp_board_led_on(CENTRAL_SCANNING_LED);
}


/**@brief Function for initializing power management.
 */
static void power_management_init(void)
{
    ret_code_t err_code;
    err_code = nrf_pwr_mgmt_init();
    APP_ERROR_CHECK(err_code);
}


/**@brief Function for handling the idle state (main loop).
 *
 * @details Handle any pending log operation(s), then sleep until the next event occurs.
 */
static void idle_state_handle(void)
{
    if (NRF_LOG_PROCESS() == false)
    {
        nrf_pwr_mgmt_run();
    }
}


/**@brief Function for handling events from the button handler module.
 *
 * @param[in] pin_no        The pin that the event applies to.
 * @param[in] button_action The button action (press/release).
 */
static void button_event_handler(uint8_t pin_no, uint8_t button_action)
{
    ret_code_t err_code;

    switch (pin_no)
    {
        case MEASURE_REQUEST_1_BUTTON:
            cptButtonEvent++;
            if(cptButtonEvent==2)
            {
              uint8_t measure_request[]={0x1,0x1};
              for (uint32_t i = 0; i< NRF_SDH_BLE_CENTRAL_LINK_COUNT; i++)
              {
                  //NRF_LOG_INFO("m_rfid_c[%d].conn_handle : 0x%x",i,m_rfid_c[i].conn_handle);
                  if(m_rfid_c[i].conn_handle != BLE_CONN_HANDLE_INVALID)
                  {
                      write_measure_request(&m_rfid_c[i], measure_request);
                  }
              }
              cptButtonEvent=0;
            }
            break;

        case MEASURE_REQUEST_2_BUTTON:
            cptButtonEvent++;
            if(cptButtonEvent==2)
            {
              uint8_t measure_request[]={0x1,0x2};
              for (uint32_t i = 0; i< NRF_SDH_BLE_CENTRAL_LINK_COUNT; i++)
              {
                  if(m_rfid_c[i].conn_handle != BLE_CONN_HANDLE_INVALID)
                  {
                      write_measure_request(&m_rfid_c[i], measure_request);
                  }
              }
              cptButtonEvent=0;
            }
            break;

        case MEASURE_REQUEST_3_BUTTON:
            cptButtonEvent++;
            if(cptButtonEvent==2)
            {
              uint8_t measure_request[]={0x1,0x3};
              for (uint32_t i = 0; i< NRF_SDH_BLE_CENTRAL_LINK_COUNT; i++)
              {
                  if(m_rfid_c[i].conn_handle != BLE_CONN_HANDLE_INVALID)
                  {
                      write_measure_request(&m_rfid_c[i], measure_request);
                  }
              }
              cptButtonEvent=0;
            }
            break;

        default:
            APP_ERROR_HANDLER(pin_no);
            break;
    }
}


/**@brief Function for initializing the button handler module.
 */
static void buttons_init(void)
{
    ret_code_t err_code;

    //The array must be static because a pointer to it will be saved in the button handler module.
    static app_button_cfg_t buttons[] =
    {
        {MEASURE_REQUEST_1_BUTTON, false, BUTTON_PULL, button_event_handler},
        {MEASURE_REQUEST_2_BUTTON, false, BUTTON_PULL, button_event_handler},
        {MEASURE_REQUEST_3_BUTTON, false, BUTTON_PULL, button_event_handler}
    };

    err_code = app_button_init(buttons, ARRAY_SIZE(buttons),
                               BUTTON_DETECTION_DELAY);
    APP_ERROR_CHECK(err_code);
}


/**@brief Function for the LEDs initialization.
 *
 * @details Initializes all LEDs used by the application.
 */
static void leds_init(void)
{
    bsp_board_init(BSP_INIT_LEDS);
}


/** @brief Function for initializing the log module.
 */
static void log_init(void)
{
    ret_code_t err_code = NRF_LOG_INIT(NULL);
    APP_ERROR_CHECK(err_code);

    NRF_LOG_DEFAULT_BACKENDS_INIT();
}


/** @brief Function for initializing the timer.
 */
static void timer_init(void)
{
    ret_code_t err_code = app_timer_init();
    APP_ERROR_CHECK(err_code);
}


/**@brief Function for initializing the GATT module.
 */
static void gatt_init(void)
{
    ret_code_t err_code = nrf_ble_gatt_init(&m_gatt, NULL);
    APP_ERROR_CHECK(err_code);
}


/**@brief Function for starting a scan, or instead trigger it from peer manager (after
 *        deleting bonds).
 *
 * @param[in] p_erase_bonds Pointer to a bool to determine if bonds will be deleted before scanning.
 */
/*
void scanning_start(bool * p_erase_bonds)
{
    // Start scanning for peripherals and initiate connection
    // with devices that advertise GATT Service UUID.
    if (*p_erase_bonds == true)
    {
        // Scan is started by the PM_EVT_PEERS_DELETE_SUCCEEDED event.
        delete_bonds();
    }
    else
    {
        scan_start();
    }
}
*/


int main(void)
{
    ret_code_t err_code;
    bool erase_bonds;

    // Initialize.
    log_init();
    NRF_LOG_INFO("------------------------------------------------------------------------------------------");
    NRF_LOG_INFO("-------------------------------------Concentrator-----------------------------------------");
    NRF_LOG_INFO("------------------------------------------------------------------------------------------");

    NRF_LOG_INFO("Event types for the discovery :")
    NRF_LOG_INFO("\t%d : BLE_DB_DISCOVERY_COMPLETE",BLE_DB_DISCOVERY_COMPLETE);             
    NRF_LOG_INFO("\t%d : BLE_DB_DISCOVERY_ERROR",BLE_DB_DISCOVERY_ERROR);                   
    NRF_LOG_INFO("\t%d : BLE_DB_DISCOVERY_SRV_NOT_FOUND",BLE_DB_DISCOVERY_SRV_NOT_FOUND);   
    NRF_LOG_INFO("\t%d : BLE_DB_DISCOVERY_AVAILABLE",BLE_DB_DISCOVERY_AVAILABLE);           

    timer_init();
    buttons_init();
    leds_init();
    power_management_init();
    ble_stack_init();
    gatt_init();
    db_discovery_init();
    main_rfid_c_init();
    main_relay_c_init();
    ble_conn_state_init();

    err_code = app_button_enable();
    APP_ERROR_CHECK(err_code);

    //scanning_start(&erase_bonds);
    scan_start();

    // Enter main loop.
    for (;;)
    {
       idle_state_handle();
    }
}

How can I send you my whole project?

RE: Problems while discovering services on a multilink central

run_ar — Mon, 03 Jun 2019 12:47:09 GMT

How many instances of the DB discovery module have you registered? Could you be using the same for all connections? Check: BLE_DB_DISCOVERY_ARRAY_DEF(m_db_discovery, 2); /**< Database discovery module instances. */

The ble_app_hrs_rscs_relay example has code that shows how to start multiple instances. See the on_ble_central_evt handler in the BLE_GAP_EVT_CONNECTED event.

If this doesn't help is it possible for you to share your project so I can see what you are doing?

RE: Problems while discovering services on a multilink central

JCombes — Tue, 28 May 2019 11:33:10 GMT

Do you have any other suggestions to improve my service discovery please run_ar?

RE: Problems while discovering services on a multilink central

JCombes — Thu, 23 May 2019 14:26:18 GMT

Hi, thank you for your help.

I changed my program so it start to scan again for new peripherals only when the services of the previously connected peripheral has been discovered.

I have now the funtion "scan_start();" in my central event handlers in "case C_EVT_DISCOVERY_COMPLETE".

It works sometimes with this method but not always.

Here is an example of when it does not work :

On the conn_handle 0x0 the discovery handler continues even if the service is already discovered. Then the RFID service is discovered several times on conn_handle 0x0.

On the conn_handle 0x1 the relay service is discovered.

On the conn_handle 0x2 the RFID service is not discovered and the discovery handler stop.

RE: Problems while discovering services on a multilink central

run_ar — Thu, 23 May 2019 12:55:12 GMT

If I remember correctly there is a limitation with the discovery module. so you should only do service discovery on one peer at the time. Can you try to add a check so you do not start service discovery on the new device if the process is already ongoing?