#include <stdint.h>
#include <string.h>
#include "nordic_common.h"
#include "nrf.h"
#include "sdk_config.h"
#include "ble_hci.h"
#include "ble_gap.h"
#include "ble_advdata.h"
#include "ble_advertising.h"
#include "ble_conn_params.h"
#include "nrf_sdh.h"
#include "nrf_sdh_soc.h"
#include "nrf_sdh_ble.h"
#include "nrf_ble_gatt.h"
#include "nrf_ble_qwr.h"
#include "app_timer.h"
#include "ble_nus.h"
#include "ble_cus.h"
#include "ble_dis.h"
#include "app_uart.h"
#include "app_util_platform.h"
#include "bsp_btn_ble.h"
#include "nrf_pwr_mgmt.h"
#include "nrf_drv_twi.h"
#if defined (UART_PRESENT)
#include "nrf_uart.h"
#endif
#if defined (UARTE_PRESENT)
#include "nrf_uarte.h"
#endif
#include "ble_advdata.h"
#include "ble_advertising.h"
#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.h"
#include "nrf_delay.h"
#include "ble_init.h"
#include "am_devices_amx8x5.h"
#include "configurations.h"
#include "data_storage.h"
#include "sys_app.h"
#include "main.h"
#include "mp2722.h"
#include "2360_audio_driver.h"
#include "init_modules.h"
// DFU-related #includes
#include "nrf_power.h"
#include "nrf_dfu_ble_svci_bond_sharing.h"
#include "nrf_svci_async_function.h"
#include "nrf_svci_async_handler.h"
#include "ble_dfu.h"
#include "nrf_bootloader_info.h"
#include "nrf_pwr_mgmt.h"
//ANCS related includes
#include "peer_manager.h"
#include "peer_manager_handler.h"
#include "ble_db_discovery.h"
#include "nrf_ble_gatts_c.h"
#include "nrf_ble_ancs_c.h"
#include "ble_conn_state.h"
#include "fds.h"
#include "app_scheduler.h"
#define APP_BLE_CONN_CFG_TAG 1 /**< A tag identifying the SoftDevice BLE configuration. */
#define DEVICE_NAME "ANCS_UART" /**< Name of device. Will be included in the advertising data. */
#define NUS_SERVICE_UUID_TYPE BLE_UUID_TYPE_VENDOR_BEGIN /**< UUID type for the Nordic UART Service (vendor specific). */
#define APP_BLE_OBSERVER_PRIO 3 /**< Application's BLE observer priority. You shouldn't need to modify this value. */
#define APP_ADV_INTERVAL 64 /**< The advertising interval (in units of 0.625 ms. This value corresponds to 40 ms). */
#define APP_ADV_DURATION 18000 /* No timeout ; continous advertising */
#define MIN_CONN_INTERVAL MSEC_TO_UNITS(20, UNIT_1_25_MS) /**< Minimum acceptable connection interval (20 ms), Connection interval uses 1.25 ms units. */
#define MAX_CONN_INTERVAL MSEC_TO_UNITS(75, UNIT_1_25_MS) /**< Maximum acceptable connection interval (75 ms), Connection interval uses 1.25 ms units. */
#define SLAVE_LATENCY 0 /**< Slave latency. */
#define CONN_SUP_TIMEOUT MSEC_TO_UNITS(4000, UNIT_10_MS) /**< Connection supervisory timeout (4 seconds), Supervision Timeout uses 10 ms units. */
#define 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 MESSAGE_BUFFER_SIZE 18 /**< Size of buffer holding optional messages in notifications. */
#define SECURITY_REQUEST_DELAY APP_TIMER_TICKS(1500) /**< Delay after connection until security request is sent, if necessary (ticks). */
#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. */
#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 FPU_EXCEPTION_MASK 0x0000009F
#define SCHED_MAX_EVENT_DATA_SIZE APP_TIMER_SCHED_EVENT_DATA_SIZE /**< Maximum size of scheduler events. */
#define BLE_INIT_GLOBALS
#define ATTR_DATA_SIZE BLE_ANCS_ATTR_DATA_MAX /**< Allocated size for attribute data. */
#define SCHED_QUEUE_SIZE 10 /**< Maximum number of events in the scheduler queue. */
BLE_NUS_DEF(m_nus, NRF_SDH_BLE_TOTAL_LINK_COUNT); /**< BLE NUS 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);
BLE_CUS_DEF(m_cus);
/* Added for ANCS integration */
NRF_BLE_GATTS_C_DEF(m_gatts_c); /**< GATT Service client instance. Handles Service Changed indications from the peer. */
BLE_ANCS_C_DEF(m_ancs_c); /**< Apple Notification Service Client instance. */
BLE_DB_DISCOVERY_DEF(m_db_disc); /**< DB Discovery module instance. */
NRF_BLE_GQ_DEF(m_ble_gatt_queue, /**< BLE GATT Queue instance. */
NRF_SDH_BLE_PERIPHERAL_LINK_COUNT,
NRF_BLE_GQ_QUEUE_SIZE);
/**< Advertising module instance. */
static pm_peer_id_t m_whitelist_peers[BLE_GAP_WHITELIST_ADDR_MAX_COUNT]; /**< List of peers currently in the whitelist. */
static uint32_t m_whitelist_peer_cnt; /**< Number of peers currently in the whitelist. */
static ble_gatt_db_srv_t m_peer_srv_buf[2] = {0}; /**< Array of services with room to store both GATT Service and ANCS. */
static bool m_ancs_discovered = false; /**< Bool to keep track of when both ancs and gatts have been disovered. Only then do we want to save the peer data. */
static bool m_gatts_discovered = false; /**< Bool to keep track of when both ancs and gatts have been disovered. Only then do we want to save the peer data. */
static ble_ancs_c_evt_notif_t m_notification_latest; /**< Local copy to keep track of the newest arriving notifications. */
static ble_ancs_c_attr_t m_notif_attr_latest; /**< Local copy of the newest notification attribute. */
static ble_ancs_c_attr_t m_notif_attr_app_id_latest; /**< Local copy of the newest app attribute. */
static uint8_t m_attr_appid[ATTR_DATA_SIZE]; /**< Buffer to store attribute data. */
static uint8_t m_attr_title[ATTR_DATA_SIZE]; /**< Buffer to store attribute data. */
static uint8_t m_attr_subtitle[ATTR_DATA_SIZE]; /**< Buffer to store attribute data. */
static uint8_t m_attr_message[ATTR_DATA_SIZE]; /**< Buffer to store attribute data. */
static uint8_t m_attr_message_size[ATTR_DATA_SIZE]; /**< Buffer to store attribute data. */
static uint8_t m_attr_date[ATTR_DATA_SIZE]; /**< Buffer to store attribute data. */
static uint8_t m_attr_posaction[ATTR_DATA_SIZE]; /**< Buffer to store attribute data. */
static uint8_t m_attr_negaction[ATTR_DATA_SIZE]; /**< Buffer to store attribute data. */
static uint8_t m_attr_disp_name[ATTR_DATA_SIZE]; /**< Buffer to store attribute data. */
static uint16_t m_conn_handle = BLE_CONN_HANDLE_INVALID; /**< Handle of the current connection. */
static uint16_t m_ble_nus_max_data_len = BLE_GATT_ATT_MTU_DEFAULT - 3; /**< Maximum length of data (in bytes) that can be transmitted to the peer by the Nordic UART service module. */
static ble_uuid_t m_adv_uuids[] = /**< Universally unique service identifier. */
{
{BLE_UUID_NUS_SERVICE, NUS_SERVICE_UUID_TYPE}
};
/**@brief String literals for the iOS notification categories. used then printing to UART. */
static char const * lit_catid[BLE_ANCS_NB_OF_CATEGORY_ID] =
{
"Other",
"Incoming Call",
"Missed Call",
"Voice Mail",
"Social",
"Schedule",
"Email",
"News",
"Health And Fitness",
"Business And Finance",
"Location",
"Entertainment"
};
/**@brief String literals for the iOS notification event types. Used then printing to UART. */
static char const * lit_eventid[BLE_ANCS_NB_OF_EVT_ID] =
{
"Added",
"Modified",
"Removed"
};
/**@brief String literals for the iOS notification attribute types. Used when printing to UART. */
static char const * lit_attrid[BLE_ANCS_NB_OF_NOTIF_ATTR] =
{
"App Identifier",
"Title",
"Subtitle",
"Message",
"Message Size",
"Date",
"Positive Action Label",
"Negative Action Label"
};
/**@brief String literals for the iOS notification attribute types. Used When printing to UART. */
static char const * lit_appid[BLE_ANCS_NB_OF_APP_ATTR] =
{
"Display Name"
};
static void delete_bonds(void);
/**@brief Function for printing iOS notification attribute data.
*
* @param[in] p_attr Pointer to an iOS notification attribute.
*/
static void notif_attr_print(ble_ancs_c_attr_t * p_attr)
{
if (p_attr->attr_len != 0)
{
//NRF_LOG_INFO("%s: %s", (uint32_t)lit_attrid[p_attr->attr_id],
// nrf_log_push((char *)p_attr->p_attr_data));
printf("1 - %s\n", (uint32_t)lit_attrid[p_attr->attr_id]);
printf("2 %s\n",(char *)p_attr->p_attr_data);
}
else if (p_attr->attr_len == 0)
{
printf("%s: (N/A)", (uint32_t)lit_attrid[p_attr->attr_id]);
}
}
/**@brief Function for printing iOS notification attribute data.
*
* @param[in] p_attr Pointer to an iOS App attribute.
*/
static void app_attr_print(ble_ancs_c_attr_t * p_attr)
{
if (p_attr->attr_len != 0)
{
printf("%s: %s", (uint32_t)lit_appid[p_attr->attr_id], (uint32_t)p_attr->p_attr_data);
}
else if (p_attr->attr_len == 0)
{
printf("%s: (N/A)", (uint32_t) lit_appid[p_attr->attr_id]);
}
}
/**@brief Function for printing out errors that originated from the Notification Provider (iOS).
*
* @param[in] err_code_np Error code received from NP.
*/
static void err_code_print(uint16_t err_code_np)
{
switch (err_code_np)
{
case BLE_ANCS_NP_UNKNOWN_COMMAND:
printf("Error: Command ID was not recognized by the Notification Provider. ");
break;
case BLE_ANCS_NP_INVALID_COMMAND:
printf("Error: Command failed to be parsed on the Notification Provider. ");
break;
case BLE_ANCS_NP_INVALID_PARAMETER:
printf("Error: Parameter does not refer to an existing object on the Notification Provider. ");
break;
case BLE_ANCS_NP_ACTION_FAILED:
printf("Error: Perform Notification Action Failed on the Notification Provider. ");
break;
default:
break;
}
}
/**@brief Function for setting up GATTC notifications from the Notification Provider.
*
* @details This function is called when a successful connection has been established.
*/
static void apple_notification_setup(void)
{
ret_code_t ret;
nrf_delay_ms(100); // Delay because we cannot add a CCCD to close to starting encryption. iOS specific.
ret = ble_ancs_c_notif_source_notif_enable(&m_ancs_c);
APP_ERROR_CHECK(ret);
ret = ble_ancs_c_data_source_notif_enable(&m_ancs_c);
APP_ERROR_CHECK(ret);
printf("Notifications Enabled.");
}
/**@brief Function for printing an iOS notification.
*
* @param[in] p_notif Pointer to the iOS notification.
*/
static void notif_print(ble_ancs_c_evt_notif_t * p_notif)
{
printf("\r\nNotification");
printf("Event: %s", (uint32_t)lit_eventid[p_notif->evt_id]);
printf("Category ID: %s", (uint32_t)lit_catid[p_notif->category_id]);
printf("\nC ********* ategory ID: %s", (uint32_t)lit_catid[p_notif->category_id]);
printf("Category Cnt:%u", (unsigned int) p_notif->category_count);
printf("UID: %u", (unsigned int) p_notif->notif_uid);
printf("Flags:");
if (p_notif->evt_flags.silent == 1)
{
printf(" Silent");
}
if (p_notif->evt_flags.important == 1)
{
printf(" Important");
}
if (p_notif->evt_flags.pre_existing == 1)
{
printf(" Pre-existing");
}
if (p_notif->evt_flags.positive_action == 1)
{
printf(" Positive Action");
}
if (p_notif->evt_flags.negative_action == 1)
{
printf(" Negative Action");
}
}
/***********************************************************************************/
/*!
\fn void nrf_qwr_error_handler(uint32_t nrf_error)
\brief Function for handling Queued Write Module errors.
A pointer to this function will be passed to each service which may need to inform the
application about an error.
\param nrf_error : Error code containing information about what went wrong.
\return No return.
*************************************************************************************/
void nrf_qwr_error_handler(uint32_t nrf_error)
{
APP_ERROR_HANDLER(nrf_error);
}
/**@brief Function for handling events from the GATT Servive client module.
@param[in] p_evt GATT Service event.
*/
static void gatts_c_evt_handler(nrf_ble_gatts_c_evt_t * p_evt)
{
ret_code_t ret = NRF_SUCCESS;
switch (p_evt->evt_type)
{
case NRF_BLE_GATTS_C_EVT_DISCOVERY_COMPLETE:
{
printf("GATT Service and Service Changed characteristic found on server.");
ret = nrf_ble_gatts_c_handles_assign(&m_gatts_c,
p_evt->conn_handle,
&p_evt->params.srv_changed_char);
APP_ERROR_CHECK(ret);
pm_peer_id_t peer_id;
ret = pm_peer_id_get(p_evt->conn_handle, &peer_id);
APP_ERROR_CHECK(ret);
memset(&m_peer_srv_buf[0], 0, sizeof(m_peer_srv_buf[0]));
m_peer_srv_buf[0].charateristics[0] = p_evt->params.srv_changed_char;
m_gatts_discovered = true;
if(m_gatts_discovered && m_ancs_discovered)
{
ret = pm_peer_data_remote_db_store(peer_id,
(ble_gatt_db_srv_t *)m_peer_srv_buf,
sizeof(m_peer_srv_buf),
NULL);
if (ret == NRF_ERROR_STORAGE_FULL)
{
ret = fds_gc();
}
APP_ERROR_CHECK(ret);
}
ret = nrf_ble_gatts_c_enable_indication(&m_gatts_c, true);
APP_ERROR_CHECK(ret);
} break;
case NRF_BLE_GATTS_C_EVT_DISCOVERY_FAILED:
printf("GATT Service or Service Changed characteristic not found on server.");
break;
case NRF_BLE_GATTS_C_EVT_DISCONN_COMPLETE:
printf("GATTS Service client disconnected connection handle %i.",
p_evt->conn_handle);
break;
case NRF_BLE_GATTS_C_EVT_SRV_CHANGED:
printf("Service Changed indication received.");
// Discover peer's services.
m_ancs_discovered = false;
m_gatts_discovered = false;
ret = ble_db_discovery_start(&m_db_disc, p_evt->conn_handle);
APP_ERROR_CHECK(ret);
break;
default:
break;
}
}
/**@brief Function for handling the Apple Notification Service client.
*
* @details This function is called for all events in the Apple Notification client that
* are passed to the application.
*
* @param[in] p_evt Event received from the Apple Notification Service client.
*/
static void ancs_c_evt_handler(ble_ancs_c_evt_t * p_evt)
{
switch (p_evt->evt_type)
{
case BLE_ANCS_C_EVT_DISCOVERY_COMPLETE:
{
ret_code_t ret = NRF_SUCCESS;
printf("Apple Notification Center Service discovered on the server.");
ret = nrf_ble_ancs_c_handles_assign(&m_ancs_c, p_evt->conn_handle, &p_evt->service);
APP_ERROR_CHECK(ret);
pm_peer_id_t peer_id;
ret = pm_peer_id_get(p_evt->conn_handle, &peer_id);
APP_ERROR_CHECK(ret);
// Copy the needed ANCS handles into a ble_gatt_db_srv_t struct that will be stored in
// flash.
ble_gatt_db_char_t * p_char = m_peer_srv_buf[1].charateristics;
memset(&m_peer_srv_buf[1], 0, sizeof(m_peer_srv_buf[1]));
p_char[0].characteristic = p_evt->service.control_point_char;
p_char[1].characteristic = p_evt->service.notif_source_char;
p_char[1].cccd_handle = p_evt->service.notif_source_cccd.handle;
p_char[2].characteristic = p_evt->service.data_source_char;
p_char[2].cccd_handle = p_evt->service.data_source_cccd.handle;
m_ancs_discovered = true;
if (m_gatts_discovered && m_ancs_discovered)
{
ret = pm_peer_data_remote_db_store(peer_id,
(ble_gatt_db_srv_t *)m_peer_srv_buf,
sizeof(m_peer_srv_buf),
NULL);
if (ret == NRF_ERROR_STORAGE_FULL)
{
ret = fds_gc();
}
APP_ERROR_CHECK(ret);
}
apple_notification_setup();
} break;
case BLE_ANCS_C_EVT_NOTIF:
printf("BLE_ANCS_C_EVT_NOTIF\n");
m_notification_latest = p_evt->notif;
notif_print(&m_notification_latest);
break;
case BLE_ANCS_C_EVT_NOTIF_ATTRIBUTE:
printf("BLE_ANCS_C_EVT_NOTIF_ATTRIBUTE \n");
m_notif_attr_latest = p_evt->attr;
notif_attr_print(&m_notif_attr_latest);
if (p_evt->attr.attr_id == BLE_ANCS_NOTIF_ATTR_ID_APP_IDENTIFIER)
{
m_notif_attr_app_id_latest = p_evt->attr;
}
break;
case BLE_ANCS_C_EVT_DISCOVERY_FAILED:
printf("Apple Notification Center Service not discovered on the server.");
break;
case BLE_ANCS_C_EVT_APP_ATTRIBUTE:
app_attr_print(&p_evt->attr);
break;
case BLE_ANCS_C_EVT_NP_ERROR:
err_code_print(p_evt->err_code_np);
break;
default:
// No implementation needed.
break;
}
}
/**@brief Function for handling the Apple Notification Service client errors.
*
* @param[in] nrf_error Error code containing information about what went wrong.
*/
static void apple_notification_error_handler(uint32_t nrf_error)
{
APP_ERROR_HANDLER(nrf_error);
}
/**@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 ret;
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_BONDED_PEER_CONNECTED:
{
if (p_evt->peer_id != PM_PEER_ID_INVALID)
{
uint32_t data_len = sizeof(m_peer_srv_buf);
ret = pm_peer_data_remote_db_load(p_evt->peer_id, m_peer_srv_buf, &data_len);
if (ret == NRF_ERROR_NOT_FOUND)
{
printf("Could not find the remote database in flash.");
ret = nrf_ble_gatts_c_handles_assign(&m_gatts_c, p_evt->conn_handle, NULL);
APP_ERROR_CHECK(ret);
// Discover peer's services.
m_ancs_discovered = false;
m_gatts_discovered = false;
memset(&m_db_disc, 0x00, sizeof(m_db_disc));
ret = ble_db_discovery_start(&m_db_disc, p_evt->conn_handle);
APP_ERROR_CHECK(ret);
}
else
{
// Check if the load was successful.
ASSERT(data_len == sizeof(m_peer_srv_buf));
APP_ERROR_CHECK(ret);
printf("Remote Database loaded from flash.");
// Assign the loaded handles to the GATT Service client module.
ble_gatt_db_char_t srv_changed_handles = m_peer_srv_buf[0].charateristics[0];
ret = nrf_ble_gatts_c_handles_assign(&m_gatts_c,
p_evt->conn_handle,
&srv_changed_handles);
APP_ERROR_CHECK(ret);
// Enable indications.
ret = nrf_ble_gatts_c_enable_indication(&m_gatts_c, true);
APP_ERROR_CHECK(ret);
//Load the relevant handles into a ble_ancs_c_service_t struct that can be
// assigned to the ANCS module.
ble_ancs_c_service_t ancs_handles;
ble_gatt_db_char_t * p_char = m_peer_srv_buf[1].charateristics;
ancs_handles.control_point_char = p_char[0].characteristic;
ancs_handles.notif_source_char = p_char[1].characteristic;
ancs_handles.notif_source_cccd.handle = p_char[1].cccd_handle;
ancs_handles.data_source_char = p_char[2].characteristic;
ancs_handles.data_source_cccd.handle = p_char[2].cccd_handle;
ret = nrf_ble_ancs_c_handles_assign(&m_ancs_c, p_evt->conn_handle,
&ancs_handles);
APP_ERROR_CHECK(ret);
}
}
} break;
case PM_EVT_CONN_SEC_SUCCEEDED:
{
// Check it the Service Changed characteristic handle exists in our client instance.
// If it is invalid, we know service discovery is needed.
// (No database was loaded during @ref PM_EVT_BONDED_PEER_CONNECTED)
if (m_gatts_c.srv_changed_char.characteristic.handle_value == BLE_GATT_HANDLE_INVALID)
{
ret = nrf_ble_gatts_c_handles_assign(&m_gatts_c, p_evt->conn_handle, NULL);
APP_ERROR_CHECK(ret);
// Discover peer's services.
m_ancs_discovered = false;
m_gatts_discovered = false;
memset(&m_db_disc, 0x00, sizeof(m_db_disc));
ret = ble_db_discovery_start(&m_db_disc, p_evt->conn_handle);
APP_ERROR_CHECK(ret);
}
} break;
case PM_EVT_PEERS_DELETE_SUCCEEDED:
{
advertising_start(false);
} break;
case PM_EVT_PEER_DATA_UPDATE_SUCCEEDED:
{
// Note: You should check on what kind of white list policy your application should use.
if ( p_evt->params.peer_data_update_succeeded.flash_changed
&& (p_evt->params.peer_data_update_succeeded.data_id == PM_PEER_DATA_ID_BONDING))
{
printf("New Bond, add the peer to the whitelist if possible");
printf("\tm_whitelist_peer_cnt %d, MAX_PEERS_WLIST %d",
m_whitelist_peer_cnt + 1,
BLE_GAP_WHITELIST_ADDR_MAX_COUNT);
if (m_whitelist_peer_cnt < BLE_GAP_WHITELIST_ADDR_MAX_COUNT)
{
// Bonded to a new peer, add it to the whitelist.
m_whitelist_peers[m_whitelist_peer_cnt++] = p_evt->peer_id;
// The whitelist has been modified, update it in the Peer Manager.
ret = pm_device_identities_list_set(m_whitelist_peers, m_whitelist_peer_cnt);
if (ret != NRF_ERROR_NOT_SUPPORTED)
{
APP_ERROR_CHECK(ret);
}
ret = pm_whitelist_set(m_whitelist_peers, m_whitelist_peer_cnt);
APP_ERROR_CHECK(ret);
}
}
} break;
default:
break;
}
}
/**@brief Fetch the list of peer manager peer IDs.
*
* @param[inout] p_peers The buffer where to store the list of peer IDs.
* @param[inout] p_size In: The size of the @p p_peers buffer.
* Out: The number of peers copied in the buffer.
*/
static void peer_list_get(pm_peer_id_t * p_peers, uint32_t * p_size)
{
pm_peer_id_t peer_id;
uint32_t peers_to_copy;
peers_to_copy = (*p_size < BLE_GAP_WHITELIST_ADDR_MAX_COUNT) ?
*p_size : BLE_GAP_WHITELIST_ADDR_MAX_COUNT;
peer_id = pm_next_peer_id_get(PM_PEER_ID_INVALID);
*p_size = 0;
while ((peer_id != PM_PEER_ID_INVALID) && (peers_to_copy--))
{
p_peers[(*p_size)++] = peer_id;
peer_id = pm_next_peer_id_get(peer_id);
}
}
/**@brief Function for the Peer Manager initialization.
*/
static void peer_manager_init(void)
{
ble_gap_sec_params_t sec_param;
ret_code_t ret;
ret = pm_init();
APP_ERROR_CHECK(ret);
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;
ret = pm_sec_params_set(&sec_param);
APP_ERROR_CHECK(ret);
ret = pm_register(pm_evt_handler);
APP_ERROR_CHECK(ret);
}
/**@brief Handler for shutdown preparation.
*
* @details During shutdown procedures, this function will be called at a 1 second interval
* untill the function returns true. When the function returns true, it means that the
* app is ready to reset to DFU mode.
*
* @param[in] event Power manager event.
*
* @retval True if shutdown is allowed by this power manager handler, otherwise false.
*/
static bool app_shutdown_handler(nrf_pwr_mgmt_evt_t event)
{
switch (event)
{
case NRF_PWR_MGMT_EVT_PREPARE_DFU:
NRF_LOG_INFO("Power management wants to reset to DFU mode.");
// YOUR_JOB: Get ready to reset into DFU mode
//
// If you aren't finished with any ongoing tasks, return "false" to
// signal to the system that reset is impossible at this stage.
//
// Here is an example using a variable to delay resetting the device.
//
// if (!m_ready_for_reset)
// {
// return false;
// }
// else
//{
//
// // Device ready to enter
// uint32_t err_code;
// err_code = sd_softdevice_disable();
// APP_ERROR_CHECK(err_code);
// err_code = app_timer_stop_all();
// APP_ERROR_CHECK(err_code);
//}
break;
default:
// YOUR_JOB: Implement any of the other events available from the power management module:
// -NRF_PWR_MGMT_EVT_PREPARE_SYSOFF
// -NRF_PWR_MGMT_EVT_PREPARE_WAKEUP
// -NRF_PWR_MGMT_EVT_PREPARE_RESET
return true;
}
NRF_LOG_INFO("Power management allowed to reset to DFU mode.");
return true;
}
/**@brief Register application shutdown handler with priority 0.
*/
NRF_PWR_MGMT_HANDLER_REGISTER(app_shutdown_handler, 0);
static void buttonless_dfu_sdh_state_observer(nrf_sdh_state_evt_t state, void * p_context)
{
if (state == NRF_SDH_EVT_STATE_DISABLED)
{
// Softdevice was disabled before going into reset. Inform bootloader to skip CRC on next boot.
nrf_power_gpregret2_set(BOOTLOADER_DFU_SKIP_CRC);
//Go to system off.
nrf_pwr_mgmt_shutdown(NRF_PWR_MGMT_SHUTDOWN_GOTO_SYSOFF);
}
}
/* nrf_sdh state observer. */
NRF_SDH_STATE_OBSERVER(m_buttonless_dfu_state_obs, 0) =
{
.handler = buttonless_dfu_sdh_state_observer,
};
static void ble_dfu_buttonless_evt_handler(ble_dfu_buttonless_evt_type_t event)
{
ret_code_t err_code;
switch (event)
{
case BLE_DFU_EVT_BOOTLOADER_ENTER_PREPARE:
NRF_LOG_INFO("Device is preparing to enter bootloader mode\r\n");
break;
case BLE_DFU_EVT_BOOTLOADER_ENTER:
NRF_LOG_INFO("Device will enter bootloader mode\r\n");
break;
case BLE_DFU_EVT_BOOTLOADER_ENTER_FAILED:
NRF_LOG_ERROR("Device failed to enter bootloader mode\r\n");
break;
default:
NRF_LOG_INFO("Unknown event from ble_dfu.\r\n");
break;
}
}
/**@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 should forward the
* events to their respective service instances.
*
* @param[in] p_event Pointer to the database discovery event.
*/
static void db_disc_handler(ble_db_discovery_evt_t * p_evt)
{
ble_ancs_c_on_db_disc_evt(&m_ancs_c, p_evt);
nrf_ble_gatts_c_on_db_disc_evt(&m_gatts_c, p_evt);
}
/**@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(ble_db_discovery_init_t));
db_init.evt_handler = db_disc_handler;
db_init.p_gatt_queue = &m_ble_gatt_queue;
ret_code_t ret = ble_db_discovery_init(&db_init);
APP_ERROR_CHECK(ret);
}
/**@brief Function for initializing the Event Scheduler.
*/
static void ble_scheduler_init(void)
{
APP_SCHED_INIT(SCHED_MAX_EVENT_DATA_SIZE, SCHED_QUEUE_SIZE);
}
/***********************************************************************************/
/*!
\fn void ble_evt_handler(ble_evt_t const * p_ble_evt, void * p_context)
\brief Function for handling BLE events.
\param p_ble_evt : Bluetooth stack event.
\param p_context : Unused.
\return No return.
*************************************************************************************/
void ble_evt_handler(ble_evt_t const * p_ble_evt, void * p_context)
{
uint32_t err_code;
pm_handler_secure_on_connection(p_ble_evt);
switch (p_ble_evt->header.evt_id)
{
case BLE_GAP_EVT_CONNECTED:
printf("Connected \n");
m_conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
err_code = nrf_ble_qwr_conn_handle_assign(&m_qwr, m_conn_handle);
printf("Connected err_code = %d \n",err_code);
APP_ERROR_CHECK(err_code);
break;
case BLE_GAP_EVT_DISCONNECTED:
printf("Disconnected \n");
// LED indication will be changed when advertising starts.
m_conn_handle = BLE_CONN_HANDLE_INVALID;
if (p_ble_evt->evt.gap_evt.conn_handle == m_ancs_c.conn_handle)
{
m_ancs_c.conn_handle = BLE_CONN_HANDLE_INVALID;
}
break;
case BLE_GAP_EVT_PHY_UPDATE_REQUEST:
{
printf("PHY update request.\n");
ble_gap_phys_t const phys =
{
.rx_phys = BLE_GAP_PHY_AUTO,
.tx_phys = BLE_GAP_PHY_AUTO,
};
err_code = sd_ble_gap_phy_update(p_ble_evt->evt.gap_evt.conn_handle, &phys);
APP_ERROR_CHECK(err_code);
} break;
case BLE_GAP_EVT_SEC_PARAMS_REQUEST:
// Pairing not supported
err_code = sd_ble_gap_sec_params_reply(m_conn_handle, BLE_GAP_SEC_STATUS_PAIRING_NOT_SUPP, NULL, NULL);
APP_ERROR_CHECK(err_code);
break;
case BLE_GATTS_EVT_SYS_ATTR_MISSING:
// No system attributes have been stored.
err_code = sd_ble_gatts_sys_attr_set(m_conn_handle, NULL, 0, 0);
APP_ERROR_CHECK(err_code);
break;
case BLE_GATTC_EVT_TIMEOUT:
// Disconnect on GATT Client timeout event.
err_code = sd_ble_gap_disconnect(p_ble_evt->evt.gattc_evt.conn_handle,
BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
APP_ERROR_CHECK(err_code);
break;
case BLE_GATTS_EVT_TIMEOUT:
// Disconnect on GATT Server timeout event.
err_code = sd_ble_gap_disconnect(p_ble_evt->evt.gatts_evt.conn_handle,
BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
APP_ERROR_CHECK(err_code);
break;
default:
// No implementation needed.
break;
}
}
/***********************************************************************************/
/*!
\fn void ble_stack_init(void)
\brief Function for the SoftDevice initialization.
his function initializes the SoftDevice and the BLE event interrupt.
\return No return.
*************************************************************************************/
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);
}
/***********************************************************************************/
/*!
\fn void gap_params_init(void)
\brief void Function for the GAP initialization.
This function will set up all the necessary GAP (Generic Access Profile) parameters of
the device. It also sets the permissions and appearance.
\return No return.
*************************************************************************************/
void gap_params_init(void)
{
uint32_t err_code;
ble_gap_conn_params_t gap_conn_params;
ble_gap_conn_sec_mode_t sec_mode;
ble_gap_addr_t device_addr;
uint8_t tmp_len;
BLE_GAP_CONN_SEC_MODE_SET_OPEN(&sec_mode);
// Get BLE address.
err_code = sd_ble_gap_addr_get(&device_addr);
strcpy((char *)tmp_local_name, DEVICE_NAME);
tmp_len = strlen((char *)tmp_local_name);
snprintf((char *)&tmp_local_name[tmp_len], 30-tmp_len, "_%02x", device_addr.addr[0]);
//strcpy((char *)&g_u8_device_id[0], device_addr.addr[0]);
g_u8_device_id[0] = device_addr.addr[0];
// printf("device_id: %s\n",tmp_local_name);
err_code = sd_ble_gap_device_name_set(&sec_mode,
(const uint8_t *) tmp_local_name,
strlen((char *)tmp_local_name));
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);
}
/***********************************************************************************/
/*!
\fn void gatt_evt_handler(nrf_ble_gatt_t * p_gatt, nrf_ble_gatt_evt_t const * p_evt)
\brief Function for handling events from the GATT library.
\param nrf_ble_gatt_t * p_gatt :
\param rf_ble_gatt_evt_t const * p_evt :
\return No return.
*************************************************************************************/
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);
}
/***********************************************************************************/
/*!
\fn void gatt_init(void)
\brief Function for initializing the GATT library.
\return No return.
*************************************************************************************/
void gatt_init(void)
{
ret_code_t err_code;
err_code = nrf_ble_gatt_init(&m_gatt, gatt_evt_handler);
APP_ERROR_CHECK(err_code);
err_code = nrf_ble_gatt_att_mtu_periph_set(&m_gatt, NRF_SDH_BLE_GATT_MAX_MTU_SIZE);
APP_ERROR_CHECK(err_code);
}
void cus_evt_handler(ble_cus_t * p_cus, ble_cus_evt_t * p_evt)
{
uint8_t u8_cmd_id = 0;
switch(p_evt->evt_type)
{
case BLE_LEDS_STATES_CHAR_EVT_COMMAND_RX:
{
NRF_LOG_INFO("BLE_LEDS_STATES_CHAR_EVT_COMMAND_RX");
}break;
case BLE_BUTTONS_STATES_CHAR_NOTIFICATIONS_ENABLED:
{
NRF_LOG_INFO("buttons states char notifications are enabled.");
} break;
case BLE_BUTTONS_STATES_CHAR_NOTIFICATIONS_DISABLED:
{
NRF_LOG_INFO("buttons states char notifications are disabled.");
} break;
case BLE_POTENTIO_LEVEL_CHAR_NOTIFICATIONS_ENABLED:
{
NRF_LOG_INFO("potentio level char notifications are enabled.");
} break;
case BLE_POTENTIO_LEVEL_CHAR_NOTIFICATIONS_DISABLED:
{
NRF_LOG_INFO("potentio level char notifications are disabled.");
} break;
default:
break;
}
}
/***********************************************************************************/
/*!
\fn void cus_init(void)
\brief Function for custom service initialization.
\return No return.
*************************************************************************************/
void cus_init(void)
{
ret_code_t err_code;
ble_cus_init_t cus_init = {0};
cus_init.evt_handler = cus_evt_handler;
err_code = ble_cus_init(&m_cus, &cus_init);
APP_ERROR_CHECK(err_code);
}
/***********************************************************************************/
/*!
\fn void services_init(void)
\brief Function for initializing services that will be used by the application.
\return No return.
*************************************************************************************/
void services_init(void)
{
uint32_t err_code;
ble_nus_init_t nus_init;
ble_dis_init_t dis_init;
nrf_ble_qwr_init_t qwr_init = {0};
ble_ancs_c_init_t ancs_c_init;
nrf_ble_gatts_c_init_t gatts_c_init;
ret_code_t ret;
// 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);
cus_init();
bas_init();
#if 1//OTA_CODE_ENABLED
// Initialize the DFU service
ble_dfu_buttonless_init_t dfus_init =
{
.evt_handler = ble_dfu_buttonless_evt_handler
};
err_code = ble_dfu_buttonless_init(&dfus_init);
APP_ERROR_CHECK(err_code);
#endif
// Initialize Device Information Service.
memset(&dis_init, 0, sizeof(dis_init));
ble_srv_ascii_to_utf8(&dis_init.manufact_name_str, "TITAN");
ble_srv_ascii_to_utf8(&dis_init.model_num_str, "NORDIC");
ble_srv_ascii_to_utf8(&dis_init.serial_num_str, "NORDIC");
ble_srv_ascii_to_utf8(&dis_init.hw_rev_str, "1.0");
ble_srv_ascii_to_utf8(&dis_init.fw_rev_str, "1.0");
dis_init.dis_char_rd_sec = SEC_OPEN;
err_code = ble_dis_init(&dis_init);
APP_ERROR_CHECK(err_code);
// Init the GATTS client module.
memset(&gatts_c_init, 0, sizeof(gatts_c_init));
gatts_c_init.evt_handler = gatts_c_evt_handler;
gatts_c_init.p_gatt_queue = &m_ble_gatt_queue;
ret = nrf_ble_gatts_c_init(&m_gatts_c, &gatts_c_init);
APP_ERROR_CHECK(ret);
// Init the Apple Notification Center Service client module.
memset(&ancs_c_init, 0, sizeof(ancs_c_init));
ret = nrf_ble_ancs_c_attr_add(&m_ancs_c,
BLE_ANCS_NOTIF_ATTR_ID_APP_IDENTIFIER,
m_attr_appid,
ATTR_DATA_SIZE);
APP_ERROR_CHECK(ret);
ret = nrf_ble_ancs_c_app_attr_add(&m_ancs_c,
BLE_ANCS_APP_ATTR_ID_DISPLAY_NAME,
m_attr_disp_name,
sizeof(m_attr_disp_name));
APP_ERROR_CHECK(ret);
ret = nrf_ble_ancs_c_attr_add(&m_ancs_c,
BLE_ANCS_NOTIF_ATTR_ID_TITLE,
m_attr_title,
ATTR_DATA_SIZE);
APP_ERROR_CHECK(ret);
ret = nrf_ble_ancs_c_attr_add(&m_ancs_c,
BLE_ANCS_NOTIF_ATTR_ID_MESSAGE,
m_attr_message,
ATTR_DATA_SIZE);
APP_ERROR_CHECK(ret);
ret = nrf_ble_ancs_c_attr_add(&m_ancs_c,
BLE_ANCS_NOTIF_ATTR_ID_SUBTITLE,
m_attr_subtitle,
ATTR_DATA_SIZE);
APP_ERROR_CHECK(ret);
ret = nrf_ble_ancs_c_attr_add(&m_ancs_c,
BLE_ANCS_NOTIF_ATTR_ID_MESSAGE_SIZE,
m_attr_message_size,
ATTR_DATA_SIZE);
APP_ERROR_CHECK(ret);
ret = nrf_ble_ancs_c_attr_add(&m_ancs_c,
BLE_ANCS_NOTIF_ATTR_ID_DATE,
m_attr_date,
ATTR_DATA_SIZE);
APP_ERROR_CHECK(ret);
ret = nrf_ble_ancs_c_attr_add(&m_ancs_c,
BLE_ANCS_NOTIF_ATTR_ID_POSITIVE_ACTION_LABEL,
m_attr_posaction,
ATTR_DATA_SIZE);
APP_ERROR_CHECK(ret);
ret = nrf_ble_ancs_c_attr_add(&m_ancs_c,
BLE_ANCS_NOTIF_ATTR_ID_NEGATIVE_ACTION_LABEL,
m_attr_negaction,
ATTR_DATA_SIZE);
APP_ERROR_CHECK(ret);
ancs_c_init.evt_handler = ancs_c_evt_handler;
ancs_c_init.error_handler = apple_notification_error_handler;
ancs_c_init.p_gatt_queue = &m_ble_gatt_queue;
ret = ble_ancs_c_init(&m_ancs_c, &ancs_c_init);
APP_ERROR_CHECK(ret);
}
/**@brief Function for handling advertising events.
*
* @details This function is called for advertising events that are passed to the application.
*
* @param[in] ble_adv_evt Advertising event.
*/
static void on_adv_evt(ble_adv_evt_t ble_adv_evt)
{
ret_code_t ret;
switch (ble_adv_evt)
{
case BLE_ADV_EVT_FAST:
printf("Fast advertising");
//ret = bsp_indication_set(BSP_INDICATE_ADVERTISING);
//APP_ERROR_CHECK(ret);
break;
case BLE_ADV_EVT_SLOW:
printf("Slow advertising");
//ret = bsp_indication_set(BSP_INDICATE_ADVERTISING_SLOW);
//APP_ERROR_CHECK(ret);
break;
case BLE_ADV_EVT_FAST_WHITELIST:
printf("Fast advertising with Whitelist");
//ret = bsp_indication_set(BSP_INDICATE_ADVERTISING_WHITELIST);
//APP_ERROR_CHECK(ret);
break;
case BLE_ADV_EVT_IDLE:
sleep_mode_enter();
break;
case BLE_ADV_EVT_WHITELIST_REQUEST:
{
ble_gap_addr_t whitelist_addrs[BLE_GAP_WHITELIST_ADDR_MAX_COUNT];
ble_gap_irk_t whitelist_irks[BLE_GAP_WHITELIST_ADDR_MAX_COUNT];
uint32_t addr_cnt = BLE_GAP_WHITELIST_ADDR_MAX_COUNT;
uint32_t irk_cnt = BLE_GAP_WHITELIST_ADDR_MAX_COUNT;
ret = pm_whitelist_get(whitelist_addrs, &addr_cnt, whitelist_irks, &irk_cnt);
APP_ERROR_CHECK(ret);
printf("pm_whitelist_get returns %d addr in whitelist and %d irk whitelist",
addr_cnt,
irk_cnt);
// Apply the whitelist.
ret = ble_advertising_whitelist_reply(&m_advertising,
whitelist_addrs,
addr_cnt,
whitelist_irks,
irk_cnt);
APP_ERROR_CHECK(ret);
}
break;
default:
break;
}
}
/***********************************************************************************/
/*!
\fn void advertising_init(void)
\brief Function for initializing the Advertising functionality.
\return No return.
*************************************************************************************/
void advertising_init(void)
{
uint32_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_GENERAL_DISC_MODE;
init.srdata.uuids_complete.uuid_cnt = sizeof((char *)m_adv_uuids) / sizeof(m_adv_uuids[0]);
init.srdata.uuids_complete.p_uuids = m_adv_uuids;
init.config.ble_adv_fast_enabled = true;
init.config.ble_adv_fast_interval = APP_ADV_INTERVAL;
init.config.ble_adv_fast_timeout = APP_ADV_DURATION;
init.evt_handler = on_adv_evt;
err_code = ble_advertising_init(&m_advertising, &init);
APP_ERROR_CHECK(err_code);
ble_advertising_conn_cfg_tag_set(&m_advertising, APP_BLE_CONN_CFG_TAG);
}
/***********************************************************************************/
/*!
\fn void on_conn_params_evt(ble_conn_params_evt_t * p_evt)
\brief Function for handling an event from the Connection Parameters Module.
This function will be called for all events in the Connection Parameters Module
which are passed to the application.
\param p_evt : Event received from the Connection Parameters Module.
\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.
\return No return.
*************************************************************************************/
void on_conn_params_evt(ble_conn_params_evt_t * p_evt)
{
uint32_t err_code;
if (p_evt->evt_type == BLE_CONN_PARAMS_EVT_FAILED)
{
err_code = sd_ble_gap_disconnect(m_conn_handle, BLE_HCI_CONN_INTERVAL_UNACCEPTABLE);
APP_ERROR_CHECK(err_code);
}
}
/***********************************************************************************/
/*!
\fn void conn_params_error_handler(uint32_t nrf_error)
\brief Function for handling errors from the Connection Parameters module.
\param nrf_error : Error code containing information about what went wrong.
\return No return.
*************************************************************************************/
static void conn_params_error_handler(uint32_t nrf_error)
{
APP_ERROR_HANDLER(nrf_error);
}
/***********************************************************************************/
/*!
\fn void conn_params_init(void)
\brief Function for initializing the Connection Parameters module.
\return No return.
*************************************************************************************/
void conn_params_init(void)
{
uint32_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;// true in ancs
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 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 starting advertising. */
void advertising_start(bool erase_bonds)
{
if (erase_bonds == true)
{
delete_bonds();
// Advertising is started by PM_EVT_PEERS_DELETE_SUCCEEDED event.
}
else
{
ret_code_t ret;
memset(m_whitelist_peers, PM_PEER_ID_INVALID, sizeof(m_whitelist_peers));
m_whitelist_peer_cnt = (sizeof(m_whitelist_peers) / sizeof(pm_peer_id_t));
peer_list_get(m_whitelist_peers, &m_whitelist_peer_cnt);
ret = pm_whitelist_set(m_whitelist_peers, m_whitelist_peer_cnt);
APP_ERROR_CHECK(ret);
// Setup the device identies list.
// Some SoftDevices do not support this feature.
ret = pm_device_identities_list_set(m_whitelist_peers, m_whitelist_peer_cnt);
if (ret != NRF_ERROR_NOT_SUPPORTED)
{
APP_ERROR_CHECK(ret);
}
ret = ble_advertising_start(&m_advertising, BLE_ADV_MODE_FAST);
APP_ERROR_CHECK(ret);
}
}
/***********************************************************************************/
/*!
\fn void ble_init(void)
\brief Function for initializing the ble module.
\return No return.
*************************************************************************************/
int main(void)
{
ret_code_t err_code;
bool erase_bonds;
uint32_t err_code = ble_dfu_buttonless_async_svci_init();
APP_ERROR_CHECK(err_code);
///.Initialize all hardware related mod
ble_scheduler_init();
ble_stack_init();
gap_params_init();
gatt_init();
db_discovery_init(); // for ancs
services_init();
advertising_init();
conn_params_init();
peer_manager_init(); // for ancs
// Start execution.
NRF_LOG_INFO("Debug logging for app over RTT started.");
advertising_start(erase_bonds);
err_code = sd_ble_gap_tx_power_set(BLE_GAP_TX_POWER_ROLE_CONN, m_advertising.adv_handle, 0);
APP_ERROR_CHECK(err_code);
return 0;
}
Hi I am using nRF5 SDK 17.1.0.
Hi I am trying to integrate ANCS in ble_app_uart example. In this example, I am not using bsp library as it is for my custom board.
I am able to compile the code and my device get's connected.
My device get's automatically disconnected as soon as connection is established triggering the BLE_GAP_EVT_PHY_UPDATE_REQUEST event.
Can you please let me know if any configurations or code changes required to resolve this issue.
Logs:
Thanks
Fast advertisingble_app_init Connected Connected err_code = 0 PHY update request.
