Best way to implement system clock on nRF51

[Alessandro]

Hi everybody,

a while ago I used the approach proposed here devzone.nordicsemi.com/.../ to keep the date and time on a NRF51822 device while using Softdevice S110 and the Timeslot advertiser-scanner (github.com/.../nRF51-multi-role-conn-observer-advertiser).

In practice I created an app_timer timer that executes every 250 milliseconds (this is the resolution I wanted) and inside the handler I incremented some variables accordingly to keep date and time. The problem is that I noticed that the time was not accurate, it was wrong, sometimes of several seconds, already after 1 hour. Here is the first question: I think that the time was wrong mainly because the app_timer handler gets delayed by the BLE stack, am I correct?

My idea to improve this is to connect an RTC1 COMPARE event to the TIMER1 COUNT task through PPI. The RTC1 will be configured to fire the event every second. This way I could keep the time in TIMER1 as a Unix timestamp (seconds since 1970-01-01) and I could read the number of milliseconds from RTC1 (I will use the number of ticks together with the prescaler to compute the milliseconds). This way there is no software handler involved and therefore it could not get delayed, is it correct? Is this going to be more precise than the solution using the app_timer? Will this solution consume more power? Do I need to keep on the 16MHz clock?

The implication of this solution is that I cannot use the app_timer library anymore or I could modify it to connect the RTC COMPARE event with the TIMER COUNT task and this should not interfere with the normal operation of the library, right?

I could try to implement the solution but since I am not sure it will work I would like some feedback from you.

Thanks a lot. Alessandro

[Clem Taylor]

So my changes to app_timer seem to be working.

gist.github.com/.../26da578862ffe083bf72

Now I just need to figure out a less horrible way of doing long term app_timer events, specifically tasks that happen hourly and daily (synced to real time). My app_timer rewrite for the nrf52 uses int64_t for the internal timestamps and will happily queue events with timeouts >2*24 base ticks. It really won't work on the nrf51 because it makes heavy use of __builtin_clz() which is CLZ instruction on the Cortex-M4, but a pile of code on the Cortex-M0.

I have it setup to decouple the hardware prescaler from the API, so I always operate on 32768Hz, but under the hood it can be lower frequency. I mostly use timestampGet(), but the other two routines might be useful in some cases.

typedef struct
{
    int32_t seconds;       // seconds (signed for delta) 
    int32_t ticks;         // in TIMESTAMP_TICKS_PER_SECOND 
} timestamp_t;

void timestampGet(timestamp_t *ts)
{
    uint32_t overflow, ticks, s, t;

    app_timer_ticks(&overflow, &ticks);

    s = ticks / TIMER_TICKS_PER_SECOND; // becomes >> 
    t = ticks % TIMER_TICKS_PER_SECOND; // becomes & 

    ts->seconds =
        overflow * ((1 << RTC_TICKS_BITS) / TIMER_TICKS_PER_SECOND) + s;
    ts->ticks = t * (TIMER_PRESCALER + 1); // timestamp_t.ticks always mod 32768 
}

/* getTicks32: Convert overflow count and ticks to a 32 bit value 
 *    Note: This rolls over every 36 hours, 35 minutes, 2 seconds for 32768Hz RTC. 
 *    Note: This is in RTC ticks, not timestamp_t.ticks which are always 32768Hz. 
 */
uint32_t getTicks32(void)
{
    uint32_t overflow, ticks;
    uint32_t count;
 
    app_timer_ticks(&overflow, &ticks);
   
    count = (overflow << RTC_TICKS_BITS) + ticks;
 
    return count;
}
 
/* getTicks64: Convert overflow count and ticks to a 64 bit monotonic value 
 *    Note: This is in RTC ticks, not timestamp_t.ticks which are always 32768Hz. 
 */
int64_t getTicks64(void)
{
    uint32_t overflow, ticks;
    int64_t count;
 
    app_timer_ticks(&overflow, &ticks);
 
    count = (((int64_t) overflow) << RTC_TICKS_BITS) + ticks;
 
    return count;
}

[Alessandro]

Thanks Clem, this is really good.

I was wondering, how do you compute TIMER_TICKS_PER_SECOND? Do you use ROUNDED_DIV(APP_TIMER_CLOCK_FREQ, (PRESCALER + 1)) from app_util.h?

If I want to compute the milliseconds can I do it like this? millis = timestamp_t.ticks * (1000/APP_TIMER_CLOCK_FREQ);

Moreover, what do you mean that you have decoupled the hardware prescaler from the API?