TASKS_CAPTURE cannot read the correct value

Question

Hello!

I compare the timer every 1ms and process it.
In order to check whether it can be executed every 1ms, I am going to refer to the register value by "TASKS_CAPTURE".
The description of the timer itself is as follows.

Timer 1 is used.

nrf_drv_timer_config_t timer_cfg = NRF_DRV_TIMER_DEFAULT_CONFIG;
err_code = nrf_drv_timer_init(&TIMER, &timer_cfg, timer_twi_event_handler);
APP_ERROR_CHECK(err_code);

time_ticks = nrf_drv_timer_us_to_ticks(&TIMER, time_us);

nrf_drv_timer_extended_compare(
    &TIMER, NRF_TIMER_CC_CHANNEL1, time_ticks, NRF_TIMER_SHORT_COMPARE1_CLEAR_MASK, true);

nrf_drv_timer_enable(&TIMER);

The description of "TASKS_CAPTURE" is as follows.

void timer_twi_event_handler(nrf_timer_event_t event_type, void* p_context)
{

    switch (event_type)
    {
        case NRF_TIMER_EVENT_COMPARE1:
            if(j == 48){
                j = 0;
            }
					
            NRF_TIMER1 -> TASKS_CAPTURE[0] = 1;
            uint8_t caputured_value = NRF_TIMER1 -> CC[0];

            flags = true;
            time++;
            //receive_data();
            ret_code_t ret = nrf_drv_spi_xfer(&spi,&xfer_spi,flags);//Function for starting the SPI data transfer with additional option flags
            if(ret == NRF_SUCCESS)
            {
                uint32_t start_tsk_addr = nrf_drv_spi_start_task_get(&spi);
            }

            if(j < 24){
              //put_in_array(buf);
              for(int a = 0; a < 20; a++){
                  buf[j*21+a] = mpu_buf[a];
              }
              buf[j*21+20] = caputured_value;
            }else if(j >= 24){
              //put_in_array(buf2);
              for(int a = 0; a < 20; a++){
                  buf[j*21+a+8] = mpu_buf[a];
              }
              buf[j*21+20+8] = caputured_value;
            }
            j++;
            //data_handler();
					
            break;

        default:
            //Do nothing.
            break;
    }
}

The captured value is confirmed by writing to the SD card.
The values are always as follows:

This will be repeated.
Is my code something wrong?
Since "NRF_TIMER_CC_CHANNEL1" is used in the comparison, cc [0] is used when reading the register. Is this correct?

Please give me an answer.

Håkon · Accepted Answer

Hi, Glad it can help you somehow. 
 Ok, one timer. The delta you compute should indicate the number of timer ticks since last time you captured. This number will vary depending on the prescaler used for the timer. In the code I uploaded the timer is running on 16 MHz (default). When 1 ms is the target frequency for the callback handler, the timer should tick 16000 times. 
 If you change line 63 in main.c to the use 125 kHz instead of 16 MHz, the timer should tick only 125 times between each 1 ms. #define TIMER_BASE_FREQUENCY NRF_TIMER_FREQ_125kHz // Timer operating frequency 
 This should fit within your 8-bit limit. 
 
 Is it possible that you use the timer, running on 16MHz? If you hit the target number of tick, which is 16000 it could make sense. The lower 8 bits of 16000 decimal translates into 128 decimal. I assume you only write the 8 lowest bits, then this adds up.

y001 said: 
 If 128 can read the value of the register, how many registers is 1ms? 
 If the register is incremented by 1 every 1 ms, does that mean that an interrupt is called every 128 ms? 
 Even if you change PRESCALER and change the speed, Delta calculates 128, so if 128 is output, can you think that it is called correctly? 
 
 You misunderstand. You don't read 128 from any register. Reading CC[0] gives you the number of ticks from when the timer started. 
 The delta ticks are calculated from the amount of timer ticks last time, and this time the callback handler is running. 
 CC[1] is incremented with the number of ticks it needs to reach the next 1 ms cycle. 
 Prescaler/speed of timer is the same. The number of ticks needed to reach the next 1 ms cycle will decrease as the speed of the timer is decreased. 
 
 You should think of the case when the timer will eventually overflow. This could be done as simple as just resetting the timer using the CLEAR task, and write CC[0]=0 and CC[1]=timer_ticks inside the callback handler when you reach some high value close to the uint32_t limit. This solution does not handle the case when the timer if not reaching the 1 ms requirement. If a delay is detected, you can adjust for this as well by subtracting the delay found when calculating the delta ticks and subtrackt this from CC[1] to make sure that the next time 1ms is not shifted, but stays on the original 1 ms cycle. 
 You are welcome to post your callback once more with some of the updated tweaks if you want me to have look.

TASKS_CAPTURE cannot read the correct value

Top Replies