Add a sentence_time member...

...so sentences can have associated timestamps even when they're not fixes.

11 files changed, 93 insertions, 78 deletions

diff --git a/garmin.c b/garmin.c
index aaa98c02..ea0b0dd2 100644
--- a/garmin.c
+++ b/garmin.c
@@ -261,7 +261,7 @@ static int PrintPacket(struct gps_session_t *session, Packet_t *pkt)
 	    time_l -= pvt->leap_sec;
 	    // gps_tow is always like x.999 or x.998 so just round it
 	    time_l += (time_t) rint(pvt->gps_tow);
-	    session->gpsdata.fix.time = time_l;
+	    session->gpsdata.fix.time = session->gpsdata.sentence_time = time_l;
 #ifdef NTPSHM_ENABLE
 	    ntpshm_put(session, session->gpsdata.fix.time);
 #endif 
diff --git a/gps.h b/gps.h
index 030674cf..26ec088a 100644
--- a/gps.h
+++ b/gps.h
@@ -131,6 +131,7 @@ struct gps_data_t {
     int profiling;		/* profiling enabled? */
     char tag[MAXNAMELEN+1];	/* tag of last sentence processed */
     int sentence_length;	/* character count of last sentence */
+    double sentence_time;	/* sentence timestamp */
     double d_xmit_time;		/* beginning of sentence transmission */
     double d_recv_time;		/* daemon receipt time (-> E1+T1) */
     double d_decode_time;	/* daemon end-of-decode time (-> D1) */
diff --git a/gps.py b/gps.py
index 12547272..c404bda8 100755
--- a/gps.py
+++ b/gps.py
@@ -45,23 +45,39 @@ class gpstimings:
     def __init__(self):
         self.tag = ""
         self.length = 0
-        self.gps_time = 0.0
+        self.sentence_time = 0.0
         self.d_recv_time = 0
         self.d_decode_time = 0
         self.emit_time = 0
         self.poll_time = 0
         self.c_recv_time = 0
         self.c_decode_time = 0
-    def collect(self, tag, length, gps_time, xmit_time, recv_time, decode_time, poll_time, emit_time):
+    def collect(self, tag, length, sentence_time, xmit_time, recv_time, decode_time, poll_time, emit_time):
         self.tag = tag
         self.length = int(length)
-        self.gps_time = float(gps_time)
+        self.sentence_time = float(sentence_time)
         self.d_xmit_time = float(xmit_time)
         self.d_recv_time = float(recv_time)
         self.d_decode_time = float(decode_time)
         self.poll_time = float(poll_time)
         self.emit_time = float(emit_time)
 
+class gpsfix:
+    def __init__(self):
+	self.mode = MODE_NO_FIX
+        self.time = 0.0
+        self.ept = 0.0
+	self.latitude = self.longitude = 0.0
+        self.eph = 0.0
+	self.altitude = ALTITUDE_NOT_VALID	# Meters
+        self.epv = 0.0
+	self.track = TRACK_NOT_VALID		# Degrees from true north
+	self.speed = 0.0			# Knots
+	self.climb = 0.0			# Meters per second
+        self.epd = 0.0
+        self.eps = 0.0
+        self.epc = 0.0
+
 class gpsdata:
     "Position, track, velocity and status information returned by a GPS."
 
@@ -79,16 +95,9 @@ class gpsdata:
 	# Initialize all data members 
 	self.online = 0			# NZ if GPS on, zero if not
 
-	self.mode = MODE_NO_FIX
-	self.latitude = self.longitude = 0.0
-        self.eph = 0.0
-	self.altitude = ALTITUDE_NOT_VALID	# Meters
-        self.epv = 0.0
-	self.track = TRACK_NOT_VALID		# Degrees from true north
-	self.speed = 0.0			# Knots
-	self.climb = 0.0			# Meters per second
-
         self.valid = 0
+        self.fix = gpsfix()
+        
 	self.status = STATUS_NO_FIX
         self.utc = ""
 
@@ -110,18 +119,18 @@ class gpsdata:
 
     def __repr__(self):
 	st = ""
-	st += "Lat/lon:  %f %f\n" % (self.latitude, self.longitude)
-        if self.altitude == ALTITUDE_NOT_VALID:
+	st += "Lat/lon:  %f %f\n" % (self.fix.latitude, self.fix.longitude)
+        if self.fix.altitude == ALTITUDE_NOT_VALID:
             st += "Altitude: ALTITUDE_NOT_VALID\n"
         else:
-            st += "Altitude: %f\n" % (self.altitude)
-	st += "Speed:    %f\n" % (self.speed)
+            st += "Altitude: %f\n" % (self.fix.altitude)
+	st += "Speed:    %f\n" % (self.fix.speed)
         if self.track == TRACK_NOT_VALID:
             st += "Track:    TRACK_NOT_VALID\n"
         else:
-            st += "Track:    %f\n" % (self.track)
+            st += "Track:    %f\n" % (self.fix.track)
 	st += "Status:   STATUS_%s\n" %("NO_FIX","FIX","DGPS_FIX")[self.status]
-	st += "Mode:     MODE_"+("ZERO", "NO_FIX", "2D","3D")[self.mode]+"\n"
+	st += "Mode:     MODE_"+("ZERO", "NO_FIX", "2D","3D")[self.fix.mode]+"\n"
 	st += "Quality:  %d p=%2.2f h=%2.2f v=%2.2f\n" % \
               (self.satellites_used, self.pdop, self.hdop, self.vdop)
 	st += "Y: %s satellites in view:\n" % len(self.satellites)
@@ -198,7 +207,7 @@ class gps(gpsdata):
 	    if data[0] == "?":
 		continue
 	    if cmd in ('A', 'a'):
-	      self.altitude = float(data)
+	      self.fix.altitude = float(data)
               self.valid |= ALTITUDE_SET
 	    elif cmd in ('B', 'b'):
               (f1, f2, f3, f4) = data.split()
@@ -212,57 +221,57 @@ class gps(gpsdata):
               self.valid |= TIME_SET
 	    elif cmd in ('E', 'e'):
 	      parts = data.split()
-	      (self.epe, self.eph, self.epv) = map(float, parts)
+	      (self.epe, self.fix.eph, self.fix.epv) = map(float, parts)
               self.valid |= HERR_SET | VERR_SET | PERR_SET
 	    elif cmd in ('I', 'i'):
 	      self.gps_id = data
 	    elif cmd in ('M', 'm'):
-	      self.mode = int(data)
+	      self.fix.mode = int(data)
               self.valid |= MODE_SET
 	    elif cmd in ('N', 'n'):
 	      self.driver_mode = int(data)
 	    elif cmd in ('O', 'o'):
                 fields = data.split()
                 if fields[0] == '?':
-                    self.mode = MODE_NO_FIX
+                    self.fix.mode = MODE_NO_FIX
                 else:
-                    self.gps_time = float(fields[0])
-                    self.ept = float(fields[1])
-                    self.latitude = float(fields[2])
-                    self.longitude = float(fields[3])
+                    self.fix.time = float(fields[0])
+                    self.fix.ept = float(fields[1])
+                    self.fix.latitude = float(fields[2])
+                    self.fix.longitude = float(fields[3])
                     def default(i, d):
                         if fields[i] == '?':
                             return d
                         else:
                             return float(fields[i])
-                    self.altitude = default(4, ALTITUDE_NOT_VALID)
-                    if self.altitude == ALTITUDE_NOT_VALID:
-                        self.mode = MODE_2D
+                    self.fix.altitude = default(4, ALTITUDE_NOT_VALID)
+                    if self.fix.altitude == ALTITUDE_NOT_VALID:
+                        self.fix.mode = MODE_2D
                     else:
-                        self.mode = MODE_3D
-                    self.eph = default(5, 0.0)
-                    self.epv = default(6, 0.0)
-                    self.track = default(7, TRACK_NOT_VALID)
-                    self.speed = default(8, 0.0)
-                    self.climb = default(9, 0.0)
-                    self.epd = default(10, 0.0)
-                    self.eps = default(11, 0.0)
-                    self.epc = default(12, 0.0)
+                        self.fix.mode = MODE_3D
+                    self.fix.eph = default(5, 0.0)
+                    self.fix.epv = default(6, 0.0)
+                    self.fix.track = default(7, TRACK_NOT_VALID)
+                    self.fix.speed = default(8, 0.0)
+                    self.fix.climb = default(9, 0.0)
+                    self.fix.epd = default(10, 0.0)
+                    self.fix.eps = default(11, 0.0)
+                    self.fix.epc = default(12, 0.0)
                     self.valid |= TIME_SET|TIMERR_SET|LATLON_SET|MODE_SET
-                    if self.mode == MODE_3D:
+                    if self.fix.mode == MODE_3D:
                         self.valid |= ALTITUDE_SET | CLIMB_SET
-                    if self.eph:
+                    if self.fix.eph:
                         self.valid |= HERR_SET
-                    if self.epv:
+                    if self.fix.epv:
                         self.valid |= VERR_SET
-                    if self.track != TRACK_NOT_VALID:
+                    if self.fix.track != TRACK_NOT_VALID:
                         self.valid |= TRACK_SET | SPEED_SET
-                    if self.eps:
+                    if self.fix.eps:
                         self.valid |= SPEEDERR_SET
-                    if self.epc:
+                    if self.fix.epc:
                         self.valid |= CLIMBERR_SET
 	    elif cmd in ('P', 'p'):
-	      (self.latitude, self.longitude) = map(float, data.split())
+	      (self.fix.latitude, self.fix.longitude) = map(float, data.split())
               self.valid |= LATLON_SET
 	    elif cmd in ('Q', 'q'):
 	      parts = data.split()
@@ -273,13 +282,13 @@ class gps(gpsdata):
 	      self.status = int(data)
               self.valid |= STATUS_SET
 	    elif cmd in ('T', 't'):
-	      self.track = float(data)
+	      self.fix.track = float(data)
               self.valid |= TRACK_SET
 	    elif cmd in ('U', 'u'):
-	      self.climb = float(data)
+	      self.fix.climb = float(data)
               self.valid |= CLIMB_SET
 	    elif cmd in ('V', 'v'):
-	      self.speed = float(data)
+	      self.fix.speed = float(data)
               self.valid |= SPEED_SET
 	    elif cmd in ('X', 'x'):
 	      self.online = (data[0] == '1')
@@ -308,8 +317,8 @@ class gps(gpsdata):
             sys.stderr.write("GPS DATA %s\n" % repr(data))
         self.timings.c_recv_time = time.time()
 	self.__unpack(data)
-        if self.gps_time:
-            basetime = self.gps_time - tzoffset()
+        if self.timings.sentence_time:
+            basetime = self.sentence_time - tzoffset()
             self.timings.c_decode_time = time.time() - basetime
             self.timings.c_recv_time -= basetime
         return 0
diff --git a/gpsd.c b/gpsd.c
index d1942dcd..254d0992 100644
--- a/gpsd.c
+++ b/gpsd.c
@@ -504,8 +504,8 @@ static int handle_request(int fd, char *buf, int buflen)
 	    return -1;	/* Buffer would overflow.  Just return an error */
     }
  breakout:
-    if (ud->profiling && (ud->valid & TIME_SET)) {
-	double fixtime = ud->fix.time - gmt_offset;
+    if (ud->profiling && ud->sentence_time) {
+	double fixtime = ud->sentence_time - gmt_offset;
 	sprintf(phrase, ",$=%s %d %f %f %f %f %f %f",
 		ud->tag,
 		ud->sentence_length,
diff --git a/gpsd.py b/gpsd.py
index 36ac3af8..18b630f2 100755
--- a/gpsd.py
+++ b/gpsd.py
@@ -53,8 +53,8 @@ class NMEA:
             lon = intpart + frac * 100.0 / 60.0
             if words[3] == 'W':
                 lon = -lon
-        self.data.latitude = lat
-        self.data.longitude = lon
+        self.data.fix.latitude = lat
+        self.data.fix.longitude = lon
         return True
 
     # Three sentences, GGA and GGL and RMC, contain timestamps.
@@ -143,7 +143,7 @@ class NMEA:
 
     def processGPGSA(self,words):
         mask = 0
-        self.data.mode = int(words[1])
+        self.data.fix.mode = int(words[1])
         self.data.satellites_used = map(int, filter(lambda x: x, words[2:14]))
         (newpdop, newhdop, newvdop) = (self.data.pdop, self.data.hdop, self.data.vdop)
         if words[14]:
@@ -155,7 +155,7 @@ class NMEA:
         if words[14] and words[15] and words[16]:
             (self.data.pdop, self.data.hdop, self.data.vdop) = (newpdop, newhdop, newvdop)
             mask = gps.DOP_SET
-        self.logger(3, "GPGSA sets mode %d\n" % self.data.mode)
+        self.logger(3, "GPGSA sets mode %d\n" % self.data.fix.mode)
         self.data.valid = mask
 
     def __nmea_sane_satellites(self):
@@ -292,7 +292,7 @@ class gpsd(gps.gpsdata):
             return 0;
 
     def activate(self):
-        self.mode = gps.MODE_NO_FIX;
+        self.fix.mode = gps.MODE_NO_FIX;
         self.status = gps.STATUS_NO_FIX;
         self.altitude = gps.ALTITUDE_NOT_VALID
         self.track = gps.TRACK_NOT_VALID
@@ -375,7 +375,7 @@ class gpsd(gps.gpsdata):
                     if self.dsock > -1:
                         self.dsock.send(self.dsock, \
                               "R %0.8f %0.8f %0.2f\r\n" % \
-                              (self.latitude, self.longitude, self.altitude))
+                              (self.fix.latitude, self.fix.longitude, self.altitude))
 	return self.valid;
 
 # SirF-II control code
diff --git a/gpsprof b/gpsprof
index 051e1deb..7e5d70bf 100755
--- a/gpsprof
+++ b/gpsprof
@@ -44,7 +44,7 @@ class spaceplot:
     def gather(self, session):
         # Include altitude, not used here, for 3D plot experiments.
         # Watch out for the ALTITUDE_NOT_VALID value from gps.py.
-        self.fixes.append((session.latitude, session.longitude, session.altitude))
+        self.fixes.append((session.fix.latitude, session.fix.longitude, session.fix.altitude))
         return True
     def data(self, session):
         self.fp.write("# Position uncertainty, %s, %s, %ds cycle\n" % \
@@ -314,7 +314,7 @@ def plotframe(await, fname, file, speed, threshold, title):
                 sys.stderr.write("gpsprof: gpsd has vanished.\n")
                 sys.exit(1)
             baton.twirl()
-            if session.mode <= gps.MODE_NO_FIX:
+            if session.fix.mode <= gps.MODE_NO_FIX:
                 continue
             if countdown == await:
                 sys.stderr.write("gathering samples...")
diff --git a/libgpsd_core.c b/libgpsd_core.c
index 03fe6e6f..4c900eda 100644
--- a/libgpsd_core.c
+++ b/libgpsd_core.c
@@ -164,6 +164,7 @@ int gpsd_poll(struct gps_session_t *session)
 	    return ONLINE_SET;
 
 	session->driverstate |= FULL_PACKET;
+	session->gpsdata.sentence_time = 0;
 	session->gpsdata.d_recv_time = timestamp();
 
 	session->gpsdata.valid = ONLINE_SET | session->device_type->parse_packet(session);
diff --git a/nmea_parse.c b/nmea_parse.c
index d3253c47..8061161e 100644
--- a/nmea_parse.c
+++ b/nmea_parse.c
@@ -143,7 +143,7 @@ static int processGPRMC(int count, char *field[], struct gps_data_t *out)
 	if (count > 9) {
 	    merge_ddmmyy(field[9], out);
 	    merge_hhmmss(field[1], out);
-	    out->fix.time = mktime(&out->nmea_date) + out->subseconds;
+	    out->fix.time = out->sentence_time = mktime(&out->nmea_date) + out->subseconds;
 	}
 	mask |= TIME_SET;
 	do_lat_lon(&field[3], out);
@@ -204,7 +204,7 @@ static int processGPGLL(int count, char *field[], struct gps_data_t *out)
 
 	merge_hhmmss(field[5], out);
 	if (out->nmea_date.tm_year) {
-	    out->fix.time = mktime(&out->nmea_date) + out->subseconds;
+	    out->fix.time = out->sentence_time = mktime(&out->nmea_date) + out->subseconds;
 	    mask |= TIME_SET;
 	}
 	do_lat_lon(&field[1], out);
@@ -249,7 +249,7 @@ static int processGPGGA(int c UNUSED, char *field[], struct gps_data_t *out)
 
 	merge_hhmmss(field[1], out);
 	if (out->nmea_date.tm_year) {
-	    out->fix.time = mktime(&out->nmea_date) + out->subseconds;
+	    out->fix.time = out->sentence_time = mktime(&out->nmea_date) + out->subseconds;
 	    mask |= TIME_SET;
 	}
 	do_lat_lon(&field[2], out);
@@ -422,7 +422,7 @@ static int processGPZDA(int c UNUSED, char *field[], struct gps_data_t *out)
     out->nmea_date.tm_year = atoi(field[4]) - 1900;
     out->nmea_date.tm_mon = atoi(field[3]);
     out->nmea_date.tm_mday = atoi(field[2]);
-    out->fix.time = mktime(&out->nmea_date) + out->subseconds;
+    out->fix.time = out->sentence_time = mktime(&out->nmea_date) + out->subseconds;
     return TIME_SET;
 }
 
diff --git a/sirf.c b/sirf.c
index 385e8625..ededaa53 100644
--- a/sirf.c
+++ b/sirf.c
@@ -194,7 +194,7 @@ int sirf_parse(struct gps_session_t *session, unsigned char *buf, int len)
 			navtype,session->gpsdata.status,session->gpsdata.fix.mode);
 	    /* byte 20 is HDOP, see below */
 	    /* byte 21 is "mode 2", not clear how to interpret that */ 
-	    session->gpsdata.fix.time
+	    session->gpsdata.fix.time = session->gpsdata.sentence_time
 		= gpstime_to_unix(getw(22), getl(24)*1e-2, -LEAP_SECONDS);
 #ifdef NTPSHM_ENABLE
 	    ntpshm_put(session, session->gpsdata.fix.time);
@@ -236,6 +236,8 @@ int sirf_parse(struct gps_session_t *session, unsigned char *buf, int len)
 	    good = session->gpsdata.PRN[st] && 
 		session->gpsdata.azimuth[st] && 
 		session->gpsdata.elevation[st];
+	    session->gpsdata.sentence_time
+		= gpstime_to_unix(getw(1), getl(5)*1e-2, -LEAP_SECONDS);
 #ifdef __UNUSED__
 	    gpsd_report(4, "PRN=%2d El=%3.2f Az=%3.2f ss=%3d stat=%04x %c\n",
 			getb(off), 
@@ -379,7 +381,8 @@ int sirf_parse(struct gps_session_t *session, unsigned char *buf, int len)
 	    session->gpsdata.nmea_date.tm_min = getb(16);
 	    session->gpsdata.nmea_date.tm_sec = 0;
 	    session->gpsdata.subseconds = getw(17)*1e-3;
-	    session->gpsdata.fix.time=mktime(&session->gpsdata.nmea_date)+session->gpsdata.subseconds;
+	    session->gpsdata.fix.time = session->gpsdata.sentence_time
+		= mktime(&session->gpsdata.nmea_date)+session->gpsdata.subseconds;
 	    gpsd_report(5, "MID 41 UTC: %lf\n", session->gpsdata.fix.time);
 	    /* skip 4 bytes of satellite map */
 	    session->gpsdata.fix.latitude = getl(23)*1e-7;
diff --git a/xgps.c b/xgps.c
index 1d9430d1..3df56aa6 100644
--- a/xgps.c
+++ b/xgps.c
@@ -315,10 +315,10 @@ static void update_panel(struct gps_data_t *gpsdata, char *message)
     } else {
 	newstate = gpsdata->fix.mode;
 	switch (gpsdata->fix.mode) {
-	case 2:
+	case MODE_2D:
 	    sprintf(s, "2D %sFIX",(gpsdata->status==STATUS_DGPS_FIX)?"DIFF ":"");
 	    break;
-	case 3:
+	case MODE_3D:
 	    sprintf(s, "3D %sFIX",(gpsdata->status==STATUS_DGPS_FIX)?"DIFF ":"");
 	    break;
 	default:
diff --git a/zodiac.c b/zodiac.c
index 95e21f3d..3256628a 100644
--- a/zodiac.c
+++ b/zodiac.c
@@ -133,6 +133,16 @@ static int zodiac_send_rtcm(struct gps_session_t *session,
 
 static int handle1000(struct gps_session_t *session)
 {
+    session->gpsdata.nmea_date.tm_mday = getb(19);
+    session->gpsdata.nmea_date.tm_mon = getb(20) - 1;
+    session->gpsdata.nmea_date.tm_year = getb(21) - 1900;
+    session->gpsdata.nmea_date.tm_hour = getb(22);
+    session->gpsdata.nmea_date.tm_min = getb(23);
+    session->gpsdata.nmea_date.tm_sec = getb(24);
+    session->gpsdata.subsecond = getw(25);
+    session->gpsdata.fix.time = session->gpsdata->sentence_time =
+	mktime(&out->nmea_date) + out->subseconds;
+
 #if 0
     gpsd_report(1, "date: %%lf\n", session->gpsdata.fix.time);
     gpsd_report(1, "  solution invalid:\n");
@@ -156,15 +166,6 @@ static int handle1000(struct gps_session_t *session)
     gpsd_report(1, "Separation: %f\n", getw(33) * 1e-2);
 #endif
 
-    session->gpsdata.nmea_date.tm_mday = getb(19);
-    session->gpsdata.nmea_date.tm_mon = getb(20) - 1;
-    session->gpsdata.nmea_date.tm_year = getb(21) - 1900;
-    session->gpsdata.nmea_date.tm_hour = getb(22);
-    session->gpsdata.nmea_date.tm_min = getb(23);
-    session->gpsdata.nmea_date.tm_sec = getb(24);
-    session->gpsdata.subsecond = getw(25);
-    session->gpsdata.fix.time = mktime(&out->nmea_date) + out->subseconds;
-
     session->gpsdata.fix.latitude  = getl(27) * RAD_2_DEG * 1e-8;
     session->gpsdata.fix.longitude = getl(29) * RAD_2_DEG * 1e-8;
     session->gpsdata.fix.speed     = getl(34) * 1e-2 * MPS_TO_KNOTS;