How to scan only advertising name??

[Dev_Dev]

i used nrf52840 and scanning.

'A'(nrf52) is scanning and 'B'(nrf52) is advertising.. (with 2 products)

How do I find it by name 'B'?

i couldn't get NRF_BLE_SCAN_EVT_FILTER_MATCH...

i get NRF_BLE_SCAN_EVT_NOT_FOUND...

thankyou..

/**< Scan parameters requested for scanning and connection. */
static ble_gap_scan_params_t const m_scan_param =
{
    .active        = 0x01,
    .interval      = NRF_BLE_SCAN_SCAN_INTERVAL,
    .window        = NRF_BLE_SCAN_SCAN_WINDOW,
    .filter_policy = BLE_GAP_SCAN_FP_ACCEPT_ALL, //BLE_GAP_SCAN_FP_WHITELIST,BLE_GAP_SCAN_FP_ACCEPT_ALL
    .timeout       = SCAN_DURATION_WITELIST,
    .scan_phys     = BLE_GAP_PHY_1MBPS,

};


/**@brief Function for handling Scanning Module events.
 */
static void scan_evt_handler(scan_evt_t const * p_scan_evt)
{
    ret_code_t err_code;
    data_t   adv_data;
    // Initialize advertisement report for parsing
    adv_data.p_data   = (uint8_t *) p_scan_evt->params.p_not_found->data.p_data;
    
    adv_data.data_len = p_scan_evt->params.p_not_found->data.len;

    uint8_t         ad_types[N_AD_TYPES];
    uint8_t       * p_parsed_uuid;
    uint16_t        parsed_uuid_len = adv_data.data_len;
    uint8_t         uuid_buffer[UUID128_SIZE]; 

    uint16_t parsed_name_len;
    uint8_t * p_parsed_name;
    uint16_t data_offset = 0;
    uint16_t target_name_len= strlen(m_target_periph_name);
    ble_gap_evt_adv_report_t const * adv_report = p_scan_evt->params.p_not_found;

    switch(p_scan_evt->scan_evt_id)
    {
        case NRF_BLE_SCAN_EVT_FILTER_MATCH: 
        {
            DEBUG_PRINTF("___FILTER_MATCH!\r\n");
            
        } break;
        case NRF_BLE_SCAN_EVT_CONNECTING_ERROR:
        {
            err_code = p_scan_evt->params.connecting_err.err_code;
            APP_ERROR_CHECK(err_code);
        } break;
        
        case NRF_BLE_SCAN_EVT_NOT_FOUND:
        {

            //DEBUG_PRINTF("___NOT FOUND!\r\n");
            #if 0
            ad_types[0] = BLE_GAP_AD_TYPE_128BIT_SERVICE_UUID_COMPLETE;
            ad_types[1] = BLE_GAP_AD_TYPE_128BIT_SERVICE_UUID_MORE_AVAILABLE;

            for (uint8_t i = 0; (i < N_AD_TYPES) && (data_offset == 0); i++)
            {
                parsed_uuid_len = ble_advdata_search(adv_data.p_data, adv_data.data_len, &data_offset, ad_types[i]);
            }

            if (data_offset == 0 )
            {
                // Could not find any relevant UUIDs in the encoded data.
                return;
            }
           
            p_parsed_uuid = &adv_data.p_data[data_offset]; //The UUID we found 

            //Copy the UUID to our list of devices
            memset(uuid_buffer,0,UUID128_SIZE);
            memcpy(uuid_buffer, p_parsed_uuid, parsed_uuid_len);

             NRF_LOG_INFO("Device-addr %02x:%02x:%02x:%02x:%02x:%02x",
             p_scan_evt->params.p_not_found->peer_addr.addr[5],
             p_scan_evt->params.p_not_found->peer_addr.addr[4],
             p_scan_evt->params.p_not_found->peer_addr.addr[3],
             p_scan_evt->params.p_not_found->peer_addr.addr[2],
             p_scan_evt->params.p_not_found->peer_addr.addr[1],
             p_scan_evt->params.p_not_found->peer_addr.addr[0]
             );



            NRF_LOG_INFO("Hexdump:");
            NRF_LOG_HEXDUMP_INFO(p_parsed_uuid,parsed_uuid_len);
            #endif
        }
            break;

        case NRF_BLE_SCAN_EVT_CONNECTED:
        {
           //
        
        } break;

        case NRF_BLE_SCAN_EVT_SCAN_TIMEOUT:
        {
            NRF_LOG_INFO("Scan timed out.");
            //scan_start();
        } break;

        default:
        break;
    }
}

void ble_scan_init(void)
{
    ret_code_t          err_code;
    nrf_ble_scan_init_t init_scan;

    memset(&init_scan, 0, sizeof(init_scan));

    init_scan.p_scan_param     = &m_scan_param;
    init_scan.connect_if_match = true;
    init_scan.conn_cfg_tag     = APP_BLE_CONN_CFG_TAG;

    err_code = nrf_ble_scan_init(&m_scan, &init_scan, scan_evt_handler);
    APP_ERROR_CHECK(err_code);

    ble_uuid_t uuid =
    {
        .uuid = TARGET_UUID,
        .type = BLE_UUID_TYPE_BLE,
    };

    err_code = nrf_ble_scan_filter_set(&m_scan,
                                       SCAN_UUID_FILTER,
                                       &uuid);
    APP_ERROR_CHECK(err_code);

    err_code = nrf_ble_scan_filter_set(&m_scan,
                                        SCAN_NAME_FILTER,
                                        m_target_periph_name);
    APP_ERROR_CHECK(err_code);

    err_code = nrf_ble_scan_filters_enable(&m_scan,
                                           NRF_BLE_SCAN_ALL_FILTER,
                                           false);
    APP_ERROR_CHECK(err_code);

}

[Dev_Dev]

case NRF_BLE_SCAN_EVT_NOT_FOUND:
        {
            //name check
            /* Scan encoded adv. payload for data of type BLE_GAP_AD_TYPE_COMPLETE_LOCAL_NAME */ 
            parsed_name_len = ble_advdata_search(adv_report->data.p_data, adv_report->data.len, &data_offset, BLE_GAP_AD_TYPE_SHORT_LOCAL_NAME);
            
            /* Name found if parsed_name_len != 0 */
            p_parsed_name = &adv_report->data.p_data[data_offset];            

            // if p_parsed_name == target name, then Connect with peripheral
            if(memcmp(m_target_periph_name, p_parsed_name, target_name_len)== 0)                    // compare only target_name_len chars of advertised name and target name
            {
                
                    DEBUG_PRINTF("SEARCH OK!\r\n");
            }
        }

 

 I solved. [BLE_GAP_AD_TYPE_SHORT_LOCAL_NAME]

Product search was successful, but the connection was unsuccessful.

how to connect??

is not working init_scan.connect_if_match = true;

[Hung Bui]

Hi Hwang,

The reason it doesn't connect because it didn't consider that it's a name matched. 
As you can see you found the packet inside NRF_BLE_SCAN_EVT_NOT_FOUND. 
I would suggest to use SCAN_SHORT_NAME_FILTER instead of SCAN_NAME_FILTER when you call ble_scan_init()

Like this: 

err_code = nrf_ble_scan_filter_set(&m_scan,SCAN_SHORT_NAME_FILTER ,m_target_periph_name);

Another option is to connect manually using the address of the advertiser that you find inside NRF_BLE_SCAN_EVT_NOT_FOUND using sd_ble_gap_connect().