problem with fds in the light swich project

[UdjinPr]

Hello, I am trying to combine light switch client example with fds functionality.

For these I did next steps:

1. Included all ‘c’ files from the fds example to the light switch project.
2. Added links for all ‘h’ files to the "User Include Directories" in light switch project 
3. Activated necessary variables in the sdk_config.c 
4. Copy main.c from the fds_flash to the light switch project. 
5. Changed all NRF_ messages to __LOG l.

As a result there aren’t any mistakes after compilation project, but program sticks in wait_for_fds_ready() function in the loop.

 

My main.c.: 

 

Fullscreen

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

#include <stdint.h>

#include <string.h>

#include "nrf.h"

#include "nordic_common.h"

#ifdef SOFTDEVICE_PRESENT

#include "nrf_sdh.h"

#include "nrf_sdh_ble.h"

#else

#include "nrf_drv_clock.h"

#endif

#include "fds.h"

#include "app_timer.h"

#include "app_error.h"

#include "nrf_cli.h"

#include "fds_example.h"

#define NRF_LOG_MODULE_NAME app

#include "nrf_log.h"

#include "nrf_log_ctrl.h"

#include "log.h"

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

#include <stdint.h>
#include <string.h>
#include "nrf.h"
#include "nordic_common.h"
#ifdef SOFTDEVICE_PRESENT
#include "nrf_sdh.h"
#include "nrf_sdh_ble.h"
#else
#include "nrf_drv_clock.h"
#endif
#include "fds.h"
#include "app_timer.h"
#include "app_error.h"
#include "nrf_cli.h"
#include "fds_example.h"

#define NRF_LOG_MODULE_NAME app
#include "nrf_log.h"
#include "nrf_log_ctrl.h"

#include "log.h"


/* A tag identifying the SoftDevice BLE configuration. */
#define APP_BLE_CONN_CFG_TAG    1


/* Array to map FDS return values to strings. */
char const * fds_err_str[] =
{
    "FDS_SUCCESS",
    "FDS_ERR_OPERATION_TIMEOUT",
    "FDS_ERR_NOT_INITIALIZED",
    "FDS_ERR_UNALIGNED_ADDR",
    "FDS_ERR_INVALID_ARG",
    "FDS_ERR_NULL_ARG",
    "FDS_ERR_NO_OPEN_RECORDS",
    "FDS_ERR_NO_SPACE_IN_FLASH",
    "FDS_ERR_NO_SPACE_IN_QUEUES",
    "FDS_ERR_RECORD_TOO_LARGE",
    "FDS_ERR_NOT_FOUND",
    "FDS_ERR_NO_PAGES",
    "FDS_ERR_USER_LIMIT_REACHED",
    "FDS_ERR_CRC_CHECK_FAILED",
    "FDS_ERR_BUSY",
    "FDS_ERR_INTERNAL",
};

/* Array to map FDS events to strings. */
static char const * fds_evt_str[] =
{
    "FDS_EVT_INIT",
    "FDS_EVT_WRITE",
    "FDS_EVT_UPDATE",
    "FDS_EVT_DEL_RECORD",
    "FDS_EVT_DEL_FILE",
    "FDS_EVT_GC",
};

/* Dummy configuration data. */
static configuration_t m_dummy_cfg =
{
    .config1_on  = false,
    .config2_on  = true,
    .boot_count  = 0x0,
    .device_name = "dummy",
};

/* A record containing dummy configuration data. */
static fds_record_t const m_dummy_record =
{
    .file_id           = CONFIG_FILE,
    .key               = CONFIG_REC_KEY,
    .data.p_data       = &m_dummy_cfg,
    /* The length of a record is always expressed in 4-byte units (words). */
    .data.length_words = (sizeof(m_dummy_cfg) + 3) / sizeof(uint32_t),
};

/* Keep track of the progress of a delete_all operation. */
static struct
{
    bool delete_next;   //!< Delete next record.
    bool pending;       //!< Waiting for an fds FDS_EVT_DEL_RECORD event, to delete the next record.
} m_delete_all;

/* Flag to check fds initialization. */
static bool volatile m_fds_initialized;


static void fds_evt_handler(fds_evt_t const * p_evt)
{
   __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Event: %s received (%s)\n",
                  fds_evt_str[p_evt->id],
                  fds_err_str[p_evt->result]);

    switch (p_evt->id)
    {
        case FDS_EVT_INIT:
            if (p_evt->result == FDS_SUCCESS)
            {
                m_fds_initialized = true;
            }
            break;

        case FDS_EVT_WRITE:
        {
            if (p_evt->result == FDS_SUCCESS)
            {
                __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Record ID:\t0x%04x\n",  p_evt->write.record_id);
                __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "File ID:\t0x%04x\n",    p_evt->write.file_id);
                __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Record key:\t0x%04x\n", p_evt->write.record_key);
            }
        } break;

        case FDS_EVT_DEL_RECORD:
        {
            if (p_evt->result == FDS_SUCCESS)
            {
                __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Record ID:\t0x%04x\n",  p_evt->del.record_id);
                __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "File ID:\t0x%04x\n",    p_evt->del.file_id);
                __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Record key:\t0x%04x\n", p_evt->del.record_key);
            }
            m_delete_all.pending = false;
        } break;

        default:
            break;
    }
}


/**@brief   Begin deleting all records, one by one. */
void delete_all_begin(void)
{
    m_delete_all.delete_next = true;
}


/**@brief   Process a delete all command.
 *
 * Delete records, one by one, until no records are left.
 */
void delete_all_process(void)
{
    if (   m_delete_all.delete_next
        & !m_delete_all.pending)
    {
        __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Deleting next record.\n");

        m_delete_all.delete_next = record_delete_next();
        if (!m_delete_all.delete_next)
        {
             __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "No records left to delete.\n");
        }
    }
}


#ifdef SOFTDEVICE_PRESENT
/**@brief   Function for initializing the SoftDevice and enabling the BLE stack. */
static void ble_stack_init(void)
{
    ret_code_t rc;
    uint32_t   ram_start;

    /* Enable the SoftDevice. */
    rc = nrf_sdh_enable_request();
    APP_ERROR_CHECK(rc);

    rc = nrf_sdh_ble_default_cfg_set(APP_BLE_CONN_CFG_TAG, &ram_start);
    APP_ERROR_CHECK(rc);

    rc = nrf_sdh_ble_enable(&ram_start);
    APP_ERROR_CHECK(rc);
}
#else
static void clock_init(void)
{
    /* Initialize the clock. */
    ret_code_t rc = nrf_drv_clock_init();
    APP_ERROR_CHECK(rc);

    nrf_drv_clock_lfclk_request(NULL);

    /* Wait for the clock to be ready. */
    while (!nrf_clock_lf_is_running()) {;}
}
#endif


/**@brief   Initialize the timer. */
static void timer_init1(void)
{
    ret_code_t err_code = app_timer_init1();
    APP_ERROR_CHECK(err_code);
}


/**@brief   Initialize logging. */
static void log_init1(void)
{
    ret_code_t rc = NRF_LOG_INIT(NULL);
    APP_ERROR_CHECK(rc);
}


/**@brief   Sleep until an event is received. */
static void power_manage(void)
{
#ifdef SOFTDEVICE_PRESENT
    (void) sd_app_evt_wait();
#else
    __WFE();
#endif
}


/**@brief   Wait for fds to initialize. */
static void wait_for_fds_ready(void)
{
    while (!m_fds_initialized)
    {
        power_manage();
    }
}


int main(void)
{
    ret_code_t rc;


    //ble_stack_init();

    timer_init1();
    log_init1();
   // cli_init();
     __LOG_INIT(LOG_SRC_APP | LOG_SRC_ACCESS | LOG_SRC_BEARER, LOG_LEVEL_INFO, LOG_CALLBACK_DEFAULT);
     __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "----- BLE Mesh Light Switch Client Demo -----\n");


    __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "FDS example started.\n")

    /* Register first to receive an event when initialization is complete. */
    (void) fds_register(fds_evt_handler);

    __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Initializing fds...\n");

    rc = fds_init();
    APP_ERROR_CHECK(rc);

    /* Wait for fds to initialize. */
    wait_for_fds_ready();

    __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Available commands:\n");
    __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "- print all\t\tprint records\n");
    __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "- print config\tprint configuration\n");
    __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "- update\t\tupdate configuration\n");
    __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "- stat\t\tshow statistics\n");
    __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "- write\t\twrite a new record\n");
    __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "- delete\t\tdelete a record\n");
    __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "- delete_all\tdelete all records\n");
    __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "- gc\t\trun garbage collection\n");

    __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Reading flash usage statistics...\n");

    fds_stat_t stat = {0};

    rc = fds_stat(&stat);
    APP_ERROR_CHECK(rc);
    __LOG(LOG_SRC_APP, LOG_LEVEL_INFO,"Found %d valid records.\n", stat.valid_records);
    __LOG(LOG_SRC_APP, LOG_LEVEL_INFO,"Found %d dirty records (ready to be garbage collected).\n", stat.dirty_records);



    fds_record_desc_t desc = {0};
    fds_find_token_t  tok  = {0};

    rc = fds_record_find(CONFIG_FILE, CONFIG_REC_KEY, &desc, &tok);

    if (rc == FDS_SUCCESS)
    {
        /* A config file is in flash. Let's update it. */
        fds_flash_record_t config = {0};

        /* Open the record and read its contents. */
        rc = fds_record_open(&desc, &config);
        APP_ERROR_CHECK(rc);

        /* Copy the configuration from flash into m_dummy_cfg. */
        memcpy(&m_dummy_cfg, config.p_data, sizeof(configuration_t));

        __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Config file found, updating boot count to %d.\n", m_dummy_cfg.boot_count);

        /* Update boot count. */
        m_dummy_cfg.boot_count++;

        /* Close the record when done reading. */
        rc = fds_record_close(&desc);
        APP_ERROR_CHECK(rc);

        /* Write the updated record to flash. */
        rc = fds_record_update(&desc, &m_dummy_record);
        APP_ERROR_CHECK(rc);
    }
    else
    {
        /* System config not found; write a new one. */
        __LOG(LOG_SRC_APP, LOG_LEVEL_INFO, "Writing config file...\n");

        rc = fds_record_write(&desc, &m_dummy_record);
        APP_ERROR_CHECK(rc);
    }

   //cli_start();

    /* Enter main loop. */
    for (;;)
    {
        if (!NRF_LOG_PROCESS())
        {
            power_manage();
        }
       // cli_process();
        delete_all_process();
    }
}