Prior to subclass branch.

Author: peterhinch

gps/README.md

@@ -1,3 +1,5 @@
+** WARNING: Under development and subject to change **
+
 # 1. as_GPS
 
 This is an asynchronous device driver for GPS devices which communicate with
@@ -216,7 +218,8 @@ gps = as_GPS.AS_GPS(sreader, fix_cb=callback, cb_mask= as_GPS.RMC | as_GPS.VTG)
  `as_GPS.DMY` returns 'DD/MM/YY'.  
  `as_GPS.LONG` returns a string of form 'January 1st, 2014'.
 
- * `time` No args. Returns the current time in form 'hh:mm:ss'.
+ * `time_string` Arg `local` default `True`. Returns the current time in form
+ 'hh:mm:ss.sss'. If `local` is `False` returns UTC time. 
 
 ## 2.3 Public coroutines
 
@@ -262,7 +265,7 @@ Note that if the GPS module does not support producing GSV sentences this
 coroutine will pause forever. It can also pause for arbitrary periods if
 satellite reception is blocked, such as in a building.
 
-## 2.4 Public bound variables
+## 2.4 Public bound variables/properties
 
 These are updated whenever a sentence of the relevant type has been correctly
 received from the GPS unit. For crucial navigation data the `time_since_fix`
@@ -291,18 +294,18 @@ The following are counts since instantiation.
 
 ### 2.4.3 Date and time
 
- * `utc` [hrs: int, mins: int, secs: float] UTC time e.g. [23, 3, 58.0]. Note
+ * `utc` [hrs: int, mins: int, secs: int] UTC time e.g. [23, 3, 58]. Note
  that some GPS hardware may only provide integer seconds. The MTK3339 chip
- provides a float.
- * `local_time` [hrs: int, mins: int, secs: float] Local time.
+ provides a float whose value is always an integer.
+ * `local_time` [hrs: int, mins: int, secs: int] Local time.
  * `date` [day: int, month: int, year: int] e.g. [23, 3, 18]
  * `local_offset` Local time offset in hrs as specified to constructor.
 
 The `utc` bound variable updates on receipt of RMC, GLL or GGA messages.
 
 The `date` and `local_time` variables are updated when an RMC message is
-received. A local time offset will result in date changes where the time
-offset causes the local time to pass midnight.
+received. A local time offset will affect the `date` value where the offset
+causes the local time to pass midnight.
 
 ### 2.4.4 Satellite data
 
@@ -504,13 +507,15 @@ This takes the following arguments:
 
 ## 4.3 Public methods
 
-These return immediately. Times are derived from the GPS PPS signal. These
-functions should not be called until a valid time/date message and PPS signal
-have occurred: await the `ready` coroutine prior to first use.
+These return an accurate GPS time of day. As such they return as fast as
+possible without error checking: these functions should not be called until a
+valid time/date message and PPS signal have occurred. Await the `ready`
+coroutine prior to first use. Subsequent calls may occur without restriction.
 
- * `get_secs` No args. Returns a float: the period past midnight in seconds.
+ * `get_ms` No args. Returns an integer: the period past midnight in ms. This
+ method does not allocate and may be called in an interrupt context.
  * `get_t_split` No args. Returns time of day tuple of form
- (hrs: int, mins: int, secs: float).
+ (hrs: int, mins: int, secs: int, μs: int).
 
 ## 4.4 Public coroutines
 

gps/as_GPS.py

@@ -62,8 +62,7 @@ class AS_GPS(object):
     # https://stackoverflow.com/questions/9847213/how-do-i-get-the-day-of-week-given-a-date-in-python?noredirect=1&lq=1
     # Adapted for Python 3 and Pyboard RTC format.
     @staticmethod
-    def _week_day(year, month, day):
-        offset = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334]
+    def _week_day(year, month, day, offset = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334]):
         aux = year - 1700 - (1 if month <= 2 else 0)
         # day_of_week for 1700/1/1 = 5, Friday
         day_of_week  = 5
@@ -137,12 +136,13 @@ def __init__(self, sreader, local_offset=0, fix_cb=lambda *_ : None, cb_mask=RMC
 
         #####################
         # Data From Sentences
-        # Time. Ignore http://www.gpsinformation.org/dale/nmea.htm, hardware
-        # returns a float.
-        self.utc = [0, 0, 0.0]  # [h: int, m: int, s: float]
-        self.local_time = [0, 0, 0.0]  # [h: int, m: int, s: float]
-        self.date = [0, 0, 0]  # [dd: int, mm: int, yy: int]
+        # Time. http://www.gpsinformation.org/dale/nmea.htm indicates seconds
+        # is an integer. However hardware returns a float, but the fractional
+        # part is always zero. So treat seconds value as an integer. For
+        # precise timing use PPS signal and as_tGPS library.
         self.local_offset = local_offset  # hrs
+        self._rtcbuf = [0]*8  # Buffer for RTC setting
+        self.epoch_time = 0  # Integer secs since epoch (Y2K under MicroPython)
 
         # Position/Motion
         self._latitude = [0, 0.0, 'N']  # (°, mins, N/S)
@@ -202,7 +202,6 @@ def _update(self, line):
         if not self._crc_check(line, segs[-1]):
             self.crc_fails += 1  # Update statistics
             return None
-
         self.clean_sentences += 1  # Sentence is good but unparsed.
         segs[0] = segs[0][1:]  # discard $
         segs = segs[:-1]  # and checksum
@@ -258,47 +257,33 @@ def _fix(self, gps_segments, idx_lat, idx_long):
         self._fix_time = self._get_time()
         return True
 
-    # Set timestamp. If time/date not present retain last reading (if any).
-    def _set_timestamp(self, utc_string):
-        if not utc_string:
-            return False
-        # Possible timestamp found
-        try:
-            self.utc[0] = int(utc_string[0:2])  # h
-            self.utc[1] = int(utc_string[2:4])  # mins
-            self.utc[2] = float(utc_string[4:])  # secs from chip is a float
-            return True
-        except ValueError:
-            return False
-        for idx in range(3):
-            self.local_time[idx] = self.utc[idx]
-        return True
-
     # A local offset may exist so check for date rollover. Local offsets can
     # include fractions of an hour but not seconds (AFAIK).
-    def _set_date(self, date_string):
-        if not date_string:
+    def _set_date_time(self, utc_string, date_string):
+        if not date_string or not utc_string:
             return False
         try:
+            hrs = int(utc_string[0:2])  # h
+            mins = int(utc_string[2:4])  # mins
+            secs = int(utc_string[4:6])  # secs from chip is a float but FP is always 0
             d = int(date_string[0:2])  # day
             m = int(date_string[2:4])  # month
             y = int(date_string[4:6]) + 2000  # year
-        except ValueError:  # Bad Date stamp value present
+        except ValueError:  # Bad date or time strings
             return False
-        hrs = self.utc[0]
-        mins = self.utc[1]
-        secs = self.utc[2]
-        wday = self._week_day(y, m, d) - 1
-        t = self._mktime((y, m, d, hrs, mins, int(secs), wday, 0, 0))
+        wday = self._week_day(y, m, d)
+        t = self._mktime((y, m, d, hrs, mins, int(secs), wday - 1, 0, 0))
+        self.epoch_time = t  # This is the fundamental datetime reference.
+        # Need local time for setting Pyboard RTC in interrupt context
         t += int(3600 * self.local_offset)
-        y, m, d, hrs, mins, *_ = self._localtime(t)  # Preserve float seconds
-        y -= 2000
-        self.local_time[0] = hrs
-        self.local_time[1] = mins
-        self.local_time[2] = secs
-        self.date[0] = d
-        self.date[1] = m
-        self.date[2] = y
+        y, m, d, hrs, mins, secs, *_ = self._localtime(t)
+        self._rtcbuf[0] = y
+        self._rtcbuf[1] = m
+        self._rtcbuf[2] = d
+        self._rtcbuf[3] = wday
+        self._rtcbuf[4] = hrs
+        self._rtcbuf[5] = mins
+        self._rtcbuf[6] = secs
         return True
 
     ########################################
@@ -313,10 +298,8 @@ def _set_date(self, date_string):
 
     def _gprmc(self, gps_segments):  # Parse RMC sentence
         self._valid &= ~RMC
-        # UTC Timestamp.
-        if not self._set_timestamp(gps_segments[1]):
-            return False # Bad Timestamp value present
-        if not self._set_date(gps_segments[9]):
+        # UTC Timestamp and date.
+        if not self._set_date_time(gps_segments[1], gps_segments[9]):
             return False
 
         # Check Receiver Data Valid Flag
@@ -356,12 +339,6 @@ def _gprmc(self, gps_segments):  # Parse RMC sentence
 
     def _gpgll(self, gps_segments):  # Parse GLL sentence
         self._valid &= ~GLL
-        # UTC Timestamp.
-        try:
-            self._set_timestamp(gps_segments[5])
-        except ValueError:  # Bad Timestamp value present
-            return False
-
         # Check Receiver Data Valid Flag
         if gps_segments[6] != 'A':  # Invalid. Don't update data
             return True  # Correctly parsed
@@ -391,18 +368,12 @@ def _gpvtg(self, gps_segments):  # Parse VTG sentence
     def _gpgga(self, gps_segments):  # Parse GGA sentence
         self._valid &= ~GGA
         try:
-            # UTC Timestamp
-            self._set_timestamp(gps_segments[1])
-
             # Number of Satellites in Use
             satellites_in_use = int(gps_segments[7])
-
             # Horizontal Dilution of Precision
             hdop = float(gps_segments[8])
-
             # Get Fix Status
             fix_stat = int(gps_segments[6])
-
         except ValueError:
             return False
 
@@ -647,9 +618,28 @@ def speed_string(self, unit=KPH):
             return sform.format(speed, 'knots')
         return sform.format(speed, 'km/h')
 
-    def time(self, local=True):
-        t = self.local_time if local else self.utc
-        return '{:02d}:{:02d}:{:06.3f}'.format(*t)
+    # Return local time (hrs: int, mins: int, secs:float)
+    @property
+    def local_time(self):
+        t = self.epoch_time + int(3600 * self.local_offset)
+        _, _, _, hrs, mins, secs, *_ = self._localtime(t)
+        return hrs, mins, secs
+
+    @property
+    def date(self):
+        t = self.epoch_time + int(3600 * self.local_offset)
+        y, m, d, *_ = self._localtime(t)
+        return d, m, y - 2000
+
+    @property
+    def utc(self):
+        t = self.epoch_time + int(3600 * self.local_offset)
+        _, _, _, hrs, mins, secs, *_ = self._localtime(t)
+        return hrs, mins, secs
+
+    def time_string(self, local=True):
+        hrs, mins, secs = self.local_time if local else self.utc
+        return '{:02d}:{:02d}:{:02d}'.format(hrs, mins, secs)
 
     def date_string(self, formatting=MDY):
         day, month, year = self.date

gps/as_GPS_time.py

@@ -13,6 +13,7 @@
 print('Available tests:')
 print('calibrate(minutes=5) Set and calibrate the RTC.')
 print('drift(minutes=5) Repeatedly print the difference between RTC and GPS time.')
+print('time(minutes=1) Print get_ms() and get_t_split values.')
 
 # Setup for tests. Red LED toggles on fix, blue on PPS interrupt.
 async def setup():
@@ -35,7 +36,7 @@ async def drift_test(gps_tim):
     dstart = await gps_tim.delta()
     while running:
         dt = await gps_tim.delta()
-        print('{}  Delta {}μs'.format(gps_tim.gps.time(), dt))
+        print('{}  Delta {}μs'.format(gps_tim.gps.time_string(), dt))
         await asyncio.sleep(10)
     return dt - dstart
 
@@ -58,11 +59,33 @@ async def do_drift(minutes):
     await gps_tim.set_rtc()
     print('Measuring drift.')
     change = await drift_test(gps_tim)
-    print('Rate of change {}μs/hr'.format(int(60 * change/minutes)))
+    ush = int(60 * change/minutes)
+    spa = int(ush * 365 * 24 / 1000000)
+    print('Rate of change {}μs/hr {}secs/year'.format(ush, spa))
 
 def drift(minutes=5):
     global running
     running = True
     loop = asyncio.get_event_loop()
     loop.create_task(killer(minutes))
     loop.run_until_complete(do_drift(minutes))
+
+# Every 10s print the difference between GPS time and RTC time
+async def do_time(minutes):
+    print('Setting up GPS.')
+    gps_tim = await setup()
+    print('Waiting for time data.')
+    await gps_tim.ready()
+    print('Setting RTC.')
+    await gps_tim.set_rtc()
+    while running:
+        await asyncio.sleep(1)
+        hrs, mins, secs, us = gps_tim.get_t_split()
+        print('{}ms Time: {:02d}:{:02d}:{:02d}:{:06d}'.format(gps_tim.get_ms(), hrs, mins, secs, us))
+
+def time(minutes=1):
+    global running
+    running = True
+    loop = asyncio.get_event_loop()
+    loop.create_task(killer(minutes))
+    loop.run_until_complete(do_time(minutes))