fstorage read a int or float from flash

RE: fstorage read a int or float from flash

melt — Tue, 28 May 2019 14:43:16 GMT

Thank you very much

RE: fstorage read a int or float from flash

Kenneth — Tue, 28 May 2019 13:39:31 GMT

typedef struct
{
    uint32_t data_uint32;                                  
    float  data_float;                              
    char string[12];
} my_data;

my_data m_my_data;
my_data m_my_data_readback;

    memset(&m_my_data, 0, sizeof(m_my_data));
    memset(&m_my_data_readback, 0, sizeof(m_my_data_readback));
    
    m_my_data.data_uint32 = 123;
    m_my_data.data_float = 456.789;    
    memcpy(m_my_data.string, m_hello_world_read, sizeof(m_my_data.string)-1);  
    
    NRF_LOG_INFO("Writing " NRF_LOG_FLOAT_MARKER " to flash.", NRF_LOG_FLOAT(m_my_data.data_float));
    rc = nrf_fstorage_write(&fstorage, 0x3e300, &m_my_data, sizeof(m_my_data), NULL);
    APP_ERROR_CHECK(rc);

    wait_for_flash_ready(&fstorage);
    NRF_LOG_INFO("Done.");

    rc = nrf_fstorage_read(&fstorage, 0x3e300, &m_my_data_readback, sizeof(m_my_data_readback));
    APP_ERROR_CHECK(rc);
    NRF_LOG_INFO("Reading " NRF_LOG_FLOAT_MARKER " from flash.", NRF_LOG_FLOAT(m_my_data_readback.data_float));

    wait_for_flash_ready(&fstorage);
    NRF_LOG_INFO("Done.");

NRF_LOG is not very fond of float values, but the above seems to work. The above example will store both an uint32, float, and a string, but for the purpose of the example only output the float value.

RE: fstorage read a int or float from flash

melt — Mon, 27 May 2019 14:02:45 GMT

thanks but it does do anything

what should I add in the 3rd argument in the function namely size ? &m_data_read,sizeof(m_data_read));

RE: fstorage read a int or float from flash

Kenneth — Mon, 27 May 2019 13:33:04 GMT

'const' typically means the variable is fixed (read-only) and thereby cannot be updated. I suggest to remove the const for any variable you want to be able to update run-time.

https://www.geeksforgeeks.org/how-to-modify-a-const-variable-in-c/

RE: fstorage read a int or float from flash

melt — Mon, 27 May 2019 10:59:57 GMT

Hi Kenneth

I can confirm it is written correctly.

Segger is showing a warrning as follow on the following read function

rc = nrf_fstorage_read(&fstorage, 0x90000, &m_data_read,sizeof(m_data_read));

warning : argument 3 of 'nrf_fstorage_read' discards 'const' qualifier from pointer target type [-Wdiscarded-qualifiers]

RE: fstorage read a int or float from flash

Kenneth — Mon, 20 May 2019 09:25:21 GMT

Have you first made sure it's stored as expected by calling:

nrfjprog --memrd 0x3E100 --n 100

RE: fstorage read a int or float from flash

melt — Fri, 17 May 2019 07:36:08 GMT

Kenneth let me rephrase the question

In the fbelow peripheral example in SDK15.2. How do I read the value BADC0FEE

I can sucessfully read "hello word" using

rc = nrf_fstorage_read(&fstorage, 0x3e100, &m_data_read,sizeof(m_data_read));

/**
 * Copyright (c) 2016 - 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.
 *
 */

/** @file
 *
 * @brief fstorage example main file.
 *
 * This example showcases fstorage usage.
 */

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

#include "nrf.h"
#include "nrf_soc.h"
#include "nordic_common.h"
#include "boards.h"
#include "app_timer.h"
#include "app_util.h"
#include "nrf_fstorage.h"

#ifdef SOFTDEVICE_PRESENT
#include "nrf_sdh.h"
#include "nrf_sdh_ble.h"
#include "nrf_fstorage_sd.h"
#else
#include "nrf_drv_clock.h"
#include "nrf_fstorage_nvmc.h"
#endif

#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.h"


#define BUTTON_DETECTION_DELAY  APP_TIMER_TICKS(50)
#define APP_BLE_CONN_CFG_TAG    1


/* Defined in cli.c */
extern void cli_init(void);
extern void cli_start(void);
extern void cli_process(void);

static void fstorage_evt_handler(nrf_fstorage_evt_t * p_evt);


NRF_FSTORAGE_DEF(nrf_fstorage_t fstorage) =
{
    /* Set a handler for fstorage events. */
    .evt_handler = fstorage_evt_handler,

    /* These below are the boundaries of the flash space assigned to this instance of fstorage.
     * You must set these manually, even at runtime, before nrf_fstorage_init() is called.
     * The function nrf5_flash_end_addr_get() can be used to retrieve the last address on the
     * last page of flash available to write data. */
    .start_addr = 0x3e000,
    .end_addr   = 0x3ffff,
};

/* Dummy data to write to flash. */
static uint32_t m_data          = 0xBADC0FFE;
static char     m_hello_world[] = "hello world";


/**@brief   Helper function to obtain the last address on the last page of the on-chip flash that
 *          can be used to write user data.
 */
static uint32_t nrf5_flash_end_addr_get()
{
    uint32_t const bootloader_addr = NRF_UICR->NRFFW[0];
    uint32_t const page_sz         = NRF_FICR->CODEPAGESIZE;
    uint32_t const code_sz         = NRF_FICR->CODESIZE;

    return (bootloader_addr != 0xFFFFFFFF ?
            bootloader_addr : (code_sz * page_sz));
}


#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   Sleep until an event is received. */
static void power_manage(void)
{
#ifdef SOFTDEVICE_PRESENT
    (void) sd_app_evt_wait();
#else
    __WFE();
#endif
}


static void fstorage_evt_handler(nrf_fstorage_evt_t * p_evt)
{
    if (p_evt->result != NRF_SUCCESS)
    {
        NRF_LOG_INFO("--> Event received: ERROR while executing an fstorage operation.");
        return;
    }

    switch (p_evt->id)
    {
        case NRF_FSTORAGE_EVT_WRITE_RESULT:
        {
            NRF_LOG_INFO("--> Event received: wrote %d bytes at address 0x%x.",
                         p_evt->len, p_evt->addr);
        } break;

        case NRF_FSTORAGE_EVT_ERASE_RESULT:
        {
            NRF_LOG_INFO("--> Event received: erased %d page from address 0x%x.",
                         p_evt->len, p_evt->addr);
        } break;

        default:
            break;
    }
}


static void print_flash_info(nrf_fstorage_t * p_fstorage)
{
    NRF_LOG_INFO("========| flash info |========");
    NRF_LOG_INFO("erase unit: \t%d bytes",      p_fstorage->p_flash_info->erase_unit);
    NRF_LOG_INFO("program unit: \t%d bytes",    p_fstorage->p_flash_info->program_unit);
    NRF_LOG_INFO("==============================");
}


void wait_for_flash_ready(nrf_fstorage_t const * p_fstorage)
{
    /* While fstorage is busy, sleep and wait for an event. */
    while (nrf_fstorage_is_busy(p_fstorage))
    {
        power_manage();
    }
}


static void log_init(void)
{
    ret_code_t rc = NRF_LOG_INIT(NULL);
    APP_ERROR_CHECK(rc);
}


int main(void)
{
    ret_code_t rc;

#ifndef SOFTDEVICE_PRESENT
    clock_init();
#endif

    timer_init();
    log_init();
    cli_init();

    NRF_LOG_INFO("fstorage example started.");

    nrf_fstorage_api_t * p_fs_api;

#ifdef SOFTDEVICE_PRESENT
    NRF_LOG_INFO("SoftDevice is present.");
    NRF_LOG_INFO("Initializing nrf_fstorage_sd implementation...");
    /* Initialize an fstorage instance using the nrf_fstorage_sd backend.
     * nrf_fstorage_sd uses the SoftDevice to write to flash. This implementation can safely be
     * used whenever there is a SoftDevice, regardless of its status (enabled/disabled). */
    p_fs_api = &nrf_fstorage_sd;
#else
    NRF_LOG_INFO("SoftDevice not present.");
    NRF_LOG_INFO("Initializing nrf_fstorage_nvmc implementation...");
    /* Initialize an fstorage instance using the nrf_fstorage_nvmc backend.
     * nrf_fstorage_nvmc uses the NVMC peripheral. This implementation can be used when the
     * SoftDevice is disabled or not present.
     *
     * Using this implementation when the SoftDevice is enabled results in a hardfault. */
    p_fs_api = &nrf_fstorage_nvmc;
#endif

    rc = nrf_fstorage_init(&fstorage, p_fs_api, NULL);
    APP_ERROR_CHECK(rc);

    print_flash_info(&fstorage);

    /* It is possible to set the start and end addresses of an fstorage instance at runtime.
     * They can be set multiple times, should it be needed. The helper function below can
     * be used to determine the last address on the last page of flash memory available to
     * store data. */
    (void) nrf5_flash_end_addr_get();

    /* Let's write to flash. */
    NRF_LOG_INFO("Writing \"%x\" to flash.", m_data);
    rc = nrf_fstorage_write(&fstorage, 0x3e000, &m_data, sizeof(m_data), NULL);
    APP_ERROR_CHECK(rc);

    wait_for_flash_ready(&fstorage);
    NRF_LOG_INFO("Done.");

#ifdef SOFTDEVICE_PRESENT
    /* Enable the SoftDevice and the BLE stack. */
    NRF_LOG_INFO("Enabling the SoftDevice.");
    ble_stack_init();

    m_data = 0xDEADBEEF;

    NRF_LOG_INFO("Writing \"%x\" to flash.", m_data);
    rc = nrf_fstorage_write(&fstorage, 0x3e100, &m_data, sizeof(m_data), NULL);
    APP_ERROR_CHECK(rc);

    wait_for_flash_ready(&fstorage);
    NRF_LOG_INFO("Done.");
#endif

    NRF_LOG_INFO("Writing \"%s\" to flash.", m_hello_world);
    rc = nrf_fstorage_write(&fstorage, 0x3f000, m_hello_world, sizeof(m_hello_world), NULL);
    APP_ERROR_CHECK(rc);

    wait_for_flash_ready(&fstorage);
    NRF_LOG_INFO("Done.");

    NRF_LOG_INFO("Use 'read' to read bytes from the flash.");
    NRF_LOG_INFO("Use 'write' to write bytes to the flash.");
    NRF_LOG_INFO("Use 'erase' to erase flash pages.");
    NRF_LOG_INFO("Use 'flasharea' to print and configure the flash read boundaries.");

    cli_start();

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


/**
 * @}
 */

RE: fstorage read a int or float from flash

melt — Thu, 16 May 2019 12:30:51 GMT

Hi Kenneth

1. I have removed the const still the same

2. I have not erased it, im following the example and they dont mention anything on erasing the flash under the peripheral fstorage example, also the "Hello world" read and writes works 100% so why would I not be able to read the hex value.

3.correct thanks I have changed it to %x

my problem is rc = nrf_fstorage_read(&fstorage, 0x3f000, m_data_read, sizeof(m_data_read)); has a 3rd argument. when im reading just a hex byte what do I put as length - 1?

im looking at the below lib explanation of the various functions

https://infocenter.nordicsemi.com/index.jsp?topic=%2Fcom.nordic.infocenter.sdk5.v15.0.0%2Fgroup__nrf__fstorage.html&anchor=gaebb4176a9aa38b3398e446efa0592939

should I not use a pointer to that hex value in flash and dereference it?

m_data_pointer = *nrf_fstorage_rmap(&fstorage, 0x3e100);

I dont think im using the right function to read a hex value.

thanks for the help

RE: fstorage read a int or float from flash

Kenneth — Thu, 16 May 2019 11:57:34 GMT

Hi,

Haven't tested the code, but a few things to try:

1. I notice you have declared m_data_read as const, not sure if that will work here.

2. I assume you have first erased the flash page, so the memory 0x3e100 is all FFF..

3. Shouldn't it be with an 'x' in NRF_LOG_INFO("Writing \"%x\" to flash.", m_data_read); not 's'.

Anyways, you may need to look into how to cast the data to the correct format it was stored in this thread:
https://devzone.nordicsemi.com/f/nordic-q-a/47093/can-i-store-a-struct-in-eeprom-using-nordic-spi-api-and-sent-struct-through-nordic-ble-api

Best regards,
Kenneth