pygnssutils 1.2.4__tar.gz → 1.2.6__tar.gz

{pygnssutils-1.2.4/src/pygnssutils.egg-info → pygnssutils-1.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pygnssutils
-Version: 1.2.4
+Version: 1.2.6
 Summary: GNSS Command Line Utilities
 Author-email: Steve Smith <semuadmin@semuconsulting.com>
 Maintainer-email: Steve Smith <semuadmin@semuconsulting.com>
@@ -34,7 +34,7 @@ Requires-Dist: certifi>=2025.0.0
 Requires-Dist: paho-mqtt>=2.1.0
 Requires-Dist: pyserial>=3.5
 Requires-Dist: pyspartn>=1.0.8
-Requires-Dist: pyubx2>=1.3.3
+Requires-Dist: pyubx2>=1.3.6
 Requires-Dist: pynmeagps>=1.1.5
 Requires-Dist: pysbf2>=1.0.4
 Requires-Dist: pyubxutils>=1.0.6
@@ -328,7 +328,7 @@ Streaming terminated, 93 messages processed with 0 errors.
 
 ### <a name="gnssstreamerservice">Installing gnssstreamer as a systemd service on Linux</a>
 
-This example should work for most Linux distributions running `systemd` and `python3>=3.8`, including Raspberry Pi OS (*substitute `dnf` for `apt` as necessary*).
+This example should work for most Linux distributions running `systemd` and `python3>=3.10`, including Raspberry Pi OS (*substitute `dnf` or `pacman` for `apt` as necessary*).
 
 The example `gnssstreamer.conf` file will set up `gnssstreamer` as a multi-client TCP socket server accessible on `hostip:50012` (*check TCP port 50012 is allowed through any active firewall*).
 
@@ -543,11 +543,11 @@ class pygnssutils.rinex_conv.RinexConvertor(app, rinex_version, rinex_type, gnss
 
 A command line utility and Python class `RinexConverter` to convert binary GNSS data logs to RINEX text file format.
 
-**NB: RINEX conversion is an experimental work in progress (*contributions and feedback welcome*). The current ALPHA release implements the following functionality:**
+**NB: RINEX conversion is an experimental work in progress (*contributions and feedback welcome*). The current release implements the following functionality:**
 
 1. RINEX versions 3.05 and 4.02.
 1. Convert binary UBX RXM-RAW or RXM-RAWX (raw observation) data from u-blox receivers (e.g. ZED-F9P) to RINEX Observation file format.
-1. Convert binary RXM-SFRBX (navigation subframe) data from u-blox receivers to RINEX Navigation file format. **Currently supports GPS LNAV/CNAV, GAL FNAV/INAV, BDS D1/D2 & GLO L1OF**, but the underlying `RinexConverterNavigation` class will be enhanced in future releases.
+1. Convert binary RXM-SFRBX (navigation subframe) data from u-blox receivers to RINEX Navigation file format.
 1. Convert RTCM3 Ephemerides messages (1019, 1020, 1041-1046) from any source (including NTRIP caster or RTK base station receiver) to RINEX Navigation file format.
 1. Convert NMEA MWD (wind speed and direction) and XDR (temperature and pressure) sensor data to RINEX Meteorology file format.
 

{pygnssutils-1.2.4 → pygnssutils-1.2.6}/README.md

@@ -284,7 +284,7 @@ Streaming terminated, 93 messages processed with 0 errors.
 
 ### <a name="gnssstreamerservice">Installing gnssstreamer as a systemd service on Linux</a>
 
-This example should work for most Linux distributions running `systemd` and `python3>=3.8`, including Raspberry Pi OS (*substitute `dnf` for `apt` as necessary*).
+This example should work for most Linux distributions running `systemd` and `python3>=3.10`, including Raspberry Pi OS (*substitute `dnf` or `pacman` for `apt` as necessary*).
 
 The example `gnssstreamer.conf` file will set up `gnssstreamer` as a multi-client TCP socket server accessible on `hostip:50012` (*check TCP port 50012 is allowed through any active firewall*).
 
@@ -499,11 +499,11 @@ class pygnssutils.rinex_conv.RinexConvertor(app, rinex_version, rinex_type, gnss
 
 A command line utility and Python class `RinexConverter` to convert binary GNSS data logs to RINEX text file format.
 
-**NB: RINEX conversion is an experimental work in progress (*contributions and feedback welcome*). The current ALPHA release implements the following functionality:**
+**NB: RINEX conversion is an experimental work in progress (*contributions and feedback welcome*). The current release implements the following functionality:**
 
 1. RINEX versions 3.05 and 4.02.
 1. Convert binary UBX RXM-RAW or RXM-RAWX (raw observation) data from u-blox receivers (e.g. ZED-F9P) to RINEX Observation file format.
-1. Convert binary RXM-SFRBX (navigation subframe) data from u-blox receivers to RINEX Navigation file format. **Currently supports GPS LNAV/CNAV, GAL FNAV/INAV, BDS D1/D2 & GLO L1OF**, but the underlying `RinexConverterNavigation` class will be enhanced in future releases.
+1. Convert binary RXM-SFRBX (navigation subframe) data from u-blox receivers to RINEX Navigation file format.
 1. Convert RTCM3 Ephemerides messages (1019, 1020, 1041-1046) from any source (including NTRIP caster or RTK base station receiver) to RINEX Navigation file format.
 1. Convert NMEA MWD (wind speed and direction) and XDR (temperature and pressure) sensor data to RINEX Meteorology file format.
 

{pygnssutils-1.2.4 → pygnssutils-1.2.6}/pyproject.toml

@@ -38,7 +38,7 @@ dependencies = [
     "paho-mqtt>=2.1.0",
     "pyserial>=3.5",
     "pyspartn>=1.0.8",
-    "pyubx2>=1.3.3",
+    "pyubx2>=1.3.6",
     "pynmeagps>=1.1.5",
     "pysbf2>=1.0.4",
     "pyubxutils>=1.0.6",

{pygnssutils-1.2.4 → pygnssutils-1.2.6}/src/pygnssutils/_version.py

@@ -8,4 +8,4 @@ Created on 2 Oct 2020
 :license: BSD 3-Clause
 """
 
-__version__ = "1.2.4"
+__version__ = "1.2.6"

{pygnssutils-1.2.4 → pygnssutils-1.2.6}/src/pygnssutils/globals.py

@@ -206,10 +206,6 @@ ALLNMEA = "allnmea"
 ALLUBX = "allubx"
 MINNMEA = "minnmea"
 MINUBX = "minubx"
-ALLNMEA_CLS = [b"\xf0", b"\xf1"]
-MINMMEA_ID = [b"\xf0\x00", b"\xf0\x02", b"\xf0\x03", b"\xf0\x04", b"\xf0\x05"]
-ALLUBX_CLS = [b"\x01"]
-MINUBX_ID = [b"\x01\x04", b"\x01\x07", b"\x01\x35"]
 PYGNSSUTILS_CRT = f"{HOME}/pygnssutils.crt"
 """Name of default TLS CRT file"""
 PYGNSSUTILS_CRTPATH = "PYGNSSUTILS_CRTPATH"

{pygnssutils-1.2.4 → pygnssutils-1.2.6}/src/pygnssutils/gnssmqttclient_cli.py

@@ -65,7 +65,8 @@ def main():
     clientid = getenv(ENV_MQTT_CLIENTID, default="enter-client-id")
     ap = ArgumentParser(
         description="Client ID can be read from environment variable MQTTCLIENTID",
-        epilog=EPILOG,
+        epilog=EPILOG
+        + " NB: This utility is DEPRECATED and will be removed in the next release of pygnssutils (1.2.7)",
         formatter_class=ArgumentDefaultsHelpFormatter,
     )
     ap.add_argument("-V", "--version", action="version", version="%(prog)s " + VERSION)

{pygnssutils-1.2.4 → pygnssutils-1.2.6}/src/pygnssutils/gnssreader.py

@@ -1,18 +1,20 @@
 """
 gnssreader.py
 
-Generic GNSS class.
+Generic GNSS reader / parser class.
 
-Reads and parses individual UBX, SBF, QGC, NMEA or RTCM3 messages from any viable
-data stream which supports a read(n) -> bytes method.
+Reads and parses individual UBX, SBF, QGC, UNI, NMEA or RTCM3 messages from any viable
+GNSS data stream which supports a read(n) -> bytes method.
 
 It is essentially an amalgamation of the Reader classes in the separate pyubx2, pynmeagps,
-pyrtcm, pysbf2 and pyqgc packages.
+pyrtcm, pysbf2, pyqgc and pyunigps packages.
 
 Returns both the raw binary data (as bytes) and the parsed data.
 
-- 'protfilter' governs which protocols (NMEA, UBX, SBF, QGC or RTCM3) are processed
-- 'quitonerror' governs how errors are handled
+- 'protfilter' governs which protocols (NMEA, UBX, SBF, QGC, UNI or RTCM3) are processed.
+- 'msgfilter' governs which individual message types are processed.
+- `parsing` governs whether payloads are fully or partially parsed.
+- 'quitonerror' governs how errors are handled.
 - 'msgmode' indicates the type of UBX datastream (output GET, input SET, query POLL).
   If msgmode is set to SETPOLL, input/query mode will be automatically detected by parser.
 
@@ -28,7 +30,7 @@ Created on 6 Oct 2025
 from logging import getLogger
 from socket import socket
 from types import FunctionType, NoneType
-from typing import Literal
+from typing import Any, Literal
 
 from pynmeagps import (
     NMEA_HDR,
@@ -81,6 +83,7 @@ from pyubx2 import (
     UBXReader,
     UBXStreamError,
     UBXTypeError,
+    escapeall,
 )
 from pyunigps import (
     UNI_HDR,
@@ -93,6 +96,7 @@ from pyunigps import (
 )
 
 from pygnssutils.exceptions import GNSSStreamError
+from pygnssutils.globals import DEFAULT_BUFSIZE
 
 NMEA_PROTOCOL = 1
 """NMEA Protocol"""
@@ -106,6 +110,108 @@ QGC_PROTOCOL = 16
 """QGC Protocol (Quectel)"""
 UNI_PROTOCOL = 32
 """UNI Protocol (Unicore)"""
+PARSE_NONE = 0
+"""No Parsing, raw output only"""
+PARSE_FULL = 1
+"""Full parsing of all attributes"""
+PARSE_META = 2
+"""Parse protocol and message Id only"""
+
+PROTOCOLS = {
+    NMEA_PROTOCOL: "NMEA",
+    UBX_PROTOCOL: "UBX",
+    RTCM3_PROTOCOL: "RTCM",
+    SBF_PROTOCOL: "SBF",
+    QGC_PROTOCOL: "QGC",
+    UNI_PROTOCOL: "UNI",
+}
+
+
+class GNSSMessage:
+    """
+    Generic GNSSMessage class.
+
+    Holds partially parsed GNSS binary messages (`parsing=2`).
+    """
+
+    def __init__(self, protocol: int, msgid: int | str, data: bytes):
+        """
+        Constructor
+
+        :param int protocol: GNSS protocol e.g. 2 (=UBX)
+        :param int | str msgid: GNSS message id e.g. 0x0215 or "GNGSA"
+        :param bytes data: raw data from original message
+        """
+
+        self._protocol = protocol
+        self._identity = msgid
+        self._data = data
+
+    def __str__(self) -> str:
+        """
+        Human readable representation.
+
+        :return: human readable representation
+        :rtype: str
+        """
+
+        prot = PROTOCOLS.get(self._protocol, "UNKNOWN")
+        ident = (
+            f"0x{self._identity:04x}"
+            if self._protocol in (UBX_PROTOCOL, QGC_PROTOCOL)
+            else self._identity
+        )
+        return f"<{prot}({ident}, length={self.length}, data={escapeall(self._data)})>"
+
+    def __repr__(self) -> str:
+        """
+        Machine readable representation.
+
+        eval(repr(obj)) = obj
+
+        :return: machine readable representation
+        :rtype: str
+
+        """
+
+        ident = (
+            f"'{self._identity}'"
+            if isinstance(self._identity, str)
+            else f"{self._identity}"
+        )
+        return f"GNSSMessage({self._protocol}, {ident}, {self._data})"
+
+    @property
+    def protocol(self) -> int:
+        """
+        Getter for protocol.
+        """
+
+        return self._protocol
+
+    @property
+    def identity(self) -> int | str:
+        """
+        Getter for identity.
+        """
+
+        return self._identity
+
+    @property
+    def data(self) -> bytes:
+        """
+        Getter for raw data.
+        """
+
+        return self._data
+
+    @property
+    def length(self) -> int:
+        """
+        Getter for length of original raw data.
+        """
+
+        return len(self._data)
 
 
 class GNSSReader:
@@ -127,8 +233,9 @@ class GNSSReader:
         quitonerror: Literal[0, 1, 2] = ERR_LOG,
         parsebitfield: bool = True,
         labelmsm: Literal[0, 1] = 1,
-        bufsize: int = 4096,
-        parsing: bool = True,
+        bufsize: int = DEFAULT_BUFSIZE,
+        parsing: Literal[0, 1, 2] = PARSE_FULL,
+        msgfilter: tuple | int | str = "",
         errorhandler: FunctionType | NoneType = None,
     ):
         """Constructor.
@@ -138,13 +245,15 @@ class GNSSReader:
         :param int validate: VALCKSUM (1) = Validate checksum,
             VALNONE (0) = ignore invalid checksum (1)
         :param int protfilter: NMEA_PROTOCOL (1), UBX_PROTOCOL (2), RTCM3_PROTOCOL (4),
-            SBF_PROTOCOL (8), QGC_PROTOCOL (16), UNI_PROTOCOL (32). Can be OR'd (7)
+            SBF_PROTOCOL (8), QGC_PROTOCOL (16), UNI_PROTOCOL (32). Can be OR'd (63)
         :param Literal[0,1,2]  quitonerror: ERR_IGNORE (0) = ignore errors, \
             ERR_LOG (1) = log continue, ERR_RAISE (2) = (re)raise (1)
         :param bool parsebitfield: 1 = parse bitfields, 0 = leave as bytes (1)
         :param Literal[0,1] labelmsm: RTCM3 MSM label type 1 = RINEX, 2 = BAND (1)
         :param int bufsize: socket recv buffer size (4096)
-        :param bool parsing: True = parse data, False = don't parse data (output raw only) (True)
+        :param Literal[0,1,2] parsing: PARSE_NONE (0) = no parsing (raw only), \
+            PARSE_FULL (1) = full parsing, PARSE_META (2) = parse metadata only (1)
+        :param tuple | int | str msgfilter: parsed message filter ("" = ALL)
         :param FunctionType | NoneType errorhandler: error handling object or function (None)
         :raises: UBXStreamError (if mode is invalid)
         """
@@ -162,6 +271,10 @@ class GNSSReader:
         self._labelmsm = labelmsm
         self._msgmode = msgmode
         self._parsing = parsing
+        self._msgfilter = (
+            (msgfilter,) if not isinstance(msgfilter, tuple) else msgfilter
+        )
+        self._filtermsg = self._msgfilter not in ((), ("",))
         self._logger = getLogger(__name__)
 
         if self._msgmode not in (GET, SET, POLL, SETPOLL):
@@ -174,12 +287,12 @@ class GNSSReader:
 
         return self
 
-    def __next__(self) -> tuple:
+    def __next__(self) -> tuple[bytes | NoneType, Any]:
         """
         Return next item in iteration.
 
         :return: tuple of (raw_data as bytes, parsed_data as UBXMessage)
-        :rtype: tuple
+        :rtype: tuple[bytes | NoneType, Any]
         :raises: StopIteration
 
         """
@@ -187,22 +300,24 @@ class GNSSReader:
         raw_data, parsed_data = self.read()
         if raw_data is None and parsed_data is None:
             raise StopIteration
-        return (raw_data, parsed_data)
+        return raw_data, parsed_data
 
-    def read(self) -> tuple:
+    def read(self) -> tuple[bytes | NoneType, Any]:
         """
-        Read a single NMEA, UBX, SBF, QGC or RTCM3 message from the stream buffer
+        Read a single NMEA, UBX, SBF, QGC, UNI or RTCM3 message from the stream buffer
         and return both raw and parsed data.
 
         'protfilter' determines which protocols are parsed.
         'quitonerror' determines whether to raise, log or ignore parsing errors.
 
         :return: tuple of (raw_data as bytes, parsed_data as NMEAMessage, UBXMessage,
-            SBFMessage, QGCMessage or RTCMMessage)
-        :rtype: tuple
+            SBFMessage, QGCMessage, UNIMessage, RTCMMessage or (if `parsing=2`) GNSSMessage)
+        :rtype: tuple[bytes | NoneType, Any]
         :raises: Exception (if invalid or unrecognised protocol in data stream)
         """
 
+        raw_data = None
+        parsed_data = None
         parsing = True
         while parsing:  # loop until end of valid message or EOF
             try:
@@ -274,7 +389,6 @@ class GNSSReader:
                         parsing = False
                     else:
                         continue
-                # unrecognised protocol header
                 else:
                     raise GNSSStreamError(f"Unknown protocol header {bytehdr}.")
 
@@ -311,173 +425,209 @@ class GNSSReader:
                     self._do_error(err)
                 continue
 
-        return (raw_data, parsed_data)
+        return raw_data, parsed_data
 
-    def _parse_ubx(self, hdr: bytes) -> tuple[bytes, UBXMessage | NoneType]:
+    def _parse_ubx(
+        self, hdr: bytes
+    ) -> tuple[bytes, UBXMessage | GNSSMessage | NoneType]:
         """
         Parse UBX message (using pyubx2).
 
         :param bytes hdr: UBX header (b'\\xb5\\x62')
         :return: tuple of (raw_data as bytes, parsed_data as UBXMessage or None)
-        :rtype: tuple[bytes, UBXMessage | NoneType]
+        :rtype: tuple[bytes, UBXMessage | GNSSMessage | NoneType]
         """
 
         # read the rest of the UBX message from the buffer
         byten = self._read_bytes(4)
-        clsid = byten[0:1]
-        msgid = byten[1:2]
+        msgid = byten[0:2]
+        msgidi = int.from_bytes(msgid, "big")  # UBX msgids are documented in big endian
         lenb = byten[2:4]
         leni = int.from_bytes(lenb, "little", signed=False)
-        byten = self._read_bytes(leni + 2)
-        plb = byten[0:leni]
-        cksum = byten[leni : leni + 2]
-        raw_data = hdr + clsid + msgid + lenb + plb + cksum
+        paycrc = self._read_bytes(leni + 2)
+        raw_data = hdr + msgid + lenb + paycrc
         # only parse if we need to (filter passes UBX)
-        if (self._protfilter & UBX_PROTOCOL) and self._parsing:
-            parsed_data = UBXReader.parse(
-                raw_data,
-                validate=self._validate,
-                msgmode=self._msgmode,
-                parsebitfield=self._parsebf,
-            )
-        else:
-            parsed_data = None
-        return (raw_data, parsed_data)
-
-    def _parse_sbf(self, hdr: bytes) -> tuple[bytes, SBFMessage | NoneType]:
+        parsed_data = None
+        if self._protfilter & UBX_PROTOCOL and (
+            not self._filtermsg or msgidi in self._msgfilter
+        ):
+            if self._parsing == PARSE_FULL:
+                parsed_data = UBXReader.parse(
+                    raw_data,
+                    validate=self._validate,
+                    msgmode=self._msgmode,
+                    parsebitfield=self._parsebf,
+                )
+            elif self._parsing == PARSE_META:
+                parsed_data = GNSSMessage(UBX_PROTOCOL, msgidi, raw_data)
+        return raw_data, parsed_data
+
+    def _parse_sbf(
+        self, hdr: bytes
+    ) -> tuple[bytes, SBFMessage | GNSSMessage | NoneType]:
         """
         Parse SBF message (using pysbf2).
 
         :param bytes hdr: SBF header (b'\\x24\\x40')
         :return: tuple of (raw_data as bytes, parsed_data as SBFMessage or None)
-        :rtype: tuple[bytes, SBFMessage | NoneType]
+        :rtype: tuple[bytes, SBFMessage | GNSSMessage | NoneType]
         """
 
         # read the rest of the SBF message from the buffer
         byten = self._read_bytes(6)
         crc = byten[0:2]
         msgid = byten[2:4]
+        msgidi = int.from_bytes(msgid, "little") & 0x1FFF
         lenb = byten[4:6]
         # lenb includes 8 byte header
         leni = int.from_bytes(lenb, "little", signed=False) - 8
         plb = self._read_bytes(leni)
         raw_data = hdr + crc + msgid + lenb + plb
         # only parse if we need to (filter passes SBF)
-        if (self._protfilter & SBF_PROTOCOL) and self._parsing:
-            parsed_data = SBFReader.parse(
-                raw_data,
-                validate=self._validate,
-                parsebitfield=self._parsebf,
-            )
-        else:
-            parsed_data = None
-        return (raw_data, parsed_data)
-
-    def _parse_uni(self, hdr: bytes) -> tuple[bytes, UNIMessage | NoneType]:
+        parsed_data = None
+        if self._protfilter & SBF_PROTOCOL and (
+            not self._filtermsg or msgidi in self._msgfilter
+        ):
+            if self._parsing == PARSE_FULL:
+                parsed_data = SBFReader.parse(
+                    raw_data,
+                    validate=self._validate,
+                    parsebitfield=self._parsebf,
+                )
+            elif self._parsing == PARSE_META:
+                parsed_data = GNSSMessage(SBF_PROTOCOL, msgidi, raw_data)
+        return raw_data, parsed_data
+
+    def _parse_uni(
+        self, hdr: bytes
+    ) -> tuple[bytes, UNIMessage | GNSSMessage | NoneType]:
         """
         Parse binary UNI message.
 
         :param bytes hdr: UNI header (b'\\xaa\\x44\\xb5')
         :return: tuple of (raw_data as bytes, parsed_data as UNIMessage or None)
-        :rtype: tuple[bytes, UNIMessage | NoneType]
+        :rtype: tuple[bytes, UNIMessage | GNSSMessage | NoneType]
         """
 
         header = self._read_bytes(21)
-        lenp = int.from_bytes(header[3:5], "little")
-        payload = self._read_bytes(lenp + 4)
+        leni = int.from_bytes(header[3:5], "little")
+        payload = self._read_bytes(leni + 4)
+        msgidi = int.from_bytes(header[1:3], "little")
         raw_data = hdr + header + payload
         # only parse if we need to (filter passes UNI)
-        if (self._protfilter & UNI_PROTOCOL) and self._parsing:
-            parsed_data = UNIReader.parse(
-                raw_data,
-                msgmode=self._msgmode,
-                validate=self._validate,
-                parsebitfield=self._parsebf,
-            )
-        else:
-            parsed_data = None
-        return (raw_data, parsed_data)
-
-    def _parse_qgc(self, hdr: bytes) -> tuple[bytes, QGCMessage | NoneType]:
+        parsed_data = None
+        if self._protfilter & UNI_PROTOCOL and (
+            not self._filtermsg or msgidi in self._msgfilter
+        ):
+            if self._parsing == PARSE_FULL:
+                parsed_data = UNIReader.parse(
+                    raw_data,
+                    validate=self._validate,
+                    msgmode=self._msgmode,
+                    parsebitfield=self._parsebf,
+                )
+            elif self._parsing == PARSE_META:
+                parsed_data = GNSSMessage(UNI_PROTOCOL, msgidi, raw_data)
+        return raw_data, parsed_data
+
+    def _parse_qgc(
+        self, hdr: bytes
+    ) -> tuple[bytes, QGCMessage | GNSSMessage | NoneType]:
         """
         Parse QGC message (using pyqgc).
 
         :param bytes hdr: QGC header (b'\\x51\\x47')
         :return: tuple of (raw_data as bytes, parsed_data as QGCMessage or None)
-        :rtype: tuple[bytes, QGCMessage | NoneType]
+        :rtype: tuple[bytes, QGCMessage | GNSSMessage | NoneType]
         """
 
         # read the rest of the QGC message from the buffer
         byten = self._read_bytes(4)
-        msggrp = byten[0:1]
-        msgid = byten[1:2]
+        msgid = byten[0:2]
+        msgidi = int.from_bytes(msgid, "big")  # QCG msgids are documented in big endian
         lenb = byten[2:4]
         leni = int.from_bytes(lenb, "little", signed=False)
-        byten = self._read_bytes(leni + 2)
-        plb = byten[0:leni]
-        cksum = byten[leni : leni + 2]
-        raw_data = hdr + msggrp + msgid + lenb + plb + cksum
+        paycrc = self._read_bytes(leni + 2)
+        raw_data = hdr + msgid + lenb + paycrc
         # only parse if we need to (filter passes QGC)
-        if (self._protfilter & QGC_PROTOCOL) and self._parsing:
-            parsed_data = QGCReader.parse(
-                raw_data,
-                msgmode=self._msgmode,
-                validate=self._validate,
-                parsebitfield=self._parsebf,
-            )
-        else:
-            parsed_data = None
-        return (raw_data, parsed_data)
-
-    def _parse_nmea(self, hdr: bytes) -> tuple[bytes, NMEAMessage | NoneType]:
+        parsed_data = None
+        if self._protfilter & QGC_PROTOCOL and (
+            not self._filtermsg or msgidi in self._msgfilter
+        ):
+            if self._parsing == PARSE_FULL:
+                parsed_data = QGCReader.parse(
+                    raw_data,
+                    validate=self._validate,
+                    msgmode=self._msgmode,
+                    parsebitfield=self._parsebf,
+                )
+            elif self._parsing == PARSE_META:
+                parsed_data = GNSSMessage(QGC_PROTOCOL, msgidi, raw_data)
+        return raw_data, parsed_data
+
+    def _parse_nmea(
+        self, hdr: bytes
+    ) -> tuple[bytes, NMEAMessage | GNSSMessage | NoneType]:
         """
         Parse NMEA message (using pynmeagps).
 
         :param bytes hdr: NMEA header (b'\\x24\\x..')
         :return: tuple of (raw_data as bytes, parsed_data as NMEAMessage or None)
-        :rtype: tuple[bytes, NMEAMessage | NoneType]
+        :rtype: tuple[bytes, NMEAMessage | GNSSMessage | NoneType]
         """
 
         # read the rest of the NMEA message from the buffer
         byten = self._read_line()  # NMEA protocol is CRLF-terminated
         raw_data = hdr + byten
+        msgids = (
+            raw_data[1:].decode("utf-8", errors="backslashreplace").split(",", 1)[0]
+        )
         # only parse if we need to (filter passes NMEA)
-        if (self._protfilter & NMEA_PROTOCOL) and self._parsing:
-            # invoke pynmeagps parser
-            parsed_data = NMEAReader.parse(
-                raw_data,
-                validate=self._validate,
-                msgmode=self._msgmode,
-            )
-        else:
-            parsed_data = None
-        return (raw_data, parsed_data)
-
-    def _parse_rtcm3(self, hdr: bytes) -> tuple[bytes, RTCMMessage | NoneType]:
+        parsed_data = None
+        if self._protfilter & NMEA_PROTOCOL and (
+            not self._filtermsg or msgids in self._msgfilter
+        ):
+            if self._parsing == PARSE_FULL:
+                parsed_data = NMEAReader.parse(
+                    raw_data,
+                    validate=self._validate,
+                    msgmode=self._msgmode,
+                )
+            elif self._parsing == PARSE_META:
+                parsed_data = GNSSMessage(NMEA_PROTOCOL, msgids, raw_data)
+        return raw_data, parsed_data
+
+    def _parse_rtcm3(
+        self, hdr: bytes
+    ) -> tuple[bytes, RTCMMessage | GNSSMessage | NoneType]:
         """
         Parse RTCM3 message (using pyrtcm).
 
         :param bytes hdr: first 2 bytes of RTCM3 header
         :return: tuple of (raw_data as bytes, parsed_stub as RTCMMessage)
-        :rtype: tuple[bytes, RTCMMessage | NoneType]
+        :rtype: tuple[bytes, RTCMMessage | GNSSMessage | NoneType]
         """
 
         hdr3 = self._read_bytes(1)
         size = hdr3[0] | (hdr[1] << 8)
         payload = self._read_bytes(size)
+        msgidi = ((int.from_bytes(payload[0:2], "big")) >> 4) & 0xFFF
         crc = self._read_bytes(3)
         raw_data = hdr + hdr3 + payload + crc
         # only parse if we need to (filter passes RTCM)
-        if (self._protfilter & RTCM3_PROTOCOL) and self._parsing:
-            # invoke pyrtcm parser
-            parsed_data = RTCMReader.parse(
-                raw_data,
-                validate=self._validate,
-                labelmsm=self._labelmsm,
-            )
-        else:
-            parsed_data = None
-        return (raw_data, parsed_data)
+        parsed_data = None
+        if self._protfilter & RTCM3_PROTOCOL and (
+            not self._filtermsg or msgidi in self._msgfilter
+        ):
+            if self._parsing == PARSE_FULL:
+                parsed_data = RTCMReader.parse(
+                    raw_data,
+                    validate=self._validate,
+                    labelmsm=self._labelmsm,
+                )
+            elif self._parsing == PARSE_META:
+                parsed_data = GNSSMessage(RTCM3_PROTOCOL, msgidi, raw_data)
+        return raw_data, parsed_data
 
     def _read_bytes(self, size: int) -> bytes:
         """