Hi,
I am working on a project where my mobile phone will be acting as a central device and nRF52840 DK will be acting as a peripheral device. I used the nRF UART and nRF toolbox app for basic string transfer from my phone to the nRF board. I was able to display the transmitted and received strings on the mobile app as well as on the desktop using Putty.
I wanted to know how the packets are going over the so I made another nRF52840 board as a sniffer. From the sniffer trace, I got to know that the data are sent and received as plain text. But I wanted to send and receive encrypted data.
When I searched on the internet I got to know that for sending and receiving encrypted data we need to pair and bond the device. So I added the peer manager to my code. Now I am able to send encrypted text from my central device to the peripheral device. The logs are attached below:
<info> app: LE Secure Connections example started. <info> app: Advertising <info> app: PERIPHERAL: Connected, handle 1. <info> app: PERIPHERAL: BLE_GAP_EVT_SEC_PARAMS_REQUEST <info> app: PERIPHERAL: BLE_GAP_EVT_LESC_DHKEY_REQUEST <info> nrf_ble_lesc: Calling sd_ble_gap_lesc_dhkey_reply on conn_handle: 1 <info> app: PERIPHERAL: BLE_GAP_EVT_PASSKEY_DISPLAY: passkey=495856 match_req=1 <info> app: Press Button 1 to confirm, Button 2 to reject <info> app: Numeric Match. Conn handle: 1 <info> peer_manager_handler: Connection secured: role: Peripheral, conn_handle: 1, procedure: Bonding <info> app: PERIPHERAL: BLE_GAP_EVT_AUTH_STATUS: status=0x0 bond=0x1 lv4: 1 kdist_own:0x3 kdist_peer:0x2
The peer manager function is given below:
static void peer_manager_init(void) { ble_gap_sec_params_t sec_params; ret_code_t err_code; err_code = pm_init(); APP_ERROR_CHECK(err_code); memset(&sec_params, 0, sizeof(ble_gap_sec_params_t)); // Security parameters to be used for all security procedures. sec_params.bond = 1; sec_params.mitm = 1; sec_params.lesc = 1; sec_params.keypress = 0; sec_params.io_caps = BLE_GAP_IO_CAPS_DISPLAY_YESNO; sec_params.oob = 0; sec_params.min_key_size = 7; sec_params.max_key_size = 16; sec_params.kdist_own.enc = 1; sec_params.kdist_own.id = 1; sec_params.kdist_peer.enc = 1; sec_params.kdist_peer.id = 1; err_code = pm_sec_params_set(&sec_params); APP_ERROR_CHECK(err_code); err_code = pm_register(pm_evt_handler); APP_ERROR_CHECK(err_code); }
The complete main.c file is also attached below:
#include "sdk_common.h" #include "ble_nus.h" #include "nrf.h" #include "ble_hci.h" #include "app_uart.h" #include "app_util_platform.h" #include "sdk_config.h" #include <stdint.h> #include <stdio.h> #include <string.h> #include "nordic_common.h" #include "nrf_sdh.h" #include "nrf_sdh_soc.h" #include "nrf_sdh_ble.h" #include "peer_manager.h" #include "peer_manager_handler.h" #include "app_timer.h" #include "bsp_btn_ble.h" #include "ble.h" #include "app_util.h" #include "ble_advdata.h" #include "ble_advertising.h" #include "ble_conn_params.h" #include "ble_db_discovery.h" #include "ble_hrs.h" #include "ble_hrs_c.h" #include "ble_conn_state.h" #include "fds.h" #include "nrf_crypto.h" #include "nrf_ble_gatt.h" #include "nrf_ble_lesc.h" #include "nrf_ble_qwr.h" #include "nrf_pwr_mgmt.h" #include "nrf_ble_scan.h" #if defined (UART_PRESENT) #include "nrf_uart.h" #endif #if defined (UARTE_PRESENT) #include "nrf_uarte.h" #endif #include "nrf_log.h" #include "nrf_log_ctrl.h" #include "nrf_log_default_backends.h" #define UART_TX_BUF_SIZE 256 /**< UART TX buffer size. */ #define UART_RX_BUF_SIZE 256 /**< UART RX buffer size. */ #define LEDBUTTON_LED BSP_BOARD_LED_2 /**< LED to be toggled with the help of the LED Button Service. */ static uint16_t m_conn_handle = BLE_CONN_HANDLE_INVALID; /**< Handle of the current connection. */ static uint16_t m_ble_nus_max_data_len = BLE_GATT_ATT_MTU_DEFAULT - 3; /**< Maximum length of data (in bytes) that can be transmitted to the peer by the Nordic UART service module. */ #define LESC_DEBUG_MODE 0 /**< Set to 1 to use the LESC debug keys. The debug mode allows you to use a sniffer to inspect traffic. */ #define LESC_MITM_NC 1 /**< Use MITM (Numeric Comparison). */ /** @brief The maximum number of peripheral and central links combined. */ #define NRF_BLE_LINK_COUNT (NRF_SDH_BLE_PERIPHERAL_LINK_COUNT + NRF_SDH_BLE_CENTRAL_LINK_COUNT) #define APP_BLE_CONN_CFG_TAG 1 /**< Tag that identifies the SoftDevice BLE configuration. */ #define DEVICE_NAME "CONNECT" /**< Name of device. Will be included in the advertising data. */ #define NUS_SERVICE_UUID_TYPE BLE_UUID_TYPE_VENDOR_BEGIN /**< UUID type for the Nordic UART Service (vendor specific). */ //#define CENTRAL_SCANNING_LED BSP_BOARD_LED_0 //#define CENTRAL_CONNECTED_LED BSP_BOARD_LED_1 #define PERIPHERAL_ADVERTISING_LED BSP_BOARD_LED_0 #define PERIPHERAL_CONNECTED_LED BSP_BOARD_LED_1 #define SCAN_DURATION 0x0000 /**< Duration of the scanning in units of 10 milliseconds. If set to 0x0000, scanning continues until it is explicitly disabled. */ #define APP_ADV_INTERVAL 300 /**< The advertising interval (in units of 0.625 ms. This value corresponds to 40 ms). */ #define APP_ADV_DURATION 18000 /**< The advertising duration (180 seconds) in units of 10 milliseconds. */ #define MIN_CONN_INTERVAL MSEC_TO_UNITS(20, UNIT_1_25_MS) /**< Minimum acceptable connection interval (20 ms), Connection interval uses 1.25 ms units. */ #define MAX_CONN_INTERVAL MSEC_TO_UNITS(75, UNIT_1_25_MS) /**< Maximum acceptable connection interval (75 ms), Connection interval uses 1.25 ms units. */ #define SLAVE_LATENCY 0 /**< Slave latency. */ #define CONN_SUP_TIMEOUT MSEC_TO_UNITS(4000, UNIT_10_MS) /**< Connection supervisory timeout (4 seconds), Supervision Timeout uses 10 ms units. */ #define SEC_PARAMS_BOND 1 /**< Perform bonding. */ #if LESC_MITM_NC #define SEC_PARAMS_MITM 1 /**< Man In The Middle protection required. */ #define SEC_PARAMS_IO_CAPABILITIES BLE_GAP_IO_CAPS_DISPLAY_YESNO /**< Display Yes/No to force Numeric Comparison. */ #else #define SEC_PARAMS_MITM 0 /**< Man In The Middle protection required. */ #define SEC_PARAMS_IO_CAPABILITIES BLE_GAP_IO_CAPS_NONE /**< No I/O caps. */ #endif #define SEC_PARAMS_LESC 1 /**< LE Secure Connections pairing required. */ #define SEC_PARAMS_KEYPRESS 0 /**< Keypress notifications not required. */ #define SEC_PARAMS_OOB 0 /**< Out Of Band data not available. */ #define SEC_PARAMS_MIN_KEY_SIZE 7 /**< Minimum encryption key size in octets. */ #define SEC_PARAMS_MAX_KEY_SIZE 16 /**< Maximum encryption key size in octets. */ #define FIRST_CONN_PARAMS_UPDATE_DELAY APP_TIMER_TICKS(15000) /**< Time from initiating event (connect or start of notification) to first time sd_ble_gap_conn_param_update is called (5 seconds). */ #define NEXT_CONN_PARAMS_UPDATE_DELAY APP_TIMER_TICKS(30000) /**< Time between each call to sd_ble_gap_conn_param_update after the first call (30 seconds). */ #define MAX_CONN_PARAMS_UPDATE_COUNT 3 /**< Number of attempts before giving up the connection parameter negotiation. */ /**@brief Priority of the application BLE event handler. * @note There is no need to modify this value. */ #define APP_BLE_OBSERVER_PRIO 3 typedef struct { bool is_connected; ble_gap_addr_t address; } conn_peer_t; BLE_NUS_DEF(m_nus, NRF_SDH_BLE_TOTAL_LINK_COUNT); //BLE_LBS_DEF(m_lbs); //BLE_HRS_DEF(m_hrs); /**< Heart Rate Service instance. */ //BLE_HRS_C_DEF(m_hrs_c); /**< Structure used to identify the Heart Rate client module. */ NRF_BLE_GATT_DEF(m_gatt); /**< GATT module instance. */ NRF_BLE_QWRS_DEF(m_qwr, NRF_SDH_BLE_TOTAL_LINK_COUNT); /**< Context for the Queued Write module.*/ BLE_ADVERTISING_DEF(m_advertising); /**< Advertising module instance. */ //BLE_DB_DISCOVERY_DEF(m_db_disc); /**< Database discovery module instance. */ NRF_BLE_SCAN_DEF(m_scan); /**< Scanning Module instance. */ //static uint16_t m_conn_handle_hrs_c = BLE_CONN_HANDLE_INVALID; /**< Connection handle for the HRS central application. */ //static volatile uint16_t m_conn_handle_num_comp_central = BLE_CONN_HANDLE_INVALID; /**< Connection handle for the central that needs a numeric comparison button press. */ static volatile uint16_t m_conn_handle_num_comp_peripheral = BLE_CONN_HANDLE_INVALID; /**< Connection handle for the peripheral that needs a numeric comparison button press. */ static conn_peer_t m_connected_peers[NRF_BLE_LINK_COUNT]; /**< Array of connected peers. */ static char * roles_str[] = { "INVALID_ROLE", "PERIPHERAL", //"CENTRAL", }; /**@brief Names that the central application scans for, and that are advertised by the peripherals. * If these are set to empty strings, the UUIDs defined below are used. */ //static const char m_target_periph_name[] = ""; /**@brief UUIDs that the central application scans for if the name above is set to an empty string, * and that are to be advertised by the peripherals. */ static ble_uuid_t m_adv_uuids[] = {//{BLE_UUID_HEART_RATE_SERVICE, BLE_UUID_TYPE_BLE}, //{BLE_UUID_RUNNING_SPEED_AND_CADENCE, BLE_UUID_TYPE_BLE} {BLE_UUID_NUS_SERVICE, NUS_SERVICE_UUID_TYPE}}; /**@brief Function for handling asserts in the SoftDevice * * @details This function is called in case of an assert in the SoftDevice. * * @warning This handler is an example only and is not meant for the 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 an event from the Connection Parameters Module. * * @details This function will be called for all events in the Connection Parameters Module * which are passed to the application. * * @note All this function does is to disconnect. This could have been done by simply setting * the disconnect_on_fail config parameter, but instead we use the event handler * mechanism to demonstrate its use. * * @param[in] p_evt Event received from the Connection Parameters Module. */ static void on_conn_params_evt(ble_conn_params_evt_t * p_evt) { uint32_t err_code; if (p_evt->evt_type == BLE_CONN_PARAMS_EVT_FAILED) { err_code = sd_ble_gap_disconnect(m_conn_handle, BLE_HCI_CONN_INTERVAL_UNACCEPTABLE); APP_ERROR_CHECK(err_code); } } /**@brief Function for handling errors from the Connection Parameters module. * * @param[in] nrf_error Error code that contains information about what went wrong. */ static void conn_params_error_handler(uint32_t nrf_error) { APP_ERROR_HANDLER(nrf_error); } /**@brief Function for handling Scanning Module events. 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; default: break; } } /**@brief Function for initializing the scanning and setting the filters. static void scan_init(void) { ret_code_t err_code; ble_uuid_t target_uuid = { .uuid = BLE_UUID_HEART_RATE_SERVICE, .type = BLE_UUID_TYPE_BLE }; nrf_ble_scan_init_t init_scan; memset(&init_scan, 0, sizeof(init_scan)); 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); if (strlen(m_target_periph_name) != 0) { 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); 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 Function for initializing the scanning. static void scan_start(void) { ret_code_t err_code; err_code = nrf_ble_scan_start(&m_scan); APP_ERROR_CHECK(err_code); NRF_LOG_INFO("Scanning"); } /**@brief Function for initializing the advertising and the scanning. */ static void adv_scan_start(void) { ret_code_t err_code; //scan_start(); // Turn on the LED to signal scanning. // bsp_board_led_on(CENTRAL_SCANNING_LED); // Start advertising. err_code = ble_advertising_start(&m_advertising, BLE_ADV_MODE_FAST); APP_ERROR_CHECK(err_code); NRF_LOG_INFO("Advertising"); } /**@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) { pm_handler_on_pm_evt(p_evt); pm_handler_disconnect_on_sec_failure(p_evt); pm_handler_flash_clean(p_evt); switch (p_evt->evt_id) { case PM_EVT_PEERS_DELETE_SUCCEEDED: adv_scan_start(); break; default: break; } } /**@brief Function for changing filter settings after establishing the connection. static void filter_settings_change(void) { ret_code_t err_code; err_code = nrf_ble_scan_all_filter_remove(&m_scan); APP_ERROR_CHECK(err_code); if (strlen(m_target_periph_name) != 0) { err_code = nrf_ble_scan_filter_set(&m_scan, SCAN_NAME_FILTER, m_target_periph_name); APP_ERROR_CHECK(err_code); } } /**@brief Handles events coming from the Heart Rate central module. static void hrs_c_evt_handler(ble_hrs_c_t * p_hrs_c, ble_hrs_c_evt_t * p_hrs_c_evt) { switch (p_hrs_c_evt->evt_type) { case BLE_HRS_C_EVT_DISCOVERY_COMPLETE: { if (m_conn_handle_hrs_c == BLE_CONN_HANDLE_INVALID) { ret_code_t err_code; m_conn_handle_hrs_c = p_hrs_c_evt->conn_handle; // We do not want to connect to two peripherals offering the same service, so when // a UUID is matched, we check whether we are not already connected to a peer which // offers the same service filter_settings_change(); NRF_LOG_INFO("CENTRAL: HRS discovered on conn_handle 0x%x", m_conn_handle_hrs_c); err_code = ble_hrs_c_handles_assign(p_hrs_c, m_conn_handle_hrs_c, &p_hrs_c_evt->params.peer_db); APP_ERROR_CHECK(err_code); // Heart rate service discovered. Enable notification of Heart Rate Measurement. err_code = ble_hrs_c_hrm_notif_enable(p_hrs_c); APP_ERROR_CHECK(err_code); } } break; // BLE_HRS_C_EVT_DISCOVERY_COMPLETE case BLE_HRS_C_EVT_HRM_NOTIFICATION: { NRF_LOG_INFO("CENTRAL: Heart Rate = %d", p_hrs_c_evt->params.hrm.hr_value); } break; default: // No implementation needed. break; } } /**@brief Function for checking whether a link already exists with a newly connected peer. * * @details This function checks whether the newly connected device is already connected. * * @param[in] p_connected_evt Bluetooth connected event. * @return True if the peer's address is found in the list of connected peers, * false otherwise. */ static bool is_already_connected(ble_gap_addr_t const * p_connected_adr) { for (uint32_t i = 0; i < NRF_BLE_LINK_COUNT; i++) { if (m_connected_peers[i].is_connected) { if (m_connected_peers[i].address.addr_type == p_connected_adr->addr_type) { if (memcmp(m_connected_peers[i].address.addr, p_connected_adr->addr, sizeof(m_connected_peers[i].address.addr)) == 0) { return true; } } } } return false; } /** @brief Function for handling a numeric comparison match request. */ static void on_match_request(uint16_t conn_handle, uint8_t role) { // Mark the appropriate conn_handle as pending. The rest is handled on button press. NRF_LOG_INFO("Press Button 1 to confirm, Button 2 to reject"); if (role == BLE_GAP_ROLE_CENTRAL) { //m_conn_handle_num_comp_central = conn_handle; } else if (role == BLE_GAP_ROLE_PERIPH) { m_conn_handle_num_comp_peripheral = conn_handle; } } /**@brief Function for assigning new connection handle to the available instance of QWR module. * * @param[in] conn_handle New connection handle. */ static void multi_qwr_conn_handle_assign(uint16_t conn_handle) { for (uint32_t i = 0; i < NRF_BLE_LINK_COUNT; i++) { if (m_qwr[i].conn_handle == BLE_CONN_HANDLE_INVALID) { ret_code_t err_code = nrf_ble_qwr_conn_handle_assign(&m_qwr[i], conn_handle); APP_ERROR_CHECK(err_code); break; } } } /**@brief Function for handling BLE Stack events that are common to both the central and peripheral roles. * @param[in] conn_handle Connection Handle. * @param[in] p_ble_evt Bluetooth stack event. */ static void on_ble_evt(uint16_t conn_handle, ble_evt_t const * p_ble_evt) { char passkey[BLE_GAP_PASSKEY_LEN + 1]; uint16_t role = ble_conn_state_role(conn_handle); pm_handler_secure_on_connection(p_ble_evt); switch (p_ble_evt->header.evt_id) { case BLE_GAP_EVT_CONNECTED: m_connected_peers[conn_handle].is_connected = true; m_connected_peers[conn_handle].address = p_ble_evt->evt.gap_evt.params.connected.peer_addr; multi_qwr_conn_handle_assign(conn_handle); break; case BLE_GAP_EVT_DISCONNECTED: memset(&m_connected_peers[conn_handle], 0x00, sizeof(m_connected_peers[0])); break; case BLE_GAP_EVT_SEC_PARAMS_REQUEST: NRF_LOG_INFO("%s: BLE_GAP_EVT_SEC_PARAMS_REQUEST", nrf_log_push(roles_str[role])); break; case BLE_GAP_EVT_PASSKEY_DISPLAY: memcpy(passkey, p_ble_evt->evt.gap_evt.params.passkey_display.passkey, BLE_GAP_PASSKEY_LEN); passkey[BLE_GAP_PASSKEY_LEN] = 0x00; NRF_LOG_INFO("%s: BLE_GAP_EVT_PASSKEY_DISPLAY: passkey=%s match_req=%d", nrf_log_push(roles_str[role]), nrf_log_push(passkey), p_ble_evt->evt.gap_evt.params.passkey_display.match_request); if (p_ble_evt->evt.gap_evt.params.passkey_display.match_request) { on_match_request(conn_handle, role); } break; case BLE_GAP_EVT_AUTH_KEY_REQUEST: NRF_LOG_INFO("%s: BLE_GAP_EVT_AUTH_KEY_REQUEST", nrf_log_push(roles_str[role])); break; case BLE_GAP_EVT_LESC_DHKEY_REQUEST: NRF_LOG_INFO("%s: BLE_GAP_EVT_LESC_DHKEY_REQUEST", nrf_log_push(roles_str[role])); break; case BLE_GAP_EVT_AUTH_STATUS: NRF_LOG_INFO("%s: BLE_GAP_EVT_AUTH_STATUS: status=0x%x bond=0x%x lv4: %d kdist_own:0x%x kdist_peer:0x%x", nrf_log_push(roles_str[role]), p_ble_evt->evt.gap_evt.params.auth_status.auth_status, p_ble_evt->evt.gap_evt.params.auth_status.bonded, p_ble_evt->evt.gap_evt.params.auth_status.sm1_levels.lv4, *((uint8_t *)&p_ble_evt->evt.gap_evt.params.auth_status.kdist_own), *((uint8_t *)&p_ble_evt->evt.gap_evt.params.auth_status.kdist_peer)); 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, }; ret_code_t err_code = sd_ble_gap_phy_update(p_ble_evt->evt.gap_evt.conn_handle, &phys); APP_ERROR_CHECK(err_code); } break; default: // No implementation needed. break; } } /**@brief Function for handling BLE Stack events that are related to central application. * * @details This function keeps the connection handles of central application up-to-date. It * parses scanning reports, initiates a connection attempt to peripherals when a target UUID * is found, and manages connection parameter update requests. Additionally, it updates the status * of LEDs used to report the central application's activity. * * @note Since this function updates connection handles, @ref BLE_GAP_EVT_DISCONNECTED events * must be dispatched to the target application before invoking this function. * * @param[in] p_ble_evt Bluetooth stack event. static void on_ble_central_evt(ble_evt_t const * p_ble_evt) { ble_gap_evt_t const * p_gap_evt = &p_ble_evt->evt.gap_evt; ret_code_t err_code; switch (p_ble_evt->header.evt_id) { // Upon connection, check which peripheral is connected (HR or RSC), initiate DB // discovery, update LEDs status, and resume scanning, if necessary. case BLE_GAP_EVT_CONNECTED: { NRF_LOG_INFO("CENTRAL: Connected, handle: %d.", p_gap_evt->conn_handle); // If no Heart Rate Sensor is currently connected, try to find them on this peripheral. if (m_conn_handle_hrs_c == BLE_CONN_HANDLE_INVALID) { NRF_LOG_INFO("CENTRAL: Searching for HRS on conn_handle 0x%x", p_gap_evt->conn_handle); err_code = ble_db_discovery_start(&m_db_disc, p_gap_evt->conn_handle); APP_ERROR_CHECK(err_code); } // Update status of LEDs. bsp_board_led_off(CENTRAL_SCANNING_LED); bsp_board_led_on(CENTRAL_CONNECTED_LED); } break; // BLE_GAP_EVT_CONNECTED // Upon disconnection, reset the connection handle of the peer that disconnected, update // the status of LEDs, and start scanning again. case BLE_GAP_EVT_DISCONNECTED: { NRF_LOG_INFO("CENTRAL: Disconnected, handle: %d, reason: 0x%x", p_gap_evt->conn_handle, p_gap_evt->params.disconnected.reason); // Update the status of LEDs. bsp_board_led_off(CENTRAL_CONNECTED_LED); bsp_board_led_on(CENTRAL_SCANNING_LED); if (p_gap_evt->conn_handle == m_conn_handle_hrs_c) { ble_uuid_t target_uuid = {.uuid = BLE_UUID_HEART_RATE_SERVICE, .type = BLE_UUID_TYPE_BLE}; m_conn_handle_hrs_c = BLE_CONN_HANDLE_INVALID; err_code = nrf_ble_scan_filter_set(&m_scan, SCAN_UUID_FILTER, &target_uuid); APP_ERROR_CHECK(err_code); } scan_start(); } break; // BLE_GAP_EVT_DISCONNECTED case BLE_GAP_EVT_TIMEOUT: { // Timeout for scanning is not specified, so only connection attemps can time out. if (p_gap_evt->params.timeout.src == BLE_GAP_TIMEOUT_SRC_CONN) { NRF_LOG_DEBUG("CENTRAL: 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_GATTC_EVT_TIMEOUT: // Disconnect on GATT Client timeout event. NRF_LOG_DEBUG("CENTRAL: 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("CENTRAL: 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 handling BLE Stack events that involves peripheral applications. Manages the * LEDs used to report the status of the peripheral applications. * * @param[in] p_ble_evt Bluetooth stack event. */ static void on_ble_peripheral_evt(ble_evt_t const * p_ble_evt) { ret_code_t err_code; switch (p_ble_evt->header.evt_id) { case BLE_GAP_EVT_CONNECTED: NRF_LOG_INFO("PERIPHERAL: Connected, handle %d.", p_ble_evt->evt.gap_evt.conn_handle); bsp_board_led_off(PERIPHERAL_ADVERTISING_LED); bsp_board_led_on(PERIPHERAL_CONNECTED_LED); break; case BLE_GAP_EVT_DISCONNECTED: NRF_LOG_INFO("PERIPHERAL: Disconnected, handle %d, reason 0x%x.", p_ble_evt->evt.gap_evt.conn_handle, p_ble_evt->evt.gap_evt.params.disconnected.reason); // LED indication will be changed when advertising starts. break; case BLE_GATTC_EVT_TIMEOUT: // Disconnect on GATT Client timeout event. NRF_LOG_DEBUG("PERIPHERAL: 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("PERIPHERAL: 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 handling advertising events. * * @param[in] ble_adv_evt Advertising event. */ static void on_adv_evt(ble_adv_evt_t ble_adv_evt) { switch (ble_adv_evt) { case BLE_ADV_EVT_FAST: bsp_board_led_on(PERIPHERAL_ADVERTISING_LED); bsp_board_led_off(PERIPHERAL_CONNECTED_LED); break; case BLE_ADV_EVT_IDLE: { ret_code_t err_code = ble_advertising_start(&m_advertising, BLE_ADV_MODE_FAST); APP_ERROR_CHECK(err_code); } break; default: // No implementation needed. break; } } /**@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; switch (p_ble_evt->header.evt_id) { case BLE_GAP_EVT_CONNECTED: NRF_LOG_INFO("Connected"); 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); break; case BLE_GAP_EVT_DISCONNECTED: NRF_LOG_INFO("Disconnected"); // LED indication will be changed when advertising starts. m_conn_handle = BLE_CONN_HANDLE_INVALID; 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_GAP_EVT_SEC_PARAMS_REQUEST: // Pairing not supported err_code = sd_ble_gap_sec_params_reply(m_conn_handle, BLE_GAP_SEC_STATUS_PAIRING_NOT_SUPP, NULL, NULL); APP_ERROR_CHECK(err_code); break; case BLE_GATTS_EVT_SYS_ATTR_MISSING: // No system attributes have been stored. err_code = sd_ble_gatts_sys_attr_set(m_conn_handle, NULL, 0, 0); APP_ERROR_CHECK(err_code); break; case BLE_GATTC_EVT_TIMEOUT: // Disconnect on GATT Client timeout event. 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. 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 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) { uint16_t conn_handle = p_ble_evt->evt.gap_evt.conn_handle; uint16_t role = ble_conn_state_role(conn_handle); if ( (p_ble_evt->header.evt_id == BLE_GAP_EVT_CONNECTED) && (is_already_connected(&p_ble_evt->evt.gap_evt.params.connected.peer_addr))) { NRF_LOG_INFO("%s: Already connected to this device as %s (handle: %d), disconnecting.", (role == BLE_GAP_ROLE_PERIPH) ? "PERIPHERAL" : "CENTRAL", (role == BLE_GAP_ROLE_PERIPH) ? "CENTRAL" : "PERIPHERAL", conn_handle); (void)sd_ble_gap_disconnect(conn_handle, BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION); // Do not process the event further. return; } on_ble_evt(conn_handle, p_ble_evt); if (role == BLE_GAP_ROLE_PERIPH) { // Manages peripheral LEDs. on_ble_peripheral_evt(p_ble_evt); } /* else if ((role == BLE_GAP_ROLE_CENTRAL) || (p_ble_evt->header.evt_id == BLE_GAP_EVT_ADV_REPORT)) { on_ble_central_evt(p_ble_evt); } */ } /**@brief Function for initializing the Heart Rate Service client. static void hrs_c_init(void) { ret_code_t err_code; ble_hrs_c_init_t hrs_c_init_obj; hrs_c_init_obj.evt_handler = hrs_c_evt_handler; err_code = ble_hrs_c_init(&m_hrs_c, &hrs_c_init_obj); APP_ERROR_CHECK(err_code); } /**@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 by 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 initializing the Peer Manager. */ static void peer_manager_init(void) { ble_gap_sec_params_t sec_params; ret_code_t err_code; err_code = pm_init(); APP_ERROR_CHECK(err_code); memset(&sec_params, 0, sizeof(ble_gap_sec_params_t)); // Security parameters to be used for all security procedures. sec_params.bond = SEC_PARAMS_BOND; sec_params.mitm = SEC_PARAMS_MITM; sec_params.lesc = SEC_PARAMS_LESC; sec_params.keypress = SEC_PARAMS_KEYPRESS; sec_params.io_caps = SEC_PARAMS_IO_CAPABILITIES; sec_params.oob = SEC_PARAMS_OOB; sec_params.min_key_size = SEC_PARAMS_MIN_KEY_SIZE; sec_params.max_key_size = SEC_PARAMS_MAX_KEY_SIZE; sec_params.kdist_own.enc = 1; sec_params.kdist_own.id = 1; sec_params.kdist_peer.enc = 1; sec_params.kdist_peer.id = 1; err_code = pm_sec_params_set(&sec_params); APP_ERROR_CHECK(err_code); err_code = pm_register(pm_evt_handler); APP_ERROR_CHECK(err_code); } /** @brief Delete all data stored for all peers. */ 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 Function for accepting or rejecting a numeric comparison. */ static void num_comp_reply(uint16_t conn_handle, bool accept) { uint8_t key_type; ret_code_t err_code; if (accept) { NRF_LOG_INFO("Numeric Match. Conn handle: %d", conn_handle); key_type = BLE_GAP_AUTH_KEY_TYPE_PASSKEY; } else { NRF_LOG_INFO("Numeric REJECT. Conn handle: %d", conn_handle); key_type = BLE_GAP_AUTH_KEY_TYPE_NONE; } err_code = sd_ble_gap_auth_key_reply(conn_handle, key_type, NULL); APP_ERROR_CHECK(err_code); } /** @brief Function for handling button presses for numeric comparison match requests. */ static void on_num_comp_button_press(bool accept) { // Check whether any links have pending match requests, and if so, send a reply. /*if (m_conn_handle_num_comp_central != BLE_CONN_HANDLE_INVALID) { num_comp_reply(m_conn_handle_num_comp_central, accept); m_conn_handle_num_comp_central = BLE_CONN_HANDLE_INVALID; } else*/ if (m_conn_handle_num_comp_peripheral != BLE_CONN_HANDLE_INVALID) { num_comp_reply(m_conn_handle_num_comp_peripheral, accept); m_conn_handle_num_comp_peripheral = BLE_CONN_HANDLE_INVALID; } } /**@brief Function for handling events from the BSP module. * * @param[in] event Event generated by button press. */ static void bsp_event_handler(bsp_event_t event) { ret_code_t err_code; switch (event) { case BSP_EVENT_KEY_0: /*err_code = ble_hrs_heart_rate_measurement_send(&m_hrs, 87); if ((err_code != NRF_SUCCESS) && (err_code != NRF_ERROR_INVALID_STATE) && (err_code != NRF_ERROR_RESOURCES) && (err_code != NRF_ERROR_BUSY) && (err_code != BLE_ERROR_GATTS_SYS_ATTR_MISSING) ) { APP_ERROR_HANDLER(err_code); }*/ on_num_comp_button_press(true); break; case BSP_EVENT_KEY_1: on_num_comp_button_press(false); break; case BSP_EVENT_DISCONNECT: err_code = sd_ble_gap_disconnect(m_conn_handle, BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION); if (err_code != NRF_ERROR_INVALID_STATE) { APP_ERROR_CHECK(err_code); } break; case BSP_EVENT_WHITELIST_OFF: if (m_conn_handle == BLE_CONN_HANDLE_INVALID) { err_code = ble_advertising_restart_without_whitelist(&m_advertising); if (err_code != NRF_ERROR_INVALID_STATE) { APP_ERROR_CHECK(err_code); } } break; default: break; } } /**@brief Function for initializing buttons and LEDs. * * @param[out] p_erase_bonds True if the clear bonding button is pressed to * wake the application up. False otherwise. */ static void buttons_leds_init(bool * p_erase_bonds) { ret_code_t err_code; bsp_event_t startup_event; err_code = bsp_init(BSP_INIT_LEDS | BSP_INIT_BUTTONS, bsp_event_handler); APP_ERROR_CHECK(err_code); err_code = bsp_btn_ble_init(NULL, &startup_event); APP_ERROR_CHECK(err_code); *p_erase_bonds = (startup_event == BSP_EVENT_CLEAR_BONDING_DATA); } /**@brief Function for initializing the GAP. * * @details This function sets up all the necessary GAP (Generic Access Profile) parameters of the * device, including the device name, appearance, and the preferred connection parameters. */ static void gap_params_init(void) { ret_code_t err_code; ble_gap_conn_params_t gap_conn_params; ble_gap_conn_sec_mode_t sec_mode; BLE_GAP_CONN_SEC_MODE_SET_OPEN(&sec_mode); err_code = sd_ble_gap_device_name_set(&sec_mode, (const uint8_t *)DEVICE_NAME, strlen(DEVICE_NAME)); APP_ERROR_CHECK(err_code); memset(&gap_conn_params, 0, sizeof(gap_conn_params)); gap_conn_params = m_scan.conn_params; gap_conn_params.min_conn_interval = MIN_CONN_INTERVAL; gap_conn_params.max_conn_interval = MAX_CONN_INTERVAL; gap_conn_params.slave_latency = SLAVE_LATENCY; gap_conn_params.conn_sup_timeout = CONN_SUP_TIMEOUT; err_code = sd_ble_gap_ppcp_set(&gap_conn_params); APP_ERROR_CHECK(err_code); } /**@brief Function for handling events from the GATT library. */ void gatt_evt_handler(nrf_ble_gatt_t * p_gatt, nrf_ble_gatt_evt_t const * p_evt) { if ((m_conn_handle == p_evt->conn_handle) && (p_evt->evt_id == NRF_BLE_GATT_EVT_ATT_MTU_UPDATED)) { m_ble_nus_max_data_len = p_evt->params.att_mtu_effective - OPCODE_LENGTH - HANDLE_LENGTH; NRF_LOG_INFO("Data len is set to 0x%X(%d)", m_ble_nus_max_data_len, m_ble_nus_max_data_len); } NRF_LOG_DEBUG("ATT MTU exchange completed. central 0x%x peripheral 0x%x", p_gatt->att_mtu_desired_central, p_gatt->att_mtu_desired_periph); } /**@brief Function for initializing the GATT library. */ void gatt_init(void) { ret_code_t err_code; err_code = nrf_ble_gatt_init(&m_gatt, gatt_evt_handler); APP_ERROR_CHECK(err_code); err_code = nrf_ble_gatt_att_mtu_periph_set(&m_gatt, NRF_SDH_BLE_GATT_MAX_MTU_SIZE); APP_ERROR_CHECK(err_code); } /**@brief Function for handling Queued Write Module errors. * * @details A pointer to this function is passed to each service that may need to inform the * application about an error. * * @param[in] nrf_error Error code containing information about what went wrong. */ static void nrf_qwr_error_handler(uint32_t nrf_error) { APP_ERROR_HANDLER(nrf_error); } /**@brief Function for initializing the Queued Write instances. */ static void qwr_init(void) { ret_code_t err_code; nrf_ble_qwr_init_t qwr_init_obj = {0}; qwr_init_obj.error_handler = nrf_qwr_error_handler; for (uint32_t i = 0; i < NRF_BLE_LINK_COUNT; i++) { err_code = nrf_ble_qwr_init(&m_qwr[i], &qwr_init_obj); APP_ERROR_CHECK(err_code); } } /**@brief Function for initializing the Connection Parameters module. */ static void conn_params_init(void) { ret_code_t err_code; ble_conn_params_init_t cp_init; memset(&cp_init, 0, sizeof(cp_init)); cp_init.p_conn_params = NULL; cp_init.first_conn_params_update_delay = FIRST_CONN_PARAMS_UPDATE_DELAY; cp_init.next_conn_params_update_delay = NEXT_CONN_PARAMS_UPDATE_DELAY; cp_init.max_conn_params_update_count = MAX_CONN_PARAMS_UPDATE_COUNT; cp_init.start_on_notify_cccd_handle = BLE_GATT_HANDLE_INVALID; // Start upon connection. cp_init.disconnect_on_fail = false;//true cp_init.evt_handler = on_conn_params_evt;//NULL; // Ignore events. cp_init.error_handler = conn_params_error_handler; err_code = ble_conn_params_init(&cp_init); APP_ERROR_CHECK(err_code); } /**@brief Function for handling database discovery events. * * @details This function is a callback function to handle events from the database discovery module. * Depending on the UUIDs that are discovered, this function forwards 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) { ble_hrs_on_db_disc_evt(&m_hrs_c, p_evt); } /**@brief Function for initializing the database discovery module. 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 for initializing the Heart Rate service. static void hrs_init(void) { ret_code_t err_code; ble_hrs_init_t hrs_init_params; uint8_t body_sensor_location; // Initialize the Heart Rate Service. body_sensor_location = BLE_HRS_BODY_SENSOR_LOCATION_FINGER; memset(&hrs_init_params, 0, sizeof(hrs_init_params)); hrs_init_params.evt_handler = NULL; hrs_init_params.is_sensor_contact_supported = true; hrs_init_params.p_body_sensor_location = &body_sensor_location; // Require LESC with MITM (Numeric Comparison). hrs_init_params.hrm_cccd_wr_sec = SEC_MITM; hrs_init_params.bsl_rd_sec = SEC_MITM; err_code = ble_hrs_init(&m_hrs, &hrs_init_params); APP_ERROR_CHECK(err_code); } /**@snippet [Handling the data received over BLE] */ /**@brief Function for handling the data from the Nordic UART Service. * * @details This function will process the data received from the Nordic UART BLE Service and send * it to the UART module. * * @param[in] p_evt Nordic UART Service event. */ /**@snippet [Handling the data received over BLE] */ static void nus_data_handler(ble_nus_evt_t * p_evt) { if (p_evt->type == BLE_NUS_EVT_RX_DATA) { uint32_t err_code; NRF_LOG_DEBUG("Received data from BLE NUS. Writing data on UART."); NRF_LOG_HEXDUMP_DEBUG(p_evt->params.rx_data.p_data, p_evt->params.rx_data.length); for (uint32_t i = 0; i < p_evt->params.rx_data.length; i++) { do { err_code = app_uart_put(p_evt->params.rx_data.p_data[i]); if ((err_code != NRF_SUCCESS) && (err_code != NRF_ERROR_BUSY)) { NRF_LOG_ERROR("Failed receiving NUS message. Error 0x%x. ", err_code); APP_ERROR_CHECK(err_code); } } while (err_code == NRF_ERROR_BUSY); } if (p_evt->params.rx_data.p_data[p_evt->params.rx_data.length - 1] == '\r') { while (app_uart_put('\n') == NRF_ERROR_BUSY); } } } /**@snippet [Handling the data received over BLE] */ /**@brief Function for initializing services that will be used by the application. */ static void services_init(void) { uint32_t err_code; ble_nus_init_t nus_init; //ble_lbs_init_t init = {0}; // Initialize NUS. memset(&nus_init, 0, sizeof(nus_init)); nus_init.data_handler = nus_data_handler; err_code = ble_nus_init(&m_nus, &nus_init); APP_ERROR_CHECK(err_code); // Initialize LBS. //init.led_write_handler = led_write_handler; //err_code = ble_lbs_init(&m_lbs, &init); //APP_ERROR_CHECK(err_code); } /**@brief Function for handling app_uart events. * * @details This function will receive a single character from the app_uart module and append it to * a string. The string will be be sent over BLE when the last character received was a * 'new line' '\n' (hex 0x0A) or if the string has reached the maximum data length. */ /**@snippet [Handling the data received over UART] */ void uart_event_handle(app_uart_evt_t * p_event) { static uint8_t data_array[BLE_NUS_MAX_DATA_LEN]; static uint8_t index = 0; uint32_t err_code; switch (p_event->evt_type) { case APP_UART_DATA_READY: UNUSED_VARIABLE(app_uart_get(&data_array[index])); index++; if ((data_array[index - 1] == '\n') || (data_array[index - 1] == '\r') || (index >= m_ble_nus_max_data_len)) { if (index > 1) { NRF_LOG_DEBUG("Ready to send data over BLE NUS"); NRF_LOG_HEXDUMP_DEBUG(data_array, index); do { uint16_t length = (uint16_t)index; err_code = ble_nus_data_send(&m_nus, data_array, &length, m_conn_handle); if ((err_code != NRF_ERROR_INVALID_STATE) && (err_code != NRF_ERROR_RESOURCES) && (err_code != NRF_ERROR_NOT_FOUND)) { APP_ERROR_CHECK(err_code); } } while (err_code == NRF_ERROR_RESOURCES); } index = 0; } break; case APP_UART_COMMUNICATION_ERROR: APP_ERROR_HANDLER(p_event->data.error_communication); break; case APP_UART_FIFO_ERROR: APP_ERROR_HANDLER(p_event->data.error_code); break; default: break; } } /**@snippet [Handling the data received over UART] */ /**@brief Function for initializing the UART module. */ /**@snippet [UART Initialization] */ static void uart_init(void) { uint32_t err_code; app_uart_comm_params_t const comm_params = { .rx_pin_no = RX_PIN_NUMBER, .tx_pin_no = TX_PIN_NUMBER, .rts_pin_no = RTS_PIN_NUMBER, .cts_pin_no = CTS_PIN_NUMBER, .flow_control = APP_UART_FLOW_CONTROL_DISABLED, .use_parity = false, #if defined (UART_PRESENT) .baud_rate = NRF_UART_BAUDRATE_115200 #else .baud_rate = NRF_UARTE_BAUDRATE_115200 #endif }; APP_UART_FIFO_INIT(&comm_params, UART_RX_BUF_SIZE, UART_TX_BUF_SIZE, uart_event_handle, APP_IRQ_PRIORITY_LOWEST, err_code); APP_ERROR_CHECK(err_code); } /**@snippet [UART Initialization] */ /**@brief Function for initializing the advertising functionality. */ static void advertising_init(void) { ret_code_t err_code; ble_advertising_init_t init; memset(&init, 0, sizeof(init)); init.advdata.name_type = BLE_ADVDATA_FULL_NAME; init.advdata.include_appearance = false;// true init.advdata.flags = BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE; init.advdata.uuids_complete.uuid_cnt = sizeof(m_adv_uuids) / sizeof(m_adv_uuids[0]); init.advdata.uuids_complete.p_uuids = m_adv_uuids; init.config.ble_adv_fast_enabled = true; init.config.ble_adv_fast_interval = APP_ADV_INTERVAL; init.config.ble_adv_fast_timeout = APP_ADV_DURATION; init.evt_handler = on_adv_evt; err_code = ble_advertising_init(&m_advertising, &init); APP_ERROR_CHECK(err_code); ble_advertising_conn_cfg_tag_set(&m_advertising, APP_BLE_CONN_CFG_TAG); } /**@brief Function for initializing logging. */ 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 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 Handles any pending log or key operations, or both, then sleeps until the next event occurs. */ static void idle_state_handle(void) { ret_code_t err_code; err_code = nrf_ble_lesc_request_handler(); APP_ERROR_CHECK(err_code); if (NRF_LOG_PROCESS() == false) { nrf_pwr_mgmt_run(); } } /*APP_TIMER_DEF(send_some_uart_data); /**< Some timer void send_some_uart_data_handler(void * p_context) { ret_code_t err_code; uint8_t string[] = "Anubhav Kumar\n\r"; uint16_t length = sizeof(string); do { err_code = ble_nus_string_send(&m_nus, string, &length); if ( (err_code != NRF_ERROR_INVALID_STATE) && (err_code != NRF_ERROR_BUSY) ) { APP_ERROR_CHECK(err_code); } } while (err_code == NRF_ERROR_BUSY); } void send_some_data_uart_init(void) { app_timer_create(&send_some_uart_data,APP_TIMER_MODE_REPEATED, send_some_uart_data_handler); app_timer_start(send_some_uart_data, APP_TIMER_TICKS(1000), NULL); }*/ int main(void) { bool erase_bonds; // Initialize. uart_init(); log_init(); timer_init(); buttons_leds_init(&erase_bonds); power_management_init(); ble_stack_init(); //scan_init(); gap_params_init(); gatt_init(); services_init(); advertising_init(); conn_params_init(); //db_discovery_init(); qwr_init();// //hrs_init(); //hrs_c_init(); peer_manager_init();// //send_some_data_uart_init(); // Start execution. NRF_LOG_INFO("LE Secure Connections example started."); if (erase_bonds == true) { delete_bonds(); // Scanning and advertising is started by PM_EVT_PEERS_DELETE_SUCEEDED. } else { adv_scan_start(); } // Enter main loop. for (;;) { idle_state_handle(); } }
Can you please tell me what type of encryption and decryption procedure is used while bonding/pairing as well as while sending the encrypted data??
And where can I check this and if possible can I change the encryption algorithm used in the code???