pygnssutils 1.2.2__tar.gz → 1.2.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pygnssutils
-Version: 1.2.2
+Version: 1.2.4
 Summary: GNSS Command Line Utilities
 Author-email: Steve Smith <semuadmin@semuconsulting.com>
 Maintainer-email: Steve Smith <semuadmin@semuconsulting.com>
@@ -34,11 +34,11 @@ 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.0
-Requires-Dist: pynmeagps>=1.1.4
+Requires-Dist: pyubx2>=1.3.3
+Requires-Dist: pynmeagps>=1.1.5
 Requires-Dist: pysbf2>=1.0.4
 Requires-Dist: pyubxutils>=1.0.6
-Requires-Dist: pyqgc>=0.2.2
+Requires-Dist: pyqgc>=1.0.0
 Requires-Dist: pyunigps>=1.0.0
 Dynamic: license-file
 
@@ -81,7 +81,7 @@ designated output stream.
 a simple SPARTN IP (MQTT) Client which receives SPARTN correction data from an SPARTN IP location service and (optionally) sends this to a
 designated output stream.
 1. `SocketServer` class based on the native Python `ThreadingTCPServer`. Capable of operating in two modes - Socket Server or NTRIP Caster. Provides two alternate client request handler classes - `ClientHandler` (HTTP) or `ClientHandlerTLS` (HTTPS).
-1. `RinexConverter` class and its associated [`pyrinexconv`](#rinexconvert) CLI utility. This implements a binary GNSS data log file to RINEX text file conversion facility. **NB: this initial ALPHA release has limited functionality.**
+1. `RinexConverter` class and its associated [`pyrinexconv`](#rinexconvert) CLI utility. This implements a binary GNSS data log file to RINEX text file conversion facility. **NB: RINEX conversion is currently an experimental work in progress (*contributions and feedback welcome*)**
 
 The pygnssutils homepage is located at [https://github.com/semuconsulting/pygnssutils](https://github.com/semuconsulting/pygnssutils).
 
@@ -543,17 +543,15 @@ 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: This ALPHA preview release is limited to the following experimental functionality:**
+**NB: RINEX conversion is an experimental work in progress (*contributions and feedback welcome*). The current ALPHA 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**, but the underlying `RinexConverterNavigation` class is readily extensible.
+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 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.
 
-A Graphical User Interface for this utility will be added to [PyGPSClient](https://github.com/semuconsulting/PyGPSClient).
-
-The intention behind this preview release is to **gauge the wider appetite for further development** of a cross-platform Python RINEX conversion utility and enhance functionality in a future release, as and when time permits. **CONTRIBUTORS WELCOME**.
+A Graphical User Interface for this utility has been added to [PyGPSClient](https://github.com/semuconsulting/PyGPSClient).
 
 Assuming the u-blox receiver is already configured to output raw observation (UBX-RXM-RAWX) and navigation subframe (UBX-RXM-SFRBX) data, a suitable input log file can be created using the pygnssutils `gnssstreamer` CLI utility e.g. ...
 

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

@@ -37,7 +37,7 @@ designated output stream.
 a simple SPARTN IP (MQTT) Client which receives SPARTN correction data from an SPARTN IP location service and (optionally) sends this to a
 designated output stream.
 1. `SocketServer` class based on the native Python `ThreadingTCPServer`. Capable of operating in two modes - Socket Server or NTRIP Caster. Provides two alternate client request handler classes - `ClientHandler` (HTTP) or `ClientHandlerTLS` (HTTPS).
-1. `RinexConverter` class and its associated [`pyrinexconv`](#rinexconvert) CLI utility. This implements a binary GNSS data log file to RINEX text file conversion facility. **NB: this initial ALPHA release has limited functionality.**
+1. `RinexConverter` class and its associated [`pyrinexconv`](#rinexconvert) CLI utility. This implements a binary GNSS data log file to RINEX text file conversion facility. **NB: RINEX conversion is currently an experimental work in progress (*contributions and feedback welcome*)**
 
 The pygnssutils homepage is located at [https://github.com/semuconsulting/pygnssutils](https://github.com/semuconsulting/pygnssutils).
 
@@ -499,17 +499,15 @@ 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: This ALPHA preview release is limited to the following experimental functionality:**
+**NB: RINEX conversion is an experimental work in progress (*contributions and feedback welcome*). The current ALPHA 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**, but the underlying `RinexConverterNavigation` class is readily extensible.
+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 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.
 
-A Graphical User Interface for this utility will be added to [PyGPSClient](https://github.com/semuconsulting/PyGPSClient).
-
-The intention behind this preview release is to **gauge the wider appetite for further development** of a cross-platform Python RINEX conversion utility and enhance functionality in a future release, as and when time permits. **CONTRIBUTORS WELCOME**.
+A Graphical User Interface for this utility has been added to [PyGPSClient](https://github.com/semuconsulting/PyGPSClient).
 
 Assuming the u-blox receiver is already configured to output raw observation (UBX-RXM-RAWX) and navigation subframe (UBX-RXM-SFRBX) data, a suitable input log file can be created using the pygnssutils `gnssstreamer` CLI utility e.g. ...
 

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

@@ -38,11 +38,11 @@ dependencies = [
     "paho-mqtt>=2.1.0",
     "pyserial>=3.5",
     "pyspartn>=1.0.8",
-    "pyubx2>=1.3.0",
-    "pynmeagps>=1.1.4",
+    "pyubx2>=1.3.3",
+    "pynmeagps>=1.1.5",
     "pysbf2>=1.0.4",
     "pyubxutils>=1.0.6",
-    "pyqgc>=0.2.2",
+    "pyqgc>=1.0.0",
     "pyunigps>=1.0.0",
 ]
 

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

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

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

@@ -121,7 +121,7 @@ LOGLIMIT = 10485760  # max size of logfile in bytes
 NOGGA = -1
 """No GGA sentence to be sent (for NTRIP caster)"""
 EPILOG = (
-    "© 2022 semuadmin (Steve Smith) BSD 3-Clause license"
+    "© 2022-2026 semuadmin (Steve Smith) BSD 3-Clause license"
     " - https://github.com/semuconsulting/pygnssutils/"
 )
 """CLI argument parser epilog"""

{pygnssutils-1.2.2 → pygnssutils-1.2.4}/src/pygnssutils/rawnav.py

@@ -47,11 +47,11 @@ navigation data:
 
 https://www.u-blox.com/sites/default/files/ZED-F9P_IntegrationManual_UBX-18010802.pdf
 
-NB: Alpha Support currently limited to:
+NB: Alpha release currently implements:
     - GPS LNAV, CNAV
     - GAL FNAV, INAV
-    - BDS D1
-... pending transcription of other GNSS ICDs.
+    - BDS D1, D2
+    - GLO L1OF
 
 Created on 20 Apr 2026
 
@@ -60,7 +60,7 @@ Created on 20 Apr 2026
 :license: BSD 3-Clause
 """
 
-# pylint: disable=fixme, unused-argument, unused-variable, too-many-arguments, too-many-positional-arguments
+# pylint: disable=unused-argument, unused-variable, too-many-arguments, too-many-positional-arguments
 
 import struct
 from logging import getLogger
@@ -79,8 +79,8 @@ from pygnssutils.rinex_globals import (
     QZS,
     SBA,
     UBXRINEXGNSS,
-    UBXRINEXOBSCODE,
 )
+from pygnssutils.rinex_helpers import get_obscode_ubx
 
 IS1 = "_is1"
 """IS1 field name suffix (between MSB and ISB)"""
@@ -120,7 +120,7 @@ class RawNav:
         self,
         gnss: Literal["G", "R", "E", "C", "J", "S", "I"],
         svid: int,
-        sigid: str,
+        sigcode: str,
         **kwargs,  # pylint: disable=unused-argument
     ):
         """
@@ -128,17 +128,18 @@ class RawNav:
 
         :param Literal["G","R","E","C","J","S","I"] gnss: GNSS code
         :param int svid: RINEX SV id e.g. 14
-        :param str sigid: RINEX signal id e.g. "1C"
+        :param str sigcode: RINEX signal code e.g. "1C"
         :param dict kwargs: optional keyword arguments
         """
 
         self._logger = getLogger(__name__)
         self._gnss = gnss
         self._svid = svid
-        self._sigid = sigid
-        self.wn = -1
-        self.toc = -1
-        self.tow = -1
+        self._sigcode = sigcode
+        if gnss != "R":
+            self.wn = -1
+            self.toc = -1
+            self.tow = -1
         self._subframeacq = 0
         self._msb = {}
         self._isb = {}
@@ -290,7 +291,7 @@ class RawNav:
 
         stg = (
             f"<RAWNAV({self.identity}, gnss={self._gnss}, svid={self._svid}, "
-            f"sigid={self._sigid}, sfracq={self._subframeacq}, "
+            f"sigid={self._sigcode}, sfracq={self._subframeacq}, "
         )
         for i, att in enumerate(self.__dict__):
             if att[0] != "_":  # only show public attributes
@@ -310,7 +311,7 @@ class RawNav:
         :rtype: str
         """
 
-        return f"{self._gnss}{self._svid:02d}{self._sigid}"
+        return f"{self._gnss}{self._svid:02d}{self._sigcode}"
 
     @property
     def gnss(self) -> str:
@@ -343,18 +344,18 @@ class RawNav:
         :rtype: str
         """
 
-        return f"{self._gnss}{self._svid:02d}"
+        return f"{self._gnss}{self._svid:>2}"  # no leading zero
 
     @property
-    def sigid(self) -> str:
+    def sigcode(self) -> str:
         """
-        Getter for signal id in RINEX format.
+        Getter for signal code in RINEX format.
 
-        :return: signal id
+        :return: signal code e.g. '1C'
         :rtype: str
         """
 
-        return self._sigid
+        return self._sigcode
 
     @property
     def subframeacq(self) -> int:
@@ -411,37 +412,37 @@ class RawNavReader:
             gnss = UBXRINEXGNSS[data.gnssId]
             svid = data.svId
             numw = data.numWords
-            sigid = UBXRINEXOBSCODE[(data.gnssId, data.sigId)]
+            sigcode = get_obscode_ubx(data.gnssId, data.sigId)
         except KeyError as err:
             raise RINEXProcessingError(
                 f"Unrecognised GNSS or Signal code: {data.gnssId=}, {data.sigId=}"
             ) from err
 
         if gnss == GPS:
-            sfrdata = self._process_rxm_sfrbx_gps(gnss, svid, sigid, numw, data)
+            sfrdata = self._process_rxm_sfrbx_gps(gnss, svid, sigcode, numw, data)
         elif gnss == GAL:
-            sfrdata = self._process_rxm_sfrbx_gal(gnss, svid, sigid, numw, data)
+            sfrdata = self._process_rxm_sfrbx_gal(gnss, svid, sigcode, numw, data)
         elif gnss == BDS:
-            sfrdata = self._process_rxm_sfrbx_bds(gnss, svid, sigid, numw, data)
+            sfrdata = self._process_rxm_sfrbx_bds(gnss, svid, sigcode, numw, data)
         elif gnss == GLO:
-            sfrdata = self._process_rxm_sfrbx_glo(gnss, svid, sigid, numw, data)
+            sfrdata = self._process_rxm_sfrbx_glo(gnss, svid, sigcode, numw, data)
         elif gnss == SBA:
-            sfrdata = self._process_rxm_sfrbx_sba(gnss, svid, sigid, numw, data)
+            sfrdata = self._process_rxm_sfrbx_sba(gnss, svid, sigcode, numw, data)
         elif gnss == QZS:
-            sfrdata = self._process_rxm_sfrbx_qzs(gnss, svid, sigid, numw, data)
+            sfrdata = self._process_rxm_sfrbx_qzs(gnss, svid, sigcode, numw, data)
         elif gnss == IRN:
-            sfrdata = self._process_rxm_sfrbx_irn(gnss, svid, sigid, numw, data)
+            sfrdata = self._process_rxm_sfrbx_irn(gnss, svid, sigcode, numw, data)
         return sfrdata
 
     def _process_rxm_sfrbx_gps(
-        self, gnss: str, svid: int, sigid: str, numw: int, data: UBXMessage
+        self, gnss: str, svid: int, sigcode: str, numw: int, data: UBXMessage
     ) -> dict[str, str | int | float | NoneType]:
         """
         Reassemble GPS subframe from individual UBX RXM-SFRBX dwrds.
 
         :param str gnss: RINEX gnss code
         :param int svid: SV
-        :param str sigid: RINEX sigid
+        :param str sigcode: RINEX sig code e.g. '1C'
         :param UBXMessage data: parsed UBX RXM-SFRBX message
         :return: dict of subframe attributes
         :rtype: dict[str, str | int | float | NoneType]
@@ -450,21 +451,19 @@ class RawNavReader:
 
         subframe = 0
         subframeid = 0
-        # dataid = 0
         subframepageid = 0
 
         # for GPS LNAV, subframe = 10 * 30 bits, with each 32-bit dwrd padded with 2 bits at end
-        if sigid == "1C":  # GPS LNAV
+        if sigcode == "1C":  # GPS LNAV
             for i in range(numw):
                 wrd = getattr(data, f"dwrd_{i+1:02d}") & 0xFFFFFFFC >> 2
                 subframe += wrd << (30 * (numw - 1 - i))
             subframeid = (subframe >> 248) & 0b111
-            # dataid = subframe >> 234 & 0b11
             if subframeid in (4, 5):
                 subframepageid = subframe >> 232 & 0b111111
 
         # for GPS CNAV, subframe = 3 * 100 bits, final 20 bits of 320 bit dwrd is padding
-        elif sigid in ("2L", "2S", "5I", "5Q"):  # GPS CNAV
+        elif sigcode in ("2L", "2S", "5I", "5Q"):  # GPS CNAV
             for i in range(numw):
                 wrd = getattr(data, f"dwrd_{i+1:02d}")
                 subframe += wrd << (32 * (numw - 1 - i))
@@ -477,22 +476,21 @@ class RawNavReader:
         return {
             "gnss": gnss,
             "svid": svid,
-            "sigid": sigid,
-            # "dataid": dataid,
+            "sigcode": sigcode,
             "subframeid": subframeid,
             "subframepageid": subframepageid,
             "subframe": subframe,
         }
 
     def _process_rxm_sfrbx_gal(
-        self, gnss: str, svid: int, sigid: str, numw: int, data: UBXMessage
+        self, gnss: str, svid: int, sigcode: str, numw: int, data: UBXMessage
     ) -> dict[str, str | int | float | NoneType]:
         """
         Reassemble GALILEO subframe from individual UBX RXM-SFRBX dwrds.
 
         :param str gnss: RINEX gnss code
         :param int svid: SV
-        :param str sigid: RINEX sigid
+        :param str sigcode: RINEX sigid e.g. '5I'
         :param UBXMessage data: parsed UBX RXM-SFRBX message
         :return: dict of subframe attributes
         :rtype: dict[str, str | int | float | NoneType]
@@ -505,7 +503,7 @@ class RawNavReader:
 
         # for GAL FNAV, subframe = 244 bits,
         # 8 * 32 bit dwrds with 12 bits padding at end
-        if sigid == "5I":  # GAL FNAV
+        if sigcode == "5I":  # GAL FNAV
             for i in range(numw):
                 wrd = getattr(data, f"dwrd_{i+1:02d}")
                 subframe += wrd << (32 * (numw - 1 - i))
@@ -517,7 +515,7 @@ class RawNavReader:
         # for GAL INAV, subframe = 256 bits, 8 * 32 bit dwrds,
         # with word data separated into 112 msb and 16 lsb
         # (see GAL_INAV_SUBFRAME)
-        elif sigid in ("1B", "7I"):  # GAL INAV
+        elif sigcode in ("1B", "7I"):  # GAL INAV
             supsubframe = 0
             for i in range(numw):
                 wrd = getattr(data, f"dwrd_{i+1:02d}")
@@ -532,21 +530,21 @@ class RawNavReader:
         return {
             "gnss": gnss,
             "svid": svid,
-            "sigid": sigid,
+            "sigcode": sigcode,
             "subframeid": subframeid,
             "subframepageid": subframepageid,
             "subframe": subframe,
         }
 
     def _process_rxm_sfrbx_bds(
-        self, gnss: str, svid: int, sigid: str, numw: int, data: UBXMessage
+        self, gnss: str, svid: int, sigcode: str, numw: int, data: UBXMessage
     ) -> dict[str, str | int | float | NoneType]:
         """
         Reassemble BEIDOU subframe from individual UBX RXM-SFRBX dwrds.
 
         :param str gnss: RINEX gnss code
         :param int svid: SV
-        :param str sigid: RINEX sigid
+        :param str sigcode: RINEX sig code e.g. '2I'
         :param UBXMessage data: parsed UBX RXM-SFRBX message
         :return: dict of subframe attributes
         :rtype: dict[str, str | int | float | NoneType]
@@ -558,7 +556,7 @@ class RawNavReader:
         subframepageid = 0
         d1d2 = 0
 
-        if sigid in ("2I", "6I", "7I"):  # BDS D1/D2
+        if sigcode in ("2I", "6I", "7I"):  # BDS D1/D2
             if data.sigId in (1, 3, 10):  # D2
                 d1d2 = 2
             else:  # D1
@@ -572,16 +570,16 @@ class RawNavReader:
             elif d1d2 == 2 and subframeid in (1,):
                 subframepageid = subframe >> 254 & 0b1111
 
-        elif sigid == "1D":  # BDS CNV1
+        elif sigcode == "1D":  # BDS CNV1
             pass  # TODO
 
-        elif sigid == "5D":  # BDS CNV2
+        elif sigcode == "5D":  # BDS CNV2
             pass  # TODO
 
         return {
             "gnss": gnss,
             "svid": svid,
-            "sigid": sigid,
+            "sigcode": sigcode,
             "d1d2": d1d2,
             "subframeid": subframeid,
             "subframepageid": subframepageid,
@@ -589,14 +587,14 @@ class RawNavReader:
         }
 
     def _process_rxm_sfrbx_glo(
-        self, gnss: str, svid: int, sigid: str, numw: int, data: UBXMessage
+        self, gnss: str, svid: int, sigcode: str, numw: int, data: UBXMessage
     ) -> dict[str, str | int | float | NoneType]:
         """
         Reassemble GLONASS subframe from individual UBX RXM-SFRBX dwrds.
 
         :param str gnss: RINEX gnss code
         :param int svid: SV
-        :param str sigid: RINEX sigid
+        :param str sigcode: RINEX sigid e.g. '1C'
         :param UBXMessage data: parsed UBX RXM-SFRBX message
         :return: dict of subframe attributes
         :rtype: dict[str, str | int | float | NoneType]
@@ -606,35 +604,38 @@ class RawNavReader:
         subframe = 0
         subframeid = 0
         subframepageid = 0
+        freqid = data.freqId
 
-        # for GLO, subframe = 85 bits, 3 * 32 bit dwrds, plus
-        # a receiver-generated 4th 32 dwrd containing subframe and page ids
-        if sigid in ("1C", "2C"):  # GLO L1,L2
+        # for GLO, subframe = 85 bits,
+        # 3 * 32 bit dwrds with 11 bits padding at end,
+        # plus a receiver-generated 4th dwrd containing superframe and frame ids
+        if sigcode in ("1C",):  # GLO L1OF
             for i in range(numw):
                 wrd = getattr(data, f"dwrd_{i+1:02d}")
                 subframe += wrd << (32 * (numw - 1 - i))
-            subframepageid = (subframe >> 16) & 0xFFFF
-            subframeid = subframe & 0b11111111
-            subframe = (subframe >> 43) & 0x1FFFFFFFFFFFFFFFFFFFFF  # strip 4th dwrd
+            # strip 4th dwrd, leaving 85 bit subframe
+            subframe = (subframe >> 43) & 0x1FFFFFFFFFFFFFFFFFFFFF  # 2**85-1
+            subframeid = (subframe >> 80) & 0b01111
 
         return {
             "gnss": gnss,
             "svid": svid,
-            "sigid": sigid,
+            "sigcode": sigcode,
             "subframeid": subframeid,
             "subframepageid": subframepageid,
             "subframe": subframe,
+            "freqid": freqid,
         }
 
     def _process_rxm_sfrbx_sba(
-        self, gnss: str, svid: int, sigid: str, numw: int, data: UBXMessage
+        self, gnss: str, svid: int, sigcode: str, numw: int, data: UBXMessage
     ) -> dict[str, str | int | float | NoneType]:
         """
         Reassemble SBAS subframe from individual UBX RXM-SFRBX dwrds.
 
         :param str gnss: RINEX gnss code
         :param int svid: SV
-        :param str sigid: RINEX sigid
+        :param str sigcode: RINEX sigcode e.g. '1C'
         :param UBXMessage data: parsed UBX RXM-SFRBX message
         :return: dict of subframe attributes
         :rtype: dict[str, str | int | float | NoneType]
@@ -642,22 +643,39 @@ class RawNavReader:
         """
 
         subframe = 0
-        tow = 0
         subframeid = 0
         subframepageid = 0
-        sfrdata = {}
-        # TODO
-        return sfrdata
+        svid -= 100  # adjust SV ID range
+
+        # for SBAS, subframe = 250 bits,
+        # 8 * 32 bit dwrds with 6 bits padding at end
+        if sigcode == "1C":  # SBAS L1C/A
+            for i in range(numw):
+                wrd = getattr(data, f"dwrd_{i+1:02d}")
+                subframe += wrd << (32 * (numw - 1 - i))
+            subframe = (
+                subframe >> 12
+            ) & 0x3FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF  # (2**250 - 1)
+            subframeid = (subframe >> 236) & 0b111111
+
+        return {
+            "gnss": gnss,
+            "svid": svid,
+            "sigcode": sigcode,
+            "subframeid": subframeid,
+            "subframepageid": subframepageid,
+            "subframe": subframe,
+        }
 
     def _process_rxm_sfrbx_qzs(
-        self, gnss: str, svid: int, sigid: str, numw: int, data: UBXMessage
+        self, gnss: str, svid: int, sigcode: str, numw: int, data: UBXMessage
     ) -> dict[str, str | int | float | NoneType]:
         """
         Reassemble QZSS subframe from individual UBX RXM-SFRBX dwrds.
 
         :param str gnss: RINEX gnss code
         :param int svid: SV
-        :param str sigid: RINEX sigid
+        :param str sigcode: RINEX sigcode e.g. '1C'
         :param UBXMessage data: parsed UBX RXM-SFRBX message
         :return: dict of subframe attributes
         :rtype: dict[str, str | int | float | NoneType]
@@ -665,22 +683,65 @@ class RawNavReader:
         """
 
         subframe = 0
-        tow = 0
         subframeid = 0
         subframepageid = 0
-        sfrdata = {}
-        # TODO
-        return sfrdata
+        svid -= 192  # adjust SV ID range
+
+        # for QZSS L1C/A, subframe = 10 * 30 bits, with each 32-bit dwrd padded with 2 bits at end
+        # same as GPS LNAV
+        if sigcode == "1C":  # QZSS L1C/A
+            for i in range(numw):
+                wrd = getattr(data, f"dwrd_{i+1:02d}") & 0xFFFFFFFC >> 2
+                subframe += wrd << (30 * (numw - 1 - i))
+            subframeid = (subframe >> 248) & 0b111
+            if subframeid in (4, 5):
+                subframepageid = subframe >> 232 & 0b111111
+
+        # for QZSS L1S, subframe = 250 bits, 8 * 32 bit dwrds with 6 bits padding at end
+        # same as SBAS L1C/A
+        if sigcode == "1Z":  # QZSS L1S
+            for i in range(numw):
+                wrd = getattr(data, f"dwrd_{i+1:02d}")
+                subframe += wrd << (32 * (numw - 1 - i))
+            subframe = (
+                subframe >> 12
+            ) & 0x3FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF  # (2**250 - 1)
+            subframeid = (subframe >> 236) & 0b111111
+
+        # for QZSS L2C, L5I, subframe = 3 * 100 bits, final 20 bits of 320 bit dwrd is padding
+        # same as GPS CNAV
+        elif sigcode in (
+            "2L",
+            "2S",
+            "5I",
+        ):  # QZSS L2C, L5I
+            for i in range(numw):
+                wrd = getattr(data, f"dwrd_{i+1:02d}")
+                subframe += wrd << (32 * (numw - 1 - i))
+            subframe = (
+                (subframe >> 20)
+                & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
+            )  # (2**300 - 1)
+            subframeid = (subframe >> 280) & 0b111111
+
+        return {
+            "gnss": gnss,
+            "svid": svid,
+            "sigcode": sigcode,
+            "subframeid": subframeid,
+            "subframepageid": subframepageid,
+            "subframe": subframe,
+        }
 
     def _process_rxm_sfrbx_irn(
-        self, gnss: str, svid: int, sigid: str, numw: int, data: UBXMessage
+        self, gnss: str, svid: int, sigcode: str, numw: int, data: UBXMessage
     ) -> dict[str, str | int | float | NoneType]:
         """
         Reassemble IRNSS (NAVIC) subframe from individual UBX RXM-SFRBX dwrds.
 
         :param str gnss: RINEX gnss code
         :param int svid: SV
-        :param str sigid: RINEX sigid
+        :param str sigcode: RINEX sigcode e.g. '5A'
         :param UBXMessage data: parsed UBX RXM-SFRBX message
         :return: dict of subframe attributes
         :rtype: dict[str, str | int | float | NoneType]
@@ -688,9 +749,26 @@ class RawNavReader:
         """
 
         subframe = 0
-        tow = 0
         subframeid = 0
         subframepageid = 0
-        sfrdata = {}
-        # TODO
-        return sfrdata
+
+        # for IRN L5A, subframe = 3 * 100 bits, final 20 bits of 320 bit dwrd is padding
+        # same as GPS CNAV
+        if sigcode in ("5A",):  # IRN L5A
+            for i in range(numw):
+                wrd = getattr(data, f"dwrd_{i+1:02d}")
+                subframe += wrd << (32 * (numw - 1 - i))
+            subframe = (
+                (subframe >> 20)
+                & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
+            )  # (2**300 - 1)
+            subframeid = (subframe >> 280) & 0b111111
+
+        return {
+            "gnss": gnss,
+            "svid": svid,
+            "sigcode": sigcode,
+            "subframeid": subframeid,
+            "subframepageid": subframepageid,
+            "subframe": subframe,
+        }