This post is older than 2 years and might not be relevant anymore
More Info: Consider searching for newer posts

Bootloader DFU stop advertising after updating new firmware

Hello,

I'm using this example of code (nRF5_SDK_11.0.0_89a8197\examples\dfu\bootloader\pca10040\dual_bank_ble_s132\arm5_no_packs) with my custom board  to perform a dfu. So in this it"s seems to support use of button but in my case there is no button on board so i disabled the below code:

//dfu_start |= ((nrf_gpio_pin_read(BOOTLOADER_BUTTON) == 0) ? true: false);

and all  related function thats use BOOTLOADER_BUTTON.

1. is the desactivation of the button code can run the app as if there was no button on board or there is another trick to enter the DFUmode without using the button. ? 

2. I have another issue ; i have downloaded an hex file over the air, the DFU work well , and bootloader give control to the application but stop advertinsing.as "DfuTrgt" si i can't perform another dfu . Do you have any idea where and how to change code  in order to perform dfu again even if application ?

Best regards

Parents Reply Children
  • Hi

    yes i have already follow this link and i have add all files which required tu support dfu in app. So, when programme the new app with this modification my app stop advertising "HRM_Blinky". I have runned it in debug mode (Im using keil ) the software do not jump on "advertising_start()" .

    Here the modification that's i made on main.c (experimental_ble_app_blinky project) :

    /* Copyright (c) 2015 Nordic Semiconductor. All Rights Reserved.
     *
     * The information contained herein is property of Nordic Semiconductor ASA.
     * Terms and conditions of usage are described in detail in NORDIC
     * SEMICONDUCTOR STANDARD SOFTWARE LICENSE AGREEMENT.
     *
     * Licensees are granted free, non-transferable use of the information. NO
     * WARRANTY of ANY KIND is provided. This heading must NOT be removed from
     * the file.
     *
     */
    
    /** 
     * @brief Blinky Sample Application main file.
     *
     * This file contains the source code for a sample server application using the LED Button service.
     */
    
    #include <stdint.h>
    #include <string.h>
    #include "nordic_common.h"
    #include "nrf.h"
    #include "app_error.h"
    #include "ble.h"
    #include "ble_hci.h"
    #include "ble_srv_common.h"
    #include "ble_advdata.h"
    #include "ble_conn_params.h"
    #include "softdevice_handler.h"
    #include "app_timer.h"
    #include "app_button.h"
    #include "ble_lbs.h"
    #include "bsp.h"
    #include "ble_gap.h"
    #ifdef BLE_DFU_APP_SUPPORT
    #include "ble_dfu.h"
    #include "dfu_app_handler.h"
    #endif // BLE_DFU_APP_SUPPORT
    #include "ble_advertising.h"
    #include "ble_bas.h"
    #include "ble_dis.h"
    #include "device_manager.h"
    #include "pstorage.h"
    #include "nrf_delay.h"
    
    #define IS_SRVC_CHANGED_CHARACT_PRESENT  1                                          /**< Include or not the service_changed characteristic. if not enabled, the server's database cannot be changed for the lifetime of the device*/
    
    #define CENTRAL_LINK_COUNT              0                                           /**< Number of central links used by the application. When changing this number remember to adjust the RAM settings*/
    #define PERIPHERAL_LINK_COUNT           1                                           /**< Number of peripheral links used by the application. When changing this number remember to adjust the RAM settings*/
    
    #define ADVERTISING_LED_PIN             BSP_LED_0_MASK                              /**< Is on when device is advertising. */
    #define CONNECTED_LED_PIN               BSP_LED_0_MASK                              /**< Is on when device has connected. */
    
    #define LEDBUTTON_LED_PIN               BSP_LED_0_MASK                              /**< LED to be toggled with the help of the LED Button Service. */
    //#define LEDBUTTON_BUTTON_PIN            BSP_BUTTON_0                                /**< Button that will trigger the notification event with the LED Button Service */
    
    #define DEVICE_NAME                     "Nordic_Blinky"                             /**< Name of device. Will be included in the advertising data. */
    
    #define APP_ADV_INTERVAL                64                                          /**< The advertising interval (in units of 0.625 ms; this value corresponds to 40 ms). */
    #define APP_ADV_TIMEOUT_IN_SECONDS      BLE_GAP_ADV_TIMEOUT_GENERAL_UNLIMITED       /**< The advertising time-out (in units of seconds). When set to 0, we will never time out. */
    
    #define APP_TIMER_PRESCALER             0                                           /**< Value of the RTC1 PRESCALER register. */
    #define APP_TIMER_MAX_TIMERS            6                                           /**< Maximum number of simultaneously created timers. */
    #define APP_TIMER_OP_QUEUE_SIZE         4                                           /**< Size of timer operation queues. */
    
    #define MIN_CONN_INTERVAL               MSEC_TO_UNITS(100, UNIT_1_25_MS)            /**< Minimum acceptable connection interval (0.5 seconds). */
    #define MAX_CONN_INTERVAL               MSEC_TO_UNITS(200, UNIT_1_25_MS)            /**< Maximum acceptable connection interval (1 second). */
    #define SLAVE_LATENCY                   0                                           /**< Slave latency. */
    #define CONN_SUP_TIMEOUT                MSEC_TO_UNITS(4000, UNIT_10_MS)             /**< Connection supervisory time-out (4 seconds). */
    #define FIRST_CONN_PARAMS_UPDATE_DELAY  APP_TIMER_TICKS(20000, APP_TIMER_PRESCALER) /**< Time from initiating event (connect or start of notification) to first time sd_ble_gap_conn_param_update is called (15 seconds). */
    #define NEXT_CONN_PARAMS_UPDATE_DELAY   APP_TIMER_TICKS(5000, APP_TIMER_PRESCALER)  /**< Time between each call to sd_ble_gap_conn_param_update after the first call (5 seconds). */
    #define MAX_CONN_PARAMS_UPDATE_COUNT    3                                           /**< Number of attempts before giving up the connection parameter negotiation. */
    
    #define SEC_PARAM_BOND                   1                                          /**< Perform bonding. */
    #define SEC_PARAM_MITM                   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 APP_GPIOTE_MAX_USERS            1                                           /**< Maximum number of users of the GPIOTE handler. */
    #define BUTTON_DETECTION_DELAY          APP_TIMER_TICKS(50, APP_TIMER_PRESCALER)    /**< Delay from a GPIOTE event until a button is reported as pushed (in number of timer ticks). */
    
    #define DEAD_BEEF                       0xDEADBEEF                                  /**< Value used as error code on stack dump, can be used to identify stack location on stack unwind. */
    
    #ifdef BLE_DFU_APP_SUPPORT
    #define DFU_REV_MAJOR                    0x00                                       /** DFU Major revision number to be exposed. */
    #define DFU_REV_MINOR                    0x01                                       /** DFU Minor revision number to be exposed. */
    #define DFU_REVISION                     ((DFU_REV_MAJOR << 8) | DFU_REV_MINOR)     /** DFU Revision number to be exposed. Combined of major and minor versions. */
    #define APP_SERVICE_HANDLE_START         0x000C                                     /**< Handle of first application specific service when when service changed characteristic is present. */
    #define BLE_HANDLE_MAX                   0xFFFF                                     /**< Max handle value in BLE. */
    
    STATIC_ASSERT(IS_SRVC_CHANGED_CHARACT_PRESENT);                                     /** When having DFU Service support in application the Service Changed Characteristic should always be present. */
    #endif // BLE_DFU_APP_SUPPORT
    
    #ifdef BLE_DFU_APP_SUPPORT
    static ble_dfu_t                         m_dfus;                                    /**< Structure used to identify the DFU service. */
    #endif // BLE_DFU_APP_SUPPORT
    
    static uint16_t                         m_conn_handle = BLE_CONN_HANDLE_INVALID;    /**< Handle of the current connection. */
    static ble_lbs_t                        m_lbs;                                      /**< LED Button Service instance. */
    
    static dm_application_instance_t         m_app_handle;                              /**< Application identifier allocated by device manager */
    /**@brief Function for assert macro callback.
     *
     * @details This function will be called in case of an assert in the SoftDevice.
     *
     * @warning This handler is an example only and does not fit a final product. You need to analyze 
     *          how your product is supposed to react in case of Assert.
     * @warning On assert from the SoftDevice, the system can only recover on reset.
     *
     * @param[in] line_num    Line number of the failing ASSERT call.
     * @param[in] p_file_name File name of the failing ASSERT call.
     */
    void assert_nrf_callback(uint16_t line_num, const uint8_t * p_file_name)
    {
        app_error_handler(DEAD_BEEF, line_num, p_file_name);
    }
    
    
    /**@brief Function for the LEDs initialization.
     *
     * @details Initializes all LEDs used by the application.
     */
    static void leds_init(void)
    {
    	  //LEDS_CONFIGURE(ADVERTISING_LED_PIN | CONNECTED_LED_PIN | LEDBUTTON_LED_PIN);
        //LEDS_OFF(ADVERTISING_LED_PIN | CONNECTED_LED_PIN | LEDBUTTON_LED_PIN);
    	
        LEDS_CONFIGURE(ADVERTISING_LED_PIN | CONNECTED_LED_PIN );
        LEDS_OFF(ADVERTISING_LED_PIN | CONNECTED_LED_PIN );	
    }
    
    
    /**@brief Function for the Timer initialization.
     *
     * @details Initializes the timer module.
     */
    static void timers_init(void)
    {
        // Initialize timer module, making it use the scheduler
        APP_TIMER_INIT(APP_TIMER_PRESCALER, APP_TIMER_OP_QUEUE_SIZE, false);
    }
    
    
    /**@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_CONN_SEC_MODE_SET_OPEN(&sec_mode);
    
        err_code = sd_ble_gap_device_name_set(&sec_mode,
                                              (const uint8_t *)DEVICE_NAME,
                                              strlen(DEVICE_NAME));
        APP_ERROR_CHECK(err_code);
    
        memset(&gap_conn_params, 0, sizeof(gap_conn_params));
    
        gap_conn_params.min_conn_interval = MIN_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);
    }
    
    
    #ifdef BLE_DFU_APP_SUPPORT
    /**@brief Function for stopping advertising.
     */
    static void advertising_stop(void)
    {
        uint32_t err_code;
    
        err_code = sd_ble_gap_adv_stop();
        APP_ERROR_CHECK(err_code);
    
        err_code = bsp_indication_set(BSP_INDICATE_IDLE);
        APP_ERROR_CHECK(err_code);
    }
    
    
    /**@brief Function for loading application-specific context after establishing a secure connection.
     *
     * @details This function will load the application context and check if the ATT table is marked as
     *          changed. If the ATT table is marked as changed, a Service Changed Indication
     *          is sent to the peer if the Service Changed CCCD is set to indicate.
     *
     * @param[in] p_handle The Device Manager handle that identifies the connection for which the context
     *                     should be loaded.
     */
    static void app_context_load(dm_handle_t const * p_handle)
    {
        uint32_t                 err_code;
        static uint32_t          context_data;
        dm_application_context_t context;
    
        context.len    = sizeof(context_data);
        context.p_data = (uint8_t *)&context_data;
    
        err_code = dm_application_context_get(p_handle, &context);
        if (err_code == NRF_SUCCESS)
        {
            // Send Service Changed Indication if ATT table has changed.
            if ((context_data & (DFU_APP_ATT_TABLE_CHANGED << DFU_APP_ATT_TABLE_POS)) != 0)
            {
                err_code = sd_ble_gatts_service_changed(m_conn_handle, APP_SERVICE_HANDLE_START, BLE_HANDLE_MAX);
                if ((err_code != NRF_SUCCESS) &&
                    (err_code != BLE_ERROR_INVALID_CONN_HANDLE) &&
                    (err_code != NRF_ERROR_INVALID_STATE) &&
                    (err_code != BLE_ERROR_NO_TX_PACKETS) &&
                    (err_code != NRF_ERROR_BUSY) &&
                    (err_code != BLE_ERROR_GATTS_SYS_ATTR_MISSING))
                {
                    APP_ERROR_HANDLER(err_code);
                }
            }
    
            err_code = dm_application_context_delete(p_handle);
            APP_ERROR_CHECK(err_code);
        }
        else if (err_code == DM_NO_APP_CONTEXT)
        {
            // No context available. Ignore.
        }
        else
        {
            APP_ERROR_HANDLER(err_code);
        }
    }
    
    
    /** @snippet [DFU BLE Reset prepare] */
    /**@brief Function for preparing for system reset.
     *
     * @details This function implements @ref dfu_app_reset_prepare_t. It will be called by
     *          @ref dfu_app_handler.c before entering the bootloader/DFU.
     *          This allows the current running application to shut down gracefully.
     */
    static void reset_prepare(void)
    {
        uint32_t err_code;
    
        if (m_conn_handle != BLE_CONN_HANDLE_INVALID)
        {
            // Disconnect from peer.
            err_code = sd_ble_gap_disconnect(m_conn_handle, BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
            APP_ERROR_CHECK(err_code);
            err_code = bsp_indication_set(BSP_INDICATE_IDLE);
            APP_ERROR_CHECK(err_code);
        }
        else
        {
            // If not connected, the device will be advertising. Hence stop the advertising.
            advertising_stop();
        }
    
        err_code = ble_conn_params_stop();
        APP_ERROR_CHECK(err_code);
    
        nrf_delay_ms(500);
    }
    /** @snippet [DFU BLE Reset prepare] */
    #endif // BLE_DFU_APP_SUPPORT
    
    
    
    /**@brief Function for handling the Device Manager events.
     *
     * @param[in] p_evt  Data associated to the device manager event.
     */
    static uint32_t device_manager_evt_handler(dm_handle_t const * p_handle,
                                               dm_event_t const  * p_event,
                                               ret_code_t        event_result)
    {
        APP_ERROR_CHECK(event_result);
    
    #ifdef BLE_DFU_APP_SUPPORT
        if (p_event->event_id == DM_EVT_LINK_SECURED)
        {
            app_context_load(p_handle);
        }
    #endif // BLE_DFU_APP_SUPPORT
    
        return NRF_SUCCESS;
    }
    
    
    /**@brief Function for the Device Manager initialization.
     *
     * @param[in] erase_bonds  Indicates whether bonding information should be cleared from
     *                         persistent storage during initialization of the Device Manager.
     */
    static void device_manager_init(bool erase_bonds)
    {
        uint32_t               err_code;
        dm_init_param_t        init_param = {.clear_persistent_data = erase_bonds};
        dm_application_param_t register_param;
    
        // Initialize persistent storage module.
        err_code = pstorage_init();
        APP_ERROR_CHECK(err_code);
    
        err_code = dm_init(&init_param);
        APP_ERROR_CHECK(err_code);
    
        memset(&register_param.sec_param, 0, sizeof(ble_gap_sec_params_t));
    
        register_param.sec_param.bond         = SEC_PARAM_BOND;
        register_param.sec_param.mitm         = SEC_PARAM_MITM;
        register_param.sec_param.lesc         = SEC_PARAM_LESC;
        register_param.sec_param.keypress     = SEC_PARAM_KEYPRESS;
        register_param.sec_param.io_caps      = SEC_PARAM_IO_CAPABILITIES;
        register_param.sec_param.oob          = SEC_PARAM_OOB;
        register_param.sec_param.min_key_size = SEC_PARAM_MIN_KEY_SIZE;
        register_param.sec_param.max_key_size = SEC_PARAM_MAX_KEY_SIZE;
        register_param.evt_handler            = device_manager_evt_handler;
        register_param.service_type           = DM_PROTOCOL_CNTXT_GATT_SRVR_ID;
    
        err_code = dm_register(&m_app_handle, &register_param);
        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;
        ble_advdata_t scanrsp;
    
        ble_uuid_t adv_uuids[] = {{LBS_UUID_SERVICE, m_lbs.uuid_type}};
    
        // Build and set advertising data
        memset(&advdata, 0, sizeof(advdata));
    
        advdata.name_type          = BLE_ADVDATA_FULL_NAME;
        advdata.include_appearance = true;
        advdata.flags              = BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE;
    
    
        memset(&scanrsp, 0, sizeof(scanrsp));
        scanrsp.uuids_complete.uuid_cnt = sizeof(adv_uuids) / sizeof(adv_uuids[0]);
        scanrsp.uuids_complete.p_uuids  = adv_uuids;
    
        err_code = ble_advdata_set(&advdata, &scanrsp);
        APP_ERROR_CHECK(err_code);
    }
    
    
    /**@brief Function for handling write events to the LED characteristic.
     *
     * @param[in] p_lbs     Instance of LED Button Service to which the write applies.
     * @param[in] led_state Written/desired state of the LED.
     */
    static void led_write_handler(ble_lbs_t * p_lbs, uint8_t led_state)
    {
        if (led_state)
        {
            LEDS_ON(LEDBUTTON_LED_PIN);
        }
        else
        {
            LEDS_OFF(LEDBUTTON_LED_PIN);
        }
    }
    
    
    /**@brief Function for initializing services that will be used by the application.
     */
    static void services_init(void)
    {
        uint32_t       err_code;
        ble_lbs_init_t init;
    
        init.led_write_handler = led_write_handler;
    
        err_code = ble_lbs_init(&m_lbs, &init);
        APP_ERROR_CHECK(err_code);
    	
    	
    #ifdef BLE_DFU_APP_SUPPORT
        /** @snippet [DFU BLE Service initialization] */
        ble_dfu_init_t   dfus_init;
    
        // Initialize the Device Firmware Update Service.
        memset(&dfus_init, 0, sizeof(dfus_init));
    
        dfus_init.evt_handler   = dfu_app_on_dfu_evt;
        dfus_init.error_handler = NULL;
        dfus_init.evt_handler   = dfu_app_on_dfu_evt;
        dfus_init.revision      = DFU_REVISION;
    
        err_code = ble_dfu_init(&m_dfus, &dfus_init);
        APP_ERROR_CHECK(err_code);
    
        dfu_app_reset_prepare_set(reset_prepare);
        dfu_app_dm_appl_instance_set(m_app_handle);
        /** @snippet [DFU BLE Service initialization] */
    #endif // BLE_DFU_APP_SUPPORT
    }
    
    
    /**@brief Function for handling the Connection Parameters Module.
     *
     * @details This function will be called for all events in the Connection Parameters Module that
     *          are passed to the application.
     *
     * @note All this function does is to disconnect. This could have been done by simply
     *       setting the disconnect_on_fail config parameter, but instead we use the event
     *       handler mechanism to demonstrate its use.
     *
     * @param[in] p_evt  Event received from the Connection Parameters Module.
     */
    static void on_conn_params_evt(ble_conn_params_evt_t * p_evt)
    {
        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);
        }
    }
    
    
    /**@brief Function for handling a Connection Parameters error.
     *
     * @param[in] nrf_error  Error code containing information about what went wrong.
     */
    static void conn_params_error_handler(uint32_t nrf_error)
    {
        APP_ERROR_HANDLER(nrf_error);
    }
    
    
    /**@brief Function for initializing the Connection Parameters module.
     */
    static void conn_params_init(void)
    {
        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;
        cp_init.evt_handler                    = on_conn_params_evt;
        cp_init.error_handler                  = conn_params_error_handler;
    
        err_code = ble_conn_params_init(&cp_init);
        APP_ERROR_CHECK(err_code);
    }
    
    
    /**@brief Function for starting advertising.
     */
    static void advertising_start(void)
    {
        uint32_t             err_code;
        ble_gap_adv_params_t adv_params;
    
        // Start advertising
        memset(&adv_params, 0, sizeof(adv_params));
    
        adv_params.type        = BLE_GAP_ADV_TYPE_ADV_IND;
        adv_params.p_peer_addr = NULL;
        adv_params.fp          = BLE_GAP_ADV_FP_ANY;
        adv_params.interval    = APP_ADV_INTERVAL;
        adv_params.timeout     = APP_ADV_TIMEOUT_IN_SECONDS;
    
        err_code = sd_ble_gap_adv_start(&adv_params);
        APP_ERROR_CHECK(err_code);
        LEDS_ON(ADVERTISING_LED_PIN);
    }
    
    
    /**@brief Function for handling the Application's BLE stack events.
     *
     * @param[in] p_ble_evt  Bluetooth stack event.
     */
    static void on_ble_evt(ble_evt_t * p_ble_evt)
    {
        uint32_t err_code;
    
        switch (p_ble_evt->header.evt_id)
        {
            case BLE_GAP_EVT_CONNECTED:
                LEDS_ON(CONNECTED_LED_PIN);
                LEDS_OFF(ADVERTISING_LED_PIN);
                m_conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
    
                err_code = app_button_enable();
                APP_ERROR_CHECK(err_code);
                break;
    
            case BLE_GAP_EVT_DISCONNECTED:
                LEDS_OFF(CONNECTED_LED_PIN);
                m_conn_handle = BLE_CONN_HANDLE_INVALID;
    
                err_code = app_button_disable();
                APP_ERROR_CHECK(err_code);
    
                advertising_start();
                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;
    
            default:
                // No implementation needed.
                break;
        }
    }
    
    
    /**@brief Function for dispatching a BLE stack event to all modules with a BLE stack event handler.
     *
     * @details This function is called from the scheduler in the main loop after a BLE stack
     *          event has been received.
     *
     * @param[in] p_ble_evt  Bluetooth stack event.
     */
    static void ble_evt_dispatch(ble_evt_t * p_ble_evt)
    {
        on_ble_evt(p_ble_evt);
        ble_conn_params_on_ble_evt(p_ble_evt);
        ble_lbs_on_ble_evt(&m_lbs, p_ble_evt);
    #ifdef BLE_DFU_APP_SUPPORT
        /** @snippet [Propagating BLE Stack events to DFU Service] */
        ble_dfu_on_ble_evt(&m_dfus, p_ble_evt);
        /** @snippet [Propagating BLE Stack events to DFU Service] */
    #endif // BLE_DFU_APP_SUPPORT
    }
    
    
    /**@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(CENTRAL_LINK_COUNT,
                                                        PERIPHERAL_LINK_COUNT,
                                                        &ble_enable_params);
        APP_ERROR_CHECK(err_code);
    #ifdef BLE_DFU_APP_SUPPORT
        ble_enable_params.gatts_enable_params.service_changed = 1;
    #endif // BLE_DFU_APP_SUPPORT
        //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 handling events from the button handler module.
     *
     * @param[in] pin_no        The pin that the event applies to.
     * @param[in] button_action The button action (press/release).
     */
    //static void button_event_handler(uint8_t pin_no, uint8_t button_action)
    //{
    //    uint32_t err_code;
    
    //    switch (pin_no)
    //    {
    //        case LEDBUTTON_BUTTON_PIN:
    //            err_code = ble_lbs_on_button_change(&m_lbs, button_action);
    //            if (err_code != NRF_SUCCESS &&
    //                err_code != BLE_ERROR_INVALID_CONN_HANDLE &&
    //                err_code != NRF_ERROR_INVALID_STATE)
    //            {
    //                APP_ERROR_CHECK(err_code);
    //            }
    //            break;
    
    //        default:
    //            APP_ERROR_HANDLER(pin_no);
    //            break;
    //    }
    //}
    
    
    /**@brief Function for initializing the button handler module.
     */
    //static void buttons_init(void)
    //{
    //    uint32_t err_code;
    
    //    //The array must be static because a pointer to it will be saved in the button handler module.
    //    static app_button_cfg_t buttons[] =
    //    {
    //        {LEDBUTTON_BUTTON_PIN, false, BUTTON_PULL, button_event_handler}
    //    };
    
    //    err_code = app_button_init(buttons, sizeof(buttons) / sizeof(buttons[0]),
    //                               BUTTON_DETECTION_DELAY);
    //    APP_ERROR_CHECK(err_code);
    //}
    
    
    /**@brief Function for the Power Manager.
     */
    static void power_manage(void)
    {
        uint32_t err_code = sd_app_evt_wait();
    
        APP_ERROR_CHECK(err_code);
    }
    
    
    /**@brief Function for application main entry.
     */
    int main(void)
    {
        bool erase_bonds;
    	
    		// Initialize.
        leds_init();
        timers_init();
        //buttons_init();
        ble_stack_init();
        gap_params_init();
        services_init();
        advertising_init();
        conn_params_init();
    		device_manager_init(erase_bonds);
        // Start execution.
        advertising_start();
    
        // Enter main loop.
        for (;;)
        {
            power_manage();
        }
    }
    
    
    /**
     * @}
     */
    

  • I would like to know if the code that's i have added is coorect, if not could you please correct me if i'm looking wrong. I dont have any probleme with debugging application

  • Before we can look into the code, we need to have your debug information. If you don't have any problem with debugging it, you should tell us where exactly the problem happens, where the assertion is. Then we can give you advices or run the test here.

    We can't do the homework for you. 

  • I can't have more debug information because i use DAP Link Debugger . How can I print debug information with this debugger (Nordic use Jlink debugger to have more information)  and in my project i don't have sdk_config.h inside project

Related