adafruit-circuitpython-gps 3.11.9__tar.gz → 4.0.0__tar.gz

{adafruit_circuitpython_gps-3.11.9 → adafruit_circuitpython_gps-4.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: adafruit-circuitpython-gps
-Version: 3.11.9
+Version: 4.0.0
 Summary: CircuitPython library for GPS modules.
 Author-email: Adafruit Industries <circuitpython@adafruit.com>
 License-Expression: MIT

{adafruit_circuitpython_gps-3.11.9 → adafruit_circuitpython_gps-4.0.0}/adafruit_circuitpython_gps.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: adafruit-circuitpython-gps
-Version: 3.11.9
+Version: 4.0.0
 Summary: CircuitPython library for GPS modules.
 Author-email: Adafruit Industries <circuitpython@adafruit.com>
 License-Expression: MIT

{adafruit_circuitpython_gps-3.11.9 → adafruit_circuitpython_gps-4.0.0}/adafruit_gps.py

@@ -40,7 +40,7 @@ try:
 except ImportError:
     pass
 
-__version__ = "3.11.9"
+__version__ = "4.0.0"
 __repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_GPS.git"
 
 
@@ -315,9 +315,14 @@ class GPS:
             |    3 - 3D fix
         """
         self.satellites = None
-        """The number of satellites in use, 0 - 12"""
+        """The number of satellites in use (GGA), 0 - 12"""
         self.satellites_prev = None
         """The number of satellites in use from the previous data point, 0 - 12"""
+        self.satellites_in_view = None
+        """The number of satellites in view (GSV), 0 - 12"""
+        self.satellites_in_view_prev = None
+        """The number of satellites in view from the previous data point, 0 - 12"""
+
         self.horizontal_dilution = None
         """Horizontal dilution of precision (GGA)"""
         self.altitude_m = None
@@ -678,6 +683,9 @@ class GPS:
         # GPS quality indicator
         self.fix_quality = parsed_data[5]
 
+        # Capture previous value
+        self.satellites_prev = self.satellites
+
         # Number of satellites in use, 0 - 12
         self.satellites = parsed_data[6]
 
@@ -754,8 +762,12 @@ class GPS:
         self.total_mess_num = data[0]
         # Message number
         self.mess_num = data[1]
+
+        # Capture previous value
+        self.satellites_in_view_prev = self.satellites_in_view
+
         # Number of satellites in view
-        self.satellites = data[2]
+        self.satellites_in_view = data[2]
 
         sat_tup = data[3:]
 
@@ -784,7 +796,7 @@ class GPS:
 
         if self.mess_num == self.total_mess_num:
             # Last part of GSV message
-            if len(self._sats) == self.satellites:
+            if len(self._sats) == self.satellites_in_view:
                 # Transfer received satellites to self.sats
                 if self.sats is None:
                     self.sats = {}
@@ -802,11 +814,16 @@ class GPS:
                     self.sats[sat[0]] = sat
             self._sats.clear()
 
-        self.satellites_prev = self.satellites
-
         return True
 
 
+_GPSI2C_MAX_PENDING = const(128)  # NMEA sentences are <= 82 bytes; an unterminated
+# buffer past this means a terminator was lost, so
+# resync rather than growing without bound (issue #123).
+_GPSI2C_MIN_PACKET = const(11)  # smallest viable sentence; matches the gate in
+# _read_sentence() before it attempts a readline().
+
+
 class GPS_GtopI2C(GPS):
     """GTop-compatible I2C GPS parsing module.  Can parse simple NMEA data
     sentences from an I2C-capable GPS module to read latitude, longitude, and more.
@@ -819,31 +836,70 @@ class GPS_GtopI2C(GPS):
         address: int = _GPSI2C_DEFAULT_ADDRESS,
         debug: bool = False,
         timeout: float = 5.0,
+        chunk_size: int = 32,
     ) -> None:
         from adafruit_bus_device import i2c_device  # noqa: PLC0415
 
         super().__init__(None, debug)  # init the parent with no UART
         self._i2c = i2c_device.I2CDevice(i2c_bus, address)
         self._lastbyte = None
-        self._charbuff = bytearray(1)
-        self._internalbuffer = []
+        self._chunk = bytearray(chunk_size)
+        self._pending = bytearray()
         self._timeout = timeout
 
+    def _fill(self) -> int:
+        """Read one chunk from the module into the pending buffer.
+
+        The GTop I2C protocol has no way to report how much data is waiting: the
+        module returns 0x0A filler bytes when it has nothing to send. Those are
+        discarded here, so a return value of 0 means the module is idle and there
+        is no point asking again until more time has passed.
+
+        Returns the number of real bytes recovered.
+        """
+        with self._i2c as i2c:
+            i2c.readinto(self._chunk)
+        recovered = 0
+        for char in self._chunk:
+            if char == 0x0A and self._lastbyte != 0x0D:
+                continue  # filler LF (a real LF only ever follows a CR)
+            self._pending.append(char)
+            self._lastbyte = char  # last approved byte, for CR/LF across chunks
+            recovered += 1
+        return recovered
+
+    def _newline_index(self) -> int:
+        """Index of the first 0x0A in the pending buffer, or -1.
+
+        Written as an explicit scan rather than bytearray.find() so it does not
+        depend on which string methods a given CircuitPython build provides.
+        """
+        for index, char in enumerate(self._pending):
+            if char == 0x0A:
+                return index
+        return -1
+
+    def _resync(self) -> None:
+        """Discard the pending buffer after a lost terminator so it cannot grow
+        without bound.  Clearing ``_lastbyte`` prevents a stale CR from wrongly
+        preserving the next filler LF."""
+        self._pending = bytearray()
+
+        self._lastbyte = None
+
     def read(self, num_bytes: int = 1) -> bytearray:
         """Read up to num_bytes of data from the GPS directly, without parsing.
-        Returns a bytearray with up to num_bytes or None if nothing was read"""
-        result = []
-        for _ in range(num_bytes):
-            with self._i2c as i2c:
-                # we read one byte at a time, verify it isnt part of a string of
-                # 'stuffed' newlines and then append to our result array for byteification
-                i2c.readinto(self._charbuff)
-                char = self._charbuff[0]
-                if (char == 0x0A) and (self._lastbyte != 0x0D):
-                    continue  # skip duplicate \n's!
-                result.append(char)
-                self._lastbyte = char  # keep track of the last character approved
-        return bytearray(result)
+        Returns a bytearray with up to num_bytes, which may be empty if the
+        module had nothing to send or the timeout expired."""
+        deadline = time.monotonic() + self._timeout
+        while len(self._pending) < num_bytes:
+            if self._fill() == 0:
+                break  # module is idle; return what we have
+            if time.monotonic() > deadline:
+                break
+        result = self._pending[:num_bytes]
+        self._pending[:num_bytes] = b""  # in-place shrink
+        return result
 
     def write(self, bytestr: ReadableBuffer) -> None:
         """Write a bytestring data to the GPS directly, without parsing
@@ -852,26 +908,37 @@ class GPS_GtopI2C(GPS):
             i2c.write(bytestr)
 
     @property
-    def in_waiting(self) -> Literal[16]:
-        """Returns number of bytes available in UART read buffer, always 16
-        since I2C does not have the ability to know how much data is available"""
-        return 16
+    def in_waiting(self) -> int:
+        """Number of recovered bytes not yet consumed.
+
+        I2C cannot report a UART-style buffer level, so this pulls a chunk when
+        the pending buffer is below the threshold ``_read_sentence()`` needs
+        before it will attempt a ``readline()``.
+        """
+        while len(self._pending) < _GPSI2C_MIN_PACKET:
+            if self._fill() == 0:
+                break  # module idle; report what we actually have
+        return len(self._pending)
 
     def readline(self) -> Optional[bytearray]:
-        """Returns a newline terminated bytearray, must have timeout set for
-        the underlying UART or this will block forever!"""
-        timeout = time.monotonic() + self._timeout
-        while timeout > time.monotonic():
-            # check if our internal buffer has a '\n' termination already
-            if self._internalbuffer and (self._internalbuffer[-1] == 0x0A):
-                break
-            char = self.read(1)
-            if not char:
-                continue
-            self._internalbuffer.append(char[0])
-            # print(bytearray(self._internalbuffer))
-        if self._internalbuffer and self._internalbuffer[-1] == 0x0A:
-            ret = bytearray(self._internalbuffer)
-            self._internalbuffer = []  # reset the buffer to empty
-            return ret
-        return None  # no completed data yet
+        """Return a newline-terminated bytearray, or None if no complete
+        sentence is available yet.
+
+        Returns as soon as the module reports idle rather than spinning until
+        the timeout expires.  A partial sentence is retained and completed on a
+        later call; a partial that grows past a legal NMEA length is discarded
+        as a lost terminator.
+        """
+        deadline = time.monotonic() + self._timeout
+        while True:
+            newline = self._newline_index()
+            if newline >= 0:
+                line = self._pending[: newline + 1]
+                self._pending[: newline + 1] = b""  # in-place shrink
+                return line
+            if len(self._pending) > _GPSI2C_MAX_PENDING:
+                self._resync()  # unterminated and over-long => garbage
+            if self._fill() == 0:
+                return None  # module idle; no completed sentence yet
+            if time.monotonic() > deadline:
+                return None

{adafruit_circuitpython_gps-3.11.9 → adafruit_circuitpython_gps-4.0.0}/pyproject.toml

@@ -12,7 +12,7 @@ requires = [
 [project]
 name = "adafruit-circuitpython-gps"
 description = "CircuitPython library for GPS modules."
-version = "3.11.9"
+version = "4.0.0"
 readme = "README.rst"
 authors = [
     {name = "Adafruit Industries", email = "circuitpython@adafruit.com"}

{adafruit_circuitpython_gps-3.11.9 → adafruit_circuitpython_gps-4.0.0}/tests/adafruit_gps_test.py

@@ -421,7 +421,7 @@ def test_GPS_update_from_GSV_first_part():
         assert gps.update()
         assert gps.total_mess_num == 2
         assert gps.mess_num == 1
-        assert gps.satellites == 8
+        assert gps.satellites_in_view == 8
         # check two satellites, without timestamp, since it is dynamic
         sats = gps._sats
         assert sats[0][:-1] == ("GP1", 40, 83, 46)
@@ -449,7 +449,7 @@ def test_GPS_update_from_GSV_both_parts_sats_are_removed():
             assert gps.update()
             assert gps.total_mess_num == 2
             assert gps.mess_num == 1
-            assert gps.satellites == 4
+            assert gps.satellites_in_view == 4
             # first time we received satellites, so this must be None
             assert gps.sats is None
         # some time has passed so the first two satellites will be too old, but
@@ -460,7 +460,7 @@ def test_GPS_update_from_GSV_both_parts_sats_are_removed():
             assert gps.update()
             assert gps.total_mess_num == 2
             assert gps.mess_num == 2
-            assert gps.satellites == 4
+            assert gps.satellites_in_view == 4
             # we should now have 4 satellites from the two part request
             assert set(gps.sats.keys()) == {"GP1", "GP2", "GP12", "GP14"}
 
@@ -470,7 +470,7 @@ def test_GPS_update_from_GSV_both_parts_sats_are_removed():
             # a third, one part request
             m.return_value = b"$GPGSV,1,1,02,13,07,344,39,15,22,228,45*7a\r\n"
             assert gps.update()
-            assert gps.satellites == 2
+            assert gps.satellites_in_view == 2
             assert set(gps.sats.keys()) == {"GP12", "GP14", "GP13", "GP15"}