自学教程：C++ softdevice_sys_evt_handler_set函数代码示例

/**@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;        nrf_clock_lf_cfg_t clock_lf_cfg = NRF_CLOCK_LFCLKSRC;        // Initialize the SoftDevice handler module.    SOFTDEVICE_HANDLER_INIT(&clock_lf_cfg, ble_new_event_handler);        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);    // 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);}

/* *  Function for initializing the BLE stack. * *  Initializes the SoftDevice and the BLE event interrupt. * *  param[in] init_softdevice  true if SoftDevice should be initialized.  *                             The SoftDevice must only  be initialized  *                             if a chip reset has occured. Soft reset from  *                             application must not reinitialize the SoftDevice. */static void ble_stack_init(bool init_softdevice){    uint32_t         err_code;    sd_mbr_command_t com = {SD_MBR_COMMAND_INIT_SD, };    if (init_softdevice)    {        err_code = sd_mbr_command(&com);        APP_ERROR_CHECK(err_code);    }    err_code = sd_softdevice_vector_table_base_set(BOOTLOADER_REGION_START);    APP_ERROR_CHECK(err_code);    /* Initialize the SoftDevice handler module. See specific board header file */    SOFTDEVICE_HANDLER_INIT(LFCLKSRC_OPTION, NULL);    // 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);    err_code = softdevice_sys_evt_handler_set(sys_evt_dispatch);    APP_ERROR_CHECK(err_code);}

/**@brief Function for initializing the BLE stack. * * @details Initializes the SoftDevice and the BLE event interrupt. * * @param[in] init_softdevice  true if SoftDevice should be initialized. The SoftDevice must only  *                             be initialized if a chip reset has occured. Soft reset from  *                             application must not reinitialize the SoftDevice. */static void ble_stack_init(bool init_softdevice){    uint32_t         err_code;    sd_mbr_command_t com = {SD_MBR_COMMAND_INIT_SD, };    if (init_softdevice)    {        err_code = sd_mbr_command(&com);        APP_ERROR_CHECK(err_code);    }        err_code = sd_softdevice_vector_table_base_set(BOOTLOADER_REGION_START);    APP_ERROR_CHECK(err_code);       SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_XTAL_20_PPM, true);    // 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);        err_code = softdevice_sys_evt_handler_set(sys_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;    // Initialize the SoftDevice handler module.    SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_XTAL_20_PPM, NULL);    // Enable BLE stack.    ble_enable_params_t ble_enable_params;    memset(&ble_enable_params, 0, sizeof(ble_enable_params));#if (defined(S130) || defined(s132))    ble_enable_params.gatts_enable_params.attr_tab_size   = BLE_GATTS_ATTR_TAB_SIZE_DEFAULT;#endif    ble_enable_params.gatts_enable_params.service_changed = false;#ifdef S120    ble_enable_params.gap_enable_params.role              = BLE_GAP_ROLE_CENTRAL;#endif    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 System events.    err_code = softdevice_sys_evt_handler_set(sys_evt_dispatch);    APP_ERROR_CHECK(err_code);}

void BLETransceiver::bleStackInit(void){	uint32_t err_code;	//RP new sequence initialization	//https://devzone.nordicsemi.com/question/18132/softdevice-7071-hangs-on-sd_softdevice_enable/	// Initialize the SoftDevice handler module. Use scheduler	SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_SYNTH_250_PPM, USE_EVENT_SCHEDULER);	//RP new BLE sequence initialization	//https://devzone.nordicsemi.com/question/18132/softdevice-7071-hangs-on-sd_softdevice_enable/	// 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_cb_t)&bleEvtDispatch, (void*) this});	APP_ERROR_CHECK(err_code);	// Register with the SoftDevice handler module for BLE events.	err_code = softdevice_sys_evt_handler_set(sysEvtDispatch);	APP_ERROR_CHECK(err_code);}

/**@brief Function for initializing the BLE stack. * * @details Initializes the SoftDevice and the BLE event interrupt. * * @param[in] init_softdevice  true if SoftDevice should be initialized. The SoftDevice must only  *                             be initialized if a chip reset has occured. Soft reset from  *                             application must not reinitialize the SoftDevice. */static void ble_stack_init(bool init_softdevice){    uint32_t         err_code;    sd_mbr_command_t com = {SD_MBR_COMMAND_INIT_SD, };    if (init_softdevice)    {        err_code = sd_mbr_command(&com);        APP_ERROR_CHECK(err_code);    }        err_code = sd_softdevice_vector_table_base_set(BOOTLOADER_REGION_START);    APP_ERROR_CHECK(err_code);       SOFTDEVICE_HANDLER_APPSH_INIT(NRF_CLOCK_LFCLKSRC_XTAL_20_PPM, true);    // Enable BLE stack     ble_enable_params_t ble_enable_params;    memset(&ble_enable_params, 0, sizeof(ble_enable_params));        // Below code line is needed for s130. For s110 is inrrelevant - but executable    // can run with both s130 and s110.    ble_enable_params.gatts_enable_params.attr_tab_size   = BLE_GATTS_ATTR_TAB_SIZE_DEFAULT;    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);        err_code = softdevice_sys_evt_handler_set(sys_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;    // Initialize the SoftDevice handler module.    SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_XTAL_20_PPM, NULL);    // Enable BLE stack.    ble_enable_params_t ble_enable_params;    memset(&ble_enable_params, 0, sizeof(ble_enable_params));#ifdef S130    ble_enable_params.gatts_enable_params.attr_tab_size   = BLE_GATTS_ATTR_TAB_SIZE_DEFAULT;#endif	    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);}

/**@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, NULL);#if defined(S110) || defined(S130)    // Enable BLE stack.    ble_enable_params_t ble_enable_params;    memset(&ble_enable_params, 0, sizeof(ble_enable_params));#ifdef S130    //ble_enable_params.gatts_enable_params.attr_tab_size   = BLE_GATTS_ATTR_TAB_SIZE_MIN;    //これだと自分のATTが出てこなかった    ble_enable_params.gatts_enable_params.attr_tab_size   = BLE_GATTS_ATTR_TAB_SIZE_MIN;    //これだと自分のATTが出てこなかった    ble_enable_params.gap_enable_params.periph_conn_count = 1;#endif    ble_enable_params.gatts_enable_params.service_changed = IS_SRVC_CHANGED_CHARACT_PRESENT;#ifdef S130    uint32_t app_ram_base = (uint32_t)m_ble_buf;    err_code = sd_ble_enable(&ble_enable_params, &app_ram_base);    APPL_LOG("app_ram_base : %x/n", app_ram_base);#else    err_code = sd_ble_enable(&ble_enable_params);#endif    APP_ERROR_CHECK(err_code);#endif    // 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);}

/**@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;    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(NRF_BLE_CENTRAL_LINK_COUNT,                                                    NRF_BLE_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(NRF_BLE_CENTRAL_LINK_COUNT, NRF_BLE_PERIPHERAL_LINK_COUNT);    // Enable BLE stack.#if (NRF_SD_BLE_API_VERSION == 3)    ble_enable_params.gatt_enable_params.att_mtu = NRF_BLE_GATT_MAX_MTU_SIZE;#endif    err_code = softdevice_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);}

//INIT function that starts up the Softdevice and registers the needed handlersvoid bleInit(void){	u32 err = 0;    // Initialize the SoftDevice handler with the low frequency clock source	//And a reference to the previously allocated buffer	//No event handler is given because the event handling is done in the main loop	//SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_XTAL_20_PPM, NULL);    err = softdevice_handler_init(NRF_CLOCK_LFCLKSRC_XTAL_20_PPM, currentEventBuffer, sizeOfEvent, NULL);    APP_ERROR_CHECK(err);    // Register with the SoftDevice handler module for System events.    err = softdevice_sys_evt_handler_set(sys_evt_dispatch);    APP_ERROR_CHECK(err);	//FOR THE S130 WE MUST NOW CALL sd_ble_enable() TO ENABLE BLE FUNCTIONALITY	//Decide if we include the service changed characteristic in our services	ble_enable_params_t bleSdEnableParams;    memset(&bleSdEnableParams, 0, sizeof(bleSdEnableParams));    bleSdEnableParams.gatts_enable_params.attr_tab_size = ATTR_TABLE_MAX_SIZE;    bleSdEnableParams.gatts_enable_params.service_changed = IS_SRVC_CHANGED_CHARACT_PRESENT;	err = sd_ble_enable(&bleSdEnableParams);    APP_ERROR_CHECK(err);    //Enable DC/DC (needs external LC filter, cmp. nrf51 reference manual page 43)	err = sd_power_dcdc_mode_set(NRF_POWER_DCDC_ENABLE);	APP_ERROR_CHECK(err);	//Set power mode	err = sd_power_mode_set(NRF_POWER_MODE_LOWPWR);	APP_ERROR_CHECK(err);}

/**@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);}

/**@brief Function for ANT stack initialization. * * @details Initializes the SoftDevice and the ANT+BLE event interrupt. */static void softdevice_and_stack_setup(void){    uint32_t err_code;    SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_XTAL_20_PPM, NULL);    ant_state_indicator_init(m_ant_sdm.channel_number, SDM_SENS_CHANNEL_TYPE);    // Initialize 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);    // Subscribe for BLE events.    err_code = softdevice_ble_evt_handler_set(ble_evt_dispatch);    APP_ERROR_CHECK(err_code);            // Subscribe for ANT events.    err_code = softdevice_ant_evt_handler_set(ant_evt_dispatch);    APP_ERROR_CHECK(err_code);#ifdef BONDING_ENABLE    // Register with the SoftDevice handler module for BLE events.    err_code = softdevice_sys_evt_handler_set(sys_evt_dispatch);    APP_ERROR_CHECK(err_code);#endif // BONDING_ENABLE		    err_code = ant_plus_key_set(ANTPLUS_NETWORK_NUMBER);    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, NULL);    // 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 = false;    ble_enable_params.gap_enable_params.role              = BLE_GAP_ROLE_CENTRAL;    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 System events.    err_code = softdevice_sys_evt_handler_set(sys_evt_dispatch);    APP_ERROR_CHECK(err_code);}

/**@brief Function for initializing the BLE stack. * * @details Initializes the SoftDevice and the BLE event interrupt. * * @param[in] init_softdevice  true if SoftDevice should be initialized. The SoftDevice must only  *                             be initialized if a chip reset has occured. Soft reset from  *                             application must not reinitialize the SoftDevice. */static void ble_stack_init(bool init_softdevice){    uint32_t         err_code;    sd_mbr_command_t com = {SD_MBR_COMMAND_INIT_SD, };    nrf_clock_lf_cfg_t clock_lf_cfg = NRF_CLOCK_LFCLKSRC;    if (init_softdevice)    {        err_code = sd_mbr_command(&com);        APP_ERROR_CHECK(err_code);    }        err_code = sd_softdevice_vector_table_base_set(BOOTLOADER_REGION_START);    APP_ERROR_CHECK(err_code);       SOFTDEVICE_HANDLER_APPSH_INIT(&clock_lf_cfg, true);    // Enable BLE stack.    ble_enable_params_t ble_enable_params;    // Only one connection as a central is used when performing dfu.    err_code = softdevice_enable_get_default_config(1, 1, &ble_enable_params);    APP_ERROR_CHECK(err_code);    ble_enable_params.gatts_enable_params.service_changed = IS_SRVC_CHANGED_CHARACT_PRESENT;    err_code = softdevice_enable(&ble_enable_params);    APP_ERROR_CHECK(err_code);        err_code = softdevice_sys_evt_handler_set(sys_evt_dispatch);    APP_ERROR_CHECK(err_code);}

void jshInit() {  jshInitDevices();  nrf_utils_lfclk_config_and_start();  BITFIELD_CLEAR(jshPinSoftPWM);      JshUSARTInfo inf;  jshUSARTInitInfo(&inf);  inf.pinRX = DEFAULT_CONSOLE_RX_PIN;  inf.pinTX = DEFAULT_CONSOLE_TX_PIN;  inf.baudRate = DEFAULT_CONSOLE_BAUDRATE;  jshUSARTSetup(EV_SERIAL1, &inf); // Initialize UART for communication with Espruino/terminal.  init = 1;  // Enable and sort out the timer  nrf_timer_mode_set(NRF_TIMER1,NRF_TIMER_MODE_TIMER);  nrf_timer_bit_width_set(NRF_TIMER1, NRF_TIMER_BIT_WIDTH_32);  nrf_timer_frequency_set(NRF_TIMER1, NRF_TIMER_FREQ_1MHz); // hmm = only a few options here  // Irq setup  NVIC_SetPriority(TIMER1_IRQn, 3); // low - don't mess with BLE :)  NVIC_ClearPendingIRQ(TIMER1_IRQn);  NVIC_EnableIRQ(TIMER1_IRQn);  nrf_timer_int_enable(NRF_TIMER1, NRF_TIMER_INT_COMPARE0_MASK );  // Pin change  nrf_drv_gpiote_init();  jswrap_nrf_bluetooth_init();    // Softdevice is initialised now  softdevice_sys_evt_handler_set(sys_evt_handler);}

/**@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);}

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();}

/**@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;        SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_XTAL_20_PPM, true);    err_code = softdevice_sys_evt_handler_set(sys_evt_dispatch);    APP_ERROR_CHECK(err_code);}

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);}

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;}

/**@brief Function for initializing the BLE stack. * * @details Initializes the SoftDevice and the BLE event interrupt. * * @param[in] init_softdevice  true if SoftDeviceshould be initialized. The SoftDevice must only *                             be initialized if a chip reset has occured. Soft reset from *                             application must not reinitialize the SoftDevice. */static void ble_stack_init(bool init_softdevice){    uint32_t         err_code;    sd_mbr_command_t com = {SD_MBR_COMMAND_INIT_SD, };    if (init_softdevice)    {        err_code = sd_mbr_command(&com);        APP_ERROR_CHECK(err_code);    }    err_code = sd_softdevice_vector_table_base_set(BOOTLOADER_REGION_START);    APP_ERROR_CHECK(err_code);    // TODO: enable if we're on a device with 32kHz xtal    /*nrf_clock_lf_cfg_t clock_lf_cfg = {        .source        = NRF_CLOCK_LF_SRC_XTAL,        .rc_ctiv       = 0,        .rc_temp_ctiv  = 0,        .xtal_accuracy = NRF_CLOCK_LF_XTAL_ACCURACY_20_PPM};*/    nrf_clock_lf_cfg_t clock_lf_cfg = {            .source        = NRF_CLOCK_LF_SRC_RC,            .rc_ctiv       = 16, // recommended for nRF52            .rc_temp_ctiv  = 2,  // recommended for nRF52            .xtal_accuracy = 0};    SOFTDEVICE_HANDLER_APPSH_INIT(&clock_lf_cfg, true);    // Enable BLE stack.    ble_enable_params_t ble_enable_params;    // Only one connection as a central is used when performing dfu.    err_code = softdevice_enable_get_default_config(1, 1, &ble_enable_params);    APP_ERROR_CHECK(err_code);    ble_enable_params.gatts_enable_params.service_changed = IS_SRVC_CHANGED_CHARACT_PRESENT;    err_code = softdevice_enable(&ble_enable_params);    APP_ERROR_CHECK(err_code);    err_code = softdevice_sys_evt_handler_set(sys_evt_dispatch);    APP_ERROR_CHECK(err_code);}/**@brief Function for event scheduler initialization. */static void scheduler_init(void){    APP_SCHED_INIT(SCHED_MAX_EVENT_DATA_SIZE, SCHED_QUEUE_SIZE);}

error_t btle_init(void){    APP_TIMER_INIT(0, 8, 5, false);    SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_XTAL_20_PPM, false);    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;}

/**@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);    // 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 System events.    err_code = softdevice_sys_evt_handler_set(sys_evt_dispatch);    APP_ERROR_CHECK(err_code);}

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();}

/**@brief BLE + ANT stack initialization. * * @details Initializes the SoftDevice and the stack event interrupt. */static void ble_ant_stack_init(void){    // Initialize SoftDevice    SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_XTAL_20_PPM, false);        // Subscribe for BLE events.    uint32_t err_code = softdevice_ble_evt_handler_set(ble_evt_dispatch);    APP_ERROR_CHECK(err_code);            // Subscribe for ANT events.    err_code = softdevice_ant_evt_handler_set(on_ant_evt);    APP_ERROR_CHECK(err_code);#ifdef BONDING_ENABLE    // Register with the SoftDevice handler module for BLE events.    err_code = softdevice_sys_evt_handler_set(sys_evt_dispatch);    APP_ERROR_CHECK(err_code);#endif // BONDING_ENABLE}

/** * /callgraph * @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_SYNTH_250_PPM, NULL);  // 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);}

/**@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;    // 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.attr_tab_size   = BLE_GATTS_ATTR_TAB_SIZE_MIN;    ble_enable_params.gatts_enable_params.service_changed = IS_SRVC_CHANGED_CHARACT_PRESENT;;    ble_enable_params.gap_enable_params.role = BLE_GAP_ROLE_PERIPH;    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);}

/**@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;    // 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 = false;    ble_enable_params.gap_enable_params.role              = BLE_GAP_ROLE_CENTRAL;    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 System events.    err_code = softdevice_sys_evt_handler_set(sys_evt_dispatch);    APP_ERROR_CHECK(err_code);}

/**@brief Function for initializing the BLE stack. * * @details Initializes the SoftDevice and the BLE event interrupt. * * @param[in] init_softdevice  true if SoftDevice should be initialized. The SoftDevice must only  *                             be initialized if a chip reset has occured. Soft reset from  *                             application must not reinitialize the SoftDevice. */static void ble_stack_init(bool init_softdevice){    uint32_t         err_code;    sd_mbr_command_t com = {SD_MBR_COMMAND_INIT_SD, };    // Initialize the SoftDevice handler module.    nrf_clock_lf_cfg_t clock_lf_cfg = NRF_CLOCK_LFCLKSRC;    // Check if the 32 bit crystal does Exist or Not.    if((DFU_DEVICE_INFO->device_type & 0x8000) == 0)    {		clock_lf_cfg.source = NRF_CLOCK_LF_SRC_RC;		clock_lf_cfg.rc_ctiv = 16;		clock_lf_cfg.rc_temp_ctiv = 2;    }    if (init_softdevice)    {        err_code = sd_mbr_command(&com);        APP_ERROR_CHECK(err_code);    }        err_code = sd_softdevice_vector_table_base_set(BOOTLOADER_REGION_START);    APP_ERROR_CHECK(err_code);       SOFTDEVICE_HANDLER_APPSH_INIT(&clock_lf_cfg, true);    // Enable BLE stack.    ble_enable_params_t ble_enable_params;    // Only one connection as a central is used when performing dfu.    err_code = softdevice_enable_get_default_config(1, 1, &ble_enable_params);    APP_ERROR_CHECK(err_code);    ble_enable_params.gatts_enable_params.service_changed = IS_SRVC_CHANGED_CHARACT_PRESENT;    err_code = softdevice_enable(&ble_enable_params);    APP_ERROR_CHECK(err_code);        err_code = softdevice_sys_evt_handler_set(sys_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;    // Initialize the SoftDevice handler module.    SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_XTAL_20_PPM, NULL);    // Enable BLE stack.    ble_enable_params_t ble_enable_params;    memset(&ble_enable_params, 0, sizeof(ble_enable_params));#ifdef S130    ble_enable_params.gatts_enable_params.attr_tab_size   = BLE_GATTS_ATTR_TAB_SIZE_DEFAULT;#endif    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 System events.    err_code = softdevice_sys_evt_handler_set(sys_evt_dispatch);    APP_ERROR_CHECK(err_code);    err_code = softdevice_ant_evt_handler_set(ant_evt_dispatch);    APP_ERROR_CHECK(err_code);    // TODO check this    err_code = ant_stack_static_config();    APP_ERROR_CHECK(err_code);    err_code = sd_ant_network_address_set(ANTPLUS_NETWORK_NUMBER, m_network_key);    APP_ERROR_CHECK(err_code);}