Hi Everyone,
I am working on NRF52833. I have developed code for our project. Now in this project the phone app will connect with the device using BLE for which I have implemented Pairing mechanism. When I load the firmware into the device and try to connect it via NRF connect app, the device asks for pairing. In code I have defined static Key. So when I put that static key in the pairing of phone, my NRFconnect app is able to connect to the device successfully.
Now I am having 2 devices( Device A & Device B). The same firmware is loaded into these 2 NRF52833 devices. Both the devices turned ON. What I am observing is device A and device B gets connected to each other and the devices goes into some restart mechanism. I don't want any connectivity between device A and device B. This is creating issue for me. Even though I have implemented pairing mechanism but these devices seem to connect each other without any pairing activity. How can I avoid this?? I have attached my main.c file below:-
/**
*
* 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.
*
*
*/
#include <stdint.h>
#include <string.h>
#include "nordic_common.h"
#include "nrf.h"
#include "app_error.h"
#include "ble.h"
#include "ble_hci.h"
#include "ble_srv_common.h"
#include "ble_advdata.h"
#include "ble_advertising.h"
#include "ble_bas.h"
#include "ble_dis.h"
#include "ble_conn_params.h"
#include "sensorsim.h"
#include "nrf_sdh.h"
#include "nrf_sdh_soc.h"
#include "nrf_sdh_ble.h"
#include "nrf_sdh_freertos.h"
#include "app_timer.h"
#include "peer_manager.h"
#include "peer_manager_handler.h"
#include "bsp_btn_ble.h"
#include "FreeRTOS.h"
#include "task.h"
#include "timers.h"
#include "semphr.h"
#include "fds.h"
#include "ble_conn_state.h"
#include "ble_dfu.h"
#include "nrf_pwr_mgmt.h"
#include "nrf_drv_clock.h"
#include "nrf_ble_gatt.h"
#include "nrf_ble_qwr.h"
#include "nrf_power.h"
#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.h"
#include "product_config.h"
#include "ble_lender.h"
#include "ble_borrower.h"
#include "task_led_button.h"
#include "task_lender.h"
#include "task_borrower.h"
#include "task_system.h"
#include "task_psf_comm.h"
#include "device_storage.h"
#include "nrf_drv_gpiote.h"
#include "battery.h"
#include "version.h"
#include "lender.h"
#include "borrower.h"
#include "psf_comm.h"
#include "nrf_drv_twi.h"
#include "psf_i2c.h"
#include "task_led_button.h"
#include "bq24292i.h"
#include "max17211_i2c.h"
#define DEVICE_NAME LE_DEVICE_NAME /**< Name of device. Will be included in the advertising data. */
#define MANUFACTURER_NAME "Target" /**< Manufacturer. Will be passed to Device Information Service. */
#define APP_BLE_OBSERVER_PRIO 3 /**< Application's BLE observer priority. You shouldn't need to modify this value. */
#define APP_BLE_CONN_CFG_TAG 1 /**< A tag identifying the SoftDevice BLE configuration. */
#define APP_ADV_INTERVAL 5000 //300 /**< The advertising interval (in units of 0.625 ms. This value corresponds to 187.5 ms). */
#define APP_ADV_DURATION 18000//18000 /**< The advertising duration (180 seconds) in units of 10 milliseconds. */
#define RTC_INTERVAL 1000 /**< RTC interval (ms). */
#define MIN_BATTERY_LEVEL 81 /**< Minimum simulated battery level. */
#define MAX_BATTERY_LEVEL 100 /**< Maximum simulated battery level. */
#define MIN_CONN_INTERVAL MSEC_TO_UNITS(200, UNIT_1_25_MS) /**< Minimum acceptable connection interval (0.4 seconds). */
#define MAX_CONN_INTERVAL MSEC_TO_UNITS(300, UNIT_1_25_MS) /**< Maximum acceptable connection interval (0.65 second). */
#define SLAVE_LATENCY 0 /**< Slave latency. */
#define CONN_SUP_TIMEOUT MSEC_TO_UNITS(5000, UNIT_10_MS) /**< Connection supervisory time-out (4 seconds). */
#define FIRST_CONN_PARAMS_UPDATE_DELAY 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 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 SEC_PARAM_BOND 1 /**< Perform bonding. */
#define SEC_PARAM_MITM 1 /**< 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_DISPLAY_ONLY /**< 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. */
#define SEC_PARAM_MAX_KEY_SIZE 16 /**< Maximum encryption key size. */
#define DEAD_BEEF 0xDEADBEEF /**< Value used as error code on stack dump, can be used to identify stack location on stack unwind. */
#define OSTIMER_WAIT_FOR_QUEUE 2 /**< Number of ticks to wait for the timer queue to be ready */
#define DEVICEID_SIZE 16
uint8_t device_id[DEVICEID_SIZE+1] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
extern uint8_t adv_led_button;
extern uint8_t led_on_duration;
extern uint8_t led_grn_pwr_active;
extern uint8_t led_grn_pwr_state;
int8_t rssi;
static char app_fw_version[32];
uint8_t rclr_data_buf[256] = {0};
uint8_t rcbr_data_buf[256] = {0};
uint16_t rclr_data_cnt = 0;
uint16_t rcbr_data_cnt = 0;
BLE_RCLR_DEF(m_rclr, NRF_SDH_BLE_TOTAL_LINK_COUNT); /**< BLE R3charge lender service instance. */
BLE_RCBR_DEF(m_rcbr, NRF_SDH_BLE_TOTAL_LINK_COUNT); /**< BLE R3charge borrower service instance. */
BLE_BAS_DEF(m_bas); /**< Battery service instance. */
NRF_BLE_GATT_DEF(m_gatt); /**< GATT module instance. */
NRF_BLE_QWR_DEF(m_qwr); /**< Context for the Queued Write module.*/
BLE_ADVERTISING_DEF(m_advertising); /**< Advertising module instance. */
////////////Added for bonding///////////
// Static passkey
#define STATIC_PASSKEY "123456"
static ble_opt_t m_static_pin_option;
uint8_t passkey[] = STATIC_PASSKEY;
////////////Added for bonding///////////
static uint16_t m_conn_handle = BLE_CONN_HANDLE_INVALID; /**< Handle of the current connection. */
static ble_uuid_t m_adv_uuids[] = /**< Universally unique service identifiers. */
{
// {BLE_UUID_RCLR_SERVICE, BLE_UUID_TYPE_VENDOR_BEGIN},
{BLE_UUID_RCBR_SERVICE, BLE_UUID_TYPE_VENDOR_BEGIN}
};
static void advertising_config_get(ble_adv_modes_config_t * p_config)
{
memset(p_config, 0, sizeof(ble_adv_modes_config_t));
p_config->ble_adv_fast_enabled = true;
p_config->ble_adv_fast_interval = APP_ADV_INTERVAL;
p_config->ble_adv_fast_timeout = APP_ADV_DURATION;
}
static void disconnect(uint16_t conn_handle, void * p_context)
{
UNUSED_PARAMETER(p_context);
ret_code_t err_code = sd_ble_gap_disconnect(conn_handle, BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_WARNING("Failed to disconnect connection. Connection handle: %d Error: %d", conn_handle, err_code);
}
else
{
NRF_LOG_DEBUG("Disconnected connection handle %d", conn_handle);
}
}
static TimerHandle_t m_rtc_timer; /**< Definition of battery timer. */
#if NRF_LOG_ENABLED
static TaskHandle_t m_logger_thread; /**< Definition of Logger thread. */
#endif
static void advertising_start(void * p_erase_bonds);
static void nrf_nvmc_write_word(uint32_t address, uint32_t value);
ble_rclr_t * get_rclr_service(void)
{
return &m_rclr;
}
ble_rcbr_t * get_rcbr_service(void)
{
return &m_rcbr;
}
uint16_t get_conn_handle(void)
{
return m_conn_handle;
}
uint8_t * get_rclr_rcv_buffer(void)
{
return rclr_data_buf;
}
uint16_t get_rclr_rcv_cnt(void)
{
return rclr_data_cnt;
}
uint8_t * get_rcbr_rcv_buffer(void)
{
return rcbr_data_buf;
}
uint16_t get_rcbr_rcv_cnt(void)
{
return rcbr_data_cnt;
}
/**@brief Callback function for 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] 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(DEAD_BEEF, line_num, p_file_name);
}
/**@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)
{
bool delete_bonds = false;
pm_handler_on_pm_evt(p_evt);
pm_handler_flash_clean(p_evt);
switch (p_evt->evt_id) {
case PM_EVT_PEERS_DELETE_SUCCEEDED:
//..advertising_start(&delete_bonds);
advertising_start(false);
break;
default:
break;
}
}
/**@brief Function for performing battery measurement and updating the Battery Level characteristic
* in Battery Service.
*/
void battery_level_update(void)
{
ret_code_t err_code;
uint8_t battery_level;
battery_level = battery_get_percentage(); /* Update TODO */
err_code = ble_bas_battery_level_update(&m_bas, battery_level, BLE_CONN_HANDLE_ALL);
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);
}
}
uint32_t rtc_val = 0;
uint32_t get_system_rtc(void)
{
return rtc_val;
}
/**@brief Function for handling the RTC event
*
* @details This function will be called each time the RTC timer expires.
*
* @param[in] xTimer Handler to the timer that called this function.
* You may get identifier given to the function xTimerCreate using pvTimerGetTimerID.
*/
static void rtc_timeout_handler(TimerHandle_t xTimer)
{
UNUSED_PARAMETER(xTimer);
rtc_val++;
}
static StaticTimer_t xRTCTimer;
/**@brief Function for the Timer initialization.
*
* @details Initializes the timer module. This creates and starts application timers.
*/
static void timers_init(void)
{
// Initialize timer module.
ret_code_t err_code = app_timer_init();
APP_ERROR_CHECK(err_code);
// Create timers.
m_rtc_timer = xTimerCreateStatic("RTC",
RTC_INTERVAL,
pdTRUE,
NULL,
rtc_timeout_handler,
&xRTCTimer);
/* Error checking */
if (NULL == m_rtc_timer) {
APP_ERROR_HANDLER(NRF_ERROR_NO_MEM);
}
}
/**@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);
//commented for adding device id.
//err_code = sd_ble_gap_device_name_set(&sec_mode,
// (const uint8_t *)DEVICE_NAME,
// strlen(DEVICE_NAME));
#ifdef USE_DEVICEID_ON_SRDATA
err_code = sd_ble_gap_device_name_set(&sec_mode,
(const uint8_t *)DEVICE_NAME,
strlen(DEVICE_NAME));
#else
uint8_t basename_size = strlen(DEVICE_NAME);
uint8_t devicename[DEVICEID_SIZE+1+basename_size+1];
memcpy(&devicename[0], (const uint8_t *)DEVICE_NAME, basename_size);
devicename[basename_size] = '-';
memcpy(&devicename[basename_size+1], device_id, DEVICEID_SIZE);
memset(&devicename[basename_size+1+DEVICEID_SIZE], 0x00, 1);
err_code = sd_ble_gap_device_name_set(&sec_mode,
(const uint8_t *)devicename,
strlen(devicename));
#endif
APP_ERROR_CHECK(err_code);
err_code = sd_ble_gap_appearance_set(BLE_APPEARANCE_HEART_RATE_SENSOR_HEART_RATE_BELT);
APP_ERROR_CHECK(err_code);
memset(&gap_conn_params, 0, sizeof(gap_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);
////////Added for bonding ///////////
m_static_pin_option.gap_opt.passkey.p_passkey = &passkey[0];
err_code = sd_ble_opt_set(BLE_GAP_OPT_PASSKEY, &m_static_pin_option);
APP_ERROR_CHECK(err_code);
////////Added for bonding ///////////
}
/**@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);
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 will be passed to each service which 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);
}
static void rclr_data_handler(ble_rclr_evt_t * p_evt)
{
if (p_evt->type == BLE_RCLR_EVT_RX_DATA) {
uint32_t err_code;
if(p_evt->params.rx_data.length < sizeof(rclr_data_buf)) {
memset(rclr_data_buf, 0, sizeof(rclr_data_buf));
memcpy(rclr_data_buf, p_evt->params.rx_data.p_data, p_evt->params.rx_data.length);
rclr_data_cnt = p_evt->params.rx_data.length;
/* Inform lender Task we have a command */
lender_task_queue_event(LENDER_TASK_EVT_SETTING_CMD);
}
} else if(p_evt->type == BLE_RCLR_EVT_NOTIF_ENABLED) {
/* Inform lender Task notifications have begun */
lender_task_queue_event(LENDER_TASK_EVT_NOTIF_EN);
}
}
static void rcbr_data_handler_new(ble_rcbr_evt_t * p_evt)
{
psf_comm_task_evt_t evt;
if (p_evt->type == BLE_RCBR_EVT_RX_DATA) {
uint32_t err_code;
if(p_evt->params.rx_data.length < MAX_FRAME_PAYLOAD_SIZE) {
evt.evt_id = PSF_COMM_TASK_EVT_PSF_DATA;
evt.length = p_evt->params.rx_data.length;
memcpy(evt.payload, p_evt->params.rx_data.p_data, p_evt->params.rx_data.length);
psf_comm_task_queue_event(&evt);
}
} else if(p_evt->type == BLE_RCBR_EVT_NOTIF_ENABLED) {
/* Inform Toilet Task notifications have begun */
// toilet_task_queue_event(TOILET_TASK_EVT_NOTIF_EN);
}
}
static void rcbr_data_handler(ble_rcbr_evt_t * p_evt)
{
if (p_evt->type == BLE_RCBR_EVT_RX_DATA) {
uint32_t err_code;
if(p_evt->params.rx_data.length < sizeof(rcbr_data_buf)) {
memset(rcbr_data_buf, 0, sizeof(rcbr_data_buf));
memcpy(rcbr_data_buf, p_evt->params.rx_data.p_data, p_evt->params.rx_data.length);
rcbr_data_cnt = p_evt->params.rx_data.length;
/* Inform borrower Task we have a command */
borrower_task_queue_event(BORROWER_TASK_EVT_SETTING_CMD);
}
} else if(p_evt->type == BLE_RCLR_EVT_NOTIF_ENABLED) {
/* Inform borrower Task notifications have begun */
borrower_task_queue_event(BORROWER_TASK_EVT_NOTIF_EN);
}
}
/**@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_rclr_init_t rclr_init;
ble_rcbr_init_t rcbr_init;
ble_bas_init_t bas_init;
ble_dis_init_t dis_init;
nrf_ble_qwr_init_t qwr_init = {0};
uint8_t body_sensor_location;
// Initialize Queued Write Module.
qwr_init.error_handler = nrf_qwr_error_handler;
err_code = nrf_ble_qwr_init(&m_qwr, &qwr_init);
APP_ERROR_CHECK(err_code);
// Initialize Battery Service.
memset(&bas_init, 0, sizeof(bas_init));
// Here the sec level for the Battery Service can be changed/increased.
bas_init.bl_rd_sec = SEC_OPEN;
bas_init.bl_cccd_wr_sec = SEC_OPEN;
bas_init.bl_report_rd_sec = SEC_OPEN;
bas_init.evt_handler = NULL;
bas_init.support_notification = true;
bas_init.p_report_ref = NULL;
bas_init.initial_batt_level = 100;
err_code = ble_bas_init(&m_bas, &bas_init);
APP_ERROR_CHECK(err_code);
// Initialize Device Information Service.
memset(&dis_init, 0, sizeof(dis_init));
ble_srv_ascii_to_utf8(&dis_init.manufact_name_str, (char *)MANUFACTURER_NAME);
ble_srv_ascii_to_utf8(&dis_init.model_num_str, (char *)DEVICE_MODEL_NUM);
ble_srv_ascii_to_utf8(&dis_init.serial_num_str, (char *)device_id);
ble_srv_ascii_to_utf8(&dis_init.hw_rev_str, (char *)DEVICE_HW_VER);
ble_srv_ascii_to_utf8(&dis_init.fw_rev_str, (char *)app_fw_version);
dis_init.dis_char_rd_sec = SEC_OPEN;
err_code = ble_dis_init(&dis_init);
APP_ERROR_CHECK(err_code);
// Initialize RCLR- LENDER Service
memset(&rclr_init, 0, sizeof(rclr_init));
rclr_init.data_handler = rclr_data_handler;
err_code = ble_rclr_init(&m_rclr, &rclr_init);
APP_ERROR_CHECK(err_code);
// Initialize RCBR - BORROWER Service
memset(&rcbr_init, 0, sizeof(rcbr_init));
rcbr_init.data_handler = rcbr_data_handler;
err_code = ble_rcbr_init(&m_rcbr, &rcbr_init);
APP_ERROR_CHECK(err_code);
}
/**@brief Function for starting application timers.
* @details Timers are run after the scheduler has started.
*/
static void application_timers_start(void)
{
// Start application timers.
if (pdPASS != xTimerStart(m_rtc_timer, OSTIMER_WAIT_FOR_QUEUE)) {
APP_ERROR_HANDLER(NRF_ERROR_NO_MEM);
}
}
/**@brief Function for handling 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)
{
ret_code_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 a Connection Parameters error.
*
* @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 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;
cp_init.disconnect_on_fail = false;
cp_init.evt_handler = on_conn_params_evt;
cp_init.error_handler = conn_params_error_handler;
err_code = ble_conn_params_init(&cp_init);
APP_ERROR_CHECK(err_code);
}
/**@brief Function for putting the chip into sleep mode.
*
* @note This function will not return.
*/
static void sleep_mode_enter(void)
{
ret_code_t err_code;
//err_code = bsp_indication_set(BSP_INDICATE_IDLE);
//APP_ERROR_CHECK(err_code);
//// Prepare wakeup buttons.
//err_code = bsp_btn_ble_sleep_mode_prepare();
//APP_ERROR_CHECK(err_code);
//// Go to system-off mode (this function will not return; wakeup will cause a reset).
//err_code = sd_power_system_off();
//APP_ERROR_CHECK(err_code);
}
/**@brief Function for handling advertising events.
*
* @details This function will be called for advertising events which are passed to the application.
*
* @param[in] ble_adv_evt Advertising event.
*/
static void on_adv_evt(ble_adv_evt_t ble_adv_evt)
{
uint32_t err_code;
switch (ble_adv_evt) {
case BLE_ADV_EVT_FAST:
NRF_LOG_INFO("Fast advertising.");
err_code = bsp_indication_set(BSP_INDICATE_ADVERTISING);
APP_ERROR_CHECK(err_code);
break;
case BLE_ADV_EVT_IDLE:
// sleep_mode_enter();
break;
default:
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)
{
char passkey[BLE_GAP_PASSKEY_LEN + 1];
uint16_t role = ble_conn_state_role(m_conn_handle);
pm_handler_secure_on_connection(p_ble_evt);
uint32_t err_code;
ble_gap_evt_t const * p_gap_evt = &p_ble_evt->evt.gap_evt; //$$ new
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);
adv_led_button =1;
led_grn_pwr_active = 1;
led_on_duration = get_system_rtc();
let_btn_task_evt_t evt;
evt.id = LED_TASK_EVT_PROCESS_LED_RC1;
//led_btn_task_queue_event(evt);
err_code = sd_ble_gap_rssi_start(p_ble_evt->evt.gap_evt.conn_handle,1,2); //$$ new
APP_ERROR_CHECK(err_code); //$$ new
break;
case BLE_GAP_EVT_DISCONNECTED:
NRF_LOG_INFO("Disconnected");
m_conn_handle = BLE_CONN_HANDLE_INVALID;
break;
#if 1
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(m_conn_handle, role);
// }
// break;
case BLE_GAP_EVT_PASSKEY_DISPLAY:
{
//char passkey[16 + 1];
memcpy(passkey, p_ble_evt->evt.gap_evt.params.passkey_display.passkey, 16);
passkey[16] = 0;
// Don't send delayed Security Request if security procedure is already in progress.
//err_code = app_timer_stop(m_sec_req_timer_id);
//APP_ERROR_CHECK(err_code);
NRF_LOG_INFO("Passkey: %s", nrf_log_push(passkey));
} 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;
#endif
case BLE_GAP_EVT_PHY_UPDATE_REQUEST: {
NRF_LOG_DEBUG("PHY update request.");
ble_gap_phys_t const phys = {
.rx_phys = BLE_GAP_PHY_AUTO,
.tx_phys = BLE_GAP_PHY_AUTO,
};
err_code = sd_ble_gap_phy_update(p_ble_evt->evt.gap_evt.conn_handle, &phys);
APP_ERROR_CHECK(err_code);
}
break;
case BLE_GATTC_EVT_TIMEOUT:
// Disconnect on GATT Client timeout event.
NRF_LOG_DEBUG("GATT Client Timeout.");
err_code = sd_ble_gap_disconnect(p_ble_evt->evt.gattc_evt.conn_handle,
BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
APP_ERROR_CHECK(err_code);
break;
case BLE_GATTS_EVT_TIMEOUT:
// Disconnect on GATT Server timeout event.
NRF_LOG_DEBUG("GATT Server Timeout.");
err_code = sd_ble_gap_disconnect(p_ble_evt->evt.gatts_evt.conn_handle,
BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
APP_ERROR_CHECK(err_code);
break;
case BLE_GAP_EVT_RSSI_CHANGED:
rssi = p_ble_evt->evt.gap_evt.params.rssi_changed.rssi;
// NRF_LOG_INFO("RSSI: %d", p_ble_evt->evt.gap_evt.params.rssi_changed.rssi);
break;
default:
// No implementation needed.
break;
}
}
/**@brief Function for initializing the BLE stack.
*
* @details Initializes the SoftDevice and the BLE event interrupt.
*/
static void ble_stack_init(void)
{
ret_code_t err_code;
err_code = nrf_sdh_enable_request();
APP_ERROR_CHECK(err_code);
// Configure the BLE stack using the default settings.
// Fetch the start address of the application RAM.
uint32_t ram_start = 0;
err_code = nrf_sdh_ble_default_cfg_set(APP_BLE_CONN_CFG_TAG, &ram_start);
APP_ERROR_CHECK(err_code);
// Enable BLE stack.
err_code = nrf_sdh_ble_enable(&ram_start);
APP_ERROR_CHECK(err_code);
// Register a handler for BLE events.
NRF_SDH_BLE_OBSERVER(m_ble_observer, APP_BLE_OBSERVER_PRIO, ble_evt_handler, NULL);
}
/**@brief Function for handling 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_SLEEP:
sleep_mode_enter();
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 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 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);
err_code = pm_register(pm_evt_handler);
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 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;//..
init.advdata.flags = BLE_GAP_ADV_FLAGS_LE_ONLY_LIMITED_DISC_MODE;
init.advdata.uuids_more_available.uuid_cnt = sizeof(m_adv_uuids) / sizeof(m_adv_uuids[0]);
init.advdata.uuids_more_available.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.srdata.name_type = BLE_ADVDATA_FULL_NAME;
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 the nrf log module.
*/
static void log_init(void)
{
ret_code_t err_code = NRF_LOG_INIT(NULL);
// ret_code_t err_code = NRF_LOG_INIT(app_timer_cnt_get); //..snehal
APP_ERROR_CHECK(err_code);
NRF_LOG_DEFAULT_BACKENDS_INIT();
}
/**@brief Function for starting advertising. */
static void advertising_start(void * p_erase_bonds)
{
bool erase_bonds = *(bool*)p_erase_bonds;
if (erase_bonds) {
delete_bonds();
// Advertising is started by PM_EVT_PEERS_DELETE_SUCCEEDED event.
} else {
ret_code_t err_code = ble_advertising_start(&m_advertising, BLE_ADV_MODE_FAST);
APP_ERROR_CHECK(err_code);
}
}
/* configSUPPORT_STATIC_ALLOCATION is set to 1, so the application must provide an
implementation of vApplicationGetIdleTaskMemory() to provide the memory that is
used by the Idle task. */
void vApplicationGetIdleTaskMemory( StaticTask_t **ppxIdleTaskTCBBuffer,
StackType_t **ppxIdleTaskStackBuffer,
uint32_t *pulIdleTaskStackSize )
{
/* If the buffers to be provided to the Idle task are declared inside this
function then they must be declared static - otherwise they will be allocated on
the stack and so not exists after this function exits. */
static StaticTask_t xIdleTaskTCB;
static StackType_t uxIdleTaskStack[ configMINIMAL_STACK_SIZE ];
/* Pass out a pointer to the StaticTask_t structure in which the Idle task's
state will be stored. */
*ppxIdleTaskTCBBuffer = &xIdleTaskTCB;
/* Pass out the array that will be used as the Idle task's stack. */
*ppxIdleTaskStackBuffer = uxIdleTaskStack;
/* Pass out the size of the array pointed to by *ppxIdleTaskStackBuffer.
Note that, as the array is necessarily of type StackType_t,
configMINIMAL_STACK_SIZE is specified in words, not bytes. */
*pulIdleTaskStackSize = configMINIMAL_STACK_SIZE;
}
/* configSUPPORT_STATIC_ALLOCATION and configUSE_TIMERS are both set to 1, so the
application must provide an implementation of vApplicationGetTimerTaskMemory()
to provide the memory that is used by the Timer service task. */
void vApplicationGetTimerTaskMemory( StaticTask_t **ppxTimerTaskTCBBuffer,
StackType_t **ppxTimerTaskStackBuffer,
uint32_t *pulTimerTaskStackSize )
{
/* If the buffers to be provided to the Timer task are declared inside this
function then they must be declared static - otherwise they will be allocated on
the stack and so not exists after this function exits. */
static StaticTask_t xTimerTaskTCB;
static StackType_t uxTimerTaskStack[ configTIMER_TASK_STACK_DEPTH ];
/* Pass out a pointer to the StaticTask_t structure in which the Timer
task's state will be stored. */
*ppxTimerTaskTCBBuffer = &xTimerTaskTCB;
/* Pass out the array that will be used as the Timer task's stack. */
*ppxTimerTaskStackBuffer = uxTimerTaskStack;
/* Pass out the size of the array pointed to by *ppxTimerTaskStackBuffer.
Note that, as the array is necessarily of type StackType_t,
configTIMER_TASK_STACK_DEPTH is specified in words, not bytes. */
*pulTimerTaskStackSize = configTIMER_TASK_STACK_DEPTH;
}
void vApplicationMallocFailedHook( void )
{
NRF_LOG_INFO("Malloc Failed");
}
void vApplicationStackOverflowHook(xTaskHandle *pxTask, signed char *pcTaskName )
{
for( ;; );
}
#if NRF_LOG_ENABLED
/**@brief Thread for handling the logger.
*
* @details This thread is responsible for processing log entries if logs are deferred.
* Thread flushes all log entries and suspends. It is resumed by idle task hook.
*
* @param[in] arg Pointer used for passing some arbitrary information (context) from the
* osThreadCreate() call to the thread.
*/
static void logger_thread(void * arg)
{
UNUSED_PARAMETER(arg);
while (1) {
NRF_LOG_FLUSH();
vTaskSuspend(NULL); // Suspend myself
}
}
#endif //NRF_LOG_ENABLED
/**@brief A function which is hooked to idle task.
* @note Idle hook must be enabled in FreeRTOS configuration (configUSE_IDLE_HOOK).
*/
void vApplicationIdleHook( void )
{
#if NRF_LOG_ENABLED
vTaskResume(m_logger_thread);
#endif
}
/**@brief Function for initializing the clock.
*/
static void clock_init(void)
{
ret_code_t err_code = nrf_drv_clock_init();
APP_ERROR_CHECK(err_code);
}
#define LOGGER_TASK_STACK_SIZE 512
#define LOGGER_TASK_PRIORITY 1
/* Structure that will hold the TCB of the task being created. */
StaticTask_t xLoggerTaskBuffer;
/* Buffer that the task being created will use as its stack. Note this is
an array of StackType_t variables. The size of StackType_t is dependent on
the RTOS port. */
StackType_t xLoggerStack[ LOGGER_TASK_STACK_SIZE ];
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 application main entry.
*/
int main(void)
{
bool erase_bonds;
ret_code_t err_code;
uint32_t APPPROTECT_reg;
bool status;
// Initialize modules.
log_init();
clock_init();
// Do not start any interrupt that uses system functions before system initialisation.
// The best solution is to start the OS before any other initalisation.
#if NRF_LOG_ENABLED
// Start execution.
m_logger_thread = xTaskCreateStatic(logger_thread, "LOGGER", sizeof(xLoggerStack) / sizeof(xLoggerStack[0]), NULL, LOGGER_TASK_PRIORITY, xLoggerStack, &xLoggerTaskBuffer);
if (m_logger_thread == NULL) {
APP_ERROR_HANDLER(NRF_ERROR_NO_MEM);
}
#endif
NRF_LOG_INFO("TESTING NEW FIRMWARE");
if(NRF_BLE_APPROTECT_ENABLE)
{
APPPROTECT_reg = NRF_UICR->APPROTECT;
NRF_LOG_INFO("APPROTECT REG VAL IS %x",APPPROTECT_reg);
if (NRF_UICR->APPROTECT == 0xFFFFFFFF)
{
NRF_LOG_INFO("PROTECTING FIRMWARE...SETTING APPROTECT");
nrf_nvmc_write_word((uint32_t)&(NRF_UICR->APPROTECT), 0xFFFFFF00);
//NVIC_SystemReset();
}
}
init_device_storage();
// buttons_leds_init(&erase_bonds);
// Activate deep sleep mode.
// SCB->SCR |= SCB_SCR_SLEEPDEEP_Msk;
memset(app_fw_version, 0, sizeof(app_fw_version));
app_version_str(app_fw_version, sizeof(app_fw_version));
mem_init();
// lender_readSetting();
// Configure and initialize the BLE stack.
ble_stack_init();
device_storage_init();
// borrower_readSetting();
borrower_load_settings();
// Initialize modules.
timers_init();
gap_params_init();
gatt_init();
services_init();
advertising_init();
conn_params_init();
peer_manager_init();
application_timers_start();
// Create a FreeRTOS task for the BLE stack.
// The task will run advertising_start() before entering its loop.
nrf_sdh_freertos_init(advertising_start, &erase_bonds);
err_code = nrf_drv_gpiote_init();
APP_ERROR_CHECK(err_code);
init_led_button_task();
//init_device_storage();
NRF_LOG_INFO("Device Starting");
NRF_LOG_INFO("FW Version: %s", app_fw_version);
// Start FreeRTOS scheduler.
vTaskStartScheduler();
for (;;) {
APP_ERROR_HANDLER(NRF_ERROR_FORBIDDEN);
}
}
static void nrf_nvmc_write_word(uint32_t address, uint32_t value)
{
// Enable write.
NRF_NVMC->CONFIG = NVMC_CONFIG_WEN_Wen;
__ISB();
__DSB();
*(uint32_t*)address = value;
while (NRF_NVMC->READY == NVMC_READY_READY_Busy) {;}
NRF_NVMC->CONFIG = NVMC_CONFIG_WEN_Ren;
__ISB();
__DSB();
}
uint32_t app_timer_cnt_get(void)
{
return xTaskGetTickCount();
}
uint32_t app_timer_cnt_diff_compute(uint32_t ticks_to,
uint32_t ticks_from)
{
return ((ticks_to - ticks_from) & RTC_COUNTER_COUNTER_Msk);
}
I don't want the nearby devices with same firmware to connect to each other. Please help me on how to proceed further.
Thanks & Regards,
Snehal
