sync timer with shorter timestamp than timer - c

Question

Hy I have two devices A and B both are using a 64bit timer. One tick equals 1ns. I would like to syncronise the drift of both timer. I allready know the delay between A and B. Normally I would send the current time of A frequently to B. In B i would add the propagation delay and use this value as compare value to sync B. In my case I can only send the lower 32 bit of the timer every 100ms. I tried to simple replace the lower part of B with the part of A but this work only as long as there is no overflow of the 32 bit. Is there a way to detect this overflow? Overflow example (shorted timer):
timer B: 0x00FF
timer A: 0x010A
=> 0x0A to B
replacing leads to
timer B 0x000A instead of timer B 0x010A.
So I need to detect that in A a overflow already occured which hasn't occured in B.
Underflow example (shorted timer):
timer B: 0x0205
timer A: 0x01F6
=> 0xF6 => timer B: 0x02F6 instead of 0x01F6
In this case timer B is faster than timer A.

Answer 1

Here's what I'd use to find out the closest possible value of timera, given timerb, the 32 low bits of timera in message, and the expected propagation delay in delay:
#include <stdint.h>
int64_t expected_timera(const int64_t timerb,
const uint32_t message,
const uint32_t delay)
{
const int64_t timer1 = (timerb / INT64_C(4294967296)) * INT64_C(4294967296)
+ (int64_t)message + (int64_t)delay;
const int64_t timer0 = timer1 - INT64_C(4294967296);
const int64_t timer2 = timer1 + INT64_C(4294967296);
const uint64_t delta0 = timerb - timer0;
const uint64_t delta1 = (timer1 > timerb) ? timer1 - timerb : timerb - timer1;
const uint64_t delta2 = timer2 - timerb;
if (delta0 < delta1)
return (delta0 < delta2) ? timer0 : timer2;
else
return (delta1 <= delta2) ? timer1 : timer2;
}
Personally, I would also calculate timerb from the actual timer B using a linear adjustment:
static volatile int64_t real_timer_b; /* Actual timer b */
static int64_t timerb_real; /* real_timer_b at last sync time */
static int64_t timerb_offset; /* timera at last sync time */
static int32_t timerb_scale; /* Q30 scale factor (0,2) */
static inline int64_t timerb(void)
{
return ((int64_t)(int32_t)(real_timer_b - timerb_real) * (int64_t)timerb_scale) / INT64_C(1073741824) + timerb_offset;
}
With timerb_real = 0, timerb_offset = 0, and timerb_scale = 1073741824, timerb() == real_timer_b.
When timera > timerb(), you need to increase timerb_scale. When timera < timerb(), you need to decrease timerb_scale. You do not want to calculate the exact value every 100ms, because then jitter in propagation delay would directly affect timerb(); you want to adjust it slowly, over several (dozens) of seconds. As a bonus, you can keep timerb() monotonic, without sudden jumps forward or backwards.
Network Time Protocol implementations do something very similar, and you might find further implementation help there.