Enable GSA (DOP and active satellites) parsing

Enable GSV (satellites in view) parsing.

Rewrote the GSA and GSV parsing to handle each satellite system
(talker) separately.
- self.sats now uses keys based upon the talker and satellite
  number, eg. GL67 for GLONASS adafruit#67, GP7 for GPS adafruit#7
- When the end message of a GSV sequence is received, eg. 3 of 3,
  all previous records in self.sats matching that talker are removed
  before adding the updated ones.
- self.sat_prns stores the last satellite IDs that were used for a
  fix and returned in the most recent GSA sentence. They will be
  from only one Satellite system and should have a record in
  self.sats .

Author: lesamouraipourpre

adafruit_gps.py

@@ -90,6 +90,7 @@ def __init__(self, uart, debug=False):
         self.height_geoid = None
         self.speed_knots = None
         self.track_angle_deg = None
+        self._sats = None
         self.sats = None
         self.isactivedata = None
         self.true_track = None
@@ -121,9 +122,9 @@ def update(self):
             print(sentence)
         data_type, args = sentence
         data_type = bytes(data_type.upper(), "ascii")
-        (talker, sentence_type) = (data_type[:2], data_type[2:])
+        (talker, sentence_type) = self._parse_talker(data_type)
 
-        # Check for all currently known talkers
+        # Check for all currently known GNSS talkers
         # GA - Galileo
         # GB - BeiDou Systems
         # GI - NavIC
@@ -132,17 +133,19 @@ def update(self):
         # GQ - QZSS
         # GN - GNSS / More than one of the above
         if talker not in (b'GA', b'GB', b'GI', b'GL', b'GP', b'GQ', b'GN'):
-            if self.debug:
-                print(f"  Unknown talker: {talker}")
-            # We don't know the talker so it's not new data
-            return False
+            # It's not a known GNSS source of data
+            return True
 
         if sentence_type == b'GLL':    # Geographic position - Latitude/Longitude
             self._parse_gpgll(args)
         elif sentence_type == b'RMC':  # Minimum location info
             self._parse_gprmc(args)
         elif sentence_type == b'GGA':  # 3D location fix
             self._parse_gpgga(args)
+        elif sentence_type == b'GSV':  # Satellites in view
+            self._parse_gpgsv(talker, args)
+        elif sentence_type == b'GSA':  # GPS DOP and active satellites
+            self._parse_gpgsa(talker, args)
         return True
 
     def send_command(self, command, add_checksum=True):
@@ -253,6 +256,13 @@ def _parse_sentence(self):
         data_type = sentence[1:delimiter]
         return (data_type, sentence[delimiter + 1 :])
 
+    def _parse_talker(self, data_type):
+        # Split the data_type into talker and sentence_type
+        if data_type[0] == b'P': # Proprietary codes
+            return (data_type[:1], data_type[1:])
+        else:
+            return (data_type[:2], data_type[2:])
+
     def _parse_gpgll(self, args):
         data = args.split(",")
         if data is None or data[0] is None or (data[0] == ""):
@@ -414,7 +424,8 @@ def _parse_gpgga(self, args):
         self.altitude_m = _parse_float(data[8])
         self.height_geoid = _parse_float(data[10])
 
-    def _parse_gpgsa(self, args):
+    def _parse_gpgsa(self, talker, args):
+        talker = talker.decode('ascii')
         data = args.split(",")
         if data is None or (data[0] == ""):
             return  # Unexpected number of params
@@ -424,9 +435,9 @@ def _parse_gpgsa(self, args):
         # Parse 3d fix
         self.fix_quality_3d = _parse_int(data[1])
         satlist = list(filter(None, data[2:-4]))
-        self.sat_prns = {}
-        for i, sat in enumerate(satlist, 1):
-            self.sat_prns["gps{}".format(i)] = _parse_int(sat)
+        self.sat_prns = []
+        for sat in satlist:
+            self.sat_prns.append("{}{}".format(talker, _parse_int(sat)))
 
         # Parse PDOP, dilution of precision
         self.pdop = _parse_float(data[-3])
@@ -435,9 +446,10 @@ def _parse_gpgsa(self, args):
         # Parse VDOP, vertical dilution of precision
         self.vdop = _parse_float(data[-1])
 
-    def _parse_gpgsv(self, args):
+    def _parse_gpgsv(self, talker, args):
         # Parse the arguments (everything after data type) for NMEA GPGGA
         # 3D location fix sentence.
+        talker = talker.decode('ascii')
         data = args.split(",")
         if data is None or (data[0] == ""):
             return  # Unexpected number of params.
@@ -454,33 +466,40 @@ def _parse_gpgsv(self, args):
 
         sat_tup = data[3:]
 
-        satdict = {}
-        for i in range(len(sat_tup) / 4):
+        satlist = []
+        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
+            satnum = "{}{}".format(talker, _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])  # signal-to-noise ratio in dB
             value = (satnum, satdeg, satazim, satsnr)
-            satdict[key] = value
+            satlist.append(value)
+
+        if self._sats is None:
+            self._sats = []
+        for value in satlist:
+            self._sats.append(value)
+
+        if self.mess_num == self.total_mess_num:
+            # Last part of GSV message
+            if len(self._sats) == self.satellites:
+                # Transfer received satellites to self.sats
+                if self.sats is None:
+                    self.sats = {}
+                else:
+                    # Remove all old data from self.sats which
+                    # match the current talker
+                    old = []
+                    for i in self.sats:
+                        if i[0:2] == talker:
+                            old.append(i)
+                    for i in old:
+                        self.sats.pop(i)
+                for s in self._sats:
+                    self.sats[s[0]] = s
+            self._sats.clear()
 
-        if self.sats is None:
-            self.sats = {}
-        for satnum in satdict:
-            self.sats[satnum] = satdict[satnum]
-
-        try:
-            if self.satellites < self.satellites_prev:
-                for i in self.sats:
-                    try:
-                        if int(i[-2]) >= self.satellites:
-                            del self.sats[i]
-                    except ValueError:
-                        if int(i[-1]) >= self.satellites:
-                            del self.sats[i]
-        except TypeError:
-            pass
         self.satellites_prev = self.satellites
 
 

examples/gps_satellitefix.py

@@ -0,0 +1,103 @@
+# SPDX-FileCopyrightText: 2021 lesamouraipourpre
+# SPDX-License-Identifier: MIT
+
+import time
+import board
+import busio
+
+import adafruit_gps
+
+# Create a serial connection for the GPS connection using default speed and
+# a slightly higher timeout (GPS modules typically update once a second).
+# These are the defaults you should use for the GPS FeatherWing.
+# For other boards set RX = GPS module TX, and TX = GPS module RX pins.
+# uart = busio.UART(board.TX, board.RX, baudrate=9600, timeout=10)
+
+# for a computer, use the pyserial library for uart access
+# import serial
+# uart = serial.Serial("/dev/ttyUSB0", baudrate=9600, timeout=10)
+
+# If using I2C, we'll create an I2C interface to talk to using default pins
+i2c = board.I2C()
+
+# Create a GPS module instance.
+# gps = adafruit_gps.GPS(uart, debug=False)  # Use UART/pyserial
+gps = adafruit_gps.GPS_GtopI2C(i2c, debug=False)  # Use I2C interface
+
+# Initialize the GPS module by changing what data it sends and at what rate.
+# These are NMEA extensions for PMTK_314_SET_NMEA_OUTPUT and
+# PMTK_220_SET_NMEA_UPDATERATE but you can send anything from here to adjust
+# the GPS module behavior:
+#   https://cdn-shop.adafruit.com/datasheets/PMTK_A11.pdf
+
+# Turn on everything (not all of it is parsed!)
+gps.send_command(b'PMTK314,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0')
+
+# Set update rate to once a second (1hz) which is what you typically want.
+gps.send_command(b"PMTK220,1000")
+# Or decrease to once every two seconds by doubling the millisecond value.
+# Be sure to also increase your UART timeout above!
+# gps.send_command(b'PMTK220,2000')
+# You can also speed up the rate, but don't go too fast or else you can lose
+# data during parsing.  This would be twice a second (2hz, 500ms delay):
+# gps.send_command(b'PMTK220,500')
+
+def format_dop(dop):
+    # https://en.wikipedia.org/wiki/Dilution_of_precision_(navigation)
+    if dop > 20:
+        msg = "Poor"
+    elif dop > 10:
+        msg = "Fair"
+    elif dop > 5:
+        msg = "Moderate"
+    elif dop > 2:
+        msg = "Good"
+    elif dop > 1:
+        msg = "Excellent"
+    else:
+        msg = "Ideal"
+    return f"{dop} - {msg}"
+
+talkers = {
+    'GA': 'Galileo',
+    'GB': 'BeiDou',
+    'GI': 'NavIC',
+    'GL': 'GLONASS',
+    'GP': 'GPS',
+    'GQ': 'QZSS',
+    'GN': 'GNSS'
+    }
+
+# Main loop runs forever printing the location, etc. every second.
+last_print = time.monotonic()
+while True:
+    # Make sure to call gps.update() every loop iteration and at least twice
+    # as fast as data comes from the GPS unit (usually every second).
+    # This returns a bool that's true if it parsed new data (you can ignore it
+    # though if you don't care and instead look at the has_fix property).
+    if not gps.update() or not gps.has_fix:
+        time.sleep(0.1)
+        continue
+
+    if gps.nmea_sentence[3:6] == "GSA":
+        print(f"{gps.latitude:.6f}, {gps.longitude:.6f} {gps.altitude_m}m")
+        print(f"2D Fix: {gps.has_fix}  3D Fix: {gps.has_3d_fix}")
+        print(f"  PDOP (Position Dilution of Precision): {format_dop(gps.pdop)}")
+        print(f"  HDOP (Horizontal Dilution of Precision): {format_dop(gps.hdop)}")
+        print(f"  VDOP (Vertical Dilution of Precision): {format_dop(gps.vdop)}")
+        print(f"Satellites used for fix:")
+        for s in gps.sat_prns:
+            talker = talkers[s[0:2]]
+            number = s[2:]
+            if gps.sats is None:
+                print(f"  {talker}-{number} - no info")
+            else:
+                try:
+                    sat = gps.sats[s]
+                    if sat is None:
+                        print(f"  {talker}-{number} - no info")
+                    else:
+                        print(f"  {talker}-{number} Elevation:{sat[1]}* Azimuth:{sat[2]}* SNR:{sat[3]}dB")
+                except KeyError:
+                   print(f"  {talker}-{number} - no info") 
+        print()