Bootloader DFU stop advertising after updating new firmware

RE: Bootloader DFU stop advertising after updating new firmware

Hung Bui — Tue, 22 Oct 2019 16:06:50 GMT

Hi,

I don't think we have done any qualification of nRF52 with S132v2.0. If you want to use NRF52840 I would suggest to use S140. You would need to port the application in SDK v11 to use S140 instead.
However we strongly suggest you to use our latest SDK for new development.

RE: Bootloader DFU stop advertising after updating new firmware

Geek — Thu, 10 Oct 2019 15:10:28 GMT

Thanks a lot,

i will try and share with you result :).

Can i use the SDK11 and this bootloader with nrf52840, because i plane to move all my developement to this plateform.

Is the SoftDevice s132_v2.0.0 still compatible with nrf52840?

RE: Bootloader DFU stop advertising after updating new firmware

Hung Bui — Thu, 10 Oct 2019 08:51:37 GMT

If you set it to 100 it will advertise at 100-110ms (+10ms randomized to avoid interference) interval. You are free to set it from 20 (ms)to 10000 (ms)

RE: Bootloader DFU stop advertising after updating new firmware

Geek — Wed, 09 Oct 2019 14:28:01 GMT

#define APP_ADV_INTERVAL                     MSEC_TO_UNITS(100, UNIT_0_625_MS)

I set this variable to 100, is a correct value or i should make it bigger than 100 ?

RE: Bootloader DFU stop advertising after updating new firmware

Hung Bui — Wed, 09 Oct 2019 14:20:10 GMT

You can modify APP_ADV_INTERVAL inside dfu_transport_ble.c

RE: Bootloader DFU stop advertising after updating new firmware

Geek — Wed, 09 Oct 2019 14:11:57 GMT

How can i increase advertising connexion value ?

RE: Bootloader DFU stop advertising after updating new firmware

Hung Bui — Wed, 09 Oct 2019 13:15:02 GMT

It's normal to have these 7.8mA peak, it's when the bootloader advertising. Without periodically advertising, you can't establish a connection. You can increase the advertising interval to make it draw less current.

RE: Bootloader DFU stop advertising after updating new firmware

Geek — Wed, 09 Oct 2019 12:06:15 GMT

sorry , i missed to tell that i m using small resistor(100 ohm) in line with power supply (3,6 V). So the average current is 7,8 mA .

"Is waiting for image packet" means that the connection is not established yet . That's why im totally surprised that bootloader still consuming current even though there is no connection .

RE: Bootloader DFU stop advertising after updating new firmware

Hung Bui — Wed, 09 Oct 2019 11:10:10 GMT

Hi,

The image doesn't show the current (it shows the voltage drop ? ) so I don't know what's the current is.

When you mentioned " is waiting for image packet", is the connection established or not ? In both case, the bootloader will either advertise , or have to wake up to handle the connection (even though there is no data transfer) so it's normal to periodically have some peak current.

The long period after the image transfer finish could be the period where the image is swapped the CPU has to be active to do flash operation.

RE: Bootloader DFU stop advertising after updating new firmware

Geek — Wed, 09 Oct 2019 09:37:18 GMT

Hi,

thank you for replay. I have attached some screenshot to show current drawing in different phase bootloader runing.

In this picture, bootloader continue to consume current even if is waiting for image packets (Here Peer device doesn't start sending image file).

Here, peer device start sending packet

and after finshed image downloding there is a current peak consumption due to the transition from bootloader to the application

i hope it a bit clear now.

"Are you using our unmodified bootloader ? "

yes, i m using unmodified bootloader.

RE: Bootloader DFU stop advertising after updating new firmware

Hung Bui — Wed, 09 Oct 2019 08:19:12 GMT

Usually we use a retention register instead of a shared RAM area but I think it would be fine.

200 byte per second is very low. I would assume that it's the limitation on the peer device, not because of the nRF52 ?

I'm not sure I understand what you meant by 5mA every 1s. Do you mean 5mAh ? Current can't be measured over time.

Or it's the constant 5mA current you are seeing ?

Are you using our unmodified bootloader ?

RE: Bootloader DFU stop advertising after updating new firmware

Geek — Tue, 08 Oct 2019 18:02:43 GMT

Hi Hung Bui,

I have added share memory flash adrress between bootloader and application.So its a simple way to force bootloader to enter bootloader mode by writing "true" value in to this memory adress from the application and make a prompt test to the above "flag" variable.

Now Im facing another issue, it's about power consumption. The software that's im use to send app image ,transmitt about 200 Byte every 1s and my app image is about 33KByte, So i spend more 3 min to download all the image.

During the download, Bootloader DFU draw 5mA every 1s, so for 3min I consume 900 mA.

My question is, there is any way to reduce power consumption ?

RE: Bootloader DFU stop advertising after updating new firmware

Hung Bui — Wed, 25 Sep 2019 15:27:32 GMT

Please tell exactly how you share the flag variable ? How do you switch from application to bootloader ?

Note that RAM get reset when you trigger a soft reset .

You would need to either use retention register (GPREGRET) or use flash to store the data of the flag.

RE: Bootloader DFU stop advertising after updating new firmware

Geek — Tue, 24 Sep 2019 14:46:54 GMT

Hi Hung Bui,

I Have not test the Buttonless example, I have creat a Custom Service in My Application that trigger Bootloader to enter in DFU Mode . So I have added somme line in Bootloader main code to creat shared area where i place flag that my app change when i wont to enter DFU Boot mode.

		if (flag == 1) 
		{			
			dfu_start= true;
			flag = 0;
		}

So, the problem is i can't get the flag change after soft rest . Can you please tell me the correct way to set the flag after boot to valid application.

Kindly regards

RE: Bootloader DFU stop advertising after updating new firmware

Hung Bui — Thu, 12 Sep 2019 09:01:28 GMT

Hi,

Please first make sure you have tested the buttonless example and you can do a DFU update without a button.

Then you can start integrate it into your application. Please make sure you have configured the memory properly. Increase the vs_uuid_count in the softdevice enable configuration, before calling softdevice_enable()

RE: Bootloader DFU stop advertising after updating new firmware

Geek — Wed, 11 Sep 2019 15:45:10 GMT

Yes I Know that SDK15.3 is the latest version, but for my project needs i use SDK11 version.

So, I have devlopped a Python application that integrate a dfu process and fit the dfu exmple project that you have provide in sdk11.

The problem with this example is that they use Button to enter in DFU mode and for my project needs , the dfu should bye placed in Bootloader not in the Application that's why i look for an example of bootloader thats not need tu use button to enter in dfu mode.

RE: Bootloader DFU stop advertising after updating new firmware

Hung Bui — Wed, 11 Sep 2019 08:43:41 GMT

I'm not familiar with DAP debugger, but as far as I know you should be able to set a breakpoint and step using GDB. As in this link .

What you need to do is to add a breakpoint inside app_error_handler() and check what error and which line cause the issue.

I'm not sure how you build your application without debugging ability ?

It's strongly recommended to get hold of a nRF52 DK. You can use the DK as a Jlink debugger.

One question, why do you use SDK v11 ? The latest SDK is v15.3

RE: Bootloader DFU stop advertising after updating new firmware

Geek — Tue, 10 Sep 2019 15:08:55 GMT

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

RE: Bootloader DFU stop advertising after updating new firmware

Hung Bui — Tue, 10 Sep 2019 14:00:21 GMT

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.

RE: Bootloader DFU stop advertising after updating new firmware

Geek — Tue, 10 Sep 2019 13:19:45 GMT

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

RE: Bootloader DFU stop advertising after updating new firmware

Hung Bui — Tue, 10 Sep 2019 11:25:28 GMT

Please try debugging. Here is the debug guide.

RE: Bootloader DFU stop advertising after updating new firmware

Geek — Tue, 10 Sep 2019 10:12:54 GMT

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


/**
 * @}
 */

RE: Bootloader DFU stop advertising after updating new firmware

Hung Bui — Mon, 09 Sep 2019 15:36:37 GMT

Have you try to follow this ? https://infocenter.nordicsemi.com/topic/com.nordic.infocenter.sdk5.v11.0.0/bledfu_appextending.html?cp=5_5_10_4_2_3_2_1

RE: Bootloader DFU stop advertising after updating new firmware

Geek — Mon, 09 Sep 2019 15:22:30 GMT

Thanks for replay,

Now i would like to extend my application to support DFU, So i would like to know how/where should i modifiy source files to add DFU to my application. It's not clear on infocenter documentation.

RE: Bootloader DFU stop advertising after updating new firmware

Hung Bui — Mon, 09 Sep 2019 09:13:14 GMT

Hi,

When your application is running, your bootloader can't run. You can't run 2 application at the same time. What you need is to implement a service in the application to switch to bootloader, that what we called buttonless DFU.

If you are using SDK v11, please have a look here: https://infocenter.nordicsemi.com/topic/com.nordic.infocenter.sdk5.v11.0.0/bledfu_application.html?cp=5_5_10_4_2_3_2

The example is inside the _with_dfu projects inside \examples\ble_peripheral\ble_app_hrs