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

fds is not working in buttonless DFU

Hello All,

I am working on the nrf52810 ,

Using sdk 15.3 .

I am working on the DFU feature on my application.

I have successfully integrated the my application with the buttonless DFU and its working properly.

Now I have added the fds feature to that but its not woking.

if i use fds in my application without buttonless DFU its working properly, but if i integrate fds with dfu its not working.

I have followed some post but not getting main cause.

If anyone know this issue how to solve please let me know .

What modification is required ?

Please check my file below. 

/**
 * Copyright (c) 2014 - 2019, Nordic Semiconductor ASA
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice, this
 *    list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form, except as embedded into a Nordic
 *    Semiconductor ASA integrated circuit in a product or a software update for
 *    such product, must reproduce the above copyright notice, this list of
 *    conditions and the following disclaimer in the documentation and/or other
 *    materials provided with the distribution.
 *
 * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
 *    contributors may be used to endorse or promote products derived from this
 *    software without specific prior written permission.
 *
 * 4. This software, with or without modification, must only be used with a
 *    Nordic Semiconductor ASA integrated circuit.
 *
 * 5. Any software provided in binary form under this license must not be reverse
 *    engineered, decompiled, modified and/or disassembled.
 *
 * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */
/** @example examples/ble_peripheral/ble_app_buttonless_dfu
 *
 * @brief Secure DFU Buttonless Service Application main file.
 *
 * This file contains the source code for a sample application using the proprietary
 * Secure DFU Buttonless Service. This is a template application that can be modified
 * to your needs. To extend the functionality of this application, please find
 * locations where the comment "// YOUR_JOB:" is present and read the comments.
 */

#include <stdbool.h>
#include <stdint.h>
#include <string.h>

#include "nrf_dfu_ble_svci_bond_sharing.h"
#include "nrf_svci_async_function.h"
#include "nrf_svci_async_handler.h"

#include "ble_cus.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_advertising.h"
#include "ble_conn_params.h"
#include "nrf_sdh.h"
#include "nrf_sdh_soc.h"
#include "nrf_sdh_ble.h"
#include "app_timer.h"
#include "peer_manager.h"
#include "peer_manager_handler.h"
#include "bsp_btn_ble.h"
#include "ble_hci.h"
#include "ble_advdata.h"
#include "ble_advertising.h"
#include "ble_conn_state.h"
#include "ble_dfu.h"
#include "ble_tps.h"
#include "nrf_ble_gatt.h"
#include "nrf_ble_qwr.h"
#include "fds.h"
#include "nrf_pwr_mgmt.h"
#include "nrf_drv_clock.h"
#include "nrf_power.h"
#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.h"
#include "nrf_bootloader_info.h"
#include "boards.h"

#include "app_button.h"

#include "bsp.h"
#include "ble_gap.h"


/***  Used for testing FDS ***/
static volatile uint8_t write_flag_fds_test = 0; 
#define FILE_ID_FDS_TEST     0x1111
#define REC_KEY_FDS_TEST     0x2222
/*****************************/


#define DEVICE_NAME                     "NRF_02"  //Nordic_Buttonless                       /**< Name of device. Will be included in the advertising data. */
#define DEVICE_NAME_P                   "Nrf02"  /**< Name of device. Will be included in the advertising data. */

//#define DEVICE_NAME                     "FIND02"  //Nordic_Buttonless                       /**< Name of device. Will be included in the advertising data. */
//#define DEVICE_NAME_P                   "FinD02"  /**< Name of device. Will be included in the advertising data. */

#define MANUFACTURER_NAME               "NordicSemiconductor"                       /**< Manufacturer. Will be passed to Device Information Service. */
#define APP_ADV_INTERVAL                80                                         /**< The advertising interval (in units of 0.625 ms. This value corresponds to 187.5 ms). */
#define APP_ADV_DURATION                BLE_GAP_ADV_TIMEOUT_GENERAL_UNLIMITED      /**< The advertising duration (180 seconds) in units of 10 milliseconds. */

#define ADVERTISING_LED                 BSP_BOARD_LED_3                         /**< Is on when device is advertising. */

#define APP_BLE_OBSERVER_PRIO           3                                           /**< Application's BLE observer priority. You shouldn't need to modify this value. */
#define APP_BLE_CONN_CFG_TAG            1                                           /**< A tag identifying the SoftDevice BLE configuration. */

#define MIN_CONN_INTERVAL               MSEC_TO_UNITS(100, UNIT_1_25_MS)            /**< Minimum acceptable connection interval (0.1 seconds). */
#define MAX_CONN_INTERVAL               MSEC_TO_UNITS(200, UNIT_1_25_MS)            /**< Maximum acceptable connection interval (0.2 second). */
#define SLAVE_LATENCY                   0                                           /**< Slave latency. */
#define CONN_SUP_TIMEOUT                MSEC_TO_UNITS(4000, UNIT_10_MS)             /**< Connection supervisory timeout (4 seconds). */

#define FIRST_CONN_PARAMS_UPDATE_DELAY  APP_TIMER_TICKS(5000)                       /**< Time from initiating event (connect or start of notification) to first time sd_ble_gap_conn_param_update is called (5 seconds). */
#define NEXT_CONN_PARAMS_UPDATE_DELAY   APP_TIMER_TICKS(30000)                      /**< Time between each call to sd_ble_gap_conn_param_update after the first call (30 seconds). */
#define MAX_CONN_PARAMS_UPDATE_COUNT    3                                           /**< Number of attempts before giving up the connection parameter negotiation. */

#define 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 TX_POWER_LEVEL                  (4)                                    /**< TX Power Level value. This will be set both in the TX Power service, in the advertising data, and also used to set the radio transmit power. */


#define BUTTON_DETECTION_DELAY          APP_TIMER_TICKS(50) 

#define Single_click_INTERVAL           APP_TIMER_TICKS(1000)
#define NOTIFICATION_INTERVAL           APP_TIMER_TICKS(1000)     


#define DEAD_BEEF                       0xDEADBEEF                                  /**< Value used as error code on stack dump, can be used to identify stack location on stack unwind. */

BLE_TPS_DEF(m_tps);
NRF_BLE_GATT_DEF(m_gatt);                                                           /**< GATT module instance. */
BLE_CUS_DEF(m_cus);
//NRF_BLE_QWR_DEF(m_qwr);                                                             /**< Context for the Queued Write module.*/

BLE_ADVERTISING_DEF(m_advertising);                                                 /**< Advertising module instance. */


APP_TIMER_DEF(long_button_action);
APP_TIMER_DEF(single_button_action);
APP_TIMER_DEF(Double_button_action);
APP_TIMER_DEF(m_notification_timer_id);

int custom_entry_flag;
static uint8_t m_custom_value = 0;
static uint8_t DEVICE_NAME_MED[7]       = {"FIND00"};

static uint16_t m_conn_handle = BLE_CONN_HANDLE_INVALID;                            /**< Handle of the current connection. */
//static void advertising_start(bool erase_bonds);                                    /**< Forward declaration of advertising start function */

static uint32_t cnt = 0, temp = 0, advertising_flag = 0;
static uint8_t press_cnt = 0, temp_click = 0;
static uint8_t temp_name_id_lsb;

extern int temp_name_id;
extern int TX_power_variable;
extern int custom_entry_flag;

uint8_t m_deadbeef[] = {54};//,12};//{8,45,69,44,22,45,12,32};
uint8_t *temp_data;

static uint8_t m_adv_handle = BLE_GAP_ADV_SET_HANDLE_NOT_SET;                   /**< Advertising handle used to identify an advertising set. */
static uint8_t m_enc_advdata[BLE_GAP_ADV_SET_DATA_SIZE_MAX];                    /**< Buffer for storing an encoded advertising set. */
static uint8_t m_enc_scan_response_data[BLE_GAP_ADV_SET_DATA_SIZE_MAX];         /**< Buffer for storing an encoded scan data. */

/**@brief Struct that contains pointers to the encoded advertising data. */
static ble_gap_adv_data_t m_adv_data =
{
    .adv_data =
    {
        .p_data = m_enc_advdata,
        .len    = BLE_GAP_ADV_SET_DATA_SIZE_MAX
    },
    .scan_rsp_data =
    {
        .p_data = m_enc_scan_response_data,
        .len    = BLE_GAP_ADV_SET_DATA_SIZE_MAX

    }
};

ble_advdata_t advdata;
ble_gap_adv_params_t adv_params;




/*--------------all function decleration --------*/
static void setDeviceName(uint8_t status);
static void tx_power_set(void);
static void bsp_event_handler(bsp_event_t event);
//static void ble_evt_handler(ble_evt_t const * p_ble_evt, void * p_context);
/*----     flash read/write/delete function  ----*/

static ret_code_t fds_test_find_and_delete (void);
static ret_code_t fds_test_init (void);
static ret_code_t fds_read(void);
static ret_code_t fds_test_write(void);
static void my_fds_evt_handler(fds_evt_t const * const p_fds_evt);


/*------- FOR THE UPDATE ADVERTISING VARIABLE FOR SWITCH CASE ------ */
  enum 
  { 
    STATUS_LOW,
    STATUS_MED,
    STATUS_HIGH,
    STATUS_ERR
  };
/*-------------------------------------------------------------------*/

// YOUR_JOB: Use UUIDs for service(s) used in your application.
static ble_uuid_t m_adv_uuids[] = {{BLE_UUID_DEVICE_INFORMATION_SERVICE, BLE_UUID_TYPE_BLE},
                                   {BLE_UUID_TX_POWER_SERVICE, BLE_UUID_TYPE_BLE}
                                  };



/**@brief Function for initializing the TX Power Service.
 */
static void tps_init(void)
{
    ret_code_t     err_code;
    ble_tps_init_t tps_init_obj;

    memset(&tps_init_obj, 0, sizeof(tps_init_obj));
    tps_init_obj.initial_tx_power_level = TX_POWER_LEVEL;

    tps_init_obj.tpl_rd_sec = SEC_JUST_WORKS;

    err_code = ble_tps_init(&m_tps, &tps_init_obj);
    APP_ERROR_CHECK(err_code);
}

/**@brief Handler for shutdown preparation.
 *
 * @details During shutdown procedures, this function will be called at a 1 second interval
 *          untill the function returns true. When the function returns true, it means that the
 *          app is ready to reset to DFU mode.
 *
 * @param[in]   event   Power manager event.
 *
 * @retval  True if shutdown is allowed by this power manager handler, otherwise false.
 */
static bool app_shutdown_handler(nrf_pwr_mgmt_evt_t event)
{
    switch (event)
    {
        case NRF_PWR_MGMT_EVT_PREPARE_DFU:
            NRF_LOG_INFO("Power management wants to reset to DFU mode.");
            // YOUR_JOB: Get ready to reset into DFU mode
            //
            // If you aren't finished with any ongoing tasks, return "false" to
            // signal to the system that reset is impossible at this stage.
            //
            // Here is an example using a variable to delay resetting the device.
            //
            // if (!m_ready_for_reset)
            // {
            //      return false;
            // }
            // else
            //{
            //
            //    // Device ready to enter
            //    uint32_t err_code;
            //    err_code = sd_softdevice_disable();
            //    APP_ERROR_CHECK(err_code);
            //    err_code = app_timer_stop_all();
            //    APP_ERROR_CHECK(err_code);
            //}
            break;

        default:
            // YOUR_JOB: Implement any of the other events available from the power management module:
            //      -NRF_PWR_MGMT_EVT_PREPARE_SYSOFF
            //      -NRF_PWR_MGMT_EVT_PREPARE_WAKEUP
            //      -NRF_PWR_MGMT_EVT_PREPARE_RESET
            return true;
    }

    NRF_LOG_INFO("Power management allowed to reset to DFU mode.");
    return true;
}

//lint -esym(528, m_app_shutdown_handler)
/**@brief Register application shutdown handler with priority 0.
 */
NRF_PWR_MGMT_HANDLER_REGISTER(app_shutdown_handler, 0);


static void buttonless_dfu_sdh_state_observer(nrf_sdh_state_evt_t state, void * p_context)
{
    if (state == NRF_SDH_EVT_STATE_DISABLED)
    {
        // Softdevice was disabled before going into reset. Inform bootloader to skip CRC on next boot.
        nrf_power_gpregret2_set(BOOTLOADER_DFU_SKIP_CRC);

        //Go to system off.
        nrf_pwr_mgmt_shutdown(NRF_PWR_MGMT_SHUTDOWN_GOTO_SYSOFF);
    }
}

/* nrf_sdh state observer. */
NRF_SDH_STATE_OBSERVER(m_buttonless_dfu_state_obs, 0) =
{
    .handler = buttonless_dfu_sdh_state_observer,
};


static void advertising_config_get(ble_adv_modes_config_t * p_config)
{
    memset(p_config, 0, sizeof(ble_adv_modes_config_t));

    p_config->ble_adv_fast_enabled  = true;
    p_config->ble_adv_fast_interval = APP_ADV_INTERVAL;
    p_config->ble_adv_fast_timeout  = APP_ADV_DURATION;
}


static void disconnect(uint16_t conn_handle, void * p_context)
{
    UNUSED_PARAMETER(p_context);

    ret_code_t err_code = sd_ble_gap_disconnect(conn_handle, BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
    if (err_code != NRF_SUCCESS)
    {
        NRF_LOG_WARNING("Failed to disconnect connection. Connection handle: %d Error: %d", conn_handle, err_code);
    }
    else
    {
        NRF_LOG_DEBUG("Disconnected connection handle %d", conn_handle);
    }
    
}



// YOUR_JOB: Update this code if you want to do anything given a DFU event (optional).
/**@brief Function for handling dfu events from the Buttonless Secure DFU service
 *
 * @param[in]   event   Event from the Buttonless Secure DFU service.
 */
static void ble_dfu_evt_handler(ble_dfu_buttonless_evt_type_t event)
{
    switch (event)
    {
        case BLE_DFU_EVT_BOOTLOADER_ENTER_PREPARE:
        {
            NRF_LOG_INFO("Device is preparing to enter bootloader mode.");

            // Prevent device from advertising on disconnect.
            ble_adv_modes_config_t config;
            advertising_config_get(&config);
            config.ble_adv_on_disconnect_disabled = true;
            ble_advertising_modes_config_set(&m_advertising, &config);

            // Disconnect all other bonded devices that currently are connected.
            // This is required to receive a service changed indication
            // on bootup after a successful (or aborted) Device Firmware Update.
            uint32_t conn_count = ble_conn_state_for_each_connected(disconnect, NULL);
            NRF_LOG_INFO("Disconnected %d links.", conn_count);
            break;
        }

        case BLE_DFU_EVT_BOOTLOADER_ENTER:
            // YOUR_JOB: Write app-specific unwritten data to FLASH, control finalization of this
            //           by delaying reset by reporting false in app_shutdown_handler
            NRF_LOG_INFO("Device will enter bootloader mode.");
            break;

        case BLE_DFU_EVT_BOOTLOADER_ENTER_FAILED:
            NRF_LOG_ERROR("Request to enter bootloader mode failed asynchroneously.");
            // YOUR_JOB: Take corrective measures to resolve the issue
            //           like calling APP_ERROR_CHECK to reset the device.
            break;

        case BLE_DFU_EVT_RESPONSE_SEND_ERROR:
            NRF_LOG_ERROR("Request to send a response to client failed.");
            // YOUR_JOB: Take corrective measures to resolve the issue
            //           like calling APP_ERROR_CHECK to reset the device.
            APP_ERROR_CHECK(false);
            break;

        default:
            NRF_LOG_ERROR("Unknown event from ble_dfu_buttonless.");
            break;
    }
}


/**@brief Callback function for asserts in the SoftDevice.
 *
 * @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] 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 handling Peer Manager events.
 *
 * @param[in] p_evt  Peer Manager event.
 */
static void pm_evt_handler(pm_evt_t const * p_evt)
{
    pm_handler_on_pm_evt(p_evt);
    pm_handler_flash_clean(p_evt);
}


/**@brief Function for the Timer initialization.
 *
 * @details Initializes the timer module. This creates and starts application timers.
 */
static void timers_init(void)
{

    // Initialize timer module.
    uint32_t err_code = app_timer_init();
    APP_ERROR_CHECK(err_code);

}


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

//    if (advertising_flag == 1)                                              //for normal advert
//    {
//        advertising_flag = 0;
//        err_code = sd_ble_gap_device_name_set(&sec_mode,
//                                              (const uint8_t *)DEVICE_NAME,
//                                              strlen(DEVICE_NAME));
//        APP_ERROR_CHECK(err_code);
//    }
//    else if (advertising_flag == 2)                                              //for panic advert
//    {
//        advertising_flag = 0;
//        err_code = sd_ble_gap_device_name_set(&sec_mode,
//                                              (const uint8_t *)DEVICE_NAME_P,
//                                              strlen(DEVICE_NAME_P));
//        APP_ERROR_CHECK(err_code);
//    }

    err_code = sd_ble_gap_device_name_set(&sec_mode,
                                          (const uint8_t *)DEVICE_NAME,
                                          strlen(DEVICE_NAME));
    APP_ERROR_CHECK(err_code);

    /* YOUR_JOB: Use an appearance value matching the application's use case.
       err_code = sd_ble_gap_appearance_set(BLE_APPEARANCE_);
       APP_ERROR_CHECK(err_code); */

    memset(&gap_conn_params, 0, sizeof(gap_conn_params));

    gap_conn_params.min_conn_interval = MIN_CONN_INTERVAL;
    gap_conn_params.max_conn_interval = MAX_CONN_INTERVAL;
    gap_conn_params.slave_latency     = SLAVE_LATENCY;
    gap_conn_params.conn_sup_timeout  = CONN_SUP_TIMEOUT;

    err_code = sd_ble_gap_ppcp_set(&gap_conn_params);
    APP_ERROR_CHECK(err_code);
}


/**@brief Function for handling Queued Write Module errors.
 *
 * @details A pointer to this function will be passed to each service which may need to inform the
 *          application about an error.
 *
 * @param[in]   nrf_error   Error code containing information about what went wrong.
 */
static void nrf_qwr_error_handler(uint32_t nrf_error)
{
    APP_ERROR_HANDLER(nrf_error);
}


/**@brief Function for handling the YYY Service events.
 * YOUR_JOB implement a service handler function depending on the event the service you are using can generate
 *
 * @details This function will be called for all YY Service events which are passed to
 *          the application.
 *
 * @param[in]   p_yy_service   YY Service structure.
 * @param[in]   p_evt          Event received from the YY Service.
 *
 *
   static void on_yys_evt(ble_yy_service_t     * p_yy_service,
                          ble_yy_service_evt_t * p_evt)
   {
    switch (p_evt->evt_type)
    {
        case BLE_YY_NAME_EVT_WRITE:
            APPL_LOG("[APPL]: charact written with value %s. ", p_evt->params.char_xx.value.p_str);
            break;

        default:
            // No implementation needed.
            break;
    }
   }*/

/**@brief Function for handling the Battery measurement timer timeout.
 *
 * @details This function will be called each time the battery level measurement timer expires.
 *
 * @param[in] p_context  Pointer used for passing some arbitrary information (context) from the
 *                       app_start_timer() call to the timeout handler.
 */
static void notification_timeout_handler(void * p_context)
{
    UNUSED_PARAMETER(p_context);
    ret_code_t err_code;
    
    // Increment the value of m_custom_value before nortifing it.
    m_custom_value++;
    
    err_code = ble_cus_custom_value_update(&m_cus, m_custom_value);
    APP_ERROR_CHECK(err_code);
}

/**@brief Function for handling the Custom Service Service events.
 *
 * @details This function will be called for all Custom Service events which are passed to
 *          the application.
 *
 * @param[in]   p_cus_service  Custom Service structure.
 * @param[in]   p_evt          Event received from the Custom Service.
 *
 */
static void on_cus_evt(ble_cus_t     * p_cus_service,
                       ble_cus_evt_t * p_evt)
{
    ret_code_t err_code;
    
    switch(p_evt->evt_type)
    {
        case BLE_CUS_EVT_NOTIFICATION_ENABLED:
             
             err_code = app_timer_start(m_notification_timer_id, NOTIFICATION_INTERVAL, NULL);
             APP_ERROR_CHECK(err_code);
             break;

        case BLE_CUS_EVT_NOTIFICATION_DISABLED:
            // Stop the application timer that is triggering the notifications
            err_code = app_timer_stop(m_notification_timer_id);
            APP_ERROR_CHECK(err_code);
            break;

        case BLE_CUS_EVT_CONNECTED:
            break;

        case BLE_CUS_EVT_DISCONNECTED:
            break;
        case BLE_CUS_EVT_SERVO_CTR_VALUE_RECEIVED:
            break;    

        default:
              // No implementation needed.
              break;
    }
}

/**@brief Function for initializing services that will be used by the application.
 */
static void cus_init(void)
{
            /* YOUR_JOB: Add code to initialize the services used by the application.*/
        ret_code_t                         err_code;
        ble_cus_init_t                     cus_init;

         // Initialize CUS Service init structure to zero.
        memset(&cus_init, 0, sizeof(cus_init));
        cus_init.evt_handler                = on_cus_evt;
    
        BLE_GAP_CONN_SEC_MODE_SET_OPEN(&cus_init.custom_value_char_attr_md.cccd_write_perm);
        BLE_GAP_CONN_SEC_MODE_SET_OPEN(&cus_init.custom_value_char_attr_md.read_perm);
        BLE_GAP_CONN_SEC_MODE_SET_OPEN(&cus_init.custom_value_char_attr_md.write_perm);
    
        err_code = ble_cus_init(&m_cus, &cus_init);
        APP_ERROR_CHECK(err_code);	
}

/**@brief Function for initializing services that will be used by the application.
 */
static void services_init(void)
{
    uint32_t                  err_code;
    //nrf_ble_qwr_init_t        qwr_init  = {0};
    ble_dfu_buttonless_init_t dfus_init = {0};

    // Initialize Queued Write Module.
//    qwr_init.error_handler = nrf_qwr_error_handler;

//    err_code = nrf_ble_qwr_init(&m_qwr, &qwr_init);
//    APP_ERROR_CHECK(err_code);

    dfus_init.evt_handler = ble_dfu_evt_handler;

    err_code = ble_dfu_buttonless_init(&dfus_init);
    APP_ERROR_CHECK(err_code);
    
    tps_init();
    cus_init();
}




/**@brief Function for handling the Connection Parameters Module.
 *
 * @details This function will be called for all events in the Connection Parameters Module which
 *          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 putting the chip into sleep mode.
 *
 * @note This function will not return.
 */
static void sleep_mode_enter(void)
{
    uint32_t err_code = bsp_indication_set(BSP_INDICATE_IDLE);

    APP_ERROR_CHECK(err_code);

    // Prepare wakeup buttons.
    err_code = bsp_btn_ble_sleep_mode_prepare();
    APP_ERROR_CHECK(err_code);

    //Disable SoftDevice. It is required to be able to write to GPREGRET2 register (SoftDevice API blocks it).
    //GPREGRET2 register holds the information about skipping CRC check on next boot.
    err_code = nrf_sdh_disable_request();
    APP_ERROR_CHECK(err_code);
}


/**@brief Function for handling advertising events.
 *
 * @details This function will be called for advertising events which are passed to the application.
 *
 * @param[in] ble_adv_evt  Advertising event.
 */
static void on_adv_evt(ble_adv_evt_t ble_adv_evt)
{
    uint32_t err_code;

    switch (ble_adv_evt)
    {
        case BLE_ADV_EVT_FAST:
            err_code = bsp_indication_set(BSP_INDICATE_ADVERTISING);
            APP_ERROR_CHECK(err_code);
            break;

        case BLE_ADV_EVT_IDLE:
            sleep_mode_enter();
            break;

        default:
            break;
    }
}

static void advertising_init(void)
{
    ret_code_t    err_code;
    //ble_advdata_t advdata;
    //ble_advdata_t srdata;

    //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.short_name_len     = 8;
//    advdata.include_appearance = true;                                  // changed to true to false
//    advdata.flags              = BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE;
    
//    advdata.uuids_complete.uuid_cnt = sizeof(m_adv_uuids) / sizeof(m_adv_uuids[0]);
//    advdata.uuids_complete.p_uuids  = m_adv_uuids;

//    memset(&srdata, 0, sizeof(srdata));
//    srdata.uuids_complete.uuid_cnt = sizeof(adv_uuids) / sizeof(adv_uuids[0]);
//    srdata.uuids_complete.p_uuids  = adv_uuids;

    err_code = ble_advdata_encode(&advdata, m_adv_data.adv_data.p_data, &m_adv_data.adv_data.len);
    APP_ERROR_CHECK(err_code);

//    err_code = ble_advdata_encode(&srdata, m_adv_data.scan_rsp_data.p_data, &m_adv_data.scan_rsp_data.len);
//    APP_ERROR_CHECK(err_code);

    //ble_gap_adv_params_t adv_params;

    // Set advertising parameters.
    memset(&adv_params, 0, sizeof(adv_params));

    adv_params.primary_phy     = BLE_GAP_PHY_1MBPS;
    adv_params.duration        = APP_ADV_DURATION;
    adv_params.properties.type = BLE_GAP_ADV_TYPE_CONNECTABLE_SCANNABLE_UNDIRECTED;
    adv_params.p_peer_addr     = NULL;
    adv_params.filter_policy   = BLE_GAP_ADV_FP_ANY;
    adv_params.interval        = APP_ADV_INTERVAL;

    err_code = sd_ble_gap_adv_set_configure(&m_adv_handle, &m_adv_data, &adv_params);
    APP_ERROR_CHECK(err_code);
}

/**@brief Function for starting advertising.
 */
static void advertising_start(void)
{
    ret_code_t           err_code;

    err_code = sd_ble_gap_adv_start(m_adv_handle, APP_BLE_CONN_CFG_TAG);
    APP_ERROR_CHECK(err_code);
}

/**@brief Function for stopping advertising.
 */
static void advertising_stop(void)
{
    ret_code_t           err_code;

    err_code = sd_ble_gap_adv_stop(m_adv_handle);
    APP_ERROR_CHECK(err_code);
}
/**@brief Function for handling BLE events.
 *
 * @param[in]   p_ble_evt   Bluetooth stack event.
 * @param[in]   p_context   Unused.
 */
static void ble_evt_handler(ble_evt_t const * p_ble_evt, void * p_context)
{
    uint32_t err_code = NRF_SUCCESS;

    switch (p_ble_evt->header.evt_id)
    {
        case BLE_GAP_EVT_DISCONNECTED:
            // LED indication will be changed when advertising starts.
            //bsp_board_led_off(ADVERTISING_LED);
//            bsp_board_init(BSP_INIT_LEDS);
//            bsp_board_led_off(ADVERTISING_LED);

            
            //advertising_flag = 1;

//            gap_params_init();
//            advertising_init();
//            advertising_start();                  //start normal advertising
             //setDeviceName(STATUS_MED);
            
            if(custom_entry_flag == 1)
            {
                     NRF_LOG_INFO("temp_name_id = %x\r\n", temp_name_id);
        
              // m_deadbeef[0] = temp_name_id;
              //NRF_LOG_INFO("m_deadbeef = %x\r\n", m_deadbeef[0]);

                err_code =fds_test_init();
                APP_ERROR_CHECK(err_code);
                err_code = fds_test_find_and_delete();
                APP_ERROR_CHECK(err_code);

                m_deadbeef[0] = temp_name_id;

                NRF_LOG_INFO("m_deadbeef = %x\r\n", m_deadbeef[0]);

                err_code =fds_test_write();
                APP_ERROR_CHECK(err_code);

            
                //while (write_flag_fds_test==1);
                err_code = fds_read();
                APP_ERROR_CHECK(err_code);

                temp_name_id_lsb = temp_name_id;
                temp_name_id = temp_name_id/10;
                NRF_LOG_INFO("temp_name_id = %d\r\n", temp_name_id);
                temp_name_id_lsb = temp_name_id_lsb%10;
                NRF_LOG_INFO("temp_name_id_lsb = %d\r\n", temp_name_id_lsb);

                //  gap_params_init();
                //  advertising_init();
                //   advertising_start();

                custom_entry_flag = 2;
                setDeviceName(STATUS_MED);
            }
                           
            if(custom_entry_flag != 2) //default advt
            {
              err_code =fds_test_init();
              APP_ERROR_CHECK(err_code);
              //while (write_flag_fds_test==1);
              err_code = fds_read();
              APP_ERROR_CHECK(err_code);

              

              temp_name_id_lsb = temp_name_id;
              temp_name_id = temp_name_id/10;
              NRF_LOG_INFO("temp_name_id = %d\r\n", temp_name_id);
              temp_name_id_lsb = temp_name_id_lsb%10;
              NRF_LOG_INFO("temp_name_id_lsb = %d\r\n", temp_name_id_lsb);
//              gap_params_init();
//              advertising_init();
//              advertising_start();
              setDeviceName(STATUS_MED);
            
            }

            break;

        case BLE_GAP_EVT_CONNECTED:
            err_code = bsp_indication_set(BSP_INDICATE_CONNECTED);
            APP_ERROR_CHECK(err_code);
//            m_conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
//            err_code = nrf_ble_qwr_conn_handle_assign(&m_qwr, m_conn_handle);
//            APP_ERROR_CHECK(err_code);

//            bsp_board_init(BSP_INIT_LEDS);
//            bsp_board_led_on(ADVERTISING_LED);

            break;

        case BLE_GAP_EVT_PHY_UPDATE_REQUEST:
        {
            NRF_LOG_DEBUG("PHY update request.");
            ble_gap_phys_t const phys =
            {
                .rx_phys = BLE_GAP_PHY_AUTO,
                .tx_phys = BLE_GAP_PHY_AUTO,
            };
            err_code = sd_ble_gap_phy_update(p_ble_evt->evt.gap_evt.conn_handle, &phys);
            APP_ERROR_CHECK(err_code);
            break;
        }

        case BLE_GATTC_EVT_TIMEOUT:
            // Disconnect on GATT Client timeout event.
            NRF_LOG_DEBUG("GATT Client Timeout.");
            err_code = sd_ble_gap_disconnect(p_ble_evt->evt.gattc_evt.conn_handle,
                                             BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
            APP_ERROR_CHECK(err_code);
            
            break;

        case BLE_GATTS_EVT_TIMEOUT:
            // Disconnect on GATT Server timeout event.
            NRF_LOG_DEBUG("GATT Server Timeout.");
            err_code = sd_ble_gap_disconnect(p_ble_evt->evt.gatts_evt.conn_handle,
                                             BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
            APP_ERROR_CHECK(err_code);
            break;

        default:
            // No implementation needed.
            break;
    }
}


/**@brief Function for initializing the BLE stack.
 *
 * @details Initializes the SoftDevice and the BLE event interrupt.
 */
static void ble_stack_init(void)
{
    ret_code_t err_code;

    err_code = nrf_sdh_enable_request();
    APP_ERROR_CHECK(err_code);

    // Configure the BLE stack using the default settings.
    // Fetch the start address of the application RAM.
    uint32_t ram_start = 0;
    err_code = nrf_sdh_ble_default_cfg_set(APP_BLE_CONN_CFG_TAG, &ram_start);
    APP_ERROR_CHECK(err_code);

    // Enable BLE stack.
    err_code = nrf_sdh_ble_enable(&ram_start);
    APP_ERROR_CHECK(err_code);

    NRF_SDH_BLE_OBSERVER(m_ble_observer, APP_BLE_OBSERVER_PRIO, ble_evt_handler, NULL);
}


/**@brief Function for the Peer Manager initialization.
 */
static void peer_manager_init()
{
    ble_gap_sec_params_t sec_param;
    ret_code_t           err_code;

    err_code = pm_init();
    APP_ERROR_CHECK(err_code);

    memset(&sec_param, 0, sizeof(ble_gap_sec_params_t));

    // Security parameters to be used for all security procedures.
    sec_param.bond           = SEC_PARAM_BOND;
    sec_param.mitm           = SEC_PARAM_MITM;
    sec_param.lesc           = SEC_PARAM_LESC;
    sec_param.keypress       = SEC_PARAM_KEYPRESS;
    sec_param.io_caps        = SEC_PARAM_IO_CAPABILITIES;
    sec_param.oob            = SEC_PARAM_OOB;
    sec_param.min_key_size   = SEC_PARAM_MIN_KEY_SIZE;
    sec_param.max_key_size   = SEC_PARAM_MAX_KEY_SIZE;
    sec_param.kdist_own.enc  = 1;
    sec_param.kdist_own.id   = 1;
    sec_param.kdist_peer.enc = 1;
    sec_param.kdist_peer.id  = 1;

    err_code = pm_sec_params_set(&sec_param);
    APP_ERROR_CHECK(err_code);

    err_code = pm_register(pm_evt_handler);
    APP_ERROR_CHECK(err_code);
}


/**@brief Function for handling events from the BSP module.
 *
 * @param[in]   event   Event generated when button is pressed.
 */
static void bsp_event_handler(bsp_event_t event)
{
    uint32_t err_code;

    switch (event)
    {
        case BSP_EVENT_SLEEP:
            sleep_mode_enter();
            break; // BSP_EVENT_SLEEP

        case BSP_EVENT_DISCONNECT:
            err_code = sd_ble_gap_disconnect(m_conn_handle,
                                             BLE_HCI_REMOTE_USER_TERMINATED_CONNECTION);
            if (err_code != NRF_ERROR_INVALID_STATE)
            {
                APP_ERROR_CHECK(err_code);
            }


            break; // BSP_EVENT_DISCONNECT

        case BSP_EVENT_WHITELIST_OFF:
            if (m_conn_handle == BLE_CONN_HANDLE_INVALID)
            {
                err_code = ble_advertising_restart_without_whitelist(&m_advertising);
                if (err_code != NRF_ERROR_INVALID_STATE)
                {
                    APP_ERROR_CHECK(err_code);
                }
            }
            break; // BSP_EVENT_KEY_0

        default:
            break;
    }
}

/**@brief Function for initializing buttons and leds.
 *
 * @param[out] p_erase_bonds  Will be true if the clear bonding button was pressed to wake the application up.
 */
static void buttons_leds_init(bool * p_erase_bonds)
{
    uint32_t err_code;
    bsp_event_t startup_event;

    err_code = bsp_init(BSP_INIT_LEDS | BSP_INIT_BUTTONS, bsp_event_handler);
    APP_ERROR_CHECK(err_code);

    /*err_code = bsp_btn_ble_init(NULL, &startup_event);
    APP_ERROR_CHECK(err_code);

    *p_erase_bonds = (startup_event == BSP_EVENT_CLEAR_BONDING_DATA);*/
}


/**@brief Function for the Power manager.
 */
static void log_init(void)
{
    uint32_t err_code = NRF_LOG_INIT(NULL);
    APP_ERROR_CHECK(err_code);

    NRF_LOG_DEFAULT_BACKENDS_INIT();
}


/**@brief   Function for initializing the GATT module.
 * @details The GATT module handles ATT_MTU and Data Length update procedures automatically.
 */
static void gatt_init(void)
{
    ret_code_t err_code = nrf_ble_gatt_init(&m_gatt, NULL);
    APP_ERROR_CHECK(err_code);
}




static void power_management_init(void)
{
    uint32_t err_code = nrf_pwr_mgmt_init();
    APP_ERROR_CHECK(err_code);
}


/////////////////////////////////////*********************************************************

#if USE_BSP == 0

#define PIN_0 0

APP_TIMER_DEF(m_button_action);

#define BUTTON_STATE_POLL_INTERVAL_MS  10UL

#define LONG_PRESS(MS)    (uint32_t)(MS)/BUTTON_STATE_POLL_INTERVAL_MS 
 

/**********************************************************************************************/

/**@brief Function for handling events from the button handler module.
 *
 .
 * @param[in] p_context   Unused.
 */
void single_click_timeout_handler(void * p_context)
{
      uint32_t err_code;

      if(press_cnt  ==  2)
      {
        NRF_LOG_INFO("double Button press"); 
        
        press_cnt=0;
              
        /***************************/
        err_code = sd_ble_gap_adv_stop(m_adv_handle);     //stop advertising
        APP_ERROR_CHECK(err_code);
//        advertising_stop();

        advertising_flag = 2;

          err_code = fds_read();
          APP_ERROR_CHECK(err_code);

          /********************************----------SORTING ID IN BITS-------------*************************************/
            
          temp_name_id_lsb = temp_name_id;
          temp_name_id = temp_name_id/10;
          NRF_LOG_INFO("temp_name_id = %d\r\n", temp_name_id);
          temp_name_id_lsb = temp_name_id_lsb%10;
          NRF_LOG_INFO("temp_name_id_lsb = %d\r\n", temp_name_id_lsb);

//        gap_params_init();
//        advertising_init();
//
//        advertising_start();                  //panic normal advertising
        setDeviceName(STATUS_MED);
        /***************************/
      }
      else
      {
        press_cnt = 0;
        if( temp_click == 0)
        {          
          temp_click = 1;
          NRF_LOG_INFO("single button press");

          app_timer_stop(single_button_action);
          APP_ERROR_CHECK(err_code);

          /***************************/
          advertising_flag = 1;
          
          err_code = fds_read();
          APP_ERROR_CHECK(err_code);

          /********************************----------SORTING ID IN BITS-------------*************************************/
            
          temp_name_id_lsb = temp_name_id;
          temp_name_id = temp_name_id/10;
          NRF_LOG_INFO("temp_name_id = %d\r\n", temp_name_id);
          temp_name_id_lsb = temp_name_id_lsb%10;
          NRF_LOG_INFO("temp_name_id_lsb = %d\r\n", temp_name_id_lsb);
//          gap_params_init();
//          advertising_init();
//
//          advertising_start();                  //start normal advertising
          setDeviceName(STATUS_MED);
          //tx_power_set();
          /***************************/
        }
      }

      
      return;
}

/**********************************************************************************************/

/**@brief Function for the button handler module.
 *
 .
 * @param[in] p_context   Unused.
 */
void button_press_timeout_handler(void * p_context)
{ 
     uint32_t err_code;
     static uint32_t cnt;


     if (app_button_is_pushed(0))
     {
         cnt++;
         if ( cnt >= LONG_PRESS(2000))
         {
             cnt = 0;
             temp_click = 0;

             NRF_LOG_INFO("Long Button press");

             err_code = sd_ble_gap_adv_stop(m_adv_handle);     //stop advertising
             APP_ERROR_CHECK(err_code);

//             advertising_stop();
         }
         else
         {
            err_code = app_timer_start(long_button_action, 
                                       APP_TIMER_TICKS(BUTTON_STATE_POLL_INTERVAL_MS),
                                       NULL);
            APP_ERROR_CHECK(err_code);
         }
     }
     else
     {
          cnt = 0 ;
          press_cnt++;
          if(press_cnt==1)
          {
            err_code = app_timer_start(single_button_action, 
                                   Single_click_INTERVAL,
                                   NULL);
            APP_ERROR_CHECK(err_code);
          }

     }
     
    return;
}

/*void button_timeout_handler(void * p_context)
{ 
     uint32_t err_code;
     static uint32_t cnt = 0, flag = 0,temp=0;

     if ((app_button_is_pushed(0)))
     {
         cnt++;
         if ( (cnt >= LONG_PRESS(2000)) && (flag == 1 ))
         {
             cnt = 0;
             flag = 2;

             NRF_LOG_INFO("Long Button press");
             NRF_LOG_INFO("stop advertising...");

             err_code = sd_ble_gap_adv_stop(m_adv_handle);     //stop advertising
             //uint32_t err_code = ble_advertising_start(&m_advertising, BLE_ADV_MODE_IDLE);   //stop****************
             APP_ERROR_CHECK(err_code);
             
             return;
         }
         else
         {
              err_code = app_timer_start(m_button_action, 
                                         APP_TIMER_TICKS(BUTTON_STATE_POLL_INTERVAL_MS),
                                         NULL);
              APP_ERROR_CHECK(err_code);
         }
     }
     else if((flag == 2 && temp == 1) ||  temp == 0 )
     {

          cnt = 0;                         // reset counter variable
          flag = 1;
          temp = 1;

          NRF_LOG_INFO("Short button press");
          NRF_LOG_INFO("advertising.......");

          gap_params_init();
          advertising_init();

          advertising_start();            //start advertising
          return;
     }

}*/

void button_callback(uint8_t pin_no, uint8_t button_action)
{
      uint32_t err_code;

      
      if ((pin_no == BUTTON_1) && (button_action == APP_BUTTON_PUSH))
      {
          err_code = app_timer_start(long_button_action, 
                                     APP_TIMER_TICKS(BUTTON_STATE_POLL_INTERVAL_MS),
                                     NULL);
          APP_ERROR_CHECK(err_code);
      }
}
/**@brief Function for initializing the button handler module.
 */
static void buttons_init(void)
{

      uint32_t err_code;
      
      static app_button_cfg_t  button_cfg;

      button_cfg.pin_no         = BUTTON_1;
      button_cfg.button_handler = button_callback;
      button_cfg.pull_cfg       = NRF_GPIO_PIN_PULLUP;
      button_cfg.active_state   = APP_BUTTON_ACTIVE_LOW;
      
      err_code = app_button_init(&button_cfg, 1, 100);
      APP_ERROR_CHECK(err_code);
      
      err_code = app_button_enable();
      APP_ERROR_CHECK(err_code);

      /*Enable an app timer instance to detect long button press*/

      err_code = app_timer_create(&long_button_action, APP_TIMER_MODE_SINGLE_SHOT, button_press_timeout_handler);
      APP_ERROR_CHECK(err_code);

      err_code = app_timer_create(&single_button_action, APP_TIMER_MODE_SINGLE_SHOT, single_click_timeout_handler);
      APP_ERROR_CHECK(err_code);
}
#endif //USE_BSP


//*********************************************************************************************////////////////////////////////////////////


/**@brief Function for handling the idle state (main loop).
 *
 * @details If there is no pending log operation, then sleep until next the next event occurs.
 */
static void idle_state_handle(void)
{
    if (NRF_LOG_PROCESS() == false)
    {
        nrf_pwr_mgmt_run();
    }
}


/**@brief Function for changing the tx power.
 */
static void tx_power_set(void)
{
    ret_code_t err_code = sd_ble_gap_tx_power_set(BLE_GAP_TX_POWER_ROLE_ADV, m_advertising.adv_handle, TX_POWER_LEVEL);
    APP_ERROR_CHECK(err_code);
    ble_tps_tx_power_level_set(&m_tps, TX_POWER_LEVEL);
}

#define DEVICE_NAME_LOW "123"
//uint8_t DEVICE_NAME_MED[7]= {"FIND_00"};//{0x65,'i','n','d','_','1','1'};
#define DEVICE_NAME_HIGH "789"
#define DEVICE_NAME_ERR "987"



static void setDeviceName(uint8_t status)
{
    ble_gap_conn_sec_mode_t sec_mode;
    BLE_GAP_CONN_SEC_MODE_SET_OPEN(&sec_mode);
    

    if( advertising_flag == 1)
    {
      DEVICE_NAME_MED[2]= 0x4E;
     // setDeviceName(STATUS_MED);
    }
    else if (advertising_flag == 2)
    {
      DEVICE_NAME_MED[2]= 0x6E;
     // setDeviceName(STATUS_MED);
    }

    DEVICE_NAME_MED[4]=0x30 + temp_name_id;
    DEVICE_NAME_MED[5]=0x30 + temp_name_id_lsb;

    // Set the device name
    switch(status)
    {
        case STATUS_LOW:
            sd_ble_gap_device_name_set(&sec_mode, (const uint8_t *)DEVICE_NAME_LOW, strlen(DEVICE_NAME_LOW));
            bsp_board_led_on(BSP_BOARD_LED_1);
            break;
        case STATUS_MED:
            sd_ble_gap_device_name_set(&sec_mode, (const uint8_t *)DEVICE_NAME_MED, 7);
            bsp_board_led_on(BSP_BOARD_LED_3);
            break;
        case STATUS_HIGH:
            sd_ble_gap_device_name_set(&sec_mode, (const uint8_t *)DEVICE_NAME_HIGH, strlen(DEVICE_NAME_HIGH));
            bsp_board_led_on(BSP_BOARD_LED_2);
            break;
        case STATUS_ERR:
            sd_ble_gap_device_name_set(&sec_mode, (const uint8_t *)DEVICE_NAME_ERR, strlen(DEVICE_NAME_ERR));
            bsp_board_led_on(BSP_BOARD_LED_0);
            break;   
    }

    // Encode the advertising packet and start advertising
    ble_advdata_encode(&advdata, m_adv_data.adv_data.p_data, &m_adv_data.adv_data.len);
    sd_ble_gap_adv_set_configure(&m_adv_handle, &m_adv_data, &adv_params);
    sd_ble_gap_adv_stop(m_adv_handle);
    sd_ble_gap_adv_start(m_adv_handle, APP_BLE_CONN_CFG_TAG);
}


/****************************************---------------Flash read write function-------------------******************************************************/


static void my_fds_evt_handler(fds_evt_t const * const p_fds_evt)
{
    switch (p_fds_evt->id)
    {
        case FDS_EVT_INIT:
            if (p_fds_evt->result != FDS_SUCCESS)
            {
                // Initialization failed.
            }
            break;
				case FDS_EVT_WRITE:
						if (p_fds_evt->result == FDS_SUCCESS)
						{
							write_flag_fds_test=1;
						}
						break;
        default:
            break;
    }
}
static ret_code_t fds_test_write(void)
{
		
		//static uint32_t const m_deadbeef[2] = {0xDEADBEEF,0xBAADF00D};
//		static uint8_t const m_deadbeef[8] = {0x00,0xA2,0xA3,0xA4,0x22,45,12,32};
		fds_record_t        record;
		fds_record_desc_t   record_desc;

		// Set up data.
		

//for (int x = 0; x<8;x++)
//{
  //m_deadbeef[0] = array_update[2];
//}



		// Set up record.
		record.file_id              = FILE_ID_FDS_TEST;
		record.key                  = REC_KEY_FDS_TEST;

      temp_data = m_deadbeef[0];

		record.data.p_data       = &temp_data;
		//record.data.length_words   = sizeof(m_deadbeef)/sizeof(uint32_t);
		record.data.length_words   = sizeof(m_deadbeef)/sizeof(uint8_t);
				
                                record_desc.record_id =1;
		ret_code_t ret = fds_record_write(&record_desc, &record);
		if (ret != FDS_SUCCESS)
		{
				return ret;
		}
		 NRF_LOG_INFO("Writing Record ID = %d \r\n",record_desc.record_id);
		return NRF_SUCCESS;
}

static ret_code_t fds_read(void)
{

bsp_board_init(BSP_INIT_LEDS);
bsp_board_led_on(ADVERTISING_LED);


		fds_flash_record_t  flash_record;
		fds_record_desc_t   record_desc;
		fds_find_token_t    ftok ={0};//Important, make sure you zero init the ftok token
		//uint32_t *data;
		uint8_t *data;
		uint32_t err_code;
                uint8_t i=0;
		
		NRF_LOG_INFO("Start searching... \r\n");
		// Loop until all records with the given key and file ID have been found.
		//while (fds_record_find(FILE_ID_FDS_TEST, REC_KEY_FDS_TEST, &record_desc, &ftok) == FDS_SUCCESS)
                while (fds_record_find_in_file(FILE_ID_FDS_TEST, &record_desc, &ftok) == FDS_SUCCESS)
		{
				err_code = fds_record_open(&record_desc, &flash_record);
				if ( err_code != FDS_SUCCESS)
				{
					return err_code;		
				}
				
				NRF_LOG_INFO("Found Record ID = %d\r\n",record_desc.record_id);
				NRF_LOG_INFO("Data = ");
				//data = (uint32_t *) flash_record.p_data;
				data = (uint8_t *) flash_record.p_data;
				for (uint8_t i=0;i<flash_record.p_header->length_words;i++)
				{
					NRF_LOG_INFO("%d ",(data[i]));
				}
				NRF_LOG_INFO("\r\n");
                                NRF_LOG_INFO("%d ",(data[i]));
                                temp_name_id = data[0];
//                                data[2]= 45;
//                                NRF_LOG_INFO("0x%8x ",data[2]);
//                                NRF_LOG_INFO("0x%8x ",data[3]);
//                                if(record_desc.record_id == 1)
//                                {
//                                  for (uint8_t i=0;i<flash_record.p_header->length_words;i++)
//                                  {
//                                        NRF_LOG_INFO("%x",data[i]);
//                                  }
//                                  //NRF_LOG_INFO("0x%8x ",data[2]);
//                                }
                                //fds_record_find_in_file()
				// Access the record through the flash_record structure.
				// Close the record when done.
				err_code = fds_record_close(&record_desc);
				if (err_code != FDS_SUCCESS)
				{
					return err_code;	
				}
		}
		return NRF_SUCCESS;
		
}

static ret_code_t fds_test_find_and_delete (void)
{

		fds_record_desc_t   record_desc;
		fds_find_token_t    ftok;
	
		ftok.page=0;
		ftok.p_addr=NULL;
		// Loop and find records with same ID and rec key and mark them as deleted. 
		while (fds_record_find(FILE_ID_FDS_TEST, REC_KEY_FDS_TEST, &record_desc, &ftok) == FDS_SUCCESS)
		{
			fds_record_delete(&record_desc);
			NRF_LOG_INFO("Deleted record ID: %d \r\n",record_desc.record_id);
		}
		// call the garbage collector to empty them, don't need to do this all the time, this is just for demonstration
		ret_code_t ret = fds_gc();
		if (ret != FDS_SUCCESS)
		{
				return ret;
		}
		return NRF_SUCCESS;
}

static ret_code_t fds_test_init (void)
{
	
		ret_code_t ret = fds_register(my_fds_evt_handler);
		if (ret != FDS_SUCCESS)
		{
					return ret;
				
		}
		ret = fds_init();
		if (ret != FDS_SUCCESS)
		{
				return ret;
		}
		
		return NRF_SUCCESS;
		
}




/****************************************----------------------------------******************************************************/


/**@brief Function for application main entry.
 */
int main(void)
{
    bool       erase_bonds;
    ret_code_t err_code;

    log_init();
    //bsp_board_init(BSP_INIT_LEDS);
    
    timers_init();
//    power_management_init();

#if USE_BSP == 0
    buttons_init();
#else
    buttons_leds_init(&erase_bonds);
#endif
    
    // Initialize the async SVCI interface to bootloader before any interrupts are enabled.
    err_code = ble_dfu_buttonless_async_svci_init();
    APP_ERROR_CHECK(err_code);

    ble_stack_init();
    gap_params_init();
    gatt_init();
    advertising_init();
    services_init();
    conn_params_init();
    peer_manager_init();
    //tx_power_set();
    //bsp_board_led_off(BSP_INIT_LEDS);


/***************************/
//          advertising_flag = 1;
//
////          gap_params_init();
////          advertising_init();
////
////          advertising_start();                  //start normal advertising
//          setDeviceName(STATUS_MED);

    NRF_LOG_INFO("Buttonless DFU Application started.");
    err_code =fds_test_init();
    APP_ERROR_CHECK(err_code);
    // Enter main loop.
    for (;;)
    {
       // idle_state_handle();
    }
}

/**
 * @}
 */

Waiting for your valuable response.

Regards,

Rohit

Related