NRF_FSTORAGE_DEF issue with nrf52832

Question

Hello,

I have some trouble to write/read data in flash region,

I am using FICR region to save data, if trying the command : nrfjprog --memrd 0x10000010 --n 0x10 I can see : 0x10000010: 00001000 00000080 FFFFFFFE FFFFFFFF |................|

So I setup NRF_FSTORAGE_DEF function as follows,

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 = 0x0007F000,
.end_addr   = 0x0007FFFF,**

};

after that, if I add more service with battery or device information or Custom service, the code can't do well not normal..... I can't write any data, and can read the previous data at that time,

please help to let me know the method to setup the memory region, how to do ?

thankful for your support in advance,

thanks. I attach the code for your understanding, please refer it,

#include <stdbool.h>
#include <stdio.h>
#include "nrf.h"
#include "bsp.h"
#include "app_error.h"
#include "nrf_nvmc.h"
#include "nordic_common.h"

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

#include "app_timer.h"
#include "nrf_drv_clock.h"

#include "nrf_fstorage_sd.h"//love_1211

#define FLASHWRITE_EXAMPLE_MAX_STRING_LEN       (62u)
#define FLASHWRITE_EXAMPLE_BLOCK_VALID          (0xA55A5AA5)
#define FLASHWRITE_EXAMPLE_BLOCK_INVALID        (0xA55A0000)
#define FLASHWRITE_EXAMPLE_BLOCK_NOT_INIT       (0xFFFFFFFF)

//love_1211
//refer to infocenter.nordicsemi.com/index.jsp

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 = 0x0007F000,
    .end_addr   = 0x0007FFFF,
};

/* Dummy data to write to flash. */
static uint32_t m_data          = 0xBADC0FFE;
//static char     m_hello_world1[] = "helloworld4";
//static char     m_hello_world2[] = "helloworld5";
//static char     m_hello_world3[] = "helloworld6";
static char     m_hello_world1[] = "helloworld7";
static char     m_hello_world2[] = "helloworld8";
static char     m_hello_world3[] = "helloworld9";

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

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

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

        default:
            break;
    }
}

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

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

/**@brief   Sleep until an event is received. */
//static void power_manage(void)
//{
//    (void) sd_app_evt_wait();
//}

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

void flash_test(void)
{//nrfjprog --memrd 0x0007F000 --n 0x70  nrfjprog --memrd 0x10000010 --n 0x10
	ret_code_t rc;
	nrf_fstorage_api_t * p_fs_api;
	
//	printf("SoftDevice is present. \r\n");
//	printf("Initializing nrf_fstorage_sd implementation... \r\n");
	/* 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;
	
	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();
	
	rc = nrf_fstorage_erase(&fstorage, 0x0007F000, 1, NULL);
	
	/* Let's write to flash. */
//	printf("Writing \"%x\" to flash. \r\n", m_data);
//	m_data = 0x12345678;//love_1211	

	rc = nrf_fstorage_erase(&fstorage, 0x0007F500, 1, NULL);
	
	rc = nrf_fstorage_write(&fstorage, 0x0007F500, m_hello_world1, sizeof(m_hello_world1), NULL);
	APP_ERROR_CHECK(rc);
	
	wait_for_flash_ready(&fstorage);

	m_data = 0x98765432;//0xDEADBE12;
		
	rc = nrf_fstorage_erase(&fstorage, 0x0007F600, 1, NULL);	
//	printf("Writing \"%x\" to flash. \r\n", m_data);
	rc = nrf_fstorage_write(&fstorage, 0x0007F600, &m_data, sizeof(m_data), NULL);
	APP_ERROR_CHECK(rc);
		
//	m_data = 0xDEADBEEF;
	
	rc = nrf_fstorage_erase(&fstorage, 0x0007F700, 1, NULL);	
//	printf("Writing \"%x\" to flash. \r\n", m_data);
	rc = nrf_fstorage_write(&fstorage, 0x0007F700, m_hello_world2, sizeof(m_hello_world2), NULL);
	APP_ERROR_CHECK(rc);
	
	wait_for_flash_ready(&fstorage);
	
	rc = nrf_fstorage_erase(&fstorage, 0x0007F800, 1, NULL);	
//	printf("Writing \"%s\" to flash. \r\n", m_hello_world);
	rc = nrf_fstorage_write(&fstorage, 0x0007F800, m_hello_world3, sizeof(m_hello_world3), NULL);
	APP_ERROR_CHECK(rc);
	
	wait_for_flash_ready(&fstorage);
	
	uint8_t    flash_data1[256] = {0};
	rc = nrf_fstorage_read(&fstorage, 0x0007F500, flash_data1, sizeof(flash_data1));
	APP_ERROR_CHECK(rc);
	
        printf("%s \r\n", flash_data1);

	uint8_t    flash_data23[4] = {0};
	rc = nrf_fstorage_read(&fstorage, 0x0007F600, flash_data23, sizeof(flash_data23));
	APP_ERROR_CHECK(rc);
	
	for(int i = 0; i < 4; i++)
        	printf("%x \r\n", flash_data23[i]);
                
	uint8_t    flash_data2[256] = {0};
	rc = nrf_fstorage_read(&fstorage, 0x0007F700, flash_data2, sizeof(flash_data2));
	APP_ERROR_CHECK(rc);
	
        printf("%s \r\n", flash_data2);
        
	uint8_t    flash_data3[256] = {0};
	rc = nrf_fstorage_read(&fstorage, 0x0007F800, flash_data3, sizeof(flash_data3));
	APP_ERROR_CHECK(rc);
	
        printf("%s \r\n", flash_data3);                
}