/** * Copyright (c) 2014 - 2017, 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 BLE Heart Rate and Running speed Relay application main file. * * @detail This application demonstrates a simple "Relay". * Meaning we pass on the values that we receive. By combining a collector part on * one end and a sensor part on the other, we show that the s130 can function * simultaneously as a central and a peripheral device. * * In the figure below, the sensor ble_app_hrs connects and interacts with the relay * in the same manner it would connect to a heart rate collector. In this case, the Relay * application acts as a central. * * On the other side, a collector (such as Master Control panel or ble_app_hrs_c) connects * and interacts with the relay the same manner it would connect to a heart rate sensor peripheral. * * 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 While testing, be careful that the Sensor and Collector are actually connecting to the Relay, * and not directly to each other! * * Peripheral Relay Central * +--------+ +-----------|----------+ +-----------+ * | Heart | | Heart | Heart | | | * | Rate | -----> | Rate -|-> Rate | -----> | Collector | * | Sensor | | Collector | Sensor | | | * +--------+ +-----------| and | +-----------+ * | Running | Running| * +--------+ | Speed -|-> Speed | * | Running|------> | Collector | Sensor | * | Speed | +-----------|----------+ * | Sensor | * +--------+ */ #include #include #include #include "nordic_common.h" #include "nrf_sdh.h" #include "nrf_sdh_soc.h" #include "nrf_sdh_ble.h" #include "peer_manager.h" #include "app_timer.h" #include "app_uart.h" #include "bsp_btn_ble.h" #include "ble.h". #include "ble_advdata.h" #include "ble_advertising.h" #include "ble_conn_params.h" #include "ble_db_discovery.h" #include "ble_nus.h" #include "ble_nus_c.h" #include "ble_conn_state.h" #include "nrf_fstorage.h" #include "fds.h" #include "nrf_ble_gatt.h" #include "nrf_log.h" #include "nrf_log_ctrl.h" #include "nrf_log_default_backends.h" #define PERIPHERAL_ADVERTISING_LED BSP_BOARD_LED_2 #define PERIPHERAL_CONNECTED_LED BSP_BOARD_LED_3 #define CENTRAL_SCANNING_LED BSP_BOARD_LED_0 #define CENTRAL_CONNECTED_LED BSP_BOARD_LED_1 #define DEVICE_NAME "Relay" /**< Name of device used for advertising. */ #define MANUFACTURER_NAME "NordicSemiconductor" /**< Manufacturer. Will be passed to Device Information Service. */ #define APP_ADV_INTERVAL 300 /**< The advertising interval (in units of 0.625 ms). This value corresponds to 187.5 ms. */ #define APP_ADV_TIMEOUT_IN_SECONDS 180 /**< The advertising timeout in units of seconds. */ #define APP_BLE_CONN_CFG_TAG 1 /**< A tag identifying the SoftDevice BLE configuration. */ #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 APP_FEATURE_NOT_SUPPORTED BLE_GATT_STATUS_ATTERR_APP_BEGIN + 2 /**< Reply when unsupported features are requested. */ #define SEC_PARAM_BOND 1 /**< Perform bonding. */ #define SEC_PARAM_MITM 0 /**< Man In The Middle protection not required. */ #define SEC_PARAM_LESC 0 /**< LE Secure Connections not enabled. */ #define SEC_PARAM_KEYPRESS 0 /**< Keypress notifications not enabled. */ #define SEC_PARAM_IO_CAPABILITIES BLE_GAP_IO_CAPS_NONE /**< No I/O capabilities. */ #define SEC_PARAM_OOB 0 /**< Out Of Band data not available. */ #define SEC_PARAM_MIN_KEY_SIZE 7 /**< Minimum encryption key size in octets. */ #define SEC_PARAM_MAX_KEY_SIZE 16 /**< Maximum encryption key size in octets. */ #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_TIMEOUT 0 #define MIN_CONNECTION_INTERVAL (uint16_t) MSEC_TO_UNITS(7.5, UNIT_1_25_MS) /**< Determines minimum connection interval in milliseconds. */ #define MAX_CONNECTION_INTERVAL (uint16_t) 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 (uint16_t) MSEC_TO_UNITS(4000, UNIT_10_MS) /**< Determines supervision time-out in units of 10 milliseconds. */ #define UUID16_SIZE 2 /**< Size of a UUID, in bytes. */ #define ECHOBACK_BLE_UART_DATA 1 /**< Echo the UART data that is received over the Nordic UART Service back to the sender. */ #define UART_TX_BUF_SIZE 256 /**< UART TX buffer size. */ #define UART_RX_BUF_SIZE 256 /**< UART RX buffer size. */ /**@brief Priority of the application BLE event handler. * @note You shouldn't need to modify this value. */ #define APP_BLE_OBSERVER_PRIO 1 /**@brief Macro to unpack 16bit unsigned UUID from an octet stream. */ #define UUID16_EXTRACT(DST, SRC) \ do \ { \ (*(DST)) = (SRC)[1]; \ (*(DST)) <<= 8; \ (*(DST)) |= (SRC)[0]; \ } while (0) /**@brief Variable length data encapsulation in terms of length and pointer to data. */ typedef struct { uint8_t * p_data; /**< Pointer to data. */ uint16_t data_len; /**< Length of data. */ } data_t; BLE_NUS_DEF(m_nus); /**< Heart rate service instance. */ BLE_NUS_C_DEF(m_ble_nus_c); /**< Heart rate service client instance. */ NRF_BLE_GATT_DEF(m_gatt); /**< GATT module instance. */ BLE_ADVERTISING_DEF(m_advertising); /**< Advertising module instance. */ BLE_DB_DISCOVERY_DEF(m_db_discovery); /**< Database discovery module instances. */ static uint16_t m_conn_handle_nus_c = BLE_CONN_HANDLE_INVALID; /**< Connection handle for the NUS central application */ //static uint16_t m_conn_handle_rscs_c = BLE_CONN_HANDLE_INVALID; /**< Connection handle for the RSC central application */ static uint16_t m_conn_handle_to_disc = BLE_CONN_HANDLE_INVALID; /**< The connection handle on which to retry the DB discovery. */ static bool m_retry_db_disc; /**< Retry DB discovery if attempted while busy. */ static bool m_do_retry_db_disc; 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. */ /**@brief names which the central applications will scan for, and which will be advertised by the peripherals. * if these are set to empty strings, the UUIDs defined below will be used */ static char const m_target_periph_name[] = ""; /**@brief UUIDs which the central applications will scan for if the name above is set to an empty string, * and which will be advertised by the peripherals. */ static ble_uuid_t m_adv_uuids[] = { {BLE_UUID_NUS_SERVICE, BLE_UUID_TYPE_VENDOR_BEGIN} }; /**@brief Parameters used when scanning. */ static ble_gap_scan_params_t const m_scan_params = { .active = 1, .interval = SCAN_INTERVAL, .window = SCAN_WINDOW, .timeout = SCAN_TIMEOUT, #if (NRF_SD_BLE_API_VERSION <= 2) .selective = 0, .p_whitelist = NULL, #endif #if (NRF_SD_BLE_API_VERSION >= 3) .use_whitelist = 0, #endif }; /**@brief Connection parameters requested for connection. */ static ble_gap_conn_params_t const m_connection_param = { MIN_CONNECTION_INTERVAL, MAX_CONNECTION_INTERVAL, SLAVE_LATENCY, SUPERVISION_TIMEOUT }; /**@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); } /**@brief Function for handling errors from the Connection Parameters module. * * @param[in] nrf_error Error code containing information about what went wrong. */ static void conn_params_error_handler(uint32_t nrf_error) { APP_ERROR_HANDLER(nrf_error); } /**@brief Parses advertisement data, providing length and location of the field in case * matching data is found. * * @param[in] Type of data to be looked for in advertisement data. * @param[in] Advertisement report length and pointer to report. * @param[out] If data type requested is found in the data report, type data length and * pointer to data will be populated here. * * @retval NRF_SUCCESS if the data type is found in the report. * @retval NRF_ERROR_NOT_FOUND if the data type could not be found. */ static uint32_t adv_report_parse(uint8_t type, data_t * p_advdata, data_t * p_typedata) { uint32_t index = 0; uint8_t * p_data; p_data = p_advdata->p_data; while (index < p_advdata->data_len) { uint8_t field_length = p_data[index]; uint8_t field_type = p_data[index + 1]; if (field_type == type) { p_typedata->p_data = &p_data[index + 2]; p_typedata->data_len = field_length - 1; return NRF_SUCCESS; } index += field_length + 1; } return NRF_ERROR_NOT_FOUND; } /**@brief Function for initiating scanning. */ static void scan_start(void) { ret_code_t err_code; (void) sd_ble_gap_scan_stop(); err_code = sd_ble_gap_scan_start(&m_scan_params); // It is okay to ignore this error since we are stopping the scan anyway. if (err_code != NRF_ERROR_INVALID_STATE) { APP_ERROR_CHECK(err_code); } } /**@brief Function for initiating advertising and scanning. */ static void adv_scan_start(void) { ret_code_t err_code; //check if there are no flash operations in progress if (!nrf_fstorage_is_busy(NULL)) { // Start scanning for peripherals and initiate connection to devices which // advertise Heart Rate or Running speed and cadence UUIDs. 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); } } /**@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) { ret_code_t err_code; switch (p_evt->evt_id) { case PM_EVT_BONDED_PEER_CONNECTED: { NRF_LOG_INFO("Connected to a previously bonded device."); } break; case PM_EVT_CONN_SEC_SUCCEEDED: { NRF_LOG_INFO("Connection secured: role: %d, conn_handle: 0x%x, procedure: %d.", ble_conn_state_role(p_evt->conn_handle), p_evt->conn_handle, p_evt->params.conn_sec_succeeded.procedure); } break; case PM_EVT_CONN_SEC_FAILED: { /* Often, when securing fails, it shouldn't be restarted, for security reasons. * Other times, it can be restarted directly. * Sometimes it can be restarted, but only after changing some Security Parameters. * Sometimes, it cannot be restarted until the link is disconnected and reconnected. * Sometimes it is impossible, to secure the link, or the peer device does not support it. * How to handle this error is highly application dependent. */ } break; case PM_EVT_CONN_SEC_CONFIG_REQ: { // Reject pairing request from an already bonded peer. pm_conn_sec_config_t conn_sec_config = {.allow_repairing = false}; pm_conn_sec_config_reply(p_evt->conn_handle, &conn_sec_config); } break; case PM_EVT_STORAGE_FULL: { // Run garbage collection on the flash. err_code = fds_gc(); if (err_code == FDS_ERR_BUSY || err_code == FDS_ERR_NO_SPACE_IN_QUEUES) { // Retry. } else { APP_ERROR_CHECK(err_code); } } break; case PM_EVT_PEERS_DELETE_SUCCEEDED: { adv_scan_start(); } break; case PM_EVT_LOCAL_DB_CACHE_APPLY_FAILED: { // The local database has likely changed, send service changed indications. pm_local_database_has_changed(); } break; case PM_EVT_PEER_DATA_UPDATE_FAILED: { // Assert. APP_ERROR_CHECK(p_evt->params.peer_data_update_failed.error); } break; case PM_EVT_PEER_DELETE_FAILED: { // Assert. APP_ERROR_CHECK(p_evt->params.peer_delete_failed.error); } break; case PM_EVT_PEERS_DELETE_FAILED: { // Assert. APP_ERROR_CHECK(p_evt->params.peers_delete_failed_evt.error); } break; case PM_EVT_ERROR_UNEXPECTED: { // Assert. APP_ERROR_CHECK(p_evt->params.error_unexpected.error); } break; case PM_EVT_CONN_SEC_START: case PM_EVT_PEER_DATA_UPDATE_SUCCEEDED: case PM_EVT_PEER_DELETE_SUCCEEDED: case PM_EVT_LOCAL_DB_CACHE_APPLIED: case PM_EVT_SERVICE_CHANGED_IND_SENT: case PM_EVT_SERVICE_CHANGED_IND_CONFIRMED: default: break; } } /**@brief Function for handling characters received by the Nordic UART Service. * * @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_DEBUG("Receiving data."); NRF_LOG_HEXDUMP_DEBUG(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) { // Send data back to 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); } } /**@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. */ 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') || (index >= (m_ble_nus_max_data_len))) { NRF_LOG_DEBUG("Ready to send data over BLE NUS"); NRF_LOG_HEXDUMP_DEBUG(data_array, index); 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_BUSY) ) { APP_ERROR_CHECK(ret_val); } } while (ret_val == NRF_ERROR_BUSY); 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; } } /**@brief Callback handling 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. */ /**@snippet [Handling events from the ble_nus_c module] */ 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); 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; } } /**@snippet [Handling events from the ble_nus_c module] */ /**@brief Function for searching a given name in the advertisement packets. * * @details Use this function to parse received advertising data and to find a given * name in them either as 'complete_local_name' or as 'short_local_name'. * * @param[in] p_adv_report advertising data to parse. * @param[in] name_to_find name to search. * @return true if the given name was found, false otherwise. */ static bool find_adv_name(ble_gap_evt_adv_report_t const * p_adv_report, char const * name_to_find) { ret_code_t err_code; data_t adv_data; data_t dev_name; // Initialize advertisement report for parsing adv_data.p_data = (uint8_t *)p_adv_report->data; adv_data.data_len = p_adv_report->dlen; //search for advertising names err_code = adv_report_parse(BLE_GAP_AD_TYPE_COMPLETE_LOCAL_NAME, &adv_data, &dev_name); if (err_code == NRF_SUCCESS) { if (memcmp(name_to_find, dev_name.p_data, dev_name.data_len)== 0) { return true; } } else { // Look for the short local name if it was not found as complete err_code = adv_report_parse(BLE_GAP_AD_TYPE_SHORT_LOCAL_NAME, &adv_data, &dev_name); if (err_code != NRF_SUCCESS) { return false; } if (memcmp(m_target_periph_name, dev_name.p_data, dev_name.data_len)== 0) { return true; } } return false; } /**@brief Function for searching a UUID in the advertisement packets. * * @details Use this function to parse received advertising data and to find a given * UUID in them. * * @param[in] p_adv_report advertising data to parse. * @param[in] uuid_to_find UUIID to search. * @return true if the given UUID was found, false otherwise. */ static bool find_adv_uuid(ble_gap_evt_adv_report_t const * p_adv_report, uint16_t uuid_to_find) { ret_code_t err_code; data_t adv_data; data_t type_data; // Initialize advertisement report for parsing. adv_data.p_data = (uint8_t *)p_adv_report->data; adv_data.data_len = p_adv_report->dlen; err_code = adv_report_parse(BLE_GAP_AD_TYPE_16BIT_SERVICE_UUID_MORE_AVAILABLE, &adv_data, &type_data); if (err_code != NRF_SUCCESS) { // Look for the services in 'complete' if it was not found in 'more available'. err_code = adv_report_parse(BLE_GAP_AD_TYPE_16BIT_SERVICE_UUID_COMPLETE, &adv_data, &type_data); if (err_code != NRF_SUCCESS) { // If we can't parse the data, then exit. return false; } } // Verify if any UUID match the given UUID. for (uint32_t i = 0; i < (type_data.data_len / UUID16_SIZE); i++) { uint16_t extracted_uuid; UUID16_EXTRACT(&extracted_uuid, &type_data.p_data[i * UUID16_SIZE]); if (extracted_uuid == uuid_to_find) { return true; } } return false; } /**@brief Function for handling BLE events from central applications. * * @details This function parses scanning reports and initiates a connection to peripherals when a * target UUID is found. It updates the status of LEDs used to report central applications * activity. * * @param[in] p_ble_evt Bluetooth stack event. */ static void on_ble_central_evt(ble_evt_t const * p_ble_evt) { ret_code_t err_code; 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("Central connected"); // If no Heart Rate sensor or RSC sensor is currently connected, try to find them on this peripheral. if (m_conn_handle_nus_c == BLE_CONN_HANDLE_INVALID) { NRF_LOG_INFO("Attempt to find NUS on conn_handle 0x%x", p_gap_evt->conn_handle); if (m_db_discovery.discovery_in_progress) { NRF_LOG_INFO("DB discovery is already in progress. Will retry later.") m_retry_db_disc = true; m_conn_handle_to_disc = p_gap_evt->conn_handle; } else { memset(&m_db_discovery, 0x00, sizeof(m_db_discovery)); err_code = ble_db_discovery_start(&m_db_discovery, 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); if (ble_conn_state_n_centrals() == NRF_SDH_BLE_CENTRAL_LINK_COUNT) { bsp_board_led_off(CENTRAL_SCANNING_LED); } else { // Resume scanning. bsp_board_led_on(CENTRAL_SCANNING_LED); scan_start(); } } break; // BLE_GAP_EVT_CONNECTED // Upon disconnection, reset the connection handle of the peer which disconnected, // update the LEDs status and start scanning again. case BLE_GAP_EVT_DISCONNECTED: { if (p_gap_evt->conn_handle == m_conn_handle_nus_c) { NRF_LOG_INFO("NUS central disconnected (reason: %d)", p_gap_evt->params.disconnected.reason); m_conn_handle_nus_c = BLE_CONN_HANDLE_INVALID; } if (m_conn_handle_nus_c == BLE_CONN_HANDLE_INVALID) // { // Start scanning scan_start(); // Update LEDs status. bsp_board_led_on(CENTRAL_SCANNING_LED); } if (ble_conn_state_n_centrals() == 0) { bsp_board_led_off(CENTRAL_CONNECTED_LED); } } break; // BLE_GAP_EVT_DISCONNECTED case BLE_GAP_EVT_ADV_REPORT: { if (strlen(m_target_periph_name) != 0) { if (find_adv_name(&p_gap_evt->params.adv_report, m_target_periph_name)) { // Initiate connection. err_code = sd_ble_gap_connect(&p_gap_evt->params.adv_report.peer_addr, &m_scan_params, &m_connection_param, APP_BLE_CONN_CFG_TAG); if (err_code != NRF_SUCCESS) { NRF_LOG_INFO("Connection Request Failed, reason %d", err_code); } } } else { // We do not want to connect to two peripherals offering the same service, so when // a UUID is matched, we check that we are not already connected to a peer which // offers the same service. if (find_adv_uuid(&p_gap_evt->params.adv_report, BLE_UUID_NUS_SERVICE) && (m_conn_handle_nus_c == BLE_CONN_HANDLE_INVALID)) // || (find_adv_uuid(&p_gap_evt->params.adv_report, BLE_UUID_RUNNING_SPEED_AND_CADENCE) // && (m_conn_handle_rscs_c == BLE_CONN_HANDLE_INVALID))) { // Initiate connection. err_code = sd_ble_gap_connect(&p_gap_evt->params.adv_report.peer_addr, &m_scan_params, &m_connection_param, APP_BLE_CONN_CFG_TAG); if (err_code != NRF_SUCCESS) { NRF_LOG_WARNING("Connection Request Failed, reason %d", err_code); } } } } break; // BLE_GAP_ADV_REPORT 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_INFO("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; #if defined(S132) 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; #endif 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 handling BLE events from peripheral applications. * @details Updates the status LEDs used to report the activity 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"); 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"); bsp_board_led_off(PERIPHERAL_CONNECTED_LED); break; #if defined(S132) 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; #endif 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; case BLE_EVT_USER_MEM_REQUEST: err_code = sd_ble_user_mem_reply(p_ble_evt->evt.gap_evt.conn_handle, NULL); APP_ERROR_CHECK(err_code); break; case BLE_GATTS_EVT_RW_AUTHORIZE_REQUEST: { ble_gatts_evt_rw_authorize_request_t req; ble_gatts_rw_authorize_reply_params_t auth_reply; req = p_ble_evt->evt.gatts_evt.params.authorize_request; if (req.type != BLE_GATTS_AUTHORIZE_TYPE_INVALID) { if ((req.request.write.op == BLE_GATTS_OP_PREP_WRITE_REQ) || (req.request.write.op == BLE_GATTS_OP_EXEC_WRITE_REQ_NOW) || (req.request.write.op == BLE_GATTS_OP_EXEC_WRITE_REQ_CANCEL)) { if (req.type == BLE_GATTS_AUTHORIZE_TYPE_WRITE) { auth_reply.type = BLE_GATTS_AUTHORIZE_TYPE_WRITE; } else { auth_reply.type = BLE_GATTS_AUTHORIZE_TYPE_READ; } auth_reply.params.write.gatt_status = APP_FEATURE_NOT_SUPPORTED; err_code = sd_ble_gatts_rw_authorize_reply(p_ble_evt->evt.gatts_evt.conn_handle, &auth_reply); APP_ERROR_CHECK(err_code); } } } break; // BLE_GATTS_EVT_RW_AUTHORIZE_REQUEST 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: { NRF_LOG_INFO("Fast advertising."); bsp_board_led_on(PERIPHERAL_ADVERTISING_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 checking if a bluetooth stack event is an advertising timeout. * * @param[in] p_ble_evt Bluetooth stack event. */ static bool ble_evt_is_advertising_timeout(ble_evt_t const * p_ble_evt) { return ( (p_ble_evt->header.evt_id == BLE_GAP_EVT_TIMEOUT) && (p_ble_evt->evt.gap_evt.params.timeout.src == BLE_GAP_TIMEOUT_SRC_ADVERTISING)); } static void db_discovery_retry(void) { m_retry_db_disc = false; NRF_LOG_INFO("Retrying DB discovery on handle 0x%x.", m_conn_handle_to_disc); memset(&m_db_discovery, 0x00, sizeof(m_db_discovery)); ret_code_t err_code = ble_db_discovery_start(&m_db_discovery, m_conn_handle_to_disc); APP_ERROR_CHECK(err_code); } /**@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); // Based on the role this device plays in the connection, dispatch to the right handler. if (role == BLE_GAP_ROLE_PERIPH || ble_evt_is_advertising_timeout(p_ble_evt)) { 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); } if (m_do_retry_db_disc) { m_do_retry_db_disc = false; db_discovery_retry(); } } /**@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 the 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; err_code = ble_nus_c_init(&m_ble_nus_c, &init); 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 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 the Peer Manager initialization. */ static void peer_manager_init(void) { ble_gap_sec_params_t sec_param; ret_code_t err_code; err_code = pm_init(); APP_ERROR_CHECK(err_code); memset(&sec_param, 0, sizeof(ble_gap_sec_params_t)); // Security parameters to be used for all security procedures. sec_param.bond = SEC_PARAM_BOND; sec_param.mitm = SEC_PARAM_MITM; sec_param.lesc = SEC_PARAM_LESC; sec_param.keypress = SEC_PARAM_KEYPRESS; sec_param.io_caps = SEC_PARAM_IO_CAPABILITIES; sec_param.oob = SEC_PARAM_OOB; sec_param.min_key_size = SEC_PARAM_MIN_KEY_SIZE; sec_param.max_key_size = SEC_PARAM_MAX_KEY_SIZE; sec_param.kdist_own.enc = 1; sec_param.kdist_own.id = 1; sec_param.kdist_peer.enc = 1; sec_param.kdist_peer.id = 1; err_code = pm_sec_params_set(&sec_param); APP_ERROR_CHECK(err_code); err_code = pm_register(pm_evt_handler); APP_ERROR_CHECK(err_code); } /**@brief Clear bond information from persistent storage. */ 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 initializing buttons and leds. * * @param[out] p_erase_bonds Will be true if the clear bonding button was pressed to * wake the application up. */ 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_LED | BSP_INIT_BUTTONS, NULL); 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 the GAP initialization. * * @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.min_conn_interval = MIN_CONNECTION_INTERVAL; gap_conn_params.max_conn_interval = MAX_CONNECTION_INTERVAL; gap_conn_params.slave_latency = SLAVE_LATENCY; gap_conn_params.conn_sup_timeout = SUPERVISION_TIMEOUT; err_code = sd_ble_gap_ppcp_set(&gap_conn_params); APP_ERROR_CHECK(err_code); } /**@brief Function for initializing the GATT module. */ static void gatt_init(void) { ret_code_t err_code = nrf_ble_gatt_init(&m_gatt, NULL); 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_CONN_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); } /**@brief Function for handling database discovery events. * * @details This function is callback function to handle events from the database discovery module. * Depending on the UUIDs that are discovered, this function should forward 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); if ( (p_evt->evt_type == BLE_DB_DISCOVERY_COMPLETE) && (m_retry_db_disc) && (m_conn_handle_to_disc != BLE_CONN_HANDLE_INVALID)) { // DB discovery cannot be restarted directly here because the // database discovery structure would need to be zeroed, however it is still // needed by the module (it might have pending events to send). // Let's set a flag and re-run DB discovery when we receive the next BLE event. NRF_LOG_INFO("DB discovery can be retried."); m_do_retry_db_disc = true; } } /** * @brief Database discovery initialization. */ 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 services that will be used by the application. * * @details Initialize the Heart Rate, Battery and Device Information services. */ static void services_init(void) { ret_code_t err_code; ble_nus_c_init_t init; init.evt_handler = ble_nus_c_evt_handler; err_code = ble_nus_c_init(&m_ble_nus_c, &init); APP_ERROR_CHECK(err_code); } /**@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 = APP_ADV_INTERVAL; init.config.ble_adv_fast_timeout = APP_ADV_TIMEOUT_IN_SECONDS; 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 to sleep until a BLE event is received by the application. */ static void power_manage(void) { ret_code_t err_code = sd_app_evt_wait(); APP_ERROR_CHECK(err_code); } int main(void) { bool erase_bonds; log_init(); timer_init(); buttons_leds_init(&erase_bonds); ble_stack_init(); gap_params_init(); gatt_init(); uart_init(); conn_params_init(); db_discovery_init(); peer_manager_init(); nus_c_init(); services_init(); advertising_init(); if (erase_bonds == true) { // Scanning and advertising is done upon PM_EVT_PEERS_DELETE_SUCCEEDED event. delete_bonds(); // Scanning and advertising is done by } else { adv_scan_start(); } NRF_LOG_INFO("Relay example started."); for (;;) { if (NRF_LOG_PROCESS() == false) { // Wait for BLE events. power_manage(); } } }