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?

[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.
	}

[leo]

Hm.. now i read it, thanks.. But what does the third point mean? "- When using the clear operation the Persistent Storage Manager will use a swap area to conserve the blocks not affected. The data page backed up in the swap area, the data page is erased, the non affected blocks are copied back." So, it deletes the whole content, but it writes back the not affected blocks? Thanks a lot.. i was wondering why it didn't work.