Hi,
I am using NR52832 withnRF5_SDK_15.3.0_59ac345.
I want to scan nearby mobile BLE devices and get its data from its advertising data and also its scan response data.
I am able to scan nearby devices, also able to get information like its mac address, RSSI, name, and service data.
Here, I am advertising my mobile using the NRF Connect application via ADVERTISER.
x
but I am not able to get scan response data.
So how can I get Scan response data in my NRF52832?
Here is the code for scanning configuration
//-----------------scanner---------------------------//
#include "nrf_ble_scan.h"
#define SCAN_DURATION_WITELIST 3000 /**< Duration of the scanning in units of 10 milliseconds. */
#define MAX_DEV_LIMIT 30
#define APP_SOC_OBSERVER_PRIO 1 /**< Applications' SoC observer priority. You shouldn't need to modify this value. */
#define SCAN_UPDATE_DELAY APP_TIMER_TICKS(2000) /**< Time from initiating event (connect or start of notification) to first time sd_ble_gap_conn_param_update is called (5 seconds). */
#define TARGET_UUID BLE_UUID_GATT /**< Target device name that application is looking for. */
int8_t RSSI=0,tmp_rssi=0;
uint8_t esp_version = 1;
int dev_count = 0; //Number of peripheral devices
static bool m_memory_access_in_progress; /**< Flag to keep track of ongoing operations on persistent memory. */
static bool m_whitelist_disabled; /**< True if whitelist has been temporarily disabled. */
static bool m_erase_bonds; /**< Bool to determine if bonds should be erased before scanning starts. Based on button push upon startup. */
uint8_t scan = 0;
struct list_dev{
uint8_t id;
int8_t rssi;
uint8_t addr[6];
uint8_t name[30];
uint8_t service_id[2];
uint8_t service_data[20];
}
mac[MAX_DEV_LIMIT];
NRF_BLE_SCAN_DEF(m_scan); /**< Scanning Module instance. */
APP_TIMER_DEF(m_scan_timer_id);
/**< 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,
.timeout = SCAN_DURATION_WITELIST,
.scan_phys = BLE_GAP_PHY_1MBPS,
};
static char const m_target_periph_name[] = "Nordic_GATTS"; /**< If you want to connect to a peripheral using a given advertising name, type its name here. */
static bool is_connect_per_addr = false; /**< If you want to connect to a peripheral with a given address, set this to true and put the correct address in the variable below. */
static ble_gap_addr_t const m_target_periph_addr =
{
/* Possible values for addr_type:
BLE_GAP_ADDR_TYPE_PUBLIC,
BLE_GAP_ADDR_TYPE_RANDOM_STATIC,
BLE_GAP_ADDR_TYPE_RANDOM_PRIVATE_RESOLVABLE,
BLE_GAP_ADDR_TYPE_RANDOM_PRIVATE_NON_RESOLVABLE. */
.addr_type = BLE_GAP_ADDR_TYPE_RANDOM_STATIC,
.addr = {0x8D, 0xFE, 0x23, 0x86, 0x77, 0xD9}
};
static void scan_start(void);
void application(int dev_count);
bool is_new_device(ble_gap_addr_t *xmac);
void reset_device_list();
void add_device_list(int index,ble_gap_addr_t *xmac,uint8_t *name,uint8_t length);
void list_all_device();
static void on_whitelist_req(void);
static void whitelist_load();
static void scan_filters_set(void);
static void scan_init(void);
static void delete_bonds(void);
/**@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 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();
}
}
/**
* @brief SoftDevice SoC event handler.
*
* @param[in] evt_id SoC event.
* @param[in] p_context Context.
*/
static void soc_evt_handler(uint32_t evt_id, void * p_context)
{
switch (evt_id)
{
case NRF_EVT_FLASH_OPERATION_SUCCESS:
/* fall through */
case NRF_EVT_FLASH_OPERATION_ERROR:
if (m_memory_access_in_progress)
{
m_memory_access_in_progress = false;
scan_start();
}
break;
default:
// No implementation needed.
break;
}
}
static void scan_evt_handler(scan_evt_t const * p_scan_evt)
{
ret_code_t err_code;
switch(p_scan_evt->scan_evt_id)
{
case NRF_BLE_SCAN_EVT_WHITELIST_REQUEST:
{
on_whitelist_req();
m_whitelist_disabled = false;
} 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_SCAN_TIMEOUT:
{
NRF_LOG_INFO("Scan Timeout");
list_all_device();
scan = 0;
//scan_start();
} break;
case NRF_BLE_SCAN_EVT_FILTER_MATCH:
break;
case NRF_BLE_SCAN_EVT_WHITELIST_ADV_REPORT:
break;
case NRF_BLE_SCAN_EVT_SCAN_REQ_REPORT:
NRF_LOG_INFO(" SCAN END");
break;
default:
break;
}
}
/**@brief Function for initializing scanning.
*/
static void 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);
}
/**@ Function for settings scan filters.
*/
static void scan_filters_set(void)
{
ret_code_t err_code;
ble_uuid_t target_uuid = {.uuid = TARGET_UUID, .type = BLE_UUID_TYPE_BLE};
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_filter_set(&m_scan, SCAN_UUID_FILTER, &target_uuid);
APP_ERROR_CHECK(err_code);
if (is_connect_per_addr)
{
err_code = nrf_ble_scan_filter_set(&m_scan, SCAN_ADDR_FILTER, m_target_periph_addr.addr);
APP_ERROR_CHECK(err_code);
err_code = nrf_ble_scan_filters_enable(&m_scan,
NRF_BLE_SCAN_NAME_FILTER | NRF_BLE_SCAN_UUID_FILTER | NRF_BLE_SCAN_ADDR_FILTER,
false);
APP_ERROR_CHECK(err_code);
}
else
{
err_code = nrf_ble_scan_filters_enable(&m_scan,
NRF_BLE_SCAN_NAME_FILTER | NRF_BLE_SCAN_UUID_FILTER,
false);
APP_ERROR_CHECK(err_code);
}
}
/**@brief Retrive a list of peer manager peer IDs.
*
* @param[inout] p_peers The buffer where to store the list of peer IDs.
* @param[inout] p_size In: The size of the @p p_peers buffer.
* Out: The number of peers copied in the buffer.
*/
static void peer_list_get(pm_peer_id_t * p_peers, uint32_t * p_size)
{
pm_peer_id_t peer_id;
uint32_t peers_to_copy;
peers_to_copy = (*p_size < BLE_GAP_WHITELIST_ADDR_MAX_COUNT) ?
*p_size : BLE_GAP_WHITELIST_ADDR_MAX_COUNT;
peer_id = pm_next_peer_id_get(PM_PEER_ID_INVALID);
*p_size = 0;
while ((peer_id != PM_PEER_ID_INVALID) && (peers_to_copy--))
{
p_peers[(*p_size)++] = peer_id;
peer_id = pm_next_peer_id_get(peer_id);
}
}
static void whitelist_load()
{
ret_code_t ret;
pm_peer_id_t peers[8];
uint32_t peer_cnt;
memset(peers, PM_PEER_ID_INVALID, sizeof(peers));
peer_cnt = (sizeof(peers) / sizeof(pm_peer_id_t));
// Load all peers from flash and whitelist them.
peer_list_get(peers, &peer_cnt);
ret = pm_whitelist_set(peers, peer_cnt);
APP_ERROR_CHECK(ret);
// Setup the device identities list.
// Some SoftDevices do not support this feature.
ret = pm_device_identities_list_set(peers, peer_cnt);
if (ret != NRF_ERROR_NOT_SUPPORTED)
{
APP_ERROR_CHECK(ret);
}
}
static void on_whitelist_req(void)
{
// Whitelist buffers.
ble_gap_addr_t whitelist_addrs[8];
ble_gap_irk_t whitelist_irks[8];
memset(whitelist_addrs, 0x00, sizeof(whitelist_addrs));
memset(whitelist_irks, 0x00, sizeof(whitelist_irks));
uint32_t addr_cnt = (sizeof(whitelist_addrs) / sizeof(ble_gap_addr_t));
uint32_t irk_cnt = (sizeof(whitelist_irks) / sizeof(ble_gap_irk_t));
// Reload the whitelist and whitelist all peers.
whitelist_load();
ret_code_t err_code;
// Get the whitelist previously set using pm_whitelist_set().
err_code = pm_whitelist_get(whitelist_addrs, &addr_cnt,
whitelist_irks, &irk_cnt);
if (((addr_cnt == 0) && (irk_cnt == 0)) ||
(m_whitelist_disabled))
{
// Don't use whitelist.
err_code = nrf_ble_scan_params_set(&m_scan, NULL);
APP_ERROR_CHECK(err_code);
}
NRF_LOG_INFO("Starting scan.");
err_code = bsp_indication_set(BSP_INDICATE_SCANNING);
APP_ERROR_CHECK(err_code);
}
/**@brief Function to start scanning.
*/
static void scan_start(void)
{
reset_device_list();
NRF_LOG_INFO("scanning...");
ret_code_t err_code;
dev_count = 0;
// If there is any pending write to flash, defer scanning until it completes.
if (nrf_fstorage_is_busy(NULL))
{
m_memory_access_in_progress = true;
return;
}
err_code = nrf_ble_scan_params_set(&m_scan, &m_scan_param);
APP_ERROR_CHECK(err_code);
err_code = nrf_ble_scan_start(&m_scan);
APP_ERROR_CHECK(err_code);
}
bool is_new_device(ble_gap_addr_t *xmac){
/* NRF_LOG_INFO("MAC: %02x:%02x:%02x:%02x:%02x:%02x",
p_gap_evt->params.adv_report.peer_addr.addr[5],
p_gap_evt->params.adv_report.peer_addr.addr[4],
p_gap_evt->params.adv_report.peer_addr.addr[3],
p_gap_evt->params.adv_report.peer_addr.addr[2],
p_gap_evt->params.adv_report.peer_addr.addr[1],
p_gap_evt->params.adv_report.peer_addr.addr[0]);*/
/*NRF_LOG_INFO("MAC_: %02x:%02x:%02x:%02x:%02x:%02x",
xmac->addr[5],
xmac->addr[4],
xmac->addr[3],
xmac->addr[2],
xmac->addr[1],
xmac->addr[0]);*/
bool res = true;
for(int i=0;i<MAX_DEV_LIMIT;i++)
{
int cnt = 0;
for(int j=0;j<6;j++)
{
if(mac[i].addr[j] == xmac->addr[j])
cnt++;
}
if(cnt == 6){
res = false;
break;
}
}
return res;
}
void list_all_device()
{
/*for(uint8_t i =0;i<dev_count;i++){
raw_print("NAME :",mac[i].name,strlen(mac[i].name));
NRF_LOG_INFO("MAC: %02x:%02x:%02x:%02x:%02x:%02x\n",
mac[i].addr[5],
mac[i].addr[4],
mac[i].addr[3],
mac[i].addr[2],
mac[i].addr[1],
mac[i].addr[0]);
}*/
}
void add_device_list(int index,ble_gap_addr_t *xmac,uint8_t *name,uint8_t len)
{
for(int j=0;j<6;j++){
mac[index].addr[j]=xmac->addr[j];
}
strncpy(mac[index].name,name,strlen(name));
raw_print("NAME : ",name,strlen(mac[dev_count].name));
NRF_LOG_INFO("MAC: %02x:%02x:%02x:%02x:%02x:%02x",
mac[index].addr[5],
mac[index].addr[4],
mac[index].addr[3],
mac[index].addr[2],
mac[index].addr[1],
mac[index].addr[0]);
dev_count++;
}
void reset_device_list(){
for(int j=0;j<MAX_DEV_LIMIT;j++){
memset(&mac[j],'\0',sizeof(struct list_dev));
}
dev_count=0;
}
static void scanner_timeout_handler(void * p_context)
{
UNUSED_PARAMETER(p_context);
/*reset_device_list();
dev_count=0;
RSSI=0;*/
//NRF_LOG_INFO("Timer Timeout");
}
//----------------------------------------------------//
/**@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)
{
uint32_t err_code = NRF_SUCCESS;
ble_gap_evt_t const * p_gap_evt = &p_ble_evt->evt.gap_evt;
switch (p_ble_evt->header.evt_id)
{
case BLE_GAP_EVT_DISCONNECTED:
NRF_LOG_INFO("DEVICE DISCONNECTED.");
allow_access_ble(false);
// LED indication will be changed when advertising starts.
break;
case BLE_GAP_EVT_CONNECTED:
NRF_LOG_INFO("DEVICE CONNECTED.");
allow_access_ble(false);
//err_code = bsp_indication_set(BSP_INDICATE_CONNECTED);
//APP_ERROR_CHECK(err_code);
m_conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
err_code = nrf_ble_qwr_conn_handle_assign(&m_qwr, m_conn_handle);
APP_ERROR_CHECK(err_code);
if (ble_conn_state_central_conn_count() < NRF_SDH_BLE_CENTRAL_LINK_COUNT)
{
scan_start();
}
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_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;
case BLE_GAP_EVT_ADV_REPORT:
if(p_gap_evt->params.adv_report.data.len != 0)
{
RSSI = -(p_gap_evt->params.adv_report.rssi);
if( p_gap_evt->params.adv_report.data.len!=0)
{
if(is_new_device(&p_gap_evt->params.adv_report.peer_addr)==true)
{
NRF_LOG_INFO("NEW DEVICE FOUND");
NRF_LOG_HEXDUMP_INFO(p_gap_evt->params.adv_report.data.p_data,p_gap_evt->params.adv_report.data.len);
uint8_t *name;
uint8_t sid[5]={0};
uint8_t *sdata,*sdata1;
uint8_t len = p_gap_evt->params.adv_report.data.len;
//strlen(ble_advdata_parse(p_gap_evt->params.adv_report.data.p_data, p_gap_evt->params.adv_report.data.len, BLE_GAP_AD_TYPE_COMPLETE_LOCAL_NAME));
//NRF_LOG_INFO("length : %d,%d",l, p_gap_evt->params.adv_report.data.len);
//strcpy(name,ble_advdata_parse(p_gap_evt->params.adv_report.data.p_data, p_gap_evt->params.adv_report.data.len, BLE_GAP_AD_TYPE_SHORT_LOCAL_NAME));
name = ble_advdata_parse(p_gap_evt->params.adv_report.data.p_data,
p_gap_evt->params.adv_report.data.len,
BLE_GAP_AD_TYPE_COMPLETE_LOCAL_NAME);
sdata = ble_advdata_parse(p_gap_evt->params.adv_report.data.p_data,
p_gap_evt->params.adv_report.data.len,
BLE_GAP_AD_TYPE_SERVICE_DATA);
//raw_print("NAME : ",name,strlen(name));
//raw_print("DATA : ",sdata,strlen(sdata));
//NRF_LOG_HEXDUMP_DEBUG(sdata1,strlen(name));
//NRF_LOG_HEXDUMP_DEBUG(sdata1,strlen(sdata));
//NRF_LOG_HEXDUMP_DEBUG(p_gap_evt->params.adv_report.data.p_data,len);
add_device_list(dev_count,&p_gap_evt->params.adv_report.peer_addr,name,p_gap_evt->params.adv_report.data.p_data[0]);
memset(p_gap_evt->params.adv_report.data.p_data,0,len);
}
else{
//NRF_LOG_INFO("DEVICE ALREADY IN LIST");
}
}
}
break;
default:
// No implementation needed.
break;
}
}
/**@brief Function for initializing the BLE stack.
*
* @details Initializes the SoftDevice and the BLE event interrupt.
*/
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);
NRF_SDH_BLE_OBSERVER(m_ble_observer, APP_BLE_OBSERVER_PRIO, ble_evt_handler, NULL);
NRF_SDH_SOC_OBSERVER(m_soc_observer, APP_SOC_OBSERVER_PRIO, soc_evt_handler, NULL);
}
Guide me to get scan response data in nrf52.
Thanks.
