Hi,
I am trying to find RSSI of the value of the nearest device also I need the Device name, address of those devices. I got the RSSI value but some problem in Device name, address.
I attached the log
#include <stdint.h> #include <stdio.h> #include <string.h> #include "nrf_sdh.h" #include "nrf_sdh_ble.h" #include "nrf_sdh_soc.h" #include "nrf_pwr_mgmt.h" #include "app_timer.h" #include "boards.h" #include "bsp.h" #include "bsp_btn_ble.h" #include "ble.h" #include "ble_hci.h" #include "ble_advertising.h" #include "ble_conn_params.h" #include "ble_db_discovery.h" #include "ble_lbs_c.h" #include "nrf_ble_gatt.h" #include "nrf_ble_scan.h" #include "nrf_log.h" #include "nrf_log_ctrl.h" #include "nrf_log_default_backends.h" #define CENTRAL_SCANNING_LED BSP_BOARD_LED_0 /**< Scanning LED will be on when the device is scanning. */ #define CENTRAL_CONNECTED_LED BSP_BOARD_LED_1 /**< Connected LED will be on when the device is connected. */ #define LEDBUTTON_LED BSP_BOARD_LED_2 /**< LED to indicate a change of state of the the Button characteristic on the peer. */ #define SCAN_INTERVAL 0x00A0 /**< Determines scan interval in units of 0.625 millisecond. */ #define SCAN_WINDOW 0x0050 /**< Determines scan window in units of 0.625 millisecond. */ #define SCAN_DURATION 0x0000 /**< Timout when scanning. 0x0000 disables timeout. */ #define MIN_CONNECTION_INTERVAL MSEC_TO_UNITS(7.5, UNIT_1_25_MS) /**< Determines minimum connection interval in milliseconds. */ #define MAX_CONNECTION_INTERVAL MSEC_TO_UNITS(30, 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 LEDBUTTON_BUTTON_PIN 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 APP_BLE_CONN_CFG_TAG 1 /**< A tag identifying the SoftDevice BLE configuration. */ #define APP_BLE_OBSERVER_PRIO 3 /**< Application's BLE observer priority. You shouldn't need to modify this value. */ #define ADDR_STRING_LEN (2 * (BLE_GAP_ADDR_LEN)+6) /**< Determines device BLE address length in string format. Address formatting: XX:XX:XX:XX:XX:XX. The hex number in the string format takes twice as much space. 6 is added in place of ":" or spaces beetwen numbers and for the string terminator. */ NRF_BLE_SCAN_DEF(m_scan); /**< Scanning module instance. */ BLE_LBS_C_DEF(m_ble_lbs_c); /**< Main structure used by the LBS client module. */ NRF_BLE_GATT_DEF(m_gatt); /**< GATT module instance. */ BLE_DB_DISCOVERY_DEF(m_db_disc); /**< DB discovery module instance. */ //static char const m_target_periph_name[] = "Nordic_Blinky"; /**< Name of the device we try to connect to. This name is searched in the scan report data*/ #define SCAN_LIST_REFRESH_INTERVAL 10000 // 10 sec static uint32_t device_number; #define FOUND_DEVICE_REFRESH_TIME APP_TIMER_TICKS(SCAN_LIST_REFRESH_INTERVAL) /**< Time after which the device list is clean and refreshed. */ #define DEVICE_NAME_MAX_SIZE 20 #define DEVICE_TO_FIND_MAX 50 typedef struct { bool is_not_empty; /**< Indicates that the structure is not empty. */ uint16_t size; /**< Size of manuf data. */ uint8_t addr[BLE_GAP_ADDR_LEN]; /**< Device address. */ char dev_name[DEVICE_NAME_MAX_SIZE]; /**< Device name. */ uint8_t manuf_buffer[BLE_GAP_ADV_SET_DATA_SIZE_MAX]; /**< Buffer for storing an manuf data. */ int8_t rssi; /**< Received Signal Strength Indication in dBm. */ char dev_peru[DEVICE_NAME_MAX_SIZE]; } scanned_device_t; static void device_list_print(scanned_device_t * p_device); scanned_device_t m_device[DEVICE_TO_FIND_MAX]; /**< Stores device info from scan data. */ void scan_device_info_clear(void) { memset(m_device, 0, sizeof(m_device)); device_number = 0; } void int_addr_to_hex_str(char * p_result, uint8_t result_len, uint8_t const * const p_addr) { ASSERT(p_result); ASSERT(p_addr); if (result_len > BLE_GAP_ADDR_LEN) { return; } char buffer[BLE_GAP_ADDR_LEN] = {0}; memset(p_result, 0, result_len); for (uint8_t i = 0; i < result_len; ++i) { sprintf(buffer, "%.2X", p_addr[result_len - (i + 1)]); strcat(p_result, buffer); if (i < (result_len - 1)) { strcat(p_result, ":"); } } } /**@brief Function for printing the devices. * *@details Function print list of devices. * * * @param[in] device Pointer to the struct storing the scanned devices. */ static void device_list_print(scanned_device_t * p_device) { NRF_LOG_INFO("start"); for (uint8_t i = 0; i < DEVICE_TO_FIND_MAX; i++) { if (p_device[i].is_not_empty) { char buffer[ADDR_STRING_LEN]; int_addr_to_hex_str(buffer, BLE_GAP_ADDR_LEN, p_device[i].addr); NRF_LOG_INFO("add : %s name : %s rssi : %d", buffer, p_device[i].dev_name, p_device[i].rssi); // NRF_LOG_INFO("name : %s", m_device[i].dev_name); } } NRF_LOG_INFO("Devices found %d", device_number); // We could now clear the list: //scan_device_info_clear(); } scanned_device_t * scan_device_info_get(void) { return m_device; } typedef struct { uint8_t * p_data; /**< Pointer to data. */ uint16_t data_len; /**< Length of data. */ } data_t; static void device_to_list_add(ble_gap_evt_adv_report_t const * p_adv_report) { uint8_t idx = 0; uint16_t dev_name_offset = 0; uint16_t field_len; data_t adv_data; // Initialize advertisement report for parsing adv_data.p_data = (uint8_t *)p_adv_report->data.p_data; adv_data.data_len = p_adv_report->data.len; for ( idx = 0; idx < DEVICE_TO_FIND_MAX; idx++) { // If address is duplicated, then return. if (memcmp(p_adv_report->peer_addr.addr, m_device[idx].addr, sizeof(p_adv_report->peer_addr.addr)) == 0) { return; } } // Device is not in the list. for (idx = 0; idx < DEVICE_TO_FIND_MAX; idx++) { if (!m_device[idx].is_not_empty) { memcpy(m_device[idx].addr, p_adv_report->peer_addr.addr, sizeof(p_adv_report->peer_addr.addr)); m_device[idx].rssi = p_adv_report->rssi; m_device[idx].is_not_empty = true; device_number = device_number +1; // Search for advertising names. field_len = ble_advdata_search(adv_data.p_data, adv_data.data_len, &dev_name_offset, BLE_GAP_AD_TYPE_COMPLETE_LOCAL_NAME); if (field_len == 0) { field_len = ble_advdata_search(adv_data.p_data, adv_data.data_len, &dev_name_offset, BLE_GAP_AD_TYPE_SHORT_LOCAL_NAME); // If name is not found, then return. if (field_len == 0) { return; } } memcpy(m_device[idx].dev_name, &adv_data.p_data[dev_name_offset], field_len); m_device[idx].dev_name[field_len] = 0; //NRF_LOG_INFO("name : %s", m_device[idx].dev_name); return; } } } /**@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); //} static void scan_start(void) { ret_code_t err_code; err_code = nrf_ble_scan_start(&m_scan); APP_ERROR_CHECK(err_code); bsp_board_led_off(CENTRAL_CONNECTED_LED); bsp_board_led_on(CENTRAL_SCANNING_LED); } /**@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 (HR or RSC), initiate DB // discovery, update LEDs status and resume scanning if necessary. */ case BLE_GAP_EVT_CONNECTED: { NRF_LOG_INFO("Connected."); // err_code = ble_lbs_c_handles_assign(&m_ble_lbs_c, 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); // 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); bsp_board_led_off(CENTRAL_SCANNING_LED); } break; // 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("Disconnected."); scan_start(); } 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_DEBUG("Connection request timed out."); } } break; case 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; 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 handling Scaning events. * * @param[in] p_scan_evt Scanning event. */ 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_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: device_to_list_add(p_scan_evt->params.p_not_found); break; default: break; } } /**@brief Function for initializing the log. */ 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 handling the list_timer event, */ static void adv_list_timer_handle(void * p_context) { //scan_device_info_clear(); //Print devices scanned_device_t * p_device_list = scan_device_info_get(); device_list_print(p_device_list); scan_device_info_clear(); } /**@brief Function for initializing the timer. */ static void timer_init(void) { ret_code_t err_code = app_timer_init(); APP_ERROR_CHECK(err_code); // Timer for refreshing scanned devices data. APP_TIMER_DEF(adv_list_timer); err_code = app_timer_create(&adv_list_timer, APP_TIMER_MODE_REPEATED, adv_list_timer_handle); APP_ERROR_CHECK(err_code); err_code = app_timer_start(adv_list_timer, FOUND_DEVICE_REFRESH_TIME, NULL); APP_ERROR_CHECK(err_code); } /**@brief Function for initializing the Power manager. */ static void power_management_init(void) { ret_code_t err_code; err_code = nrf_pwr_mgmt_init(); APP_ERROR_CHECK(err_code); } 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.connect_if_match = false; init_scan.conn_cfg_tag = APP_BLE_CONN_CFG_TAG; err_code = nrf_ble_scan_init(&m_scan, NULL , scan_evt_handler); APP_ERROR_CHECK(err_code); // // Setting filters for scanning. // err_code = nrf_ble_scan_filters_enable(&m_scan, NRF_BLE_SCAN_NAME_FILTER, false); // 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); } /**@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) { NRF_LOG_FLUSH(); nrf_pwr_mgmt_run(); } int main(void) { // Initialize. log_init(); timer_init(); power_management_init(); ble_stack_init(); scan_init(); // Start execution. NRF_LOG_INFO("BLE scanner example started, will print the number of devices found after %d seconds",SCAN_LIST_REFRESH_INTERVAL/1000); scan_start(); // Turn on the LED to signal scanning. bsp_board_led_on(CENTRAL_SCANNING_LED); // Enter main loop. for (;;) { idle_state_handle(); } }