Efficient way to compare GPS timestamps - c

Question

My target is to compare two u_long timestamps, delivered by a GPS device. A long integer like 16290212 has the following structure:
hhmmssµµ
The following code snippet shows an approach how to parse a long integer to an integer array. But I think this is not very efficient. What would be the quickest way to compare two timestamps? I would love to use an UNIX timestamp, but it is not possible in this context.
u_long timestamp_old = 16290212;
u_long base = 1000000;
/* arr[0]: hours
* arr[1]: minutes
* arr[2]: seconds
* arr[3]: miliseconds */
int arr[4];
int i=0;
// parse timestamp_old
while(base >= 1)
{
arr[i++] = (timestamp_old / base);
timestamp_old = (timestamp_old % base);
base /= 100;
}

Answer 1

Your timestamps are u_longs; compare them the same way you compare any 2 u_longs, something like <.

Answer 2

What would be the quickest way to compare two timestamps?
I want to check if the difference is smaller than 400 ms
Perhaps not the fastest yet at least a starting point with a quick worst case. Note that ssµµµ is the same as µµµµµ.
int32_t GPS_to_ms(u_long timestamp) {
int32_t ms = timestamp%100000;
int32_t hhmm = timestamp / 100000;
ms += (hhmm%100)*60*1000;
int32_t hh = hhmm / 100;
ms += hh*60*60*1000;
return ms;
}
if (GPS_to_ms(timestamp_later) - GPS_to_ms(timestamp_first) < 400) {
// timestamps are in close succession.
}
To speed things up on average, 1) assume timestamp_later >= timestamp_first
is usually true 2) timestamps typically have the same hhmm
bool GPS_compare_400(u_long first, u_long later) {
int32_t ms1 = first%100000;
int32_t hhmm1 = first/100000;
int32_t ms2 = later%100000;
int32_t hhmm2 = later/100000;
if (hhmm1 == hhmm2) {
return ms2 - ms1 < 400;
}
return GPS_to_ms(timestamp_later) - GPS_to_ms(timestamp_first) < 400;
}

Answer 3

I assume the input is a string gpstime of the form "hhmmssµµµ". I assume that trailing zeros are always present such that there are always exactly three digits for the microseconds part.
1.
int h, m, s, us;
double t;
if(sscanf(gpstime, "%2d%2d%2d%3d", &h, &m, &s, &us) == 4)
t = (h * 60L + m) * 60 + s + us/1000.;
else {
/* parse error */
t = 0;
}
If that's not efficient enough, here's something down-and-dirty, eschewing scanf:
2.
#define Ctod(c) ((c) - '0')
int h = 10 * Ctod(utctime[0]) + Ctod(utctime[1]);
int m = 10 * Ctod(utctime[2]) + Ctod(utctime[3]);
int s = 10 * Ctod(utctime[4]) + Ctod(utctime[5]);
int us = 100 * Ctod(utctime[6]) + 10 * Ctod(utctime[7]) + Ctod(utctime[8]);
double t = (h * 60L + m) * 60 + s + us/1000.;
In either case, once you've got your t values, just subtract and compare as usual.
If you don't want to use floating point, change t to long int, change the scaling factors as appropriate, and compare your final difference to 400 instead of 0.4.
(But with all of this said, I wouldn't worry about efficiency too much. 10 Hz may sound fast to a pitiful human, but a tenth of a second is a hell of a long time for a decent computer.)