pstorage reading other values than writing

[Patriko]

Hi!

Maybe I'm doing something wrong (very possible), but for example, when I want to store array of 3 uint8_t values I use:

uint8_t dataToStore[3];
dataToStore[0] = 11;
dataToStore[1] = 22;
dataToStore[2] = 33;

retval = pstorage_store(&block_handle, dataToStore, 3 , 0);
	if (retval == NRF_SUCCESS)
	{
			// Store successfully requested. Wait for operation result.
	}
	else
	{
			// Failed to request store, take corrective action.
	}

and when I want to read it from the memory to variable I use:

   retval = pstorage_block_identifier_get(&persistant_memory_handle, 0, &block_handle);
	if (retval == NRF_SUCCESS)
	{
		uint8_t           dest_data[3];
		 //Request to read 3 bytes from block at an offset of 0 bytes.
		retval = pstorage_load(dest_data, &block_handle, 3, 0);
		if (retval == NRF_SUCCESS)
		{
                         // here dest_data should be: 11, 22, 33 but it gets different values.
		}
		else
		{
				// Failed to load, take corrective action.
		}

Received value is always different than stored. What can be the reason?

[Nikita]

Read this:

Block size and offset in load, store and update shall be a multiple of word size (4 bytes).

[Patriko]

Ok, I'd changed it to:

    retval = pstorage_load(dest_data, &block_handle, 4, 0);

and

    retval = pstorage_store(&block_handle, dataToStore, 4 , 0);

but now I get retval = NRF_ERROR_INVALID_ADDR when storing value.

I think that I don't exactly understand how to specify size and offset. Can you explain it a little bit?

Thanks!

Variables

static 	uint8_t receivedData[4] __attribute__((aligned(4)));
static pstorage_handle_t persistant_memory_handle;
static uint32_t retval;
static pstorage_handle_t block_handle;

Pstorage initialization

static void init_memory(void)
{
uint32_t retval;
pstorage_module_param_t param;
	
retval = pstorage_init();
if(retval == NRF_SUCCESS)
{
	
}
else 
{
}

param.block_size = 0x10;
param.block_count = 10;
param.cb = storage_cb_handler;

retval = pstorage_register(&param, &persistant_memory_handle);
if(retval == NRF_SUCCESS)
{
	
}
else 
{
}

}

Event Notification Handler

static void storage_cb_handler(pstorage_handle_t  * handle,
                           uint8_t              op_code,
                           uint32_t             result,
                           uint8_t            * p_data,
                           uint32_t             data_len)

{
switch(op_code)
{
   case PSTORAGE_LOAD_OP_CODE:
       if (result == NRF_SUCCESS)
       {
           // Store operation successful.
       }
       else
       {
           // Store operation failed.
       }
       // Source memory can now be reused or freed.
       break;       
    case PSTORAGE_UPDATE_OP_CODE:
       if (result == NRF_SUCCESS)
       {
           // Update operation successful.
       }
       else
       {
           // Update operation failed.
       }
       break;
   case PSTORAGE_CLEAR_OP_CODE:
       if (result == NRF_SUCCESS)
       {
           // Clear operation successful.
       }
       else
       {
           // Clear operation failed.
       }
       break;

	}
}

Writing data

retval = pstorage_store(&block_handle, receivedData, 4 , 0);
	if (retval == NRF_SUCCESS)
	{
			// Store successfully requested. Wait for operation result.
	}
	else
	{
			// Failed to request store, take corrective action.
	}

Reading data

	retval = pstorage_block_identifier_get(&persistant_memory_handle, 0, &block_handle);
	if (retval == NRF_SUCCESS)
	{
		uint8_t           dest_data[4];
		 //Request to read 4 bytes from block at an offset of 12 bytes.
		retval = pstorage_load(dest_data, &block_handle, 4, 0);
		if (retval == NRF_SUCCESS)
		{
				 parse_data(dest_data);
		}
		else
		{
				// Failed to load, take corrective action.
		}
	}
	else
	{
			// Failed to get block id, take corrective action.
	}

[Nikita]

Change

uint8_t dataToStore[3];

to

static uint8_t dataToStore[4] __attribute__((aligned(4)));

Static because:

pstorage_store

No copy of the data is made, and hence memory provided for data source to be written to flash cannot be freed or reused by the application until this procedure is complete. End of this procedure is notified to the application using the notification callback registered by the application.

And your buffer should be word aligned in ram.

[Patriko]

Thanks!

Now it reach the end of pstorage_store() function (cmd_queue_enqueue), and retval is equal NRF_SUCCESS, but when trying to read value, is 0x00, 0x00, 0x00, 0x00 :(

And Event Notification Handler (static void storage_cb_handler), is not fired when writing (it fires when using pstorage_load, so I assume that reference is correct).

:(

[Nikita]

Show your full test code with pstorage_register and where and how you calling pstorage_store.