timer deviation nrf52840 sdk15.0 s140

RE: timer deviation nrf52840 sdk15.0 s140

Kenneth — Thu, 09 Aug 2018 13:25:53 GMT

Can you try to use:
#define CLOCK_CONFIG_LF_SRC 1
or
#define CLOCK_CONFIG_LF_SRC 2

instead of
#define CLOCK_CONFIG_LF_SRC 0

RE: timer deviation nrf52840 sdk15.0 s140

lmouelo — Thu, 09 Aug 2018 07:57:45 GMT

ok now i have this in central main :

static void timer_sd_handler(void * p_context){
			  
				compteur++; // affichage chaque seconde
				compteur2++; // recupere la valeur
				compteur3++; //recuperer la valeur tout les 62.5ms
				compteur4++; // affichage pour 2 valeur
	
				if(compteur==1000){
					
					//NRF_LOG_INFO("dif_Cent_Perip = %d",dif_Cent_Perip);	
					compteur = 0; 
				}
				
				if(compteur3==62){
					compteurTimer=compteur2;
					compteur3=0;
				}
				if(compteur4==1000){
					NRF_LOG_INFO("------------------>1sec<-------------------------------");
				tmp=2;
					compteur4=0;
				}
				//NRF_LOG_INFO("compteur2 = %d",compteur2);
	
}

static void lfclk_request(void)
{
    ret_code_t err_code;// = nrf_drv_clock_init();
    APP_ERROR_CHECK(err_code);
    nrf_drv_clock_lfclk_request(NULL);
		NRF_LOG_INFO("LFCLK: OFF");
    if(nrf_drv_clock_lfclk_is_running()){
		NRF_LOG_INFO("LFCLK: ON");
	}
}

void test(){
	
	ret_code_t err_code;
	
	NRF_LOG_INFO("1");

	
	NRF_LOG_INFO("3");
	//Create timers
	
	err_code = app_timer_create(&sd_timer_id,APP_TIMER_MODE_REPEATED,timer_sd_handler);
	NRF_LOG_INFO("4");
		lfclk_request();
	APP_ERROR_CHECK(err_code);
	NRF_LOG_INFO("Timer_sd_start");
	err_code = app_timer_start(sd_timer_id, COMPTEUR_INTERVAL, NULL);
	NRF_LOG_INFO("%d",err_code);
	APP_ERROR_CHECK(err_code);
}

in central sdk_config.h :

//==========================================================
// <e> CLOCK_ENABLED - nrf_drv_clock - CLOCK peripheral driver - legacy layer
//==========================================================
#ifndef CLOCK_ENABLED
#define CLOCK_ENABLED 1
#endif
// <o> CLOCK_CONFIG_LF_SRC  - LF Clock Source
 
// <0=> RC 
// <1=> XTAL 
// <2=> Synth 

#ifndef CLOCK_CONFIG_LF_SRC
#define CLOCK_CONFIG_LF_SRC 0
#endif

// <o> CLOCK_CONFIG_IRQ_PRIORITY  - Interrupt priority
 

// <i> Priorities 0,2 (nRF51) and 0,1,4,5 (nRF52) are reserved for SoftDevice
// <0=> 0 (highest) 
// <1=> 1 
// <2=> 2 
// <3=> 3 
// <4=> 4 
// <5=> 5 
// <6=> 6 
// <7=> 7 

#ifndef CLOCK_CONFIG_IRQ_PRIORITY
#define CLOCK_CONFIG_IRQ_PRIORITY 2
#endif

in peripheral main :

static void lfclk_request(void)
{
    ret_code_t err_code;// = nrf_drv_clock_init();
    APP_ERROR_CHECK(err_code);
    nrf_drv_clock_lfclk_request(NULL);
		NRF_LOG_INFO("LFCLK: OFF");
    if(nrf_drv_clock_lfclk_is_running()){
		NRF_LOG_INFO("LFCLK: ON");
	}
}

static void timer_sd_handler(void * p_context){
			
	compteur++;
	
}

void test(){
	
	

	ret_code_t err_code;
	lfclk_request();
	// Create timers
	err_code = app_timer_create(&sd_timer_id,APP_TIMER_MODE_REPEATED,timer_sd_handler);
	NRF_LOG_INFO("");
	APP_ERROR_CHECK(err_code);
	
	NRF_LOG_INFO("Timer_sd_start");
	err_code = app_timer_start(sd_timer_id, COMPTEUR_INTERVAL, NULL);
	NRF_LOG_INFO("%d",err_code);
	APP_ERROR_CHECK(err_code);
}

in peripheral config_sdk.h :

//==========================================================
// <e> CLOCK_ENABLED - nrf_drv_clock - CLOCK peripheral driver - legacy layer
//==========================================================
#ifndef CLOCK_ENABLED
#define CLOCK_ENABLED 1
#endif
// <o> CLOCK_CONFIG_LF_SRC  - LF Clock Source
 
// <0=> RC 
// <1=> XTAL 
// <2=> Synth 

#ifndef CLOCK_CONFIG_LF_SRC
#define CLOCK_CONFIG_LF_SRC 0
#endif

// <o> CLOCK_CONFIG_IRQ_PRIORITY  - Interrupt priority
 

// <i> Priorities 0,2 (nRF51) and 0,1,4,5 (nRF52) are reserved for SoftDevice
// <0=> 0 (highest) 
// <1=> 1 
// <2=> 2 
// <3=> 3 
// <4=> 4 
// <5=> 5 
// <6=> 6 
// <7=> 7 

#ifndef CLOCK_CONFIG_IRQ_PRIORITY
#define CLOCK_CONFIG_IRQ_PRIORITY 2
#endif

// </e>

So when a send the peripheral's counter to the central card, a few minute i have a diviation between the two timers (central / peripheral ) surrounding 500 ms or more than 1 second.

what part of code should I add to calibrate the CRLF or then what should I do to use an external LFXO.

I want a maximum drift of 3 seconds after 16 hours or 0.003125 per second

RE: timer deviation nrf52840 sdk15.0 s140

lmouelo — Thu, 09 Aug 2018 07:40:59 GMT

how to calibrate CRLF

RE: timer deviation nrf52840 sdk15.0 s140

Kenneth — Thu, 09 Aug 2018 07:12:18 GMT

Hello,

A few things to look into:

- An RTC tick is (1/32768=) 30.51757 us. This means that when you configure an app timer with 1ms, the timer_sd_handler() will run at every 32 RTC periods, since that is the closest: 0.9765625 ms.

- The accuracy of the RTC tick depends on the LFCLK source, for instance if you are using the internal LFRC then the accuracy is <500ppm, which means a potential drift of 500us after 1second have elapsed. However the <500ppm only apply if you have calibrated the LFRC, else it may be much larger (1% or more). A more accurate resolution can be achieved by using external LFXO,then the accuracy is typical <50ppm and there is no need to calibrate.

Best regards,
Kenneth

RE: timer deviation nrf52840 sdk15.0 s140

lmouelo — Thu, 09 Aug 2018 06:30:57 GMT

Now i can send mi counter but it's the same, there are a big diference into conter central and conteur peripheral

RE: timer deviation nrf52840 sdk15.0 s140

lmouelo — Wed, 08 Aug 2018 12:23:27 GMT

I have changed my timer, my counter increments every ms but now I have a problem with my send I can no longer store the counter reading in the table.

static void lfclk_request(void)
{
    ret_code_t err_code = nrf_drv_clock_init();
    APP_ERROR_CHECK(err_code);
    nrf_drv_clock_lfclk_request(NULL);
		NRF_LOG_INFO("LFCLK: off");
    if(nrf_drv_clock_lfclk_is_running()){
		NRF_LOG_INFO("LFCLK: ON");
	}
}

static void timer_sd_handler(void * p_context){
			
	compteur++;
//	NRF_LOG_INFO("%d",compteur);
	
}

void test(){
	

	ret_code_t err_code;
	// Initialize timer module.
	err_code = app_timer_init();
	APP_ERROR_CHECK(err_code);

	// Create timers
	err_code = app_timer_create(&sd_timer_id,APP_TIMER_MODE_REPEATED,timer_sd_handler);
	NRF_LOG_INFO("");
	APP_ERROR_CHECK(err_code);
	
	NRF_LOG_INFO("Timer_sd_start");
	err_code = app_timer_start(sd_timer_id, SD_SAVE_DATA_INTERVAL, NULL);
	APP_ERROR_CHECK(err_code);
}
static void data_send_timeout_handler(void * p_context)
{	
	
	
	bsp_board_led_on(BSP_BOARD_LED_3);
	ret_code_t err_code=20;
	uint32_t data_send=DATA_TO_SEND_IN_INTERVAL;
	static const uint8_t data_length=243;
	static uint8_t data_cid[data_length];
	static bool all_data_send=1;
	static uint32_t num_data=0;
	static int i =0;
	uint32_t tmp;
	
	
	tmp = compteur ; 
	
	if(data_send<DATA_TO_SEND_IN_INTERVAL){
		all_data_send=0;
	}
	
	
	if(param_conn.periph_to_central && all_data_send && test_1_16){
//		NRF_LOG_INFO("1/16second");
//		if(data_cid[30]!=29){
//			for(uint8_t i=0;i<data_length;i++){
//				data_cid[i]=i;
//			}
//		}
		
		if(i == 0){
			test();
			i=1;
		}
			
		

		
		
	//!!!!!!!!!!!!!!!!!!!here i have a problem !!!!!!!!!!!!!!!!!//////////////////	
		//NRF_LOG_INFO("num_data=%d",num_data);
		data_cid[0]=(tmp >> 0)& 0xFF;
		data_cid[1]=(tmp >> 8)& 0xFF;
		data_cid[2]=(tmp >> 16)& 0xFF;
		data_cid[3]=(tmp >> 24)& 0xFF;
		data_send=0;
		
		
		for(int x = 0; x<=3;x++){
		NRF_LOG_INFO("data_cid %d = %d",x,data_cid[x]);
		}
//!!!!!!!!!!!!!!!!!!!here i have a problem !!!!!!!!!!!!!!!!!//////////////////	
		//send start
		while(err_code!=NRF_SUCCESS){
			err_code=ble_cid_measurement_send(&m_cid,&data_cid[0],1,DATA_1_16_START_FLAG);
			if ((err_code != NRF_SUCCESS) &&
							(err_code != NRF_ERROR_INVALID_STATE) &&
							(err_code != NRF_ERROR_RESOURCES) &&
							(err_code != NRF_ERROR_BUSY) &&
							(err_code != BLE_ERROR_GATTS_SYS_ATTR_MISSING)
					 )
				{

					APP_ERROR_HANDLER(err_code);
				}
				
				if(m_cid.conn_handle==BLE_CONN_HANDLE_INVALID || !param_conn.periph_to_central){
					return;
				}
		}
		err_code=20;
		//NRF_LOG_INFO("send start");
		
		
		//send data
		while(data_send<DATA_TO_SEND_IN_INTERVAL){
			while(err_code!=NRF_SUCCESS){
				bsp_board_led_on(BSP_BOARD_LED_2);
				if(data_send+data_length<DATA_TO_SEND_IN_INTERVAL){

					err_code = ble_cid_measurement_send(&m_cid, data_cid, data_length,SIMPLE_DATA_SEND_FLAG);
				
				}else{

					err_code = ble_cid_measurement_send(&m_cid, data_cid, DATA_TO_SEND_IN_INTERVAL-data_send,SIMPLE_DATA_SEND_FLAG);

				}
				if ((err_code != NRF_SUCCESS) &&
							(err_code != NRF_ERROR_INVALID_STATE) &&
							(err_code != NRF_ERROR_RESOURCES) &&
							(err_code != NRF_ERROR_BUSY) &&
							(err_code != BLE_ERROR_GATTS_SYS_ATTR_MISSING)
					 )
				{

					APP_ERROR_HANDLER(err_code);


				}
				
				bsp_board_led_off(BSP_BOARD_LED_2);
				
				if(m_cid.conn_handle==BLE_CONN_HANDLE_INVALID || !param_conn.periph_to_central){
					return;

				}
			}
			err_code=20;
			data_send+=data_length;
			
			
		}
		all_data_send=1;

RE: timer deviation nrf52840 sdk15.0 s140

lmouelo — Wed, 08 Aug 2018 06:33:33 GMT

ok thank's you but how i how to do app_timer (RTC) with a 1 ms interval that increments a counter reading by 1 ms?

RE: timer deviation nrf52840 sdk15.0 s140

Kenneth — Tue, 07 Aug 2018 17:14:33 GMT

Not sure if I quite understand the resolution of your timer ticks here, but I recommend to have them to minimum 1ms. If you have very small ticks (e.g. in the tens of us), then the interrupts will be blocked during BLE events, this will work as long as the communication is 1:1 (since both are blocked equally much), but will not work in a 1:2 (since then the central will be blocked twize as much.Can that be the case?

Possible easier would be to use an app_timer (RTC) with 1ms interval that increment an 1ms counter value. You can always have finer resolution by using timer when needed.

RE: timer deviation nrf52840 sdk15.0 s140

lmouelo — Tue, 07 Aug 2018 09:41:48 GMT

the central code:

int x =0 ; 
uint32_t datatab[11]={0}; // table to save data
uint32_t CompteurCentral[11]={0};
uint32_t tab_dif_Cent_Perip[11]={0};
uint32_t dif2 ;
uint32_t i = 0;
uint32_t dif_Cent_Perip;
uint32_t delta_dif ;
uint32_t cpt=0;
static int tmp = 0;////timer&&compteur//////////////////////////////
const nrf_drv_timer_t TIMER_LED = NRF_DRV_TIMER_INSTANCE(1);

uint32_t compteurTimer;
uint32_t compteur;
uint32_t compteur2;
uint32_t compteur3;
uint32_t compteur4;

void timer_led_event_handler(nrf_timer_event_t event_type, void* p_context){
 
   
    switch (event_type)
    {
        case NRF_TIMER_EVENT_COMPARE0:
            
				compteur2++;
				compteur3++;
				compteur++;
				compteur4++;
				if(compteur==1000){
					
					//NRF_LOG_INFO("dif_Cent_Perip = %d",dif_Cent_Perip);	
					compteur = 0; 
				}
				
				if(compteur3==6250){
					compteurTimer=compteur2;
					compteur3=0;
				}
				if(compteur4==100000){
				tmp=2;
					compteur4=0;
				}
					
				break;

        default:
            //Do nothing.
            break;
    }	
}static void cid_c_evt_handler(ble_cid_c_t * p_cid_c, ble_cid_c_evt_t * p_cid_c_evt)
{
    ret_code_t err_code;
		static float moyenne[NRF_SDH_BLE_CENTRAL_LINK_COUNT] = {0};
		static float timer[NRF_SDH_BLE_CENTRAL_LINK_COUNT] = {0};
		static int compteur[NRF_SDH_BLE_CENTRAL_LINK_COUNT] ={0};
		static uint64_t time_actu[NRF_SDH_BLE_CENTRAL_LINK_COUNT]={0};
		static uint64_t time_diff[NRF_SDH_BLE_CENTRAL_LINK_COUNT]={0};
		static uint8_t num_data[NRF_SDH_BLE_CENTRAL_LINK_COUNT];
		static float  time_con[NRF_SDH_BLE_CENTRAL_LINK_COUNT]= {0};
	
		//etat gpiote
		nrf_drv_gpiote_init();
		nrf_gpio_cfg_input(7,NRF_GPIO_PIN_PULLDOWN);
		uint16_t state = nrf_gpio_pin_read(7);
		state = 1;
		
		
		
    switch (p_cid_c_evt->evt_type)
    {
        case BLE_CID_C_EVT_DISCOVERY_COMPLETE:
        {
            NRF_LOG_INFO("Cidelec service discovered.");

            err_code = ble_cid_c_handles_assign(p_cid_c,
                                                p_cid_c_evt->conn_handle,
                                                &p_cid_c_evt->params.peer_db);
            APP_ERROR_CHECK(err_code);

            // Initiate bonding.
            err_code = pm_conn_secure(p_cid_c_evt->conn_handle, false);
            if (err_code != NRF_ERROR_INVALID_STATE)
            {
                APP_ERROR_CHECK(err_code);
            }
						//param_conn.m_conn_handle=p_cid_c->conn_handle;
						m_cid_c[p_cid_c->conn_handle].conn_handle=p_cid_c->conn_handle;
        } break;

        case BLE_CID_C_EVT_NOTIFICATION_SIMPLE_DATA_RECEIVE:
        {
					bsp_board_led_invert(BSP_BOARD_LED_2);
//					for(uint8_t i=0;i<p_cid_c_evt->params.cid_data.data_length;i++){
//						if(p_cid_c_evt->params.cid_data.data[i]!=i){
//							NRF_LOG_INFO("erreur:mauvaise donnée recu");
//							i=250;
//						}
//					}
					if(param_conn[p_cid_c_evt->conn_handle].test_debit.etat_test){
						
						param_conn[p_cid_c_evt->conn_handle].test_debit.data_receive+=p_cid_c_evt->params.cid_data.data_length;
						
					}else if(data_1_16[p_cid_c_evt->conn_handle].etat_test){
						
						
						//décalage pour récuper la valeur en 32 bit (8 bit -> 32 bit)
						cpt = p_cid_c_evt->params.cid_data.data[0]+(p_cid_c_evt->params.cid_data.data[1]*256)+(p_cid_c_evt->params.cid_data.data[2]*65356)+(p_cid_c_evt->params.cid_data.data[3]*16777216);
						
						
						x++;
						
						//NRF_LOG_INFO("num_data=%d for conn %d",num_data[p_cid_c_evt->conn_handle],p_cid_c_evt->conn_handle);
				   // NRF_LOG_INFO("-----------------------------------------------------------" );

						//NRF_LOG_INFO("Connexion %d", p_cid_c_evt->conn_handle);
				
						datatab[x] = cpt; // put data on the table
						
						CompteurCentral[x] = compteurTimer; // tableau compteur central 
					
						dif_Cent_Perip = CompteurCentral[x] - datatab[x];  // différence entre central et peripheral 
			      		
						tab_dif_Cent_Perip[x] = dif_Cent_Perip ; //tableau différence entre central et peripheral
					//	NRF_LOG_INFO("data_receive=%d from conn%d time_data=%d",cpt, p_cid_c_evt->conn_handle, time_diff[p_cid_c_evt->conn_handle]);
					//	NRF_LOG_INFO("CompteurCentral = %d",CompteurCentral[x]);	
						//NRF_LOG_INFO("%d",dif_Cent_Perip);	
						
						if(tmp==2){
							
							NRF_LOG_INFO("ce= %d, p1= %d, ce= %d, p2 = %d",CompteurCentral[x-1],datatab[x-1],CompteurCentral[x],datatab[x] );
							tmp = 0;
						}
						
						if(datatab[x-1]>datatab[x]){
							
							dif2 = datatab[x-1]-datatab[x];	//compare of two values Con0 Con1
						}		
						
						else{
							
							dif2 = datatab[x]-datatab[x-1]; //compare of two values
							
						}
						if(tab_dif_Cent_Perip[x-1]>tab_dif_Cent_Perip[x]){
							
							delta_dif = tab_dif_Cent_Perip[x-1] - tab_dif_Cent_Perip[x];
							//NRF_LOG_INFO("delta_dif = %d",delta_dif);
						}
						else{
							
							delta_dif = tab_dif_Cent_Perip[x] - tab_dif_Cent_Perip[x-1];
							//NRF_LOG_INFO("delta_dif = %d",delta_dif);
						}
		
						//NRF_LOG_INFO("dif_Cent_Perip = %d ", dif_Cent_Perip);
						//NRF_LOG_INFO("delta_dif =  %d" ,delta_dif);
						//NRF_LOG_INFO("datatab X =  %d" ,datatab[x]);
						//NRF_LOG_INFO("datatab X-1 =  %d" ,datatab[x-1]);
					//	NRF_LOG_INFO("-----------------------------------------------------------" );
						
						if(x==10){
							uint32_t f = datatab[x];
							uint32_t f2 = tab_dif_Cent_Perip[x];
							uint32_t f3 = CompteurCentral[x];
							for(i = 0; i<=x;i++){
									datatab[i]=0;	
								tab_dif_Cent_Perip[i]=0;
								CompteurCentral[i]=0;
							}
							datatab[0]=f;
							tab_dif_Cent_Perip[0] =f2;
							CompteurCentral[0]=f3;
							x=0;
					//	 NRF_LOG_INFO("décalage valeur tab[0]= %d",datatab[0] );

					}
						
						
						data_1_16[p_cid_c_evt->conn_handle].data_receive+=p_cid_c_evt->params.cid_data.data_length;
						
						state =1;
						
						//NRF_LOG_INFO("EtatData = %d",state);						
						//NRF_LOG_INFO("data_receive=%d from conn%d time_data=%d",data_1_16[p_cid_c_evt->conn_handle].data_receive, p_cid_c_evt->conn_handle, time_diff[p_cid_c_evt->conn_handle]);
						

					}else{
						
						//NRF_LOG_INFO("data_receive:%d octets from conn %d",p_cid_c_evt->params.cid_data.data_length,p_cid_c_evt->conn_handle);
						
					//	NRF_LOG_INFO("EtatData = %d",state);
					}
        } break;

The peripheral code :

////timer&&compteur//////////////////////////////
const nrf_drv_timer_t TIMER_LED = NRF_DRV_TIMER_INSTANCE(1);
uint32_t compteur; 
uint32_t compteur2;
uint32_t compteur3;
uint32_t tab[20] ={0};
int d = 0;
int f;
int x ;
void timer_led_event_handler(nrf_timer_event_t event_type, void* p_context){
 
   
    switch (event_type)
    {
        case NRF_TIMER_EVENT_COMPARE0:
        d++;   
		compteur++;

		break;

        default:
            //Do nothing.
            break;
    }	
}

void test(){
	
	NRF_LOG_INFO("test");
    uint32_t time_us =10; //Time(in miliseconds) between consecutive compare events.
    uint32_t time_ticks;
    uint32_t err_code = NRF_SUCCESS;
		
    //Configure all leds on board.
    bsp_board_init(BSP_INIT_LEDS);
    //Configure TIMER_LED for generating simple light effect - leds on board will invert his state one after the other.
    nrf_drv_timer_config_t timer_cfg = NRF_DRV_TIMER_DEFAULT_CONFIG;
	err_code = nrf_drv_timer_init(&TIMER_LED, &timer_cfg, timer_led_event_handler);
	NRF_LOG_INFO("err_code %d",err_code);
    APP_ERROR_CHECK(err_code);
    time_ticks = nrf_drv_timer_us_to_ticks(&TIMER_LED, time_us);
    nrf_drv_timer_extended_compare(
         &TIMER_LED, NRF_TIMER_CC_CHANNEL0, time_ticks, NRF_TIMER_SHORT_COMPARE0_CLEAR_MASK, true);
    nrf_drv_timer_enable(&TIMER_LED);
}
tatic void data_send_timeout_handler(void * p_context)
{	
	
	
	bsp_board_led_on(BSP_BOARD_LED_3);
	ret_code_t err_code=20;
	uint32_t data_send=DATA_TO_SEND_IN_INTERVAL;
	static const uint8_t data_length=243;
	static uint8_t data_cid[data_length];
	static bool all_data_send=1;
	static uint32_t num_data=0;
	static int i =0;
	uint32_t tmp;
	
	
	tmp = compteur ; 
	
	if(data_send<DATA_TO_SEND_IN_INTERVAL){
		all_data_send=0;
	}
	
	
	if(param_conn.periph_to_central && all_data_send && test_1_16){
		
		if(i == 0){
			test();
			i=1;
		}
			
		

		
		
		
	//	NRF_LOG_INFO("num_data=%d",num_data);
		data_cid[0]=(tmp >> 0)& 0xFF;
		data_cid[1]=(tmp >> 8)& 0xFF;
		data_cid[2]=(tmp >> 16)& 0xFF;
		data_cid[3]=(tmp >> 24)& 0xFF;
		data_send=0;
		
		/*for(int x = 0; x<=3;x++){
		NRF_LOG_INFO("data_cid %d = %d",x,data_cid[x]);
		}*/
		
		//send start
		while(err_code!=NRF_SUCCESS){
			err_code=ble_cid_measurement_send(&m_cid,&data_cid[0],1,DATA_1_16_START_FLAG);
			if ((err_code != NRF_SUCCESS) &&
							(err_code != NRF_ERROR_INVALID_STATE) &&
							(err_code != NRF_ERROR_RESOURCES) &&
							(err_code != NRF_ERROR_BUSY) &&
							(err_code != BLE_ERROR_GATTS_SYS_ATTR_MISSING)
					 )
				{

					APP_ERROR_HANDLER(err_code);
				}
				
				if(m_cid.conn_handle==BLE_CONN_HANDLE_INVALID || !param_conn.periph_to_central){
					return;
				}
		}
		err_code=20;
		//NRF_LOG_INFO("send start");
		
		
		//send data
		while(data_send<DATA_TO_SEND_IN_INTERVAL){
			while(err_code!=NRF_SUCCESS){
				bsp_board_led_on(BSP_BOARD_LED_2);
				if(data_send+data_length<DATA_TO_SEND_IN_INTERVAL){

					err_code = ble_cid_measurement_send(&m_cid, data_cid, data_length,SIMPLE_DATA_SEND_FLAG);
				
				}else{

					err_code = ble_cid_measurement_send(&m_cid, data_cid, DATA_TO_SEND_IN_INTERVAL-data_send,SIMPLE_DATA_SEND_FLAG);

				}
				if ((err_code != NRF_SUCCESS) &&
							(err_code != NRF_ERROR_INVALID_STATE) &&
							(err_code != NRF_ERROR_RESOURCES) &&
							(err_code != NRF_ERROR_BUSY) &&
							(err_code != BLE_ERROR_GATTS_SYS_ATTR_MISSING)
					 )
				{

					APP_ERROR_HANDLER(err_code);


				}
				
				bsp_board_led_off(BSP_BOARD_LED_2);
				
				if(m_cid.conn_handle==BLE_CONN_HANDLE_INVALID || !param_conn.periph_to_central){
					return;

				}
			}
			err_code=20;
			data_send+=data_length;
			
			
		}
		all_data_send=1;
		s