Get data from BLE and write to flash memory using pstorage

[trananh]

Hi,

I am having trouble to use flash to store data.

First, I write function and scan beacon, get information from this beacon and save to flash

I use a timer for saving data to flash but it is not work, I always get the error code = 0x00000010. It means "invalid flag". How can I solve this problem?

Thanks and regard

[RK]

0x00000010 is not 'Invalid Flag', invalid flag is error 10 decimal, that's error 0x10 hex which is 16 decimal which is Bad Memory Address.

That tells you that source_data_1 isn't aligned.

All the other advice about checking error codes is sound, you should check them all every single time. And I doubt there was ever a 'conflict' between pstorage and the beacon_event_handler, you can most likely fix the actual error now you know the difference between decimal and hex and put the code back the way it was.

[trananh]

void pstorage_sys_event_handler (uint32_t p_evt);

bool rdy_for_next;

static void beacon_scanner_error_handler(uint32_t nrf_error)

{

    APP_ERROR_HANDLER(nrf_error);

}

static ble_beacon_scanner_init_t beacon_scanner_init;

void app_error_handler(uint32_t error_code, uint32_t line_num, const uint8_t * p_file_name)

{

    uint32_t checkErr = error_code;

    NVIC_SystemReset();

}

void assert_nrf_callback(uint16_t line_num, const uint8_t * p_file_name)

{

    app_error_handler(DEAD_BEEF, line_num, p_file_name);

}

static void sys_evt_dispatch(uint32_t sys_evt)

{

    pstorage_sys_event_handler(sys_evt);
	
}
 
static void ble_stack_init(void)

{

    uint32_t err_code;
    
    // Initialize the SoftDevice handler module.
    SOFTDEVICE_HANDLER_INIT(NRF_CLOCK_LFCLKSRC_XTAL_20_PPM, false);

    // Enable BLE stack 
    ble_enable_params_t ble_enable_params;

    memset(&ble_enable_params, 0, sizeof(ble_enable_params));

    ble_enable_params.gatts_enable_params.service_changed =   IS_SRVC_CHANGED_CHARACT_PRESENT;

    err_code = sd_ble_enable(&ble_enable_params);

    APP_ERROR_CHECK(err_code);
	
	  // Register with the SoftDevice handler module for BLE events.
    err_code = softdevice_sys_evt_handler_set(sys_evt_dispatch);

    APP_ERROR_CHECK(err_code);

}

static void scheduler_init(void)

{

    APP_SCHED_INIT(SCHED_MAX_EVENT_DATA_SIZE, SCHED_QUEUE_SIZE);

}

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

{

		if(handle->block_id == pstorage_wait_handle) { pstorage_wait_flag = 0; }  //If we are waiting for this callback, clear the wait flag.

		switch(op_code)

		{

			case PSTORAGE_LOAD_OP_CODE:

				 break;

			case PSTORAGE_STORE_OP_CODE:

				 if (result == NRF_SUCCESS)

				 {

						 rdy_for_next = true;

				 }

				 break;			
	 
			case PSTORAGE_UPDATE_OP_CODE:

				 break;

			case PSTORAGE_CLEAR_OP_CODE:

				 break;

			case PSTORAGE_ERROR_OP_CODE:

				 break;	
			 
		}	
		
}

static void power_manage(void)

{

    uint32_t err_code = sd_app_evt_wait();

    APP_ERROR_CHECK(err_code);

}

uint8_t  bufferCheck[16];

static uint8_t  temp;

uint8_t  dest_data_1[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};

static pstorage_handle_t        master_handle;

static pstorage_handle_t				block_0_handle;

static pstorage_module_param_t  param;

static void beacon_evt_handler(ble_scan_beacon_evt_t * p_evt)

{

	 int i,j = 0;

	 for(i = 0; i < 16; i++)

   {	
	   bufferCheck[i] =  p_evt->rcv_adv_packet.adv_data.uuid.uuid128[i];

	 }

	 uint32_t   retval;
			
		retval = pstorage_register(&param, &master_handle);

		APP_ERROR_CHECK(retval);

	 
   //Get block identifiers

		retval = pstorage_block_identifier_get(&master_handle, temp, &block_0_handle);

		APP_ERROR_CHECK(retval);


		
		retval = pstorage_clear(&block_0_handle, 16);  
                 
		APP_ERROR_CHECK(retval);
		
		pstorage_wait_handle = block_0_handle.block_id;            //Specify which pstorage handle to wait for 

		pstorage_wait_flag = 1; 

		retval = pstorage_store(&block_0_handle, bufferCheck, 16, 0);

	  APP_ERROR_CHECK(retval);
	 
        while(pstorage_wait_flag) { power_manage(); }              //Sleep until store operation is finished.

		nrf_delay_ms(100);

		retval = pstorage_load(dest_data_1, &block_0_handle, 16, 0);				 //Read from flash, only one block is allowed for each pstorage_load command

		APP_ERROR_CHECK(retval);

		nrf_delay_ms(100);

	  temp++; 

}

int main(void)

{

    ble_stack_init();

	  scheduler_init();
	   
	  uint32_t  retval;

		retval = pstorage_init();

		APP_ERROR_CHECK(retval);    

		param.block_size  = 16;                
   
		param.block_count = 100;         
          
		param.cb          = example_cb_handler;

	
	  beacon_scanner_init.evt_handler   = beacon_evt_handler;

    beacon_scanner_init.error_handler = beacon_scanner_error_handler;

    app_beacon_scanner_init(&beacon_scanner_init);

    app_beacon_scanner_start();
	
    for (;;)

    {

			  power_manage();

    }

}