Flash memory utilization

RE: Flash memory utilization

jeff — Tue, 11 Nov 2014 04:43:18 GMT

static void updateSetting(){
   uint8_t err_code;

simple_uart_putstring((const uint8_t *)"writing Settings\n");

uint32_t* indata = malloc(32*sizeof(uint32_t));

int i;
for (i=0;i<32;i++){
	
	 indata[i] = i;
}

err_code =  ble_flash_page_write 	( 128,	indata,		32	) ;	
APP_ERROR_CHECK(err_code);
}

/**@brief function to get setting from flash */

static void getSetting(){

uint8_t err_code;

simple_uart_putstring((const uint8_t *)"getting Settings\n");


uint32_t *setting0 = malloc(32*sizeof(uint32_t));
uint8_t *length = malloc(4*sizeof(uint8_t));
err_code = ble_flash_page_read(128, setting0, length);
APP_ERROR_CHECK(err_code);

int msg_length = (length[3]<<24 |length[2]<<16 | length[1]<<8 | length[0]) ;



int i=0;
for (i=0;i<msg_length;i++){
	uint32_t value = setting0[i];
	uint8_t result[4];

	result[0] = (value & 0x000000ff);
	result[1] = (value & 0x0000ff00) >> 8;
	result[2] = (value & 0x00ff0000) >> 16;
	result[3] = (value & 0xff000000) >> 24;
	
	char msg[9];
	sprintf(msg,"%08lx\n",(unsigned long)value);
	simple_uart_putstring((const uint8_t *)msg);
}

}

RE: Flash memory utilization

Ole Morten — Fri, 16 Aug 2013 11:48:30 GMT

You can see the size of the application in Keil's output when it's compiling. If you know that you're going to use this page for application data, you could also consider reducing the size of IROM in Keil's project settings, so that you get errors on no remaining space if the application grows into this region. You can see that this is done for all the BLE examples in the SDK.

RE: Flash memory utilization

Guest — Fri, 16 Aug 2013 11:46:11 GMT

Thanks for the clarification. I moved my code in the BLE disconnect event and it works.

Last question, at this time, I am using the code "NRF_FICR->CODESIZE - 4" to retrieve a page number to write my data. But, how can I know if I am writting in the application flash pages? Is there a way to know the application size?

RE: Flash memory utilization

Bastiaan — Fri, 16 Aug 2013 11:46:11 GMT

Thanks for the clarification. I moved my code in the BLE disconnect event and it works.

RE: Flash memory utilization

Ole Morten — Fri, 16 Aug 2013 09:45:44 GMT

Remember that doing flash operations locks the CPU. You write in a comment that you do it right before the infinite loop in main, but at this point, the chip is most likely advertising. If it is, the time it takes to erase a page may will cause an assert, and the program will end up in the app_error_handler, which by default does a reset.

I recommend that you remove the reset from the error handler, and instead uncomment the call to ble_debug_assert_handler(), since this will make it much easier for you to find errors as they happen.

The only workaround to this problem is to avoid doing flash operations except when not in a connection and not advertising.

RE: Flash memory utilization

Sébastien Despont — Wed, 14 Aug 2013 09:07:06 GMT

Dear Ole Morten,

Thanks for helping me with this problem. I am just trying to test the read/write flash page feature without success.

Please, have a look on my answer on this thread above to see my code. Teh code is executed at the end of the main function, just before the infinity loop containing the "sd_app_event_wait" softdevice function.

At this point, the ble stack is started and I should be able to use ble_flash_page_write function, but I can't. The code crash when I execute the function ble_flash_page_write, therefore, I don't have any error message to give you...

Go into the function does not help because the debugger stopped on function ble_flash_crc16_compute, but if I set a breakpoint right after, it execute successfully the ble_flash_crc16_compute function.

I think that it crashes due to a bad memory address. The page I am tring to write is NRF_FICR->CODESIZE - 4;

Do you have any idea or example which could inspired me?

Best regards

RE: Flash memory utilization

Ole Morten — Tue, 13 Aug 2013 08:14:57 GMT

Sorry for the delay, it's just been way too busy lately. However, you don't give a lot of details, so it's a little hard to help you. What exactly is not working, and how does it not work? Don't you see anything changing? What is the flash contents before and after running this snippet? Does it return an error code or does fail in some other way? Are you in a BLE connection when it fails?

It would be helpful if you could edit your original question and add the complete project you're working with, so that I can test it on my end.

RE: Flash memory utilization

Sébastien Despont — Tue, 13 Aug 2013 07:23:36 GMT

Up, this code is still not working. How can I fix that?

RE: Flash memory utilization

Sébastien Despont — Tue, 13 Aug 2013 04:48:57 GMT

Up, this code is still not working. How can I fix that?

RE: Flash memory utilization

Sébastien Despont — Tue, 06 Aug 2013 05:49:34 GMT

Thanks for your answer.

I have tried this code as you suggest, but it still doesn't work. I don't get any error number, the code just crash and I don't understand why.

Could you have a look on my codebelow? I didn't find any example which explain how to use the flash memory in the SDK.

Best regards

uint32_t page = NRF_FICR->CODESIZE - 4;

uint8_t word_count = 1;
uint32_t data_array[2]={0};

err_code = ble_flash_page_write(page,(uint32_t *) &data_array,1);
APP_ERROR_CHECK(err_code);
														
err_code = ble_flash_page_read(page, (uint32_t *) & data_array, &word_count);
APP_ERROR_CHECK(err_code);

RE: Flash memory utilization

Sébastien Despont — Tue, 06 Aug 2013 05:38:41 GMT

Thanks for your reply. So, to write 1 page, I need to use something like "NRF_FICR->CODESIZE-4"?

RE: Flash memory utilization

Ole Morten — Tue, 06 Aug 2013 05:29:41 GMT

This code most likely crashes because you are trying to overwrite the application code. There isn't a separate data flash in the nRF51822, so when you write to flash, you write to the same flash that the actual program runs from. You should therefore be careful not to erase or write to pages where there is program code, as the comment in ble_flash.h tells you.

The softdevice occupies pages 0-79 (not 127 anymore, this is actually a bug in ble_flash.h) which translates to address 0 to 0x13FFF, while the application can use pages 79-255, address 0x14000 to 0x39FFF. However, this latter part will be shared between actual application code and data storage. It is a strict requirement that the code of the application starts at address 0x14000, and how far up it will go is simply a matter of how big it is.

For data storage you should therefore make sure to use the upper pages. If you look at the bond manager, it uses pages 254 and 255, so I'd recommend you to use for example page 253 for other application storage needs.

Also remember that any flash writing or erasing locks the CPU, so you need to be careful if you try to do this while in a BLE connection. Have a look at this question for details on this.