Merge pull request #5 from dherrada/format-adding

Added ways to handle all sentences. Currently, only _parse_gpgll actually works

Author: evaherrada

.gitignore

@@ -9,4 +9,5 @@ bundles
 *.DS_Store
 .eggs
 dist
-**/*.egg-info
+**/*.egg-info
+tester.py

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,13 +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.sats = None
+        self.isactivedata = None
+        self.true_track = None
+        self.mag_track = None
         self.debug = debug
 
     def update(self):
@@ -102,17 +114,27 @@ def update(self):
         try:
             sentence = self._parse_sentence()
         except UnicodeError:
+            print("UnicodeError")
             return None
         if sentence is None:
             return False
         if self.debug:
             print(sentence)
         data_type, args = sentence
         data_type = bytes(data_type.upper(), "ascii")
-        if data_type == b'GPGGA':      # GGA, 3d location fix
-            self._parse_gpgga(args)
-        elif data_type == b'GPRMC':    # RMC, minimum location info
+        #return sentence
+        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'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
 
     def send_command(self, command, add_checksum=True):
@@ -135,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):
@@ -147,15 +173,19 @@ def _parse_sentence(self):
         # This needs to be refactored when it can be tested.
 
         # Only continue if we have at least 64 bytes in the input buffer
+        """
         if self._uart.in_waiting < 64:
             return None
+        """
 
         sentence = self._uart.readline()
         if sentence is None or sentence == b'' or len(sentence) < 1:
+            print("Sentence is none")
             return None
         try:
             sentence = str(sentence, 'ascii').strip()
         except UnicodeError:
+            print("UnicodeError")
             return None
         # Look for a checksum and validate it if present.
         if len(sentence) > 7 and sentence[-3] == '*':
@@ -165,25 +195,34 @@ def _parse_sentence(self):
             for i in range(1, len(sentence)-3):
                 actual ^= ord(sentence[i])
             if actual != expected:
+                print("Actual != expected")
                 return None  # Failed to validate checksum.
             # Remove checksum once validated.
             sentence = sentence[:-3]
         # Parse out the type of sentence (first string after $ up to comma)
         # and then grab the rest as data within the sentence.
         delineator = sentence.find(',')
         if delineator == -1:
+            print("Bad delineator")
             return None  # Invalid sentence, no comma after data type.
         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 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(float(data[4])))
         if time_utc is not None:
             hours = time_utc // 10000
             mins = (time_utc // 100) % 100
@@ -195,23 +234,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.
@@ -270,3 +296,113 @@ def _parse_gprmc(self, args):
                 # Time hasn't been set so create it.
                 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
+        try:
+            satlist
+        except NameError:
+            satlist = [None] * self.total_mess_num
+
+        sat_tup = data[3:]
+
+        satdict = {}
+        for i in range(len(sat_tup)/4):
+            j = i*4
+            key = "gps{}".format(i+(4*(self.mess_num-1)))
+            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
+
+        satlist[self.mess_num-1] = satdict
+        satlist = list(filter(None, satlist))
+        self.sats = {}
+        for satdict in satlist:
+            self.sats.update(satdict)
+        print(self.sats)