timer deviation nrf52840 sdk15.0 s140

[lmouelo]

Hello, i have a central card nrf52840 and several peripheral cards nrf52840.

I have a program that allows me to launch the timer on the central and peripherals at the same time. The peripherals send their timers to the central station and the central station compares its timer with the one received.

I have a connection interval of 62.5 ms and a connection time of 7.8ms.

When I have a central connection and 1 peripheral: I have a drift only 3 second on 16h00.

But when I have a central 2 peripheral connection: I have a drift of 1 second after a few minutes.  and i don't why  if if anyone can help me.

Here is the central code: 

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;
}
}

void test(){

NRF_LOG_INFO("test");
uint32_t time_us = 10; //Time(in microsecond) 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);
}

Here is the peripheral code: 

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);
}

thank's

[lmouelo]

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