Quick Summary:
- Devices used: nRF52832, nRF52840, Android phone
- SDK used: v16.0.0
- Example based off: ble_app_multirole_lesc
- Primary problem: Central app code does not successfully pair with Peripheral app code
Hi all, the problem in the title is just my guess of what's gone wrong with my application, so I am sorry if it is incorrect.
I have been trying to setup an application using Peer Manager + NUS(_C) based on the `ble_app_multirole_lesc` example from the nRF5 SDK v16.0.0. I have replaced the HRS references with NUS and I'm pretty sure that part is working. I also disengaged the LESC part of the code for simplifying the initial proof of concept and have set the security parameters to match the "Pairing, no bonding" configuration as detailed in the SDK documentation.
Testing my application with both an nRF52832 eval board and another board with the nRF52840, the application is not working quite as expected. I have attached my main.c file for examination. Note that I am using preprocessor conditionals to maintain one code base for targeting my three target devices: central only, peripheral only, and multirole. It is a bit messy for the moment, so let me know if anything is confusing.
/**
* Copyright (c) 2016 - 2019, Nordic Semiconductor ASA
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form, except as embedded into a Nordic
* Semiconductor ASA integrated circuit in a product or a software update for
* such product, must reproduce the above copyright notice, this list of
* conditions and the following disclaimer in the documentation and/or other
* materials provided with the distribution.
*
* 3. Neither the name of Nordic Semiconductor ASA nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* 4. This software, with or without modification, must only be used with a
* Nordic Semiconductor ASA integrated circuit.
*
* 5. Any software provided in binary form under this license must not be reverse
* engineered, decompiled, modified and/or disassembled.
*
* THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
/**
* @brief Application main file for the BLE multirole LE Secure Connections (LESC) example.
*
* @detail This application demonstrates bonding with LE Secure Connections both as a peripheral and as a central.
*
* LED layout:
* LED 1: Central side is scanning. LED 2: Central side is connected to a peripheral.
* LED 3: Peripheral side is advertising. LED 4: Peripheral side is connected to a central.
*
* @note: This application requires the use of an external ECC library for public key and shared secret calculation.
* Refer to the application's documentation for more details.
*
*/
#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 "app_uart.h"
#include "bsp_btn_ble.h"
#include "ble.h"
#include "app_util.h"
#include "ble_advdata.h"
#include "ble_nus_c.h"
#include "ble_nus.h"
#include "ble_advertising.h"
#include "ble_conn_params.h"
#include "ble_db_discovery.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"
#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.h"
#define TARGET_MULTI_ROLE 0
#define TARGET_PERIPH_ROLE 1
#define TARGET_CENTRAL_ROLE 2
#define TARGET_ROLE TARGET_MULTI_ROLE
#if TARGET_ROLE == TARGET_MULTI_ROLE
#define GAP_NAME "MULT"
#elif TARGET_ROLE == TARGET_PERIPH_ROLE
#define GAP_NAME "PERI"
#elif TARGET_ROLE == TARGET_CENTRAL_ROLE
#define GAP_NAME "CENT"
#endif
#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 0 /**< 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 CENTRAL_SCANNING_LED BSP_BOARD_LED_0
#define CENTRAL_CONNECTED_LED BSP_BOARD_LED_1
#define PERIPHERAL_ADVERTISING_LED BSP_BOARD_LED_2
#define PERIPHERAL_CONNECTED_LED BSP_BOARD_LED_3
#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_DURATION 18000 /**< The advertising duration (180 seconds) in units of 10 milliseconds. */
#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 0 /**< 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(5000) /**< 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. */
#define UART_TX_BUF_SIZE 256
#define UART_RX_BUF_SIZE 256
#define NUS_SERVICE_UUID_TYPE BLE_UUID_TYPE_VENDOR_BEGIN /**< UUID type for the Nordic UART Service (vendor specific). */
#define ECHOBACK_BLE_UART_DATA 0 /**< Echo the UART data that is received over the Nordic UART Service (NUS) back to the sender. */
/**@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;
NRF_BLE_GQ_DEF(m_ble_gatt_queue, /**< BLE GATT Queue instance. */
NRF_SDH_BLE_CENTRAL_LINK_COUNT,
NRF_BLE_GQ_QUEUE_SIZE);
/* Central role GATT Client */
//BLE_NUS_C_ARRAY_DEF(m_ble_nus_c, NRF_SDH_BLE_CENTRAL_LINK_COUNT);
#if TARGET_ROLE != TARGET_PERIPH_ROLE
BLE_NUS_C_DEF(m_ble_nus_c); /**< BLE Nordic UART Service (NUS) client instance. */
#endif
#if TARGET_ROLE != TARGET_CENTRAL_ROLE
#if TARGET_ROLE == TARGET_PERIPH_ROLE
BLE_NUS_DEF(m_nus, 1);
#else
BLE_NUS_DEF(m_nus, NRF_SDH_BLE_PERIPHERAL_LINK_COUNT);
#endif
#endif
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.*/
#if TARGET_ROLE != TARGET_CENTRAL_ROLE
BLE_ADVERTISING_DEF(m_advertising); /**< Advertising module instance. */
#endif
#if TARGET_ROLE != TARGET_PERIPH_ROLE
BLE_DB_DISCOVERY_DEF(m_db_disc); /**< Database discovery module instance. */
#endif
NRF_BLE_SCAN_DEF(m_scan); /**< Scanning Module instance. */
static uint16_t m_ble_nus_max_data_len = BLE_GATT_ATT_MTU_DEFAULT - OPCODE_LENGTH - HANDLE_LENGTH; /**< Maximum length of data (in bytes) that can be transmitted to the peer by the Nordic UART service module. */
static uint16_t m_conn_handle_nus_c = BLE_CONN_HANDLE_INVALID; /**< Connection handle for the NUS central application. */
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 char m_target_periph_name[4] = "PERI";
/**@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.
*/
#if TARGET_ROLE != TARGET_CENTRAL_ROLE
static ble_uuid_t m_adv_uuids[] = {{BLE_UUID_NUS_SERVICE, BLE_UUID_TYPE_VENDOR_BEGIN}};
#endif
/**@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 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 the Nordic UART Service Client errors.
*
* @param[in] nrf_error Error code containing information about what went wrong.
*/
static void nus_error_handler(uint32_t nrf_error)
{
APP_ERROR_HANDLER(nrf_error);
}
#if TARGET_ROLE != TARGET_CENTRAL_ROLE
/**@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("Receive the BLE UART data");
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);
}
NRF_LOG_HEXDUMP_INFO(p_evt->params.rx_data.p_data, p_evt->params.rx_data.length);
ble_nus_data_send(&m_nus, (const uint8_t *)"GOT", (const uint16_t *)3,p_evt->conn_handle);
}
else if (p_evt->type == BLE_NUS_EVT_COMM_STARTED)
{
NRF_LOG_DEBUG("NUS : BLE_NUS_EVT_COMM_STARTED");
ble_nus_data_send(&m_nus,(const uint8_t *)"HI",2,p_evt->conn_handle);
}
else if (p_evt->type == BLE_NUS_EVT_COMM_STOPPED)
{
NRF_LOG_DEBUG("NUS : BLE_NUS_EVT_COMM_STOPPED");
}
}
#endif
/**@snippet [Handling the data received over BLE] */
/**@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;
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);
uint8_t final_target_name[4];
#if TARGET_ROLE == TARGET_MULTI_ROLE
memcpy((uint8_t *)final_target_name, (const uint8_t *)"PERI", 4);
#else
memcpy((uint8_t *)final_target_name, (const uint8_t *)"CENT", 4);
#endif
#if TARGET_ROLE != TARGET_PERIPH_ROLE
if (strlen(m_target_periph_name) != 0)
{
err_code = nrf_ble_scan_filter_set(&m_scan,
SCAN_NAME_FILTER,
final_target_name);
APP_ERROR_CHECK(err_code);
}
err_code = nrf_ble_scan_filters_enable(&m_scan, NRF_BLE_SCAN_NAME_FILTER,
false);
APP_ERROR_CHECK(err_code);
#endif
}
#if TARGET_ROLE != TARGET_PERIPH_ROLE
/**@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 for %s", nrf_log_push(m_target_periph_name));
}
#endif
/**@brief Function for initializing the advertising and the scanning.
*/
static void adv_scan_start(void)
{
ret_code_t err_code;
#if TARGET_ROLE != TARGET_PERIPH_ROLE
scan_start();
// Turn on the LED to signal scanning.
bsp_board_led_on(CENTRAL_SCANNING_LED);
#endif
#if TARGET_ROLE != TARGET_CENTRAL_ROLE
// Start advertising.
err_code = ble_advertising_start(&m_advertising, BLE_ADV_MODE_FAST);
APP_ERROR_CHECK(err_code);
NRF_LOG_INFO("Advertising as %s", nrf_log_push((const uint8_t *)GAP_NAME));
#endif
}
/**@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;
}
}
#if TARGET_ROLE != TARGET_PERIPH_ROLE
/**@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);
}
}
#endif
/**@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 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);
#if TARGET_ROLE == TARGET_PERIPH_ROLE
pm_handler_secure_on_connection(p_ble_evt);
#endif
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);
NRF_LOG_INFO("BLE_GAP_EVT_CONNECTED");
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_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.
//NRF_LOG_INFO("EVT ID: %i", p_ble_evt->header.evt_id);
break;
}
}
#if TARGET_ROLE != TARGET_PERIPH_ROLE
/**@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 Nordic UART service is currently connected, try to find them on this peripheral.
if (m_conn_handle_nus_c == BLE_CONN_HANDLE_INVALID)
{
NRF_LOG_INFO("CENTRAL: Searching for NUS 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);
// TODO: reset scan filter here
if (p_gap_evt->conn_handle == m_conn_handle_nus_c)
{
m_conn_handle_nus_c = BLE_CONN_HANDLE_INVALID;
err_code = nrf_ble_scan_filter_set(&m_scan,
SCAN_NAME_FILTER,
m_target_periph_name);
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;
}
}
#endif
#if TARGET_ROLE != TARGET_CENTRAL_ROLE
/**@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);
char conn_msg[16] = "Hey it's periph";
ble_nus_data_send(&m_nus,(const uint8_t *)conn_msg,(const uint8_t *)16, p_ble_evt->evt.gap_evt.conn_handle);
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;
}
}
#endif
#if TARGET_ROLE != TARGET_CENTRAL_ROLE
/**@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;
}
}
#endif
/**@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)
{
#if TARGET_ROLE != TARGET_CENTRAL_ROLE
on_ble_peripheral_evt(p_ble_evt);
#endif
}
#if TARGET_ROLE != TARGET_PERIPH_ROLE
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);
}
#endif
}
/**@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);
ble_cfg_t ble_cfg;
// Configure the GATTS attribute table.
memset(&ble_cfg, 0x00, sizeof(ble_cfg));
ble_cfg.gap_cfg.role_count_cfg.periph_role_count = NRF_SDH_BLE_PERIPHERAL_LINK_COUNT;
ble_cfg.gap_cfg.role_count_cfg.central_role_count = NRF_SDH_BLE_CENTRAL_LINK_COUNT;
err_code = sd_ble_cfg_set(BLE_GAP_CFG_ROLE_COUNT, &ble_cfg, &ram_start);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_ERROR("sd_ble_cfg_set() returned %s when attempting to set BLE_GAP_CFG_ROLE_COUNT.",
nrf_strerror_get(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));
sec_params.bond = false;
sec_params.mitm = false;
sec_params.lesc = 0;
sec_params.keypress = 0;
sec_params.io_caps = BLE_GAP_IO_CAPS_NONE;
sec_params.oob = false;
sec_params.min_key_size = 7;
sec_params.max_key_size = 16;
sec_params.kdist_own.enc = 0;
sec_params.kdist_own.id = 0;
sec_params.kdist_peer.enc = 0;
sec_params.kdist_peer.id = 0;
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 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:
break;
case BSP_EVENT_KEY_1:
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);
}
#if TARGET_ROLE != TARGET_CENTRAL_ROLE
/**@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 *)GAP_NAME,
strlen(GAP_NAME));
APP_ERROR_CHECK(err_code);
memset(&gap_conn_params, 0, sizeof(gap_conn_params));
gap_conn_params = m_scan.conn_params;
err_code = sd_ble_gap_ppcp_set(&gap_conn_params);
APP_ERROR_CHECK(err_code);
}
#endif
/**@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 (p_evt->evt_id == NRF_BLE_GATT_EVT_ATT_MTU_UPDATED)
{
NRF_LOG_INFO("ATT MTU exchange completed.");
m_ble_nus_max_data_len = p_evt->params.att_mtu_effective - OPCODE_LENGTH - HANDLE_LENGTH;
NRF_LOG_INFO("Ble NUS max data length set to 0x%X(%d)", m_ble_nus_max_data_len, m_ble_nus_max_data_len);
}
}
/**@brief Function for initializing the GATT module. */
static void gatt_init(void)
{
ret_code_t err_code = nrf_ble_gatt_init(&m_gatt, gatt_evt_handler);
APP_ERROR_CHECK(err_code);
err_code = nrf_ble_gatt_att_mtu_central_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 = true;
cp_init.evt_handler = NULL; // Ignore events.
cp_init.error_handler = conn_params_error_handler;
err_code = ble_conn_params_init(&cp_init);
APP_ERROR_CHECK(err_code);
}
#if TARGET_ROLE != TARGET_PERIPH_ROLE
/**@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_nus_c_on_db_disc_evt(&m_ble_nus_c, p_evt);
return;
}
/**@brief Function for initializing the database discovery module. */
static void db_discovery_init(void)
{
ble_db_discovery_init_t db_init;
memset(&db_init, 0, sizeof(db_init));
db_init.evt_handler = db_disc_handler;
db_init.p_gatt_queue = &m_ble_gatt_queue;
ret_code_t err_code = ble_db_discovery_init(&db_init);
APP_ERROR_CHECK(err_code);
}
#endif
#if TARGET_ROLE != TARGET_CENTRAL_ROLE
/**@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 = 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 = ADV_INTERVAL;
init.config.ble_adv_fast_timeout = 0;
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);
}
#endif
/**@brief Function for handling characters received by the Nordic UART Service (NUS).
*
* @details This function takes a list of characters of length data_len and prints the characters out on UART.
* If @ref ECHOBACK_BLE_UART_DATA is set, the data is sent back to sender.
*/
static void ble_nus_chars_received_uart_print(uint8_t * p_data, uint16_t data_len)
{
ret_code_t ret_val;
NRF_LOG_INFO("Receiving data.");
NRF_LOG_HEXDUMP_INFO(p_data, data_len);
for (uint32_t i = 0; i < data_len; i++)
{
do
{
ret_val = app_uart_put(p_data[i]);
if ((ret_val != NRF_SUCCESS) && (ret_val != NRF_ERROR_BUSY))
{
NRF_LOG_ERROR("app_uart_put failed for index 0x%04x.", i);
APP_ERROR_CHECK(ret_val);
}
} while (ret_val == NRF_ERROR_BUSY);
}
if (p_data[data_len-1] == '\r')
{
while (app_uart_put('\n') == NRF_ERROR_BUSY);
}
if (ECHOBACK_BLE_UART_DATA)
{
#if TARGET_ROLE != TARGET_PERIPH_ROLE
// Send data back to the peripheral.
do
{
ret_val = ble_nus_c_string_send(&m_ble_nus_c, p_data, data_len);
if ((ret_val != NRF_SUCCESS) && (ret_val != NRF_ERROR_BUSY))
{
NRF_LOG_ERROR("Failed sending NUS message. Error 0x%x. ", ret_val);
APP_ERROR_CHECK(ret_val);
}
} while (ret_val == NRF_ERROR_BUSY);
#endif
}
}
/**@brief Function for handling app_uart events.
*
* @details This function receives a single character from the app_uart module and appends it to
* a string. The string is sent over BLE when the last character received is a
* 'new line' '\n' (hex 0x0A) or if the string reaches the maximum data length.
*/
void uart_event_handle(app_uart_evt_t * p_event)
{
static uint8_t data_array[BLE_NUS_MAX_DATA_LEN];
static uint16_t index = 0;
uint32_t ret_val;
switch (p_event->evt_type)
{
/**@snippet [Handling data from UART] */
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)))
{
NRF_LOG_DEBUG("Ready to send data over BLE NUS");
NRF_LOG_HEXDUMP_DEBUG(data_array, index);
#if TARGET_ROLE != TARGET_PERIPH_ROLE
do
{
ret_val = ble_nus_c_string_send(&m_ble_nus_c, data_array, index);
if ( (ret_val != NRF_ERROR_INVALID_STATE) && (ret_val != NRF_ERROR_RESOURCES) )
{
APP_ERROR_CHECK(ret_val);
}
} while (ret_val == NRF_ERROR_RESOURCES);
#endif
index = 0;
}
break;
/**@snippet [Handling data from UART] */
case APP_UART_COMMUNICATION_ERROR:
NRF_LOG_ERROR("Communication error occurred while handling UART.");
APP_ERROR_HANDLER(p_event->data.error_communication);
break;
case APP_UART_FIFO_ERROR:
NRF_LOG_ERROR("Error occurred in FIFO module used by UART.");
APP_ERROR_HANDLER(p_event->data.error_code);
break;
default:
break;
}
}
#if TARGET_ROLE != TARGET_PERIPH_ROLE
/**@brief Callback handling Nordic UART Service (NUS) client events.
*
* @details This function is called to notify the application of NUS client events.
*
* @param[in] p_ble_nus_c NUS client handle. This identifies the NUS client.
* @param[in] p_ble_nus_evt Pointer to the NUS client event.
*/
static void ble_nus_c_evt_handler(ble_nus_c_t * p_ble_nus_c, ble_nus_c_evt_t const * p_ble_nus_evt)
{
ret_code_t err_code;
switch (p_ble_nus_evt->evt_type)
{
case BLE_NUS_C_EVT_DISCOVERY_COMPLETE:
NRF_LOG_INFO("Discovery complete.");
err_code = ble_nus_c_handles_assign(p_ble_nus_c, p_ble_nus_evt->conn_handle, &p_ble_nus_evt->handles);
APP_ERROR_CHECK(err_code);
// Initiate bonding
//err_code = pm_conn_secure(p_ble_nus_evt->conn_handle, false);
//APP_ERROR_CHECK(err_code);
err_code = ble_nus_c_tx_notif_enable(p_ble_nus_c);
APP_ERROR_CHECK(err_code);
NRF_LOG_INFO("Connected to device with Nordic UART Service.");
break;
case BLE_NUS_C_EVT_NUS_TX_EVT:
ble_nus_chars_received_uart_print(p_ble_nus_evt->p_data, p_ble_nus_evt->data_len);
break;
case BLE_NUS_C_EVT_DISCONNECTED:
NRF_LOG_INFO("Disconnected.");
scan_start();
break;
}
}
#endif
#if TARGET_ROLE != TARGET_PERIPH_ROLE
/**@brief Function for initializing the Nordic UART Service (NUS) client. */
static void nus_c_init(void)
{
ret_code_t err_code;
ble_nus_c_init_t init;
init.evt_handler = ble_nus_c_evt_handler;
init.error_handler = nus_error_handler;
init.p_gatt_queue = &m_ble_gatt_queue;
err_code = ble_nus_c_init(&m_ble_nus_c, &init);
APP_ERROR_CHECK(err_code);
}
#endif
#if TARGET_ROLE != TARGET_CENTRAL_ROLE
static void nus_init(void)
{
ret_code_t err_code;
ble_nus_init_t nus_init;
// 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);
}
#endif
/**@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 the UART. */
static void uart_init(void)
{
ret_code_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,
.baud_rate = UART_BAUDRATE_BAUDRATE_Baud115200
};
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);
}
/**@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();
}
}
int main(void)
{
bool erase_bonds;
// Initialize.
log_init();
timer_init();
uart_init();
buttons_leds_init(&erase_bonds);
power_management_init();
ble_stack_init();
scan_init();
#if TARGET_ROLE != TARGET_CENTRAL_ROLE
gap_params_init();
#endif
gatt_init();
conn_params_init();
#if TARGET_ROLE != TARGET_PERIPH_ROLE
db_discovery_init();
#endif
qwr_init();
#if TARGET_ROLE != TARGET_PERIPH_ROLE
nus_c_init();
#endif
#if TARGET_ROLE != TARGET_CENTRAL_ROLE
nus_init();
#endif
peer_manager_init();
#if TARGET_ROLE != TARGET_CENTRAL_ROLE
advertising_init();
#endif
// 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();
}
}
My results:
Connecting to both cases of peripheral roles (peripheral only and multirole's peripheral) from my Android phone, I see that the peer manager connection procedure succeeds with a log like this:
<00> info> app: LE Secure Connections example started. 00> <00> info> app: Advertising 00> <00> debug> peer_manager_handler: Connected, securing connection. conn_handle: 1 00> <00> debug> peer_manager_handler: Event PM_EVT_CONN_SEC_PARAMS_REQ 00> <00> debug> peer_manager_handler: Security parameter request 00> <00> info> app: BLE_GAP_EVT_CONNECTED 00> <00> info> app: PERIPHERAL: Connected, handle 1. 00> <00> debug> peer_manager_handler: Event PM_EVT_CONN_SEC_START 00> <00> debug> peer_manager_handler: Connection security procedure started: role: Peripheral, conn_handle: 1, procedure: Bonding 00> <00> debug> peer_manager_handler: Event PM_EVT_CONN_SEC_PARAMS_REQ 00> <00> debug> peer_manager_handler: Security parameter request 00> <00> info> app: PERIPHERAL: BLE_GAP_EVT_SEC_PARAMS_REQUEST 00> <00> debug> nrf_ble_gatt: Peer on connection 0x1 requested a data length of 27 bytes. 00> <00> debug> nrf_ble_gatt: Updating data length to 27 on connection 0x1. 00> <00> debug> nrf_ble_gatt: Data length updated to 27 on connection 0x1. 00> <00> debug> nrf_ble_gatt: max_rx_octets: 27 00> <00> debug> nrf_ble_gatt: max_tx_octets: 27 00> <00> debug> nrf_ble_gatt: max_rx_time: 328 00> <00> debug> nrf_ble_gatt: max_tx_time: 2120 00> <00> debug> peer_manager_handler: Event PM_EVT_CONN_SEC_SUCCEEDED 00> <00> info> peer_manager_handler: Connection secured: role: Peripheral, conn_handle: 1, procedure: Pairing 00> <00> info> app: PERIPHERAL: BLE_GAP_EVT_AUTH_STATUS: status=0x0 bond=0x0 lv4: 0 kdist_own:0x0 kdist_peer:0x0 00> <00> info> app: PERIPHERAL: Disconnected, handle 1, reason 0x13. 00>
So this leads me to believe that the peer manager configuration is correct. However, when I try to do a test case with the nRF52832 eval board as a peripheral and the nRF52840 board as the multirole/central, this is the RTT Viewer output of the peripheral device:
<00> info> app_timer: RTC: initialized. 00> <00> info> app: LE Secure Connections example started. 00> <00> info> app: Advertising 00> <00> debug> peer_manager_handler: Connected, securing connection. conn_handle: 1 00> <00> debug> peer_manager_handler: Event PM_EVT_CONN_SEC_PARAMS_REQ 00> <00> debug> peer_manager_handler: Security parameter request 00> <00> info> app: BLE_GAP_EVT_CONNECTED 00> <00> info> app: PERIPHERAL: Connected, handle 1. 00> <00> info> app: PERIPHERAL: BLE_GAP_EVT_AUTH_STATUS: status=0x1 bond=0x0 lv4: 0 kdist_own:0x0 kdist_peer:0x0 00>
and the nRF52840 multirole device acting as a central device:
<00> info> app_timer: RTC: initialized. 00> <00> debug> ble_scan: Adding filter on PERI name 00> <00> info> app: LE Secure Connections example started. 00> <00> debug> ble_scan: Scanning 00> <00> info> app: Scanning 00> <00> info> app: Advertising 00> <00> debug> ble_scan: Connecting 00> <00> debug> ble_scan: Connection status: 0 00> <00> info> app: BLE_GAP_EVT_CONNECTED 00> <00> info> app: CENTRAL: Connected, handle: 0. 00> <00> info> app: CENTRAL: Searching for NUS on conn_handle 0x0 00> <00> debug> nrf_ble_gq: Registering connection handle: 0x0000 00> <00> debug> ble_db_disc: Starting discovery of service with UUID 0x1 on connection handle 0x0. 00> <00> debug> nrf_ble_gq: Adding item to the request queue 00> <00> debug> nrf_ble_gq: GATTC Primary Services Discovery Request 00> <00> debug> nrf_ble_gq: SD GATT procedure (2) succeeded on connection handle: 0. 00> 00> <00> debug> peer_manager_handler: Security parameter request 00> <00> debug> peer_manager_handler: Event PM_EVT_SLAVE_SECURITY_REQ 00> <00> debug> peer_manager_handler: Security Request received from peer. 00> <00> debug> peer_manager_handler: Event PM_EVT_CONN_SEC_PARAMS_REQ 00> <00> debug> peer_manager_handler: Security parameter request 00> <00> debug> ble_db_disc: Found service UUID 0x1. 00> <00> debug> nrf_ble_gq: Adding item to the request queue 00> <00> debug> nrf_ble_gq: GATTC Characteristic Discovery Request 00> <00> debug> nrf_ble_gq: SD GATT procedure (3) succeeded on connection handle: 0. 00> <00> debug> nrf_ble_gq: Processing the request queue... 00> <00> debug> peer_manager_handler: Event PM_EVT_CONN_SEC_PARAMS_REQ 00> <00> debug> peer_manager_handler: Security parameter request 00> <00> debug> nrf_ble_gq: Adding item to the request queue 00> <00> debug> nrf_ble_gq: GATTC Characteristic Discovery Request 00> <00> debug> nrf_ble_gq: SD GATT procedure (3) succeeded on connection handle: 0. 00> <00> debug> nrf_ble_gq: Processing the request queue... 00> <00> debug> peer_manager_handler: Event PM_EVT_CONN_SEC_PARAMS_REQ 00> <00> debug> peer_manager_handler: Security parameter request 00> <00> debug> nrf_ble_gq: Adding item to the request queue 00> <00> debug> nrf_ble_gq: GATTC Characteristic Descriptor Request 00> <00> debug> nrf_ble_gq: SD GATT procedure (4) succeeded on connection handle: 0. 00> <00> debug> nrf_ble_gq: Processing the request queue... 00> <00> debug> peer_manager_handler: Event PM_EVT_CONN_SEC_PARAMS_REQ 00> <00> debug> peer_manager_handler: Security parameter request 00> <00> debug> ble_db_disc: Discovery of service with UUID 0x1 completed with success on connection handle 0x0. 00> <00> info> app: Discovery complete. 00> <00> debug> nrf_ble_gq: Adding item to the request queue 00> <00> debug> nrf_ble_gq: GATTC Write Request 00> <00> debug> nrf_ble_gq: SD GATT procedure (1) succeeded on connection handle: 0. 00> <00> info> app: Connected to device with Nordic UART Service. 00> <00> debug> nrf_ble_gq: Processing the request queue... 00> <00> debug> peer_manager_handler: Event PM_EVT_CONN_SEC_PARAMS_REQ 00> <00> debug> nrf_ble_gq: Processing the request queue... 00> <00> debug> peer_manager_handler: Event PM_EVT_CONN_SEC_PARAMS_REQ 00> <00> debug> peer_manager_handler: Security parameter request 00>
As you can see, the peripheral log output is significantly different compared to when my phone is connecting to it. We do get a BLE_GAP_EVT_CONNECTED event as well as a successful NUS discovery/connection. In addition to that, when the Peripheral device is lost (in my case, turned off), the application errors out with this:
<00> error> peer_manager_sm: Could not perform security procedure. smd_params_reply() or smd_link_secure() returned Unknown error code. conn_handle: 0 00> <00> debug> peer_manager_handler: Event PM_EVT_ERROR_UNEXPECTED 00> <00> error> peer_manager_handler: Unexpected fatal error occurred: error: Unknown error code 00> <00> error> peer_manager_handler: Asserting. 00> <00> error> app: End of error report 00>
My conclusion is that my Central side code is not performing certain functionality that is needed to complete the pairing. The thing that stands out to me are the abundant PM_EVT_CONN_SEC_PARAMS_REQ events. I am not too familiar with proper peer manager procedure, but looking at the "working" Android Central -> Application Peripheral log, I see that it moves past that event. Specifically, I do not see PM_EVT_CONN_SEC_START, which I am expecting.
Could anyone point me in the right direction of what I am missing, misunderstanding, or configuring wrong?
Thanks
