Added all functions. They still need testing

Author: evaherrada

adafruit_gps.py

@@ -70,6 +70,11 @@ def _parse_float(nmea_data):
         return None
     return float(nmea_data)
 
+def _parse_str(nmea_data):
+    if nmea_data is None or nmea_data == '':
+        return None
+    return str(nmea_data)
+
 # lint warning about too many attributes disabled
 #pylint: disable-msg=R0902
 class GPS:
@@ -83,18 +88,20 @@ def __init__(self, uart, debug=False):
         self.latitude = None
         self.longitude = None
         self.fix_quality = None
+        self.fix_quality_3d = None
         self.satellites = None
         self.horizontal_dilution = None
         self.altitude_m = None
         self.height_geoid = None
-        self.velocity_knots = None
         self.speed_knots = None
+        self.speed_kmh = None
         self.track_angle_deg = None
         self.total_mess_num = None
         self.mess_num = None
-        self.gps0 = None
-        self.gps1 = None
-        self.gps2 = None
+        self.sats = None
+        self.isactivedata = None
+        self.true_track = None
+        self.mag_track = None
         self.debug = debug
 
     def update(self):
@@ -115,11 +122,18 @@ def update(self):
         data_type, args = sentence
         data_type = bytes(data_type.upper(), "ascii")
         #return sentence
-        if data_type == b'GPGGA':      # GGA, 3d location fix
-            self._parse_gpgga(args)
-        elif data_type == b'GPRMC':    # RMC, minimum location info
+
+        if data_type == b'GPGLL':       # GLL, Geographic Position – Latitude/Longitude
+            self._parse_gpgll(args)
+        elif data_type == b'GPRMC':     # RMC, minimum location info
             self._parse_gprmc(args)
-        elif data_type == b'GPGSV':
+        elif data_type == b'GPVTG':     # VTG, Track Made Good and Ground Speed
+            self._parse_gpvtg(args)
+        elif data_type == b'GPGGA':     # GGA, 3d location fix
+            self._parse_gpgga(args)
+        elif data_type == b'GPGSA':     # GSA, GPS DOP and active satellites
+            self._parse_gpgsa(args)
+        elif data_type == b'GPGSV':     # GSV, Satellites in view
             self._parse_gpgsv(args)
         return True
 
@@ -143,6 +157,10 @@ def send_command(self, command, add_checksum=True):
     def has_fix(self):
         """True if a current fix for location information is available."""
         return self.fix_quality is not None and self.fix_quality >= 1
+    
+    @property
+    def has_3d_fix(self):
+        return self.fix_quality_3d is not None and self.fix_quality_3d >= 2
 
     @property
     def datetime(self):
@@ -179,15 +197,22 @@ def _parse_sentence(self):
         data_type = sentence[1:delineator]
         return (data_type, sentence[delineator+1:])
 
-    
-    def _parse_gpgga(self, args):
-        # Parse the arguments (everything after data type) for NMEA GPGGA
-        # 3D location fix sentence.
+    def _parse_gpgll(self, args):
         data = args.split(',')
-        if data is None or len(data) != 14:
-            return  # Unexpected number of params.
-        # Parse fix time.
-        time_utc = int(_parse_float(data[0]))
+        if data is None or len(data) < 11 or data[0] is None:
+            return # Unexpected number of params.
+
+        # Parse latitude and longitude.
+        self.latitude = _parse_degrees(data[0])
+        if self.latitude is not None and \
+           data[1] is not None and data[1].lower() == 's':
+            self.latitude *= -1.0
+        self.longitude = _parse_degrees(data[2])
+        if self.longitude is not None and \
+           data[3] is not None and data[3].lower() == 'w':
+            self.longitude *= -1.0
+
+        time_utc = int(_parse_int(data[4]))
         if time_utc is not None:
             hours = time_utc // 10000
             mins = (time_utc // 100) % 100
@@ -199,23 +224,10 @@ def _parse_gpgga(self, args):
                     self.timestamp_utc.tm_mday, hours, mins, secs, 0, 0, -1))
             else:
                 self.timestamp_utc = time.struct_time((0, 0, 0, hours, mins,
-                                                       secs, 0, 0, -1))
-        # Parse latitude and longitude.
-        self.latitude = _parse_degrees(data[1])
-        if self.latitude is not None and \
-           data[2] is not None and data[2].lower() == 's':
-            self.latitude *= -1.0
-        self.longitude = _parse_degrees(data[3])
-        if self.longitude is not None and \
-           data[4] is not None and data[4].lower() == 'w':
-            self.longitude *= -1.0
-        # Parse out fix quality and other simple numeric values.
-        self.fix_quality = _parse_int(data[5])
-        self.satellites = _parse_int(data[6])
-        self.horizontal_dilution = _parse_float(data[7])
-        self.altitude_m = _parse_float(data[8])
-        self.height_geoid = _parse_float(data[10])
-
+                                                       secs, 0, 0, -1)) 
+        # Parse data active or void
+        self.isactivedata = _parse_str(data[5])
+        
     def _parse_gprmc(self, args):
         # Parse the arguments (everything after data type) for NMEA GPRMC
         # minimum location fix sentence.
@@ -275,43 +287,111 @@ def _parse_gprmc(self, args):
                 self.timestamp_utc = time.struct_time((year, month, day, 0, 0,
                                                        0, 0, 0, -1))
 
+    def _parse_gpvtg(self, args):
+        data = args.split(',')
+
+        # Parse true track made good (degrees)
+        self.true_track = _parse_float(data[0])
+
+        # Parse magnetic track made good
+        self.mag_track = _parse_float(data[2])
+
+        # Parse speed
+        self.speed_knots = _parse_float(data[4])
+        self.speed_kmh = _parse_float(data[6])
+
+    def _parse_gpgga(self, args):
+        # Parse the arguments (everything after data type) for NMEA GPGGA
+        # 3D location fix sentence.
+        data = args.split(',')
+        if data is None or len(data) != 14:
+            return  # Unexpected number of params.
+        # Parse fix time.
+        time_utc = int(_parse_float(data[0]))
+        if time_utc is not None:
+            hours = time_utc // 10000
+            mins = (time_utc // 100) % 100
+            secs = time_utc % 100
+            # Set or update time to a friendly python time struct.
+            if self.timestamp_utc is not None:
+                self.timestamp_utc = time.struct_time((
+                    self.timestamp_utc.tm_year, self.timestamp_utc.tm_mon,
+                    self.timestamp_utc.tm_mday, hours, mins, secs, 0, 0, -1))
+            else:
+                self.timestamp_utc = time.struct_time((0, 0, 0, hours, mins,
+                                                       secs, 0, 0, -1))
+        # Parse latitude and longitude.
+        self.latitude = _parse_degrees(data[1])
+        if self.latitude is not None and \
+           data[2] is not None and data[2].lower() == 's':
+            self.latitude *= -1.0
+        self.longitude = _parse_degrees(data[3])
+        if self.longitude is not None and \
+           data[4] is not None and data[4].lower() == 'w':
+            self.longitude *= -1.0
+        # Parse out fix quality and other simple numeric values.
+        self.fix_quality = _parse_int(data[5])
+        self.satellites = _parse_int(data[6])
+        self.horizontal_dilution = _parse_float(data[7])
+        self.altitude_m = _parse_float(data[8])
+        self.height_geoid = _parse_float(data[10])
+
+    def _parse_gpgsa(self, args):
+        data = args.split(',')
+        if data is None:
+            return # Unexpected number of params
+
+        # Parse selection mode
+        self.sel_mode = _parse_str(data[0])
+        # Parse 3d fix
+        self.fix_quality_3d = _parse_int(data[1])
+        sats = list(filter(None, data[2:-4]))
+        satdict = {}
+        for i in range(len(sats)):
+            satdict["self.gps{}".format(i)] = _parse_int(sats[i])
+
+        globals().update(satdict)
+        
+        # Parse PDOP, dilution of precision
+        self.pdop = _parse_float(data[-3])
+        # Parse HDOP, horizontal dilution of precision
+        self.hdop = _parse_float(data[-2])
+        # Parse VDOP, vertical dilution of precision
+        self.vdop = _parse_float(data[-1])
+
     def _parse_gpgsv(self, args):
         # Parse the arguments (everything after data type) for NMEA GPGGA
         # 3D location fix sentence.
         data = args.split(',')
         if data is None:
             return  # Unexpected number of params.
+
         # Parse number of messages
         self.total_mess_num = _parse_int(data[0]) # Total number of messages
         # Parse message number
         self.mess_num = _parse_int(data[1]) # Message number
         # Parse number of satellites in view
         self.satellites = _parse_int(data[2]) # Number of satellites
-        """
-        if self.satellites > 0:
-            self.has_fix = 1
-        """
+        try:
+            satlist
+        except NameError:
+            satlist = [None] * self.total_mess_num
+
+        sat_tup = data[3:]
 
-        sats = data[3:]
         satdict = {}
-        for i in range(len(sats) / 4):
+        for i in range(len(sat_tup) / 4):
             j = i*4
-            key = "self.gps{}".format(i)
-            satnum = _parse_int(sats[0+j]) # Satellite number
-            satdeg = _parse_int(sats[1+j]) # Elevation in degrees
-            satazim = _parse_int(sats[2+j]) # Azimuth in degrees
-            satsnr = _parse_int(sats[3+j]) # SNR (signal-to-noise ratio) in dB
+            key = "gps{}".format(i)
+            satnum = _parse_int(sat_tup[0+j]) # Satellite number
+            satdeg = _parse_int(sat_tup[1+j]) # Elevation in degrees
+            satazim = _parse_int(sat_tup[2+j]) # Azimuth in degrees
+            satsnr = _parse_int(sat_tup[3+j]) # SNR (signal-to-noise ratio) in dB
             value = (satnum, satdeg, satazim, satsnr)
             satdict[key] = value
-        """
-        params = {'self': self}
-        for k, v in satdict.items():
-            exec("%s=%s" % (k, v), params, params)
-        """
-        globals().update(satdict)
-        # Should be self.gps0, self.gps1, self.gps2, etc
-        # Each should be a tuple with 4 values
-        # gpsx[0] = satellite number
-        # gpsx[1] = elevation in degrees
-        # gpsx[2] = azimuth in degrees to true
-        # gpsx[3] = Signal-to-noise ratio in dB
+
+        satlist[self.mess_num-1] = satdict
+        satlist = list(filter(None, satlist))
+        self.sats = {}
+        for satdict in satlist:
+            self.sats.update(satdict)