Timer accuracy for micro seconds

RE: Timer accuracy for micro seconds

MaximSh — Sun, 16 Apr 2023 09:09:00 GMT

Did you try to use event manager?

RE: Timer accuracy for micro seconds

MaximSh — Sun, 02 Apr 2023 10:48:11 GMT

Hi,
I tested it without zephyr +/- like you suggested, it is working.
Looks like integrations with zephyr is the issue.

RE: Timer accuracy for micro seconds

Emil Lenngren — Sun, 02 Apr 2023 10:40:09 GMT

If I were to perform a SPIM transaction exactly every 500 us, I would do the following.

- Use one RTC compare register that publishes a DPPI event.

- Use one TIMER peripheral configured to perform the START task when the DPPI event from RTC compare is triggered.

- Use a TIMER compare register, programmed with the < 31.518 microseconds adjustment needed to match 500 microseconds, that triggers a DPPI event. A "shortcut" is programmed as well to stop the TIMER at the same time.

- Program the SPIM peripheral to listen on the DPPI event from the TIMER to start the transaction.

- Use an interrupt on the END event from SPIM to process the data, set up for the next SPIM transaction as well as program the timing and DPPI as instructed above for the next transaction to be started at the correct time.

This method will use the sleep clock and thus very low power between the cpu finished processing the last SPIM transaction result until the RTC wakes up the TIMER.

Note that the RTC runs at an interval of 1/32768 seconds, which is around 30.518 microseconds. 500 is not divisible by this number, since 500/(1/32768) = 16.384. Therefore a TIMER peripheral must be configured to wait for the last microseconds, to make the result accurate. So, assuming the RTC is turned on all the time, in order to calculate the next rtc and timer compare registers, you need to take into account the previous TIMER peripheral adjustment (before the previous SPIM transaction) and the next TIMER peripheral adjustment (to be applied in the next SPIM transaction). If you are happy with, let's say, performing a SPIM transaction every ~488 or ~519 microseconds instead, you can use the RTC only and skip the TIMER.

Not sure how to program this with Zephyr in mind though, since I have not used Zephyr.

RE: Timer accuracy for micro seconds

MaximSh — Sun, 02 Apr 2023 06:55:35 GMT

Maybe it is post processing.
1. I started form EVENT_MANAGER project
2. I generate every 500 us timer event, then submit this event to two module that should process the data
3. Every 2000 samples (1 second) i print the delta of time now - previous time , so it should be 1 second.

RE: Timer accuracy for micro seconds

Susheel Nuguru — Thu, 30 Mar 2023 15:59:03 GMT

I need to understand all the contexts in which you are doing this.
For me it seems more of the post processing latency issue when you are capturing the delta than the timer accuracy issue.
Can you give me a simplistic project to test?

RE: Timer accuracy for micro seconds

MaximSh — Wed, 29 Mar 2023 13:16:37 GMT

1. I can't read from timer interrupt, i also have a SPI read.
2. Try to use event manager and submit an event every 500 us and read the event at other modules(for example 2) and proccess some logic(try sleep for random ms)

RE: Timer accuracy for micro seconds

Susheel Nuguru — Wed, 29 Mar 2023 10:36:06 GMT

I am getting confusing results with your code snippet.

I am not sure what context the semaphore is taken but in my case I am doing this in the main context.

This below line is in the main context and is having a lot of latencies before it can execute. Like taking the semaphore. This is not a correct place to read delta. The correct place to read delta would be to get a counter capture from the TIMER to avoid all the overhead of interrupt latencies and latencies from semaphore handling between contexts.

But in your case, you can try to read the delta at the beginning of test_counter_interrupt_fn to get better accurate time difference than the one you are getting now. The one you are getting now adds other latencies(interrupt handlng/scheduler switch/semaphore handling etc) into the delta that you are printing.

printk("READ:%lld\n", k_uptime_delta(&time));

RE: Timer accuracy for micro seconds

Susheel Nuguru — Wed, 29 Mar 2023 07:21:49 GMT

Sorry for late reply maxim. I will try your code snippet right away and see if I can reproduce the same inaccuracies that you see.

RE: Timer accuracy for micro seconds

MaximSh — Thu, 23 Mar 2023 17:49:03 GMT

Still have issues if i use counter with timer0

i set alarm to 500 micro but after 2000 triggers that should print 1000(0.5*2000= 1000 mili) it prints

00> I: READ:1748
00> I: READ:1904
00> I: READ:1873
00> I: READ:1751
00> I: READ:1979
00> I: READ:1871
00> I: READ:1784
00> I: READ:1871

CONFIG_COUNTER=y

CONFIG_COUNTER_TIMER0=y

Here is my code:

#define THREAD_PRIORITY K_PRIO_PREEMPT(K_HIGHEST_APPLICATION_THREAD_PRIO)
#define TIMER DT_NODELABEL(timer0)
#define DELAY 500

Here is a k_thread_entry_t set_alarm

static void set_alarm(void)
{
    const struct device *const counter_dev = DEVICE_DT_GET(TIMER);
    int err;

    printk("Counter alarm sample\n\n");

    if (!device_is_ready(counter_dev))
    {
        printk("device not ready.\n");
        return;
    }

    counter_start(counter_dev);

    alarm_cfg.flags = 0;
    alarm_cfg.ticks = counter_us_to_ticks(counter_dev, DELAY);
    alarm_cfg.callback = test_counter_interrupt_fn;
    alarm_cfg.user_data = &alarm_cfg;

    err = counter_set_channel_alarm(counter_dev, ALARM_CHANNEL_ID,
                                    &alarm_cfg);
    printk("Set alarm in %u sec (%u ticks)\n",
           (uint32_t)(counter_ticks_to_us(counter_dev,
                                          alarm_cfg.ticks) /
                      USEC_PER_SEC),
           alarm_cfg.ticks);

    if (-EINVAL == err)
    {
        printk("Alarm settings invalid\n");
    }
    else if (-ENOTSUP == err)
    {
        printk("Alarm setting request not supported\n");
    }
    else if (err != 0)
    {
        printk("Error\n");
    }
    while (1)
    {
        static uint16_t c = 0;
        k_sem_take(&timer_semaphore, K_FOREVER);
        static int64_t time = 0;
        if (c == 2000)
        {
            LOG_INF("READ:%lld", k_uptime_delta(&time));
            c = 0;
        }
        if ((c++ % 2) == 0)
        {

            struct acc_event *event = new_acc_event();
            EVENT_SUBMIT(event);
        }
    }
}

callback that give semaphore to thread loop

static void test_counter_interrupt_fn(const struct device *counter_dev,
                                      uint8_t chan_id, uint32_t ticks,
                                      void *user_data)
{
    struct counter_alarm_cfg *config = user_data;
    uint32_t now_ticks;
    uint64_t now_usec;
    int now_sec;
    int err;

    k_sem_give(&timer_semaphore);

  

    err = counter_set_channel_alarm(counter_dev, ALARM_CHANNEL_ID,
                                    user_data);
    if (err != 0)
    {
        printk("Alarm could not be set\n");
    }
}

What is wrong?

Thanks

RE: Timer accuracy for micro seconds

Susheel Nuguru — Wed, 22 Mar 2023 07:03:34 GMT

[quote user="MaximSh"]So how to run polling of some code every 500 microseconds without using timer?[/quote]

Not sure if I understand this right, you want to have a time waiting code that waits for 500uS without using any timer? I am guessing that you want to use Kernel API for that instead of directly using timer API.

In that case you can only sleep with a resolution of the timer tick(SYS_CLOCK_TICKS_PER_SEC default value is 32768 on RTC) . If you want any better resolution, then you need to use high resolution timer API like nrfx_timer or nrfx_systick. The disadvantage of using high resolution timers is that they keep the high frequency clock on all the time and hence increasing the average power consumption of your application. If your application is running on a battery, it will be drained within days (if not hours)

RE: Timer accuracy for micro seconds

Susheel Nuguru — Wed, 22 Mar 2023 06:19:16 GMT

nrfx_timer is OS agnostic, so you can still use it in your application even in Zephyr SDK

RE: Timer accuracy for micro seconds

MaximSh — Tue, 21 Mar 2023 11:15:12 GMT

Can i use nrfx_timer with zephyr SDK? or use counter API?

RE: Timer accuracy for micro seconds

Susheel Nuguru — Mon, 20 Mar 2023 13:41:25 GMT

[quote user="MaximSh"]I try to put K_MSEC(1) but the work handler called after 1.117 ms.[/quote]

Are you calling K_MSEC(1) inside the worker handler or are you queuing the worker handler after K_MSEC(1)? After queuing the work handler, it will not necessary be called immediately if there are higher priority interrupts/threads/worker handlers that are pending to run.

If you want higher resolution timer I recommend you to use the API in modules\hal\nordic\nrfx\drivers\include\nrfx_timer.h

RE: Timer accuracy for micro seconds

MaximSh — Mon, 20 Mar 2023 11:55:29 GMT

So how to run polling of some code every 500 microseconds without using timer?
Why setting 128 MHz clock for cpu_app can't help?
it is very critical for the aplication to read from SPI data every 500 micro

Thanks

RE: Timer accuracy for micro seconds

MaximSh — Thu, 05 Jan 2023 13:39:05 GMT

I try to put K_MSEC(1) but the work handler called after 1.117 ms.
.
i fareget that i changed

hfclock to 128 MHz but i think it is not related.

static int hfclock_config_and_start(void)
{
	int ret;

	/* Use this to turn on 128 MHz clock for cpu_app */
	ret = nrfx_clock_divider_set(NRF_CLOCK_DOMAIN_HFCLK, NRF_CLOCK_HFCLK_DIV_1);

	ret -= NRFX_ERROR_BASE_NUM;
	if (ret)
	{
		return ret;
	}

	nrfx_clock_hfclk_start();
	while (!nrfx_clock_hfclk_is_running())
	{
	}

	return 0;
}

RE: Timer accuracy for micro seconds

Susheel Nuguru — Thu, 05 Jan 2023 12:09:56 GMT

The resolution of the kernel timers depend on which clock you are using. We are using RTC on nRF and the configuration CONFIG_SYS_CLOCK_TICKS_PER_SEC is set to 32768 in our samples.

You should not use k_timer for creating timeouts less than the resolution of the system timer.

RE: Timer accuracy for micro seconds

MaximSh — Tue, 03 Jan 2023 14:36:57 GMT

i didn't change configurations

RE: Timer accuracy for micro seconds

Susheel Nuguru — Tue, 03 Jan 2023 14:24:32 GMT

Are you using SyTick as kernel timer? on nRF the default should be RTC to be low power capable and the tick resolution I assumed to be 1ms.

RE: Timer accuracy for micro seconds

MaximSh — Tue, 03 Jan 2023 14:07:39 GMT

i think it converts time to ticks

RE: Timer accuracy for micro seconds

Susheel Nuguru — Tue, 03 Jan 2023 09:15:00 GMT

I thought the k_timer resolution is in milliseconds and not micro seconds. Need to look into the code to see if microseconds are also supported