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

FDS Write: Wrong Written Data

Good Afternoon,

I'm writing some config data on an empty record the first time I turn on my board and updating that same record every next time I turn on the board.

While the writing of the first data is correctly written with fds_record_write() - when I check the data with fds_record_open() -, the data is totally wrongly written when I update the record with new config data, with fds_record_update().

When the board initialises I initialise FDS and call flash_write_record_setup(&DEVICE_struct_w_config2write) after initialising the softdevice.

By looking into the code below, do you have any cue why the data is not correctly written when I update the record?

Thank you,

João Oliveira

/* Declarations in flash.h */

/* File ID and Key used for the configuration record. */

#define CONFIG_FILE     (0xF010)
#define CONFIG_REC_KEY  (0x7010)

typedef struct
{
	uint8_t enable;
	uint8_t time_adv;
}ADVERTISE;

typedef struct
{
	uint8_t state;
	ADVERTISE adv2;
}DEVICE;

/* flash_write_record_setup function in flash.c */

void flash_write_record_setup(DEVICE * config2write)
{
    ret_code_t rc;

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

    //CONFIG_FILE and CONFIG_REC_KEY defined in flash.h
    rc = fds_record_find(CONFIG_FILE, CONFIG_REC_KEY, &desc, &tok);

    if (rc == FDS_SUCCESS) //record exists => update it
    {
        /* 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);

        /* Close the record when done reading. */
        rc = fds_record_close(&desc);
        APP_ERROR_CHECK(rc);
 
        //compare existing config in flash with new one
        uint8_t ret = memcmp(config2write, config.p_data, sizeof(DEVICE));

        if(ret != 0) //if different update config in flash
        {
            /* Write the updated record to flash. */
			fds_record_t const rec =
			{
				.file_id           = CONFIG_FILE,
				.key               = CONFIG_REC_KEY,
				.data.p_data       = config2write,
				.data.length_words = (sizeof(DEVICE) + 3) / sizeof(uint32_t)
			};

            rc = fds_record_update(&desc, &rec);
            APP_ERROR_CHECK(rc);

            m_write_finished = false;
        }
        else
        {
            /* Same config data as previous, nothing to be done */
        }
    }
    else  /* System config not found; write a new one. */
    {
        fds_record_t const rec =
        {
            .file_id           = CONFIG_FILE,
            .key               = CONFIG_REC_KEY,
            .data.p_data       = config2write,
            .data.length_words = (sizeof(DEVICE) + 3) / sizeof(uint32_t)
        };

        rc = fds_record_write(&desc, &rec);
        APP_ERROR_CHECK(rc);

        m_write_finished = false;
    }
}

  • Hi,

    I tested the flash part of your code by copying it over into the fds example in SDK15.0.0. I added some logging of the state struct member to see the initial write, value on boot and update writes. As you can see below where I started with an empty device and pressed reset twice, I first write the initial value of 1, then I update it to 2 and after that, the value is 2 already so no new update is performed.

    Here is the main.c file I used, the rest is just the FDS example in SDK15.0.0 unaltered:

    /**
     * Copyright (c) 2017 - 2018, 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.
     * 
     */
    
    #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"
    
    
    /* 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)
    {
        NRF_LOG_GREEN("Event: %s received (%s)",
                      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)
                {
                    NRF_LOG_INFO("Record ID:\t0x%04x",  p_evt->write.record_id);
                    NRF_LOG_INFO("File ID:\t0x%04x",    p_evt->write.file_id);
                    NRF_LOG_INFO("Record key:\t0x%04x", p_evt->write.record_key);
                }
            } break;
    
            case FDS_EVT_DEL_RECORD:
            {
                if (p_evt->result == FDS_SUCCESS)
                {
                    NRF_LOG_INFO("Record ID:\t0x%04x",  p_evt->del.record_id);
                    NRF_LOG_INFO("File ID:\t0x%04x",    p_evt->del.file_id);
                    NRF_LOG_INFO("Record key:\t0x%04x", 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)
        {
            NRF_LOG_INFO("Deleting next record.");
    
            m_delete_all.delete_next = record_delete_next();
            if (!m_delete_all.delete_next)
            {
                NRF_LOG_CYAN("No records left to delete.");
            }
        }
    }
    
    
    #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_init(void)
    {
        ret_code_t err_code = app_timer_init();
        APP_ERROR_CHECK(err_code);
    }
    
    
    /**@brief   Initialize logging. */
    static void log_init(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();
        }
    }
    
    
    typedef struct
    {
        uint8_t enable;
        uint8_t time_adv;
    }ADVERTISE;
    
    typedef struct
    {
        uint8_t state;
        ADVERTISE adv2;
    }DEVICE;
    
    static DEVICE config2write;
    
    void flash_write_record_setup(DEVICE * config2write)
    {
        ret_code_t rc;
        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)
        {
            config2write->state = 2;
    
            /* 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);
    
            DEVICE * tmp = (DEVICE*)config.p_data;
            NRF_LOG_INFO("Current file content: %d .", tmp->state);
    
            //compare existing config in flash with new one
            uint8_t ret = memcmp(config2write, config.p_data, sizeof(DEVICE));
    
            /* Close the record when done reading. */
            rc = fds_record_close(&desc);
            APP_ERROR_CHECK(rc);
     
            NRF_LOG_INFO("NEW  : %d", ((uint32_t*)config2write)[0]);
            NRF_LOG_INFO("FLASH: %d", ((uint32_t*)config.p_data)[0]);
    
            if(ret != 0) //if different update config in flash
            {
                NRF_LOG_INFO("Updating state value to 2");
                config2write->state = 2;
                /* Write the updated record to flash. */
                fds_record_t const rec =
                {
                    .file_id           = CONFIG_FILE,
                    .key               = CONFIG_REC_KEY,
                    .data.p_data       = config2write,
                    .data.length_words = (sizeof(DEVICE) + 3) / sizeof(uint32_t)
                };
    
                rc = fds_record_update(&desc, &rec);
                APP_ERROR_CHECK(rc);
            }
            else
            {
                /* Same config data as previous, nothing to be done */
            }
        }
        else
        {
            /* System config not found; write a new one. */
            NRF_LOG_INFO("Writing config file...");
    
            fds_record_t const rec =
            {
                .file_id           = CONFIG_FILE,
                .key               = CONFIG_REC_KEY,
                .data.p_data       = config2write,
                .data.length_words = (sizeof(DEVICE) + 3) / sizeof(uint32_t)
            };
    
      
            DEVICE * tmp = (DEVICE*)rec.data.p_data;
            NRF_LOG_INFO("Wrinting state value for the first time with value: %d .", tmp->state);
    
            rc = fds_record_write(&desc, &rec);
            APP_ERROR_CHECK(rc);
        }
    }
    
    
    int main(void)
    {
        ret_code_t rc;
    
    #ifdef SOFTDEVICE_PRESENT
        ble_stack_init();
    #else
        clock_init();
    #endif
    
        timer_init();
        log_init();
        cli_init();
    
        NRF_LOG_INFO("FDS example started.")
    
        /* Register first to receive an event when initialization is complete. */
        (void) fds_register(fds_evt_handler);
    
        NRF_LOG_INFO("Initializing fds...");
    
        rc = fds_init();
        APP_ERROR_CHECK(rc);
    
        /* Wait for fds to initialize. */
        wait_for_fds_ready();
    
        NRF_LOG_INFO("Available commands:");
        NRF_LOG_INFO("- print all\t\tprint records");
        NRF_LOG_INFO("- print config\tprint configuration");
        NRF_LOG_INFO("- update\t\tupdate configuration");
        NRF_LOG_INFO("- stat\t\tshow statistics");
        NRF_LOG_INFO("- write\t\twrite a new record");
        NRF_LOG_INFO("- delete\t\tdelete a record");
        NRF_LOG_INFO("- delete_all\tdelete all records");
        NRF_LOG_INFO("- gc\t\trun garbage collection");
    
        NRF_LOG_INFO("Reading flash usage statistics...");
    
        fds_stat_t stat = {0};
    
        rc = fds_stat(&stat);
        APP_ERROR_CHECK(rc);
    
        NRF_LOG_INFO("Found %d valid records.", stat.valid_records);
        NRF_LOG_INFO("Found %d dirty records (ready to be garbage collected).", stat.dirty_records);
    
        config2write.state = 1;
        config2write.adv2.enable = 12;
        config2write.adv2.time_adv = 13;
    
    
        flash_write_record_setup(&config2write);
    
        cli_start();
    
        /* Enter main loop. */
        for (;;)
        {
            if (!NRF_LOG_PROCESS())
            {
                power_manage();
            }
            cli_process();
            delete_all_process();
        }
    }
    
    
    /**
     * @}
     */
    

    Basically, it seems like the code you sent me is working.

    My guess is that your "config2write" variable is in the wrong scope. You have to keep this variable unchanged until you get the callback from FDS. I just use a static variable in my implementation above. If this does not resolve the issue for you, please compare my code above to your own and if you still can't find a cause feel free to send me a reply below, preferably with your full source code as a zip.

    A final note: Since this is during initialization it's most likely not going to be a problem, but you open, close and read the record. You have to change the order so that you open, read and close it instead.

    Best regards,
    Rune Holmgren

  • Hi Rune,

    Thank you for your help.

    I tried the code directly in the flash_fds example as per your code and it works fine.

    Yet, when I use exactly the same code in my app I'm struggling with code alignment erros with the fds_record_update() returning error FDS_ERR_UNALIGNED_ADDR. I guess the same could happen in your code eventually. How can I guarantee that the config2write address I'm trying to save on flash is word aligned?

     

    Thank you,

    João

  • Sorry for the late reply.

    The flash in the nRF5 series can only handle whole words, so you need to make sure all data is aligned with 4-byte words. My guess would be that you are having problems with "config2write" not being word aligned. In my code above I had it stored as a static variable, so my compiler will just put it in RAM at some suitable address and there will never be a problem. If I were to store it in a struct or array of some kind it's possible to get into a situation where the data is not aligned.

    Best regards,
    Rune Holmgren

  • Dear Rune,

     

    Thank you for your reply, I also used a static variable to make sure it is word-aligned but still required to declare __ALIGN(4) in the DEVICE struct declaration itself in order to make sure it never returns FDS_ERR_UNALIGNED_ADDR when writing to flash, as flash_write_config_record() is called from different scopes (from different .c files).

    In the meantime I also created read/write fds functions for a userid in char* format. As these are also called from different scopes, in order to guarantee no word-alignment errors, the flash_write_userid_record() function copies the userid2write data into an __ALIGN(4) static char* variable to be written into flash.

    As per flash_read_userid(), I had to use a pointer to char* pointing to the flash data char* to return it.

     

    Although every read/write call seem to work fine, for some reason I can't identify some rare times the app crashes when calling flash_read_userid() just after setting up the BLE connection without any assert, and the flash record seem to get corrupted as I can't write to it anymore unless I delete it before.

    Is there anything I'm doing wrong with the read/write user id functions and calls, or could it be colliding with the BLE radio activity somehow?

     

    Find the new code below:

     

    /* Declarations in flash.h */
    
    /* File ID and Key used for the configuration record. */
    
    #define CONFIG_FILE     (0xF010)
    #define CONFIG_REC_KEY  (0x7010)
    
    /* File ID and Key used for the userid record. */
    
    #define USERID_FILE     (0xF050)
    #define USERID_REC_KEY  (0x7050)
    
    typedef struct
    {
    	uint8_t enable;
    	uint8_t time_adv;
    }ADVERTISE;
    
    typedef struct
    {
    	uint8_t state;
    	ADVERTISE adv2;
    }__ALIGN(4) DEVICE;
    
    
    /* ========= flash.c ==========
    
    ret_code_t flash_read_config(DEVICE * p_cfg)
    {
        ret_code_t read_success = FDS_ERR_NOT_FOUND;
    
        fds_record_desc_t desc = {0};
        fds_find_token_t  tok  = {0};
    
        //Loop until all records with the given key and file ID have been found.
        while (fds_record_find(CONFIG_FILE, CONFIG_REC_KEY, &desc, &tok) == FDS_SUCCESS)
        {
            ret_code_t rc;
            fds_flash_record_t frec = {0};
    
            rc = fds_record_open(&desc, &frec);
    
            switch (rc)
            {
                case FDS_SUCCESS:
                    break;
    
                case FDS_ERR_CRC_CHECK_FAILED:
                    #ifdef _UART_FLASH_
                    NRF_LOG_INFO("error: CRC check failed!");
                    #endif
                    continue;
    
                case FDS_ERR_NOT_FOUND:
                    #ifdef _UART_FLASH_
                    NRF_LOG_INFO("error: record not found!");
                    #endif
                    continue;
    
                default:
                {
                    #ifdef _UART_FLASH_
                    NRF_LOG_INFO("error: unexpected error %s.",
                                    fds_err_str[rc]);
                    #endif
    
                    continue;
                }
            }
    
            //memcpy to pass p_cfg pointer with flash data from frec.p_data
            memcpy(p_cfg, frec.p_data, sizeof(DEVICE));
    
            NRF_LOG_INFO("FLASH READ CONFIG 00%x0%x0%x @ %x:",
            p_cfg->adv2.time_adv, p_cfg->adv2.enable, p_cfg->state, tok.p_addr);
            NRF_LOG_INFO("state: %d\r\n" 
                          "adv2.enable: %d\r\n"
                          "adv2.time_adv: %d\r\n",
                          p_cfg->state, p_cfg->adv2.enable, p_cfg->adv2.time_adv);
    
            rc = fds_record_close(&desc);
            APP_ERROR_CHECK(rc);
    
            read_success = FDS_SUCCESS; //if found and read record
        }
    
        return read_success;
    }
    
    void flash_write_config_record(DEVICE * config2write)
    {
        ret_code_t rc;
    
        fds_record_desc_t desc = {0};
        fds_find_token_t  tok  = {0};
    
        // Copy write data to static word-aligned variable.
        uint32_t const len_cfg = sizeof(config2write);
        __ALIGN(4) static DEVICE flash_write_data;
        memcpy(&flash_write_data, config2write, len_cfg);
    
        //CONFIG_FILE and CONFIG_REC_KEY defined in flash.h
        rc = fds_record_find(CONFIG_FILE, CONFIG_REC_KEY, &desc, &tok);
        if (rc == FDS_SUCCESS) //record exists => update it
        {
            /* 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);
    
            //compare existing config in flash with new one      
            NRF_LOG_INFO("CONFIG IN FLASH:\r\n"
                      "state: %d\r\n" 
                      "adv2.enable: %d\r\n"
                      "adv2.time_adv: %d\r\n",
                      ((DEVICE*)config.p_data)->state, ((DEVICE*)config.p_data)->adv2.enable, ((DEVICE*)config.p_data)->adv2.time_adv);
            
            NRF_LOG_INFO("NEW CONFIG TO UPDATE:\r\n"
                          "state: %d\r\n" 
                          "adv2.enable: %d\r\n"
                          "adv2.time_adv: %d\r\n",
                          flash_write_data.state, flash_write_data.adv2.enable, flash_write_data.adv2.time_adv);
    
            uint8_t ret = memcmp(&flash_write_data, config.p_data, len_cfg);
            
            // Close the record when done reading. 
            rc = fds_record_close(&desc);
            APP_ERROR_CHECK(rc);
            
            if(ret != 0) //if different update config in flash
            {
                record_update(CONFIG_FILE, CONFIG_REC_KEY, desc, &flash_write_data, len_cfg);
    
                NRF_LOG_INFO("===== UPDATED FDS FLASH =====);
    
                m_write_finished = false;
            }
            else
            {
                 #ifdef _UART_FLASH_
                 NRF_LOG_INFO("FLASH: same config data as previous, nothing to be done:\r\n"
                          "state: %d\r\n" 
                          "adv2.enable: %d\r\n"
                          "adv2.time_adv: %d\r\n",
                          ((DEVICE*)config.p_data)->state, ((DEVICE*)config.p_data)->adv2.enable, ((DEVICE*)config.p_data)->adv2.time_adv);
                 #endif
            }
        }
        else
        {
            /* System config not found; write a new one. */
            NRF_LOG_INFO("NEW CONFIG TO WRITE:\r\n"
                          "state: %d\r\n" 
                          "adv2.enable: %d\r\n"
                          "adv2.time_adv: %d\r\n",
                          flash_write_data.state, flash_write_data.adv2.enable, flash_write_data.adv2.time_adv);
    
            record_write(CONFIG_FILE, CONFIG_REC_KEY, &flash_write_data, len_cfg);
    
            NRF_LOG_INFO("===== WROTE FDS FLASH =====");
    
            m_write_finished = false;
        }
    }
    
    //NOTE: Need Pointer to Pointer for userid to return the char* in the address pointing to freq.p_data because it is an array of chars and therefore can't use memcpy to copy freq.p_data and return because it loses scope
    static void record_write(uint32_t fid,
                             uint32_t key,
                             void const * p_data,
                             uint32_t len)
    {
        fds_record_t const rec =
        {
            .file_id           = fid,
            .key               = key,
            .data.p_data       = p_data,
            .data.length_words = (len + 3) / sizeof(uint32_t)
        };
    
        #ifdef _UART_FLASH_
        NRF_LOG_INFO("--> writing record to flash...\r\n"
                        "file: 0x%x, key: 0x%x, \"%s\", len: %u bytes",
                        fid, key, p_data, len);
        #endif
    
        ret_code_t rc = fds_record_write(NULL, &rec);
    
        #ifdef _UART_FLASH_
        if (rc != FDS_SUCCESS)
        {
            NRF_LOG_INFO("--> error: fds_record_write() returned %s.",
                            fds_err_str[rc]);
        }
        #endif
    }
    
    static void record_update(uint32_t fid,
                             uint32_t key,
                             fds_record_desc_t desc, 
                             void const * p_data,
                             uint32_t len)
    {
        fds_record_t const rec =
        {
            .file_id           = fid,
            .key               = key,
            .data.p_data       = p_data,
            .data.length_words = (len + 3) / sizeof(uint32_t)
        };
    
        #ifdef _UART_FLASH_
        NRF_LOG_INFO("--> updating record in flash...\r\n"
                        "file: 0x%x, key: 0x%x, \"%s\", len: %u bytes",
                        fid, key, p_data, len);
        #endif
    
        ret_code_t rc = fds_record_update(&desc, &rec);
    
        #ifdef _UART_FLASH_
        if (rc != FDS_SUCCESS)
        {
            NRF_LOG_INFO("--> error: fds_record_write() returned %s.",
                            fds_err_str[rc]);
        }
        #endif
    }
    
    ret_code_t flash_read_userid(char ** userid)
    {
        ret_code_t read_success = FDS_ERR_NOT_FOUND;
    
        fds_record_desc_t desc = {0};
        fds_find_token_t  tok  = {0};
    
        //Loop until all records with the given key and file ID have been found.
        while (fds_record_find(USERID_FILE, USERID_REC_KEY, &desc, &tok) == FDS_SUCCESS)
        {
            ret_code_t rc;
            fds_flash_record_t frec = {0};
    
            rc = fds_record_open(&desc, &frec);
            switch (rc)
            {
                case FDS_SUCCESS:
                    break;
    
                case FDS_ERR_CRC_CHECK_FAILED:
                    #ifdef _UART_FLASH_
                    NRF_LOG_INFO("error: CRC check failed!");
                    #endif
                    continue;
    
                case FDS_ERR_NOT_FOUND:
                    #ifdef _UART_FLASH_
                    NRF_LOG_INFO("error: record not found!");
                    #endif
                    continue;
    
                default:
                {
                    #ifdef _UART_FLASH_
                    NRF_LOG_INFO("error: unexpecte error %s.",
                                    fds_err_str[rc]);
                    #endif
    
                    continue;
                }
            }
    
            //Memcpy frec.p_data address and point to copy's address
            uint32_t const len_str = strlen((char*)frec.p_data)+1; //NOTE: +1 to include NULL char in end of string
            __ALIGN(4) static uint8_t * flash_read_data;
            flash_read_data = malloc(sizeof(uint8_t) * len_str);
            memset(flash_read_data, 0x00, sizeof(flash_read_data));
            memcpy(flash_read_data, frec.p_data, len_str);
            
            *userid = (char*)flash_read_data;
    
            rc = fds_record_close(&desc);
            APP_ERROR_CHECK(rc);
    
            read_success = FDS_SUCCESS; //if found and read record
        }
    
        return read_success;
    }
    
    void flash_write_userid_record(char * userid2write)
    {
        ret_code_t rc;
    
        fds_record_desc_t desc = {0};
        fds_find_token_t  tok  = {0};
    
        // Copy write data to static word-aligned variable.
        uint32_t const len_str = strlen(userid2write)+1; //NOTE: +1 to include NULL char in end of string
        __ALIGN(4) static char * flash_write_data;
        flash_write_data = malloc(sizeof(char) * len_str);
        memset(flash_write_data, 0x00, sizeof(flash_write_data));
        memcpy(flash_write_data, userid2write, len_str);
    
        //CONFIG_FILE and CONFIG_REC_KEY defined in flash.h
        rc = fds_record_find(USERID_FILE, USERID_REC_KEY, &desc, &tok);
        if (rc == FDS_SUCCESS) //record exists => update it
        {
            /// A userid file is in flash. Let's update it.
            fds_flash_record_t userid = {0};
    
            // Open the record and read its contents. 
            rc = fds_record_open(&desc, &userid);
            APP_ERROR_CHECK(rc);
     
            //compare existing config in flash with new one      
            //NOTE: need to copy flash data to static var to hold the data correctly, and __ALIGNED(4) to guarantee word-alignment
            uint32_t const len_str = strlen((char*)userid.p_data)+1; //NOTE: +1 to include NULL char in end of string
            __ALIGN(4) static char * flash_read_data;
            flash_read_data = malloc(sizeof(char) * len_str);
            memset(flash_read_data, 0x00, sizeof(flash_read_data));
            memcpy(flash_read_data, userid.p_data, len_str);
            
    
            //__ALIGN(4) static char * flash_read_data;
            //flash_read_data = (char*)userid.p_data;
    
            #ifdef _UART_FLASH_
            NRF_LOG_INFO("NEW USERID TO UPDATE: %s", userid2write);
            NRF_LOG_INFO("USERID IN FLASH     : %s", flash_read_data);
            #endif
    
            //NOTE: Use strlen to compare strings until end of first string
            uint8_t ret = memcmp(userid2write, flash_read_data, len_str);
    
            // Close the record when done reading. 
            rc = fds_record_close(&desc);
            APP_ERROR_CHECK(rc);
    
            if(ret != 0) //if different update config in flash
            {
                // Write the updated record to flash.
                #ifdef _UART_FLASH_            
                NRF_LOG_INFO("FLASH TO UPDATE W/ NEW USERID: %s", flash_write_data);       
                #endif
    
                record_update(USERID_FILE, USERID_REC_KEY, desc, flash_write_data, len_str);
    
                #ifdef _UART_FLASH_
                NRF_LOG_INFO("===== UPDATED FDS FLASH W/ USERID =====");
                #endif
    
                m_write_finished = false;
            }
            else
            {
                 #ifdef _UART_FLASH_
                 NRF_LOG_INFO("FLASH: same userid data as previous, nothing to be done");
                 #endif
            }
        }
        else
        {
            // System config not found; write a new one.
            #ifdef _UART_FLASH_
            NRF_LOG_INFO("FLASH TO WRITE NEW USERID: %s", flash_write_data);
            #endif
    
            record_write(USERID_FILE, USERID_REC_KEY, flash_write_data, len_str);
    
            #ifdef _UART_FLASH_
            NRF_LOG_INFO("===== WROTE FDS FLASH =====");
            #endif
    
            m_write_finished = false;
        }
    }
    

     

    Thank you,

    João

  • Hi again Rune,

     

    After struggling a lot I just found out that the problem occurs when I try to write any userid string that has a number of bytes multiple of 4 (that is 4bytes, 8bytes, 12bytes, etc). It writes without any error but when I try to read that flash data afterwards the app gets stuck without reporting erros.

    I found it very weird and tested it then in the flash_fds example directly and the same issue occurs.

    Just try to write any multiple of 4 bytes string with the command "write fid key "multiple_of_4_bytes_string"" and then read the data by calling the "print all" command but with a NRF_LOG_INFO("%s", (char*)frec.p_data) line (or any other line that makes use of frec.p_data) inside the print_all_cmd function.

     

    I guess this is a very weird bug in the FDS API that might be related to word-unalignment in flash.

     

    Looking forward to hear about your clarification about this issue,

    Best regards,

    João

Related