Question about strange behavior of Timer0

RE: Question about strange behavior of Timer0

JiachengWang — Mon, 12 Oct 2015 08:02:37 GMT

Hi, Aryan,

The first value of RTC0->COUNTER save in time_capture[0] is just used to record the initial time of waiting for the first event, and second value saved in time_capture[1] (in for loop, start form i=1) to record the time of the first event and the starting time for waiting second event, and .......

The value captured from RTC0 has no difference of unconditional/conditional, just record the time. The time used for waiting the first event is (time_capture[1] - time_capture[0]), and second event time is (time_capture[2] - time_capture[1]). The output code is

for (i=1; i<10; i++)
{
    printf("---- i = %ld, timer counter = %ld\r\n", i, time_capture[i] - time_capture[i - 1]); 
    nrf_delay_ms(100);
}

for NRF_TIMER0->CC[0] = 16 * 1000, I get the output as ---------------------------------------------------------------- ---- i = 1, timer counter = 34 ---- i = 2, timer counter = 34 ---- i = 3, timer counter = 34 ---- i = 4, timer counter = 34 ---- i = 5, timer counter = 34 ---- i = 6, timer counter = 34 ---- i = 7, timer counter = 34 ---- i = 8, timer counter = 34 ---- i = 9, timer counter = 34

Thanks a lot,

Jiacheng

RE: Question about strange behavior of Timer0

Susheel Nuguru — Mon, 12 Oct 2015 07:33:12 GMT

i did not get it : ( now you are capturing the first RTC->COUNTER value unconditionally and still it gives you same value like others which are captured condictionally??? monday morning may be .. but i don't get it :(

RE: Question about strange behavior of Timer0

JiachengWang — Mon, 12 Oct 2015 05:32:54 GMT

There is a bug in my previous code.

Inside the for loop, the EVENTS_COMPARE register is cleared after the event. For MDK, since all avriable is initialized with 0, each event has the same timer number. but for GCC, the initial value is a random number (I use GCC), so the first event has a different timer number.

The correct code should be like:

time_capture[0] = NRF_RTC0->COUNTER;
NRF_TIMER0->TASKS_CLEAR = 1;
for (i=1; i<10; i++)
{
    NRF_TIMER0->EVENTS_COMPARE[0] = 0;
    (void)NRF_TIMER0->EVENTS_COMPARE[0];
    while (NRF_TIMER0->EVENTS_COMPARE[0] == 0)
    {
    }  
    time_capture[i] = NRF_RTC0->COUNTER;
}

This code will give the same timer number for each event.

RE: Question about strange behavior of Timer0

JiachengWang — Mon, 12 Oct 2015 02:41:30 GMT

sorry, it's my mistake, in timer capture loop, "i' should be started from 0, as

for (i=0; i<10; i++)
{
    while (NRF_TIMER0->EVENTS_COMPARE[0] == 0)
    {
    }  
				NRF_TIMER0->TASKS_CAPTURE[1] = 1;
    time_capture[i] = NRF_TIMER0->CC[1];
    NRF_TIMER0->EVENTS_COMPARE[0] = 0;
    (void)NRF_TIMER0->EVENTS_COMPARE[0];
}

give output

----------------------------------------------------------------
---- i = 0, timer counter = 5
---- i = 1, timer counter = 7
---- i = 2, timer counter = 5
---- i = 3, timer counter = 7
---- i = 4, timer counter = 7
---- i = 5, timer counter = 5
---- i = 6, timer counter = 7
---- i = 7, timer counter = 5
---- i = 8, timer counter = 7
---- i = 9, timer counter = 5

It seems the first event give the right timer number.

RE: Question about strange behavior of Timer0

JiachengWang — Mon, 12 Oct 2015 01:59:15 GMT

Hi, RK and Aryan,

Thanks a lot for your help.

I'm trying to re-produce the output with a "pure" SDK environment (I use a mixed environment with som function from old SDK and som my own functions before). I'm currently use UART example code in "nRF52_SDK_0.9.1_3639cc9\examples\peripheral\uart", just with a simple modification. The main function is (add timer0 config function and modify the last lines in main function):

/* Copyright (c) 2014 Nordic Semiconductor. All Rights Reserved.
 *
 * The information contained herein is property of Nordic Semiconductor ASA.
 * Terms and conditions of usage are described in detail in NORDIC
 * SEMICONDUCTOR STANDARD SOFTWARE LICENSE AGREEMENT.
 *
 * Licensees are granted free, non-transferable use of the information. NO
 * WARRANTY of ANY KIND is provided. This heading must NOT be removed from
 * the file.
 *
 */

/** @file
 * @defgroup uart_example_main main.c
 * @{
 * @ingroup uart_example
 * @brief UART Example Application main file.
 *
 * This file contains the source code for a sample application using UART.
 * 
 */

#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include "app_uart.h"
#include "app_error.h"
#include "nrf_delay.h"
#include "nrf.h"
#include "bsp.h"

//#define ENABLE_LOOPBACK_TEST  /**< if defined, then this example will be a loopback test, which means that TX should be connected to RX to get data loopback. */

#define MAX_TEST_DATA_BYTES     (15U)                /**< max number of test bytes to be used for tx and rx. */
#define UART_TX_BUF_SIZE 256                         /**< UART TX buffer size. */
#define UART_RX_BUF_SIZE 1                           /**< UART RX buffer size. */

void uart_error_handle(app_uart_evt_t * p_event)
{
    if (p_event->evt_type == APP_UART_COMMUNICATION_ERROR)
    {
        APP_ERROR_HANDLER(p_event->data.error_communication);
    }
    else if (p_event->evt_type == APP_UART_FIFO_ERROR)
    {
        APP_ERROR_HANDLER(p_event->data.error_code);
    }
}



#ifdef ENABLE_LOOPBACK_TEST
/** @brief Function for setting the @ref ERROR_PIN high, and then enter an infinite loop.
 */
static void show_error(void)
{
    
    LEDS_ON(LEDS_MASK);
    while(true)
    {
        // Do nothing.
    }
}


/** @brief Function for testing UART loop back. 
 *  @details Transmitts one character at a time to check if the data received from the loopback is same as the transmitted data.
 *  @note  @ref TX_PIN_NUMBER must be connected to @ref RX_PIN_NUMBER)
 */
static void uart_loopback_test()
{
    uint8_t * tx_data = (uint8_t *)("\n\rLOOPBACK_TEST\n\r");
    uint8_t   rx_data;

    // Start sending one byte and see if you get the same
    for (uint32_t i = 0; i < MAX_TEST_DATA_BYTES; i++)
    {
        uint32_t err_code;
        while(app_uart_put(tx_data[i]) != NRF_SUCCESS);

        nrf_delay_ms(10);
        err_code = app_uart_get(&rx_data);

        if ((rx_data != tx_data[i]) || (err_code != NRF_SUCCESS))
        {
            show_error();
        }
    }
    return;
}


#endif

/********************************************************************************/
void timer0_initialization(void)
/*--------------------------------------------------------------------------------
| TIMER0 initialization
|
--------------------------------------------------------------------------------*/
{
  NRF_TIMER0->TASKS_STOP = 1;
  NRF_TIMER0->TASKS_CLEAR = 1;
  NRF_TIMER0->MODE = TIMER_MODE_MODE_Timer;
  NRF_TIMER0->PRESCALER = 0;
  NRF_TIMER0->BITMODE = TIMER_BITMODE_BITMODE_16Bit;
  NRF_TIMER0->SHORTS = TIMER_SHORTS_COMPARE0_CLEAR_Enabled << TIMER_SHORTS_COMPARE0_CLEAR_Pos;
  NRF_TIMER0->INTENSET = TIMER_INTENSET_COMPARE0_Enabled << TIMER_INTENSET_COMPARE0_Pos;
  NRF_TIMER0->TASKS_STOP = 1;
}


/**
 * @brief Function for main application entry.
 */
int main(void)
{
    LEDS_CONFIGURE(LEDS_MASK);
    LEDS_OFF(LEDS_MASK);
    uint32_t err_code;
    const app_uart_comm_params_t comm_params =
      {
          RX_PIN_NUMBER,
          TX_PIN_NUMBER,
          RTS_PIN_NUMBER,
          CTS_PIN_NUMBER,
          APP_UART_FLOW_CONTROL_ENABLED,
          false,
          UART_BAUDRATE_BAUDRATE_Baud38400
      };

    APP_UART_FIFO_INIT(&comm_params,
                         UART_RX_BUF_SIZE,
                         UART_TX_BUF_SIZE,
                         uart_error_handle,
                         APP_IRQ_PRIORITY_LOW,
                         err_code);

    APP_ERROR_CHECK(err_code);
			
/*******************************************************************************/
/*******************************************************************************/
/*******************************************************************************/
    uint32_t i;
    uint32_t time_capture[10];

    timer0_initialization( );
    
    NRF_TIMER0->CC[0] = 1 * 16; 
 
    NRF_TIMER0->TASKS_CLEAR = 1;
    NRF_TIMER0->TASKS_START = 1;
    for (i=1; i<10; i++)
    {
        while (NRF_TIMER0->EVENTS_COMPARE[0] == 0)
        {
        }  
				NRF_TIMER0->TASKS_CAPTURE[1] = 1;
        time_capture[i] = NRF_TIMER0->CC[1];
        NRF_TIMER0->EVENTS_COMPARE[0] = 0;
        (void)NRF_TIMER0->EVENTS_COMPARE[0];
    }
  
    printf("-------------------------------- Start ------------------------------- \r\n");
    for (i=0; i<10; i++)
    {
        printf("---- i = %ld, time delay = %ld\r\n", i, time_capture[i]); 
			  nrf_delay_ms(10);
    }
}
/** @} */

With smaller CC[0] value “NRF_TIMER0->CC[0] = 1 * 16” and capture timer0 counter and RTC0 is not used. The output of above code is as

-------------------------------- Start -------------------------------
---- i = 0, timer counter = 0
---- i = 1, timer counter = 7
---- i = 2, timer counter = 8
---- i = 3, timer counter = 9
---- i = 4, timer counter = 10
---- i = 5, timer counter = 11
---- i = 6, timer counter = 8
---- i = 7, timer counter = 9
---- i = 8, timer counter = 10
---- i = 9, timer counter = 11

It seems the first event still have different timer number. With some larger CC[0] value, NRF_TIMER0->CC[0] = 1000 * 16 give output

-------------------------------- Start -------------------------------
---- i = 0, timer counter = 0
---- i = 1, timer counter = 7
---- i = 2, timer counter = 5
---- i = 3, timer counter = 7
---- i = 4, timer counter = 5
---- i = 5, timer counter = 7
---- i = 6, timer counter = 5
---- i = 7, timer counter = 7
---- i = 8, timer counter = 5
---- i = 9, timer counter = 7

The code is simple, please help to check the lines of TIMER0 initialization, if some registers have wrong configured.

I'm using nRF52832 preview DK board (PCA10036), if possible, please repeat the output with above code at your side.

Thanks again and Best Regards,

Jiacheng

RE: Question about strange behavior of Timer0

RK — Sun, 11 Oct 2015 07:54:12 GMT

The CC register doesn't take any time at all so that's not the problem. This output makes no sense to me currently, I can't see how you could be getting this result. As long as TIMER0 is started from 0 when you start it, the first event will occur 16,000 ticks later.

As well as recording the RTC0 counts, how about recording the TIMER0 count at the same moments to just confirm they make sense. ie add a timer_capture[] variable and after each of the time_capture[x]=RTC0->COUNTER lines add something which captures the TIMER0 count to CC[1] and stores that - then print them out too.

Take that printf() at the start out too, just to eliminate that, I don't know what printf() library you have in there and whether it's asynchronous, uses timers or anything else.

RE: Question about strange behavior of Timer0

JiachengWang — Sun, 11 Oct 2015 04:17:38 GMT

Hi, Aryan,

Put "NRF_TIMER0->TASKS_CLEAR=1" there has no any help.

With more test, I have the following observation: put some delay right after "NRF_TIMER0->CC[0] = 1000 * 16;", the delay is the same. the code like

 NRF_TIMER0->CC[0] = 1000 * 16; 
  nrf_delay_ms(1);  
  
  time_capture[0] = NRF_RTC0->COUNTER;   
 
  NRF_TIMER0->TASKS_START = 1;
  for (i=1; i<10; i++)
  {
    NRF_TIMER0->EVENTS_COMPARE[0] = 0; 
    while (NRF_TIMER0->EVENTS_COMPARE[0] == 0)
    {        
    }
    time_capture[i] = NRF_RTC0->COUNTER;   
  }

then I get the output as

---------------------------------- Start --------------------------------------- 
i = 1, time delay = 34
i = 2, time delay = 34
i = 3, time delay = 34
i = 4, time delay = 33
i = 5, time delay = 34
i = 6, time delay = 34
i = 7, time delay = 34
i = 8, time delay = 34
i = 9, time delay = 34

However, if I reduce the delay as "nrf_delay_us(500);", the output is as.

---------------------------------- Start --------------------------------------- 
i = 1, time delay = 25
i = 2, time delay = 34
i = 3, time delay = 34
i = 4, time delay = 33
i = 5, time delay = 34
i = 6, time delay = 34
i = 7, time delay = 34
i = 8, time delay = 34
i = 9, time delay = 34

Why CC register take so long time? I want to use timer0 to get exact time delay as about 20us ~30us. timer0 has timing resolution of 16M, I think it is enough to control such time delay. Would you please give me some suggestions or comments?

Thanks a lot!

Jiacheng

RE: Question about strange behavior of Timer0

RK — Sun, 11 Oct 2015 02:32:02 GMT

Does it help if you put a NRF_TIMER0->TASKS_CLEAR=1 before starting the timer?

RE: Question about strange behavior of Timer0

JiachengWang — Sat, 10 Oct 2015 23:03:00 GMT

Hi, Aryan,

Thanks a lot for your quick response.

The point is that the first event time (after timer0 task tarted) is different. To record the time of first event (and remove the delay right after timer0 started), the code is modified as:

int main(void)
{
  uint32_t i;
  uint32_t time_capture[10];
   
  /* UART and RTC0 initialization */
  
  printf ("---------------------------------- Start --------------------------------------- \r\n");
  
  timer0_initialization1( );
  /* RTC0 initialization */
  rtc0_time_out_config( );
  
  time_capture[0] = NRF_RTC0->COUNTER;  
  
  NRF_TIMER0->CC[0] = 1000 * 16;
  NRF_TIMER0->TASKS_START = 1;
  
  for (i=1; i<10; i++)
  {
    NRF_TIMER0->EVENTS_COMPARE[0] = 0;    
    while (NRF_TIMER0->EVENTS_COMPARE[0] == 0)
    {        
    }
    time_capture[i] = NRF_RTC0->COUNTER;
  }
  for (i=1; i<10; i++)
  {
    printf("i = %ld, time delay = %ld, \r\n", i, time_capture[i] - time_capture[i - 1]); 
  }
  
  while(1);
}

the result is as

   ---------------------------------- Start --------------------------------------- 
    i = 1, time delay = 8, 
    i = 2, time delay = 34, 
    i = 3, time delay = 34, 
    i = 4, time delay = 34, 
    i = 5, time delay = 33, 
    i = 6, time delay = 34, 
    i = 7, time delay = 34, 
    i = 8, time delay = 34, 
    i = 9, time delay = 34,

How can I get the same time of the first event as the other events?

Thanks again.

RE: Question about strange behavior of Timer0

Susheel Nuguru — Sat, 10 Oct 2015 17:24:12 GMT

capture the RTC->COUNTER value after you get the event

  for (i=0; i<10; i++)
     {  
        NRF_TIMER0->EVENTS_COMPARE[0] = 0;
    while (NRF_TIMER0->EVENTS_COMPARE[0] == 0)
    {    
       /* delay 1ms */    
    }
    time_capture[i] = NRF_RTC0->COUNTER;  // <-- this is changed
  }

you are not using interrupts to sense the TIMER0 events, so if you add nrf_delay_ms(some_number), then you are just ignoring the events happening within that time. After that when you capture the RTC->COUNTER value then it will give you different numbers because of the initial ignored events which caused many overflows in RTC counter.