/**@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)
{
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_mac;
#ifdef RANDOM_MAC
device_mac.addr_type = BLE_GAP_ADDR_TYPE_RANDOM_PRIVATE_RESOLVABLE;
err_code = sd_ble_gap_address_set(BLE_GAP_ADDR_CYCLE_MODE_AUTO, &device_mac);
#else
uint8_t mac_addr[] = {0x00,0x19,0x25,0x39,0x54,0x95};
device_mac.addr_type = BLE_GAP_ADDR_TYPE_PUBLIC;
memcpy(device_mac.addr, mac_addr,6);
err_code = sd_ble_gap_address_set(BLE_GAP_ADDR_CYCLE_MODE_NONE, &device_mac);
APP_ERROR_CHECK(err_code);
#endif
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);
err_code = sd_ble_gap_appearance_set(BLE_APPEARANCE_GENERIC_TAG);
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);
err_code = sd_ble_gap_tx_power_set(4);
APP_ERROR_CHECK(err_code);
}
ble_error_t nRF5xGap::setAddress(AddressType_t type, const Address_t address)
{
uint8_t cycle_mode;
ble_gap_addr_t dev_addr;
/* When using Public or Static addresses, the cycle mode must be None.
When using Random Private addresses, the cycle mode must be Auto.
In auto mode, the given address is ignored.
*/
if ((type == BLEProtocol::AddressType::PUBLIC) || (type == BLEProtocol::AddressType::RANDOM_STATIC))
{
cycle_mode = BLE_GAP_ADDR_CYCLE_MODE_NONE;
memcpy(dev_addr.addr, address, ADDR_LEN);
}
else if ((type == BLEProtocol::AddressType::RANDOM_PRIVATE_RESOLVABLE) || (type == BLEProtocol::AddressType::RANDOM_PRIVATE_NON_RESOLVABLE))
{
cycle_mode = BLE_GAP_ADDR_CYCLE_MODE_AUTO;
// address is ignored when in auto mode
}
else
{
return BLE_ERROR_PARAM_OUT_OF_RANGE;
}
dev_addr.addr_type = type;
ASSERT_INT(ERROR_NONE, sd_ble_gap_address_set(cycle_mode, &dev_addr), BLE_ERROR_PARAM_OUT_OF_RANGE);
return BLE_ERROR_NONE;
}
static void ble_stack_init(void) {
uint32_t err_code;
// Initialize the softdevice handler
SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_RC_250_PPM_8000MS_CALIBRATION, false);
// Enable BLE stack
ble_enable_params_t ble_enable_params;
memset(&ble_enable_params, 0, sizeof(ble_enable_params));
ble_enable_params.gatts_enable_params.service_changed = IS_SRVC_CHANGED_CHARACT_PRESENT;
err_code = sd_ble_enable(&ble_enable_params);
APP_ERROR_HANDLER(err_code);
//register with the softdevice handler module for ble events
err_code = sofdevice_ble_evt_handler_set(ble_evt_dispatch);
APP_ERROR_CHECK(err_code);
// set the new ble address with michigan oui; no check in flash
ble_gap_addr_t gap_addr;
sd_ble_gap_address_get(&gap_addr);
gap_addr.addr_type = BLE_GAP_ADDR_TYPE_PUBLIC;
memcpy(gap_addr.addr+2, MAC_ADDR+2, sizeof(gap_addr.addr)-2);
err_code = sd_ble_gap_address_set(BLE_GAP_ADDR_CYCLE_MODE_NONE, &gap_addr);
APP_ERROR_CHECK(err_code);
}
static void ble_stack_init(void)
{
uint32_t err_code;
nrf_clock_lf_cfg_t clock_lf_cfg = NRF_CLOCK_LFCLKSRC;
// Initialize the SoftDevice handler module.
SOFTDEVICE_HANDLER_INIT(&clock_lf_cfg, NULL);
ble_enable_params_t ble_enable_params;
err_code = softdevice_enable_get_default_config(CENTRAL_LINK_COUNT,
PERIPHERAL_LINK_COUNT,
&ble_enable_params);
APP_ERROR_CHECK(err_code);
//Check the ram settings against the used number of links
CHECK_RAM_START_ADDR(CENTRAL_LINK_COUNT,PERIPHERAL_LINK_COUNT);
// Enable BLE stack.
err_code = softdevice_enable(&ble_enable_params);
APP_ERROR_CHECK(err_code);
ble_gap_addr_t addr;
err_code = sd_ble_gap_address_get(&addr);
APP_ERROR_CHECK(err_code);
err_code = sd_ble_gap_address_set(BLE_GAP_ADDR_CYCLE_MODE_NONE, &addr);
APP_ERROR_CHECK(err_code);
// Subscribe for BLE events.
err_code = softdevice_ble_evt_handler_set(ble_evt_dispatch);
APP_ERROR_CHECK(err_code);
}
/**@brief Function for initializing the BLE stack.
*
* @details Initializes the SoftDevice and the BLE event interrupt.
*/
static void ble_stack_init(void)
{
uint32_t err_code;
ble_gap_addr_t addr;
ble_enable_params_t enableParams;
// Initialize the SoftDevice handler module.
SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_SYNTH_250_PPM, false);
// Enable BLE stack
enableParams.gatts_enable_params.service_changed = 1;
sd_ble_enable(&enableParams);
// Workaround S110 7.0.0 bug
sd_ble_gap_address_get(&addr);
sd_ble_gap_address_set(BLE_GAP_ADDR_CYCLE_MODE_NONE, &addr);
// Register with the SoftDevice handler module for BLE events.
err_code = softdevice_ble_evt_handler_set(ble_evt_dispatch);
APP_ERROR_CHECK(err_code);
// Register with the SoftDevice handler module for BLE events.
err_code = softdevice_sys_evt_handler_set(sys_evt_dispatch);
APP_ERROR_CHECK(err_code);
}
static uint32_t gap_address_change(void)
{
uint32_t err_code;
ble_gap_addr_t addr;
#ifdef NRF51
err_code = sd_ble_gap_address_get(&addr);
#elif NRF52
err_code = sd_ble_gap_addr_get(&addr);
#else
#endif
VERIFY_SUCCESS(err_code);
// Increase the BLE address by one when advertising openly.
addr.addr[0] += 1;
#ifdef NRF51
err_code = sd_ble_gap_address_set(BLE_GAP_ADDR_CYCLE_MODE_NONE, &addr);
#elif NRF52
err_code = sd_ble_gap_addr_set(&addr);
#else
#endif
VERIFY_SUCCESS(err_code);
return NRF_SUCCESS;
}
uint32_t conn_mw_ble_gap_address_set(uint8_t const * const p_rx_buf,
uint32_t rx_buf_len,
uint8_t * const p_tx_buf,
uint32_t * const p_tx_buf_len)
{
SER_ASSERT_NOT_NULL(p_rx_buf);
SER_ASSERT_NOT_NULL(p_tx_buf);
SER_ASSERT_NOT_NULL(p_tx_buf_len);
uint8_t addr_cycle_mode;
ble_gap_addr_t addr;
ble_gap_addr_t * p_addr = &addr;
uint32_t err_code = NRF_SUCCESS;
uint32_t sd_err_code;
err_code = ble_gap_address_set_req_dec(p_rx_buf, rx_buf_len, &addr_cycle_mode, &p_addr);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
sd_err_code = sd_ble_gap_address_set(addr_cycle_mode, p_addr);
err_code = ble_gap_address_set_rsp_enc(sd_err_code, p_tx_buf, p_tx_buf_len);
SER_ASSERT(err_code == NRF_SUCCESS, err_code);
return err_code;
}
/**@brief Function for the GAP initialization.
*
* @details This function shall be used to setup all the necessary GAP (Generic Access Profile)
* parameters of the device. It also sets the permissions and appearance.
*/
static 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_CONN_SEC_MODE_SET_OPEN(&sec_mode);
err_code = sd_ble_gap_device_name_set(&sec_mode, DEVICE_NAME,
strlen(DEVICE_NAME));
APP_ERROR_CHECK(err_code);
static const unsigned ADDR_LEN = 6;
const uint8_t address[] = { 0xe7, 0xAA, 0xAA, 0xAA, 0xAA, 0xAB };
ble_gap_addr_t dev_addr;
dev_addr.addr_type = ADDR_TYPE_PUBLIC;
memcpy(dev_addr.addr, address, ADDR_LEN);
err_code = sd_ble_gap_address_set(&dev_addr);
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);
}
/**@brief Function for initializing the BLE stack.
*
* @details Initializes the SoftDevice and the BLE event interrupt.
*/
static void ble_stack_init(void)
{
uint32_t err_code;
// Initialize the SoftDevice handler module.
SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_XTAL_20_PPM, false);
// Enable BLE stack
ble_enable_params_t ble_enable_params;
memset(&ble_enable_params, 0, sizeof(ble_enable_params));
ble_enable_params.gatts_enable_params.service_changed = IS_SRVC_CHANGED_CHARACT_PRESENT;
err_code = sd_ble_enable(&ble_enable_params);
APP_ERROR_CHECK(err_code);
ble_gap_addr_t addr;
err_code = sd_ble_gap_address_get(&addr);
APP_ERROR_CHECK(err_code);
sd_ble_gap_address_set(BLE_GAP_ADDR_CYCLE_MODE_NONE, &addr);
APP_ERROR_CHECK(err_code);
// Subscribe for BLE events.
err_code = softdevice_ble_evt_handler_set(ble_evt_dispatch);
APP_ERROR_CHECK(err_code);
// Register with the SoftDevice handler module for BLE events.
err_code = softdevice_sys_evt_handler_set(sys_evt_dispatch);
APP_ERROR_CHECK(err_code);
}
error_t btle_init(void)
{
nrf_clock_lf_cfg_t clockConfiguration;
// Configure the LF clock according to values provided by btle_clock.h.
// It is input from the chain of the yotta configuration system.
clockConfiguration.source = LFCLK_CONF_SOURCE;
clockConfiguration.xtal_accuracy = LFCLK_CONF_ACCURACY;
clockConfiguration.rc_ctiv = LFCLK_CONF_RC_CTIV;
clockConfiguration.rc_temp_ctiv = LFCLK_CONF_RC_TEMP_CTIV;
SOFTDEVICE_HANDLER_INIT(&clockConfiguration, signalEvent);
// Enable BLE stack
/**
* Using this call, the application can select whether to include the
* Service Changed characteristic in the GATT Server. The default in all
* previous releases has been to include the Service Changed characteristic,
* but this affects how GATT clients behave. Specifically, it requires
* clients to subscribe to this attribute and not to cache attribute handles
* between connections unless the devices are bonded. If the application
* does not need to change the structure of the GATT server attributes at
* runtime this adds unnecessary complexity to the interaction with peer
* clients. If the SoftDevice is enabled with the Service Changed
* Characteristics turned off, then clients are allowed to cache attribute
* handles making applications simpler on both sides.
*/
static const bool IS_SRVC_CHANGED_CHARACT_PRESENT = true;
ble_enable_params_t ble_enable_params;
uint32_t err_code = softdevice_enable_get_default_config(CENTRAL_LINK_COUNT,
PERIPHERAL_LINK_COUNT,
&ble_enable_params);
ble_enable_params.gatts_enable_params.attr_tab_size = GATTS_ATTR_TAB_SIZE;
ble_enable_params.gatts_enable_params.service_changed = IS_SRVC_CHANGED_CHARACT_PRESENT;
ble_enable_params.common_enable_params.vs_uuid_count = UUID_TABLE_MAX_ENTRIES;
if(err_code != NRF_SUCCESS) {
return ERROR_INVALID_PARAM;
}
if (softdevice_enable(&ble_enable_params) != NRF_SUCCESS) {
return ERROR_INVALID_PARAM;
}
ble_gap_addr_t addr;
if (sd_ble_gap_address_get(&addr) != NRF_SUCCESS) {
return ERROR_INVALID_PARAM;
}
if (sd_ble_gap_address_set(BLE_GAP_ADDR_CYCLE_MODE_NONE, &addr) != NRF_SUCCESS) {
return ERROR_INVALID_PARAM;
}
ASSERT_STATUS( softdevice_ble_evt_handler_set(btle_handler));
ASSERT_STATUS( softdevice_sys_evt_handler_set(sys_evt_dispatch));
return btle_gap_init();
}
//static void BT_set_address(UINT8 *BD_ADDR)
static void BT_set_address(void)
{
uint32_t err_code;
ble_gap_addr_t t_addr={0,{0x02,0x00,0x00,0x02,0xff,0xaa}};
#if ENABLE_GET_FLASH_ID
unsigned char keyid[32];
etSpim1ReadNorFlashStdMode(KEYID_START_ADDR,keyid,31);
#if DEBUG_UART_EN
/* DbgPrintf("flash address data\r\n");
DbgPrintf("%x %x %x %x %x %x %x %x\r\n",keyid[TAG1_ADDR_OFFSET],
keyid[TAG2_ADDR_OFFSET],
keyid[MAC_ADDRESS_ADDR_OFFSET],
keyid[MAC_ADDRESS_ADDR_OFFSET+1],
keyid[MAC_ADDRESS_ADDR_OFFSET+2],
keyid[MAC_ADDRESS_ADDR_OFFSET+3],
keyid[MAC_ADDRESS_ADDR_OFFSET+4],
keyid[MAC_ADDRESS_ADDR_OFFSET+5]
);*/
#endif
if((keyid[TAG1_ADDR_OFFSET]==MAC_VALID_TAG1) && (keyid[TAG2_ADDR_OFFSET]==MAC_VALID_TAG2))
{
if((keyid[MAC_ADDRESS_ADDR_OFFSET]==0x00)
&& (keyid[MAC_ADDRESS_ADDR_OFFSET+1]==0x00)
&& (keyid[MAC_ADDRESS_ADDR_OFFSET+2]==0x00)
&& (keyid[MAC_ADDRESS_ADDR_OFFSET+3]==0x00)
&& (keyid[MAC_ADDRESS_ADDR_OFFSET+4]==0x00)
&& (keyid[MAC_ADDRESS_ADDR_OFFSET+5]==0x00))
{
//return;
//memcpy(t_addr.addr,BD_ADDR,6);
}
else if((keyid[MAC_ADDRESS_ADDR_OFFSET]==0xff)
&& (keyid[MAC_ADDRESS_ADDR_OFFSET+1]==0xff)
&& (keyid[MAC_ADDRESS_ADDR_OFFSET+2]==0xff)
&& (keyid[MAC_ADDRESS_ADDR_OFFSET+3]==0xff)
&& (keyid[MAC_ADDRESS_ADDR_OFFSET+4]==0xff)
&& (keyid[MAC_ADDRESS_ADDR_OFFSET+5]==0xff))
{
//return;
// memcpy(t_addr.addr,BD_ADDR,6);
}
else
{
memcpy(t_addr.addr,keyid+MAC_ADDRESS_ADDR_OFFSET,MAC_ADDRESS_LENGTH);
}
}
else
#endif
{
//memcpy(t_addr.addr,BD_ADDR,6);
}
err_code = sd_ble_gap_address_set(BLE_GAP_ADDR_CYCLE_MODE_NONE, &t_addr);
APP_ERROR_CHECK(err_code);
}
void ble_device_select_address(uint8_t id)
{
ble_gap_addr_t addr;
memcpy(&addr, &base_addr, sizeof(addr));
addr.addr[0] += id;
sd_ble_gap_address_set(BLE_GAP_ADDR_CYCLE_MODE_NONE, &addr);
}
static void ble_stack_init(void)
{
uint32_t err_code;
ble_gap_conn_sec_mode_t sec_mode;
uint8_t* tstr;
uint8_t cksum;
int i;
// Initialize the SoftDevice handler module.
if(BOARD_CONFIG_VALUE_ENABLE == UICR_board_config_information->LFCLKSRC_EN)
{//user config
SOFTDEVICE_HANDLER_INIT(UICR_board_config_information->LFCLKSRC, false);
}
else
{//default
SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_RC_250_PPM_TEMP_16000MS_CALIBRATION, false);
}
// Enable BLE stack
ble_enable_params_t ble_enable_params;
memset(&ble_enable_params, 0, sizeof(ble_enable_params));
ble_enable_params.gatts_enable_params.service_changed = IS_SRVC_CHANGED_CHARACT_PRESENT;
ble_enable_params.gatts_enable_params.attr_tab_size = 512;
err_code = sd_ble_enable(&ble_enable_params);
APP_ERROR_CHECK(err_code);
// Register with the SoftDevice handler module for BLE events.
err_code = softdevice_ble_evt_handler_set(ble_evt_dispatch);
APP_ERROR_CHECK(err_code);
// Register with the SoftDevice handler module for BLE events.
err_code = softdevice_sys_evt_handler_set(sys_evt_dispatch);
APP_ERROR_CHECK(err_code);
sd_ble_gap_address_get(&base_addr);
hash128(base_addr.addr, 6, device_id);
base_addr.addr_type = BLE_GAP_ADDR_TYPE_RANDOM_STATIC;
tstr = __TIME__;
cksum = 0;
for (i=0; i<strlen(__TIME__); i++) {
cksum += tstr[i];
}
base_addr.addr[0] += cksum;
sd_ble_gap_address_set(BLE_GAP_ADDR_CYCLE_MODE_NONE, &base_addr);
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);
}
/**@brief Function for initializing the Advertising functionality.
*
* @details Encodes the required advertising data and passes it to the stack.
* Also builds a structure to be passed to the stack when starting advertising.
*/
static void advertising_init(void)
{
uint32_t err_code;
ble_advdata_t advdata;
uint8_t flags = BLE_GAP_ADV_FLAG_BR_EDR_NOT_SUPPORTED;
ble_gap_conn_sec_mode_t sec_mode;
ble_gap_addr_t my_addr;
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);
err_code = sd_ble_gap_address_get(&my_addr);
APP_ERROR_CHECK(err_code);
my_addr.addr_type = BLE_GAP_ADDR_TYPE_PUBLIC;
my_addr.addr[5] = 0x00;
err_code = sd_ble_gap_address_set(&my_addr);
APP_ERROR_CHECK(err_code);
IPV6_EUI64_CREATE_FROM_EUI48 (eui64_local_iid.identifier,
my_addr.addr,
my_addr.addr_type);
ble_uuid_t adv_uuids[] =
{
{BLE_UUID_IPSP_SERVICE, BLE_UUID_TYPE_BLE}
};
//Build and set advertising data.
memset(&advdata, 0, sizeof(advdata));
advdata.name_type = BLE_ADVDATA_FULL_NAME;
advdata.flags.size = sizeof(flags);
advdata.flags.p_data = &flags;
advdata.uuids_complete.uuid_cnt = sizeof(adv_uuids) / sizeof(adv_uuids[0]);
advdata.uuids_complete.p_uuids = adv_uuids;
err_code = ble_advdata_set(&advdata, NULL);
APP_ERROR_CHECK(err_code);
//Initialize advertising parameters (used when starting advertising).
memset(&m_adv_params, 0, sizeof(m_adv_params));
m_adv_params.type = BLE_GAP_ADV_TYPE_ADV_IND;
m_adv_params.p_peer_addr = NULL; // Undirected advertisement.
m_adv_params.fp = BLE_GAP_ADV_FP_ANY;
m_adv_params.interval = APP_ADV_ADV_INTERVAL;
m_adv_params.timeout = APP_ADV_TIMEOUT;
}
error_t btle_init(void)
{
const bool useScheduler = false;
#ifdef TARGET_HRM1017
SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_RC_250_PPM_4000MS_CALIBRATION, useScheduler);
#else
SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_XTAL_20_PPM, useScheduler);
#endif
// Enable BLE stack
/**
* Using this call, the application can select whether to include the
* Service Changed characteristic in the GATT Server. The default in all
* previous releases has been to include the Service Changed characteristic,
* but this affects how GATT clients behave. Specifically, it requires
* clients to subscribe to this attribute and not to cache attribute handles
* between connections unless the devices are bonded. If the application
* does not need to change the structure of the GATT server attributes at
* runtime this adds unnecessary complexity to the interaction with peer
* clients. If the SoftDevice is enabled with the Service Changed
* Characteristics turned off, then clients are allowed to cache attribute
* handles making applications simpler on both sides.
*/
static const bool IS_SRVC_CHANGED_CHARACT_PRESENT = true;
ble_enable_params_t enableParams = {
.gatts_enable_params = {
.service_changed = IS_SRVC_CHANGED_CHARACT_PRESENT
}
};
if (sd_ble_enable(&enableParams) != NRF_SUCCESS) {
return ERROR_INVALID_PARAM;
}
ble_gap_addr_t addr;
if (sd_ble_gap_address_get(&addr) != NRF_SUCCESS) {
return ERROR_INVALID_PARAM;
}
if (sd_ble_gap_address_set(BLE_GAP_ADDR_CYCLE_MODE_NONE, &addr) != NRF_SUCCESS) {
return ERROR_INVALID_PARAM;
}
ASSERT_STATUS( softdevice_ble_evt_handler_set(btle_handler));
ASSERT_STATUS( softdevice_sys_evt_handler_set(sys_evt_dispatch));
#if NEED_BOND_MANAGER /* disabled by default */
bond_manager_init();
#endif
btle_gap_init();
return ERROR_NONE;
}
ble_error_t nRF5xGap::setAddress(AddressType_t type, const Address_t address)
{
if (type > ADDR_TYPE_RANDOM_PRIVATE_NON_RESOLVABLE) {
return BLE_ERROR_PARAM_OUT_OF_RANGE;
}
ble_gap_addr_t dev_addr;
dev_addr.addr_type = type;
memcpy(dev_addr.addr, address, ADDR_LEN);
ASSERT_INT(ERROR_NONE, sd_ble_gap_address_set(BLE_GAP_ADDR_CYCLE_MODE_NONE, &dev_addr), BLE_ERROR_PARAM_OUT_OF_RANGE);
return BLE_ERROR_NONE;
}
error_t btle_init(void)
{
nrf_clock_lfclksrc_t clockSource;
if (NRF_CLOCK->LFCLKSRC & (CLOCK_LFCLKSRC_SRC_Xtal << CLOCK_LFCLKSRC_SRC_Pos)) {
clockSource = NRF_CLOCK_LFCLKSRC_XTAL_20_PPM;
} else {
clockSource = NRF_CLOCK_LFCLKSRC_RC_250_PPM_4000MS_CALIBRATION;
}
SOFTDEVICE_HANDLER_INIT(clockSource, eventHandler);
// Enable BLE stack
/**
* Using this call, the application can select whether to include the
* Service Changed characteristic in the GATT Server. The default in all
* previous releases has been to include the Service Changed characteristic,
* but this affects how GATT clients behave. Specifically, it requires
* clients to subscribe to this attribute and not to cache attribute handles
* between connections unless the devices are bonded. If the application
* does not need to change the structure of the GATT server attributes at
* runtime this adds unnecessary complexity to the interaction with peer
* clients. If the SoftDevice is enabled with the Service Changed
* Characteristics turned off, then clients are allowed to cache attribute
* handles making applications simpler on both sides.
*/
static const bool IS_SRVC_CHANGED_CHARACT_PRESENT = true;
ble_enable_params_t enableParams = {
.gatts_enable_params = {
.service_changed = IS_SRVC_CHANGED_CHARACT_PRESENT,
.attr_tab_size = gatt_table_size
}
};
if (sd_ble_enable(&enableParams) != NRF_SUCCESS) {
return ERROR_INVALID_PARAM;
}
ble_gap_addr_t addr;
if (sd_ble_gap_address_get(&addr) != NRF_SUCCESS) {
return ERROR_INVALID_PARAM;
}
if (sd_ble_gap_address_set(BLE_GAP_ADDR_CYCLE_MODE_NONE, &addr) != NRF_SUCCESS) {
return ERROR_INVALID_PARAM;
}
ASSERT_STATUS( softdevice_ble_evt_handler_set(btle_handler));
ASSERT_STATUS( softdevice_sys_evt_handler_set(sys_evt_dispatch));
return btle_gap_init();
}
static ret_code_t address_set_v2(uint8_t cycle_mode, ble_gap_addr_t * p_addr)
{
NRF_PM_DEBUG_CHECK(p_addr != NULL);
ret_code_t ret = sd_ble_gap_address_set(cycle_mode, p_addr);
switch (ret)
{
case NRF_SUCCESS:
case NRF_ERROR_BUSY:
case NRF_ERROR_INVALID_STATE:
case NRF_ERROR_INVALID_PARAM: // If cycle_mode is not AUTO or NONE.
case BLE_ERROR_GAP_INVALID_BLE_ADDR: // If the GAP address is not valid.
return ret;
default:
return NRF_ERROR_INTERNAL;
}
}
void Node::ConfigurationLoadedHandler()
{
u32 err;
//If config is unset, set to default
if (persistentConfig.version == 0xFF)
{
logt("NODE", "config was empty, default config set");
persistentConfig.version = 0;
persistentConfig.connectionLossCounter = 0;
persistentConfig.networkId = Config->meshNetworkIdentifier;
persistentConfig.reserved = 0;
//Get a random number for the connection loss counter (hard on system start,...stat)
while(persistentConfig.connectionLossCounter == 0){
sd_rand_application_vector_get((u8*) &persistentConfig.connectionLossCounter, 2);
}
//Get an id for our testdevices when not working with persistent storage
InitWithTestDeviceSettings();
}
clusterId = this->GenerateClusterID();
//Set the BLE address so that we have the same on every startup
err = sd_ble_gap_address_set(BLE_GAP_ADDR_CYCLE_MODE_NONE, &persistentConfig.nodeAddress);
APP_ERROR_CHECK(err);
//Init softdevice and c libraries
ScanController::Initialize();
AdvertisingController::Initialize(persistentConfig.networkId);
//Fill JOIN_ME packet with data
this->UpdateJoinMePacket(NULL);
//Print configuration and start node
logt("NODE", "Config loaded nodeId:%d, connLossCount:%u, netowrkId:%d", persistentConfig.nodeId, persistentConfig.connectionLossCounter, persistentConfig.networkId);
//Go to Discovery
ChangeState(discoveryState::DISCOVERY);
}
/**@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.
*/
void gap_params_init(void)
{
uint32_t err_code = NRF_SUCCESS;
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);
sd_ble_gap_tx_power_set(gap_tx_power);
/*
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_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);
ble_gap_addr_t gap_address;
memset(&gap_address, 0, sizeof(gap_address));
//TODO: BLE_GAP_ADDR_TYPE_RANDOM_PRIVATE_RESOLVABLE & IRK
gap_address.addr_type = BLE_GAP_ADDR_TYPE_PUBLIC;
for (uint8_t i = 0; i < BLE_GAP_ADDR_LEN; i++) //Only last byte differs.
{
gap_address.addr[BLE_GAP_ADDR_LEN - 1 - i] = l_device_address[i];
}
//TODO: BLE_GAP_ADDR_CYCLE_MODE_AUTO
err_code = sd_ble_gap_address_set(BLE_GAP_ADDR_CYCLE_MODE_NONE, &gap_address);
APP_ERROR_CHECK(err_code);// Check for errors
}
/**@brief Function for initializing the BLE stack.
*
* @details Initializes the SoftDevice and the BLE event interrupt.
*/
static void ble_stack_init (void) {
uint32_t err_code;
// Initialize the SoftDevice handler module.
SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_RC_250_PPM_8000MS_CALIBRATION,
false);
// Enable BLE stack
ble_enable_params_t ble_enable_params;
memset(&ble_enable_params, 0, sizeof(ble_enable_params));
ble_enable_params.gatts_enable_params.service_changed = IS_SRVC_CHANGED_CHARACT_PRESENT;
err_code = sd_ble_enable(&ble_enable_params);
APP_ERROR_CHECK(err_code);
//Register with the SoftDevice handler module for BLE events.
err_code = softdevice_ble_evt_handler_set(ble_evt_dispatch);
APP_ERROR_CHECK(err_code);
// Register with the SoftDevice handler module for BLE events.
err_code = softdevice_sys_evt_handler_set(sys_evt_dispatch);
APP_ERROR_CHECK(err_code);
// Set the MAC address of the device
{
ble_gap_addr_t gap_addr;
// Get the current original address
sd_ble_gap_address_get(&gap_addr);
// Set the new BLE address with the Michigan OUI
gap_addr.addr_type = BLE_GAP_ADDR_TYPE_PUBLIC;
memcpy(gap_addr.addr+2, MAC_ADDR+2, sizeof(gap_addr.addr)-2);
err_code = sd_ble_gap_address_set(BLE_GAP_ADDR_CYCLE_MODE_NONE,
&gap_addr);
APP_ERROR_CHECK(err_code);
}
}
uint32_t softdevice_handler_init(nrf_clock_lfclksrc_t clock_source,
void * p_evt_buffer,
uint16_t evt_buffer_size,
softdevice_evt_schedule_func_t evt_schedule_func)
{
uint32_t err_code;
// Save configuration.
#if defined (BLE_STACK_SUPPORT_REQD) || defined (ANT_STACK_SUPPORT_REQD)
// Check that buffer is not NULL.
if (p_evt_buffer == NULL)
{
return NRF_ERROR_INVALID_PARAM;
}
// Check that buffer is correctly aligned.
if (!is_word_aligned(p_evt_buffer))
{
return NRF_ERROR_INVALID_PARAM;
}
m_evt_buffer = (uint8_t *)p_evt_buffer;
#else
// The variable p_evt_buffer is not needed if neither BLE Stack nor ANT stack support is
// required.
UNUSED_PARAMETER(p_evt_buffer);
#endif
#if defined (BLE_STACK_SUPPORT_REQD)
m_ble_evt_buffer_size = evt_buffer_size;
#else
// The variable evt_buffer_size is not needed if BLE Stack support is NOT required.
UNUSED_PARAMETER(evt_buffer_size);
#endif
m_evt_schedule_func = evt_schedule_func;
// Initialize SoftDevice.
err_code = sd_softdevice_enable(clock_source, softdevice_assertion_handler);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
/**
* Using this call, the application can select whether to include the
* Service Changed characteristic in the GATT Server. The default in all
* previous releases has been to include the Service Changed characteristic,
* but this affects how GATT clients behave. Specifically, it requires
* clients to subscribe to this attribute and not to cache attribute handles
* between connections unless the devices are bonded. If the application
* does not need to change the structure of the GATT server attributes at
* runtime this adds unnecessary complexity to the interaction with peer
* clients. If the SoftDevice is enabled with the Service Changed
* Characteristics turned off, then clients are allowed to cache attribute
* handles making applications simpler on both sides.
*/
ble_enable_params_t enableParams = {
.gatts_enable_params = {
.service_changed = 0
}
};
if ((err_code = sd_ble_enable(&enableParams)) != NRF_SUCCESS) {
return err_code;
}
ble_gap_addr_t addr;
if ((err_code = sd_ble_gap_address_get(&addr)) != NRF_SUCCESS) {
return err_code;
}
if ((err_code = sd_ble_gap_address_set(BLE_GAP_ADDR_CYCLE_MODE_NONE, &addr)) != NRF_SUCCESS) {
return err_code;
}
m_softdevice_enabled = true;
// Enable BLE event interrupt (interrupt priority has already been set by the stack).
return sd_nvic_EnableIRQ(SWI2_IRQn);
}
/**
* @brief Initialize Generic Access Profile (GAP)
*/
void init_gap()
{
ble_gap_conn_params_t gap_conn_params;
ble_gap_conn_sec_mode_t security_mode;
/*
* Set security mode
*/
BLE_GAP_CONN_SEC_MODE_SET_OPEN(&security_mode);
uint32_t retval =
sd_ble_gap_device_name_set(
&security_mode,
(const uint8_t*) BLE_DEVICE_NAME,
strlen(BLE_DEVICE_NAME)
);
APP_ERROR_CHECK(retval);
/*
* Set connection parameters
*/
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;
retval =
sd_ble_gap_ppcp_set(&gap_conn_params);
APP_ERROR_CHECK(retval);
/*
* Change MAC address, if necessary
*/
ble_gap_addr_t gap_address;
retval =
sd_ble_gap_address_get(&gap_address);
APP_ERROR_CHECK(retval);
/*
printf("Dis' your default MAC: %x:%x:%x:%x:%x:%x\n",
gap_address.addr[5],
gap_address.addr[4],
gap_address.addr[3],
gap_address.addr[2],
gap_address.addr[1],
gap_address.addr[0]
);
*/
gap_address.addr_type = BLE_GAP_ADDR_TYPE_PUBLIC;
retval =
sd_ble_gap_address_set(BLE_GAP_ADDR_CYCLE_MODE_NONE, &gap_address);
APP_ERROR_CHECK(retval);
// gap_address.addr_type = BLE_GAP_ADDR_TYPE_RANDOM_PRIVATE_NON_RESOLVABLE;
// sd_ble_gap_address_set(BLE_GAP_ADDR_CYCLE_MODE_AUTO, &gap_address);
/*
printf("MAC address, I choose you: %x:%x:%x:%x:%x:%x\n",
gap_address.addr[5],
gap_address.addr[4],
gap_address.addr[3],
gap_address.addr[2],
gap_address.addr[1],
gap_address.addr[0]
);
*/
}