Bluetooth LE Device Name not being found when using find name function

[inspiringdev123]

I am currently developing a BLE central device to find devices based on their name to extract data from their advertising packet without connecting. I was able to do this using the UUID, but since all of these devices will be transmitting the same UUID, I need to do it based on name. I was able to find the top device in my picture using ble_advdata_name_find, but I am unable to find the device below. I am setting the device name as such for now static char const target_device_name[] = "92094"; I have attached my ble event handler as well where this data processing is done. Any help is appreciated why one device is found but the other is not!

 

/**@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 is connected, initiate DB
        // discovery, update LEDs status, and resume scanning, if necessary.
        case BLE_GAP_EVT_CONNECTED:
        {
            NRF_LOG_INFO("Connection 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_lbs_c_handles_assign(&m_lbs_c[p_gap_evt->conn_handle],
                                                p_gap_evt->conn_handle,
                                                NULL);
            APP_ERROR_CHECK(err_code);

            err_code = ble_db_discovery_start(&m_db_disc[p_gap_evt->conn_handle],
                                              p_gap_evt->conn_handle);
            APP_ERROR_CHECK(err_code);

            // Update LEDs status and check whether it is needed to look for more
            // peripherals to connect to.
            bsp_board_led_on(CENTRAL_CONNECTED_LED);
            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 that disconnected, update
        // the LEDs status and start scanning again.
        case BLE_GAP_EVT_DISCONNECTED:
        {
            NRF_LOG_INFO("LBS 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)
            {
                err_code = app_button_disable();
                APP_ERROR_CHECK(err_code);

                // Turn off the LED that indicates the connection.
                bsp_board_led_off(CENTRAL_CONNECTED_LED);
            }

            // Start scanning.
            scan_start();

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

        } break;

        case BLE_GAP_EVT_TIMEOUT:
        {
            // Timeout for scanning is not specified, so only the connection requests can time out.
            if (p_gap_evt->params.timeout.src == BLE_GAP_TIMEOUT_SRC_CONN)
            {
                NRF_LOG_DEBUG("Connection request timed out.");
            }
        } break;

        case BLE_GAP_EVT_CONN_PARAM_UPDATE_REQUEST:
        {
            NRF_LOG_DEBUG("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_DEBUG("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_DEBUG("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_DEBUG("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;
/* NOTE This is where we read in scanned BLE packet. We use uuid_find to filter based on UUIDs. */
/* The ble_uuid is currently set to 0x18FF which is the LE of the Pressure Sensors Watchlist data packet */
        case BLE_GAP_EVT_ADV_REPORT: 
     
            // Initialize advertisement report for parsing.
            bleData = p_ble_evt->evt.gap_evt.params.adv_report.data;
            bool found = false;
            uint8_t * p_encoded_data = bleData.p_data;
            uint16_t data_len = bleData.len;

            found = ble_advdata_name_find(p_encoded_data,
                                  data_len,
                                  target_device_name);

            //found = ble_advdata_uuid_find(p_encoded_data,
            //                      data_len,
            //                      &ble_uuid);
            if(found)
            { 
                // Copy the entire advertising data
                memcpy(pressure_data, m_scan.scan_buffer_data, BLE_PRESSURE_ADV_DATA_BUFFER_SIZE);
                process_ble_data();
            }
            break;

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

 

[inspiringdev123]

This is the scan response data with the name. How do I go about using both of these packets to filter daat

[Einar Thorsrud]

The SoftDevice and SDK scanning module both operate separately on each advertising packet and a scan response packet is just an advertising packet in this context. So if you need to see these together, you need to parse received packets separately.

In practice that would probably involve temporarily storing relevant advertising packets and scan response packets, and when you have received both packet types from the same address, you can parse them and get all the data that way.

[inspiringdev123]

Okay thanks. Are there any examples out there that nay expediate this? 

[Einar Thorsrud]

There are no examples of this in the SDK nor anywhere else I can find now, unfortunately. But in practice I guess you can make buffers that can hold a certain amount of advertising packets and scan response packets, and when you receive one check if you have the other type of packet from the same device already buffered, and if you do, parse them (using functions provided in ble_advdata.h).