qzsl6tool 0.1.7__tar.gz

qzsl6tool-0.1.7/PKG-INFO

@@ -0,0 +1,133 @@
+Metadata-Version: 2.4
+Name: qzsl6tool
+Version: 0.1.7
+Summary: Command-line tools for reading and converting GNSS messages, including QZSS L6, RTCM, Galileo HAS, and BeiDou PPP-B2b data.
+Author-email: Satoshi Takahashi <git@s-taka.org>
+License-Expression: BSD-2-Clause
+Project-URL: Homepage, https://github.com/yoronneko/qzsl6tool
+Project-URL: Repository, https://github.com/yoronneko/qzsl6tool
+Project-URL: Documentation, https://github.com/yoronneko/qzsl6tool/tree/main/docs
+Project-URL: Release Notes, https://github.com/yoronneko/qzsl6tool/blob/main/release_note.md
+Project-URL: Bug Tracker, https://github.com/yoronneko/qzsl6tool/issues
+Keywords: GNSS,QZSS,RTCM,CLAS,MADOCA,Galileo HAS,BeiDou
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Science/Research
+Classifier: Natural Language :: English
+Classifier: Natural Language :: Japanese
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: license.txt
+Requires-Dist: bitstring
+Requires-Dist: galois
+Requires-Dist: numpy
+Dynamic: license-file
+
+# QZS L6 Tool: quasi-zenith satellite L6-band tool, ver.0.1.7
+
+![QZS L6 Tool](docs/img/qzsl6tool.png)
+
+[日本語](readme.md)
+
+## Summary
+
+- This set of tools displays GNSS (Global Navigation Satellite System) messages and extracts specific formatted data from the raw data of GNSS receivers, for example, RTCM format and Michibiki L6 format.
+- The suite consists of Python code that receives the messages via standard input, and the conversion results are sequentially outputted to the standard output. The use of standard error output is also possible as needed.
+- It is designed to be used in conjunction with tools such as ``nc`` of netcat, and ``str2str`` of [RTKLIB](https://github.com/tomojitakasu/RTKLIB).
+- Initially, it aimed to display the content of augmentation messages broadcasted by the quasi-zenith satellite Michibiki (QZS) in the L6 frequency band, including CLAS and MADO. However, it is now also capable of displaying Galileo HAS messages.
+- [Semantic versioning](https://packaging.python.org/en/latest/discussions/versioning/#choosing-a-versioning-scheme) has been applied since 2024-08-11.
+- [Release note](release_note.md)
+
+## Operating Environment
+
+- It is intended for use on the command line of Linux or macOS.
+- Python 3.8 or later is required. The ``bitstring`` module and the ``galois`` module are required.  
+``pip3 install bitstring galois``
+- With a Docker environment such as Docker Desktop, this tool can also be used on Windows, macOS, Linux, and Raspberry Pi OS inside a Linux container. The Docker image includes the Python runtime, ``nc``, and ``str2str`` from RTKLIB 2.4.3 b34.
+
+Installing from PyPI
+
+```bash
+python3 -m pip install qzsl6tool
+```
+
+Building a Docker image
+
+```bash
+docker build -t qzsl6tool .
+```
+
+Executing a docker image
+
+```bash
+docker run -it --rm qzsl6tool "cd /root/qzsl6tool/test; ./do_test.sh"
+docker run -it --rm qzsl6tool "qzsl6read.py < /root/qzsl6tool/sample/2022001A.l6"
+docker run -it --rm qzsl6tool "str2str -in ntrip://ntrip.rnav.info.hiroshima-cu.ac.jp:80/OEM7 2>/dev/null | rtcmread.py"
+docker run -it --rm -v .:/mnt qzsl6tool "qzsl6read.py < my_l6_data.l6"
+```
+
+When handling GNSS binary data on Windows, do not pass the binary stream through ``cmd.exe`` or PowerShell pipes. Keep input acquisition and the processing pipeline inside the container like above.
+
+Those who use Windows Git CLI, please execute ``git config --global core.autocrlf input`` before cloning this repository. This is to avoid CR inclusion in line ends of a Python code.
+
+## Satellite Signal Display
+
+| display | code |
+|:----:|:-------:|
+| RTCM |[rtcmread.py](docs/en/rtcmread.md) |
+| QZSS L6 |[qzsl6read.py](docs/en/qzsl6read.md) |
+| QZSS L1S | [qzsl1sread.py](docs/en/qzsl1sread.md) |
+| Galileo I/NAV | [galinavread.py](docs/en/galinavread.md) |
+| Galileo HAS |[gale6read.py](docs/en/gale6read.md) |
+|BeiDou PPP-B2b | [bdsb2read.py](docs/en/bdsb2read.md)|
+
+## GNSS Receiver Data Conversion
+
+| GNSS receiver | code | QZS L6 | QZS L1S | Galileo HAS | Galileo I/NAV | BeiDou B2b |
+|:----:|:---:| :-------:|:-----------:|:--------:|:---:|:---:|
+| Allystar HD9310 option C | [alstread.py](docs/en/alstread.md) |``-l`` option | | | | |
+| [Pocket SDR](https://github.com/tomojitakasu/PocketSDR) | [psdrread.py](docs/en/psdrread.md) | ``-l`` option | ``-l1s`` option | ``-e`` option | ``-i`` option| ``-b`` option|
+| NovAtel OEM729 | [novread.py](docs/en/novread.md) | | | ``-e`` option | | |
+| Septentrio mosaic-X5 | [septread.py](docs/en/septread.md) | | | ``-e`` option | | ``-b`` option|
+| Septentrio mosaic-CLAS | [septread.py](docs/en/septread.md) |``-l`` option | | | | |
+| u-blox ZED-F9P | [ubxread.py](docs/en/ubxread.md) | | ``-l1s`` option | | ``-i`` option| |
+
+## Time & Coordinate Conversion
+
+| conversion | code |
+|:--:|:--:|
+|GPS time, GST, BST &rarr; UTC time | [gps2utc.py](docs/en/gps2utc.md) |
+|UTC time &rarr; GPS time, GST, BST | [utc2gps.py](docs/en/utc2gps.md)|
+|LLH &rarr;  ECEF | [llh2ecef.py](docs/en/llh2ecef.md)|
+|ECEF &rarr;  LLH | [ecef2llh.py](docs/en/ecef2llh.md)|
+
+## Directory Structure
+
+```text
+├── docs/        (documentation directory)
+├── license.txt  (license description)
+├── python/      (code directory)
+├── readme-en.md (English document)
+├── readme.md    (this file, Japanese document)
+├── sample/      (sample data directory)
+└── test/        (directory to test the tools)
+```
+
+## License
+
+This project is licensed under the [BSD 2-clause license](https://opensource.org/licenses/BSD-2-Clause).
+
+Users are permitted to use this program for commercial and non-commercial purposes, with or without modification, but this copyright notice is required. The function rtk_crc24q() in ``librtcm.py`` utilizes the achievements of [RTKLIB](https://github.com/tomojitakasu/RTKLIB) ver.2.4.3b34.
+
+Copyright (c) 2022-2024 by Satoshi Takahashi  
+Copyright (c) 2007-2020 by Tomoji TAKASU

qzsl6tool-0.1.7/license.txt

@@ -0,0 +1,27 @@
+--------------------------------------------------------------------------------
+QZS L6 Tool: quasi-zenith satellite L6-band tool
+
+Released under The 2-Clause BSD License
+https://opensource.org/licenses/BSD-2-Clause
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer. Redistributions in binary form must
+reproduce the above copyright notice, this list of conditions and the following
+disclaimer in the documentation and/or other materials provided with the
+distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+--------------------------------------------------------------------------------

qzsl6tool-0.1.7/pyproject.toml

@@ -0,0 +1,97 @@
+[build-system]
+requires = ["setuptools>=77", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "qzsl6tool"
+version = "0.1.7"
+description = "Command-line tools for reading and converting GNSS messages, including QZSS L6, RTCM, Galileo HAS, and BeiDou PPP-B2b data."
+readme = "readme-en.md"
+requires-python = ">=3.8"
+license = "BSD-2-Clause"
+license-files = ["license.txt"]
+authors = [
+    { name = "Satoshi Takahashi", email = "git@s-taka.org" },
+]
+dependencies = [
+    "bitstring",
+    "galois",
+    "numpy",
+]
+keywords = [
+    "GNSS",
+    "QZSS",
+    "RTCM",
+    "CLAS",
+    "MADOCA",
+    "Galileo HAS",
+    "BeiDou",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Science/Research",
+    "Natural Language :: English",
+    "Natural Language :: Japanese",
+    "Operating System :: MacOS",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Scientific/Engineering",
+]
+
+[project.urls]
+Homepage = "https://github.com/yoronneko/qzsl6tool"
+Repository = "https://github.com/yoronneko/qzsl6tool"
+Documentation = "https://github.com/yoronneko/qzsl6tool/tree/main/docs"
+"Release Notes" = "https://github.com/yoronneko/qzsl6tool/blob/main/release_note.md"
+"Bug Tracker" = "https://github.com/yoronneko/qzsl6tool/issues"
+
+[tool.setuptools]
+py-modules = [
+    "alstread",
+    "bdsb2read",
+    "gale6read",
+    "galinavread",
+    "l6rtcm4050",
+    "libecef",
+    "libgnsstime",
+    "libnav",
+    "libqznma",
+    "libqzsl6tool",
+    "libssr",
+    "libtrace",
+    "novread",
+    "psdrread",
+    "qzsl1sread",
+    "qzsl6read",
+    "rtcmread",
+    "septread",
+    "ubxread",
+]
+script-files = [
+    "python/alstread.py",
+    "python/bdsb2read.py",
+    "python/ecef2llh.py",
+    "python/gale6read.py",
+    "python/galinavread.py",
+    "python/gps2utc.py",
+    "python/l6rtcm4050.py",
+    "python/llh2ecef.py",
+    "python/novread.py",
+    "python/psdrread.py",
+    "python/qzsl1sread.py",
+    "python/qzsl6read.py",
+    "python/rtcmread.py",
+    "python/septread.py",
+    "python/ubxread.py",
+    "python/utc2gps.py",
+]
+
+[tool.setuptools.package-dir]
+"" = "python"

qzsl6tool-0.1.7/python/alstread.py

@@ -0,0 +1,141 @@
+#! /usr/bin/env python3
+# -*- coding: utf-8 -*-
+#
+# alstread.py: Allystar HD9310 option C raw data read
+# A part of QZS L6 Tool, https://github.com/yoronneko/qzsl6tool
+#
+# Copyright (c) 2022-2026 Satoshi Takahashi, all rights reserved.
+#
+# Released under BSD 2-clause license.
+#
+# References:
+# [1] Justin Yang, QZSS L6 Enabled Multi-band Multi-GNSS Receiver
+#     https://docs.datagnss.com/rtk-board/firmware/L6/L6DE_tech_intro.pdf
+
+import argparse
+import os
+import sys
+from typing import TextIO
+
+sys.path.append(os.path.dirname(__file__))
+import libgnsstime
+import libqzsl6tool
+import libtrace
+
+class AllystarReceiver:
+    dict_snr  = {}   # SNR dictionary
+    dict_data = {}   # payload data dictionary
+    last_gpst = 0    # last received GPS time
+    l6        = b''  # L6 message
+
+    def __init__(self, trace: libtrace.Trace):
+        self.trace = trace
+
+    def read(self):  # ref. [1]
+        sync = bytes(4)
+        while True:
+            b = sys.stdin.buffer.read(1)
+            if not b:
+                return False
+            sync = sync[1:4] + b
+            if sync == b'\xf1\xd9\x02\x10':
+                break
+        l6   = sys.stdin.buffer.read(266)
+        csum = sys.stdin.buffer.read(2)
+        if not l6 or not csum:
+            return False
+        l6 = b'\x02\x10' + l6
+        len_l6    = int.from_bytes(l6[ 2: 4], 'little')
+        self.prn  = int.from_bytes(l6[ 4: 6], 'little') - 700
+        freqid    = int.from_bytes(l6[ 6: 7], 'little')
+        len_data  = int.from_bytes(l6[ 7: 8], 'little') - 2
+        self.gpsw = int.from_bytes(l6[ 8:10], 'big')
+        self.gpst = int.from_bytes(l6[10:14], 'big')
+        self.snr  = int.from_bytes(l6[14:15], 'big')
+        flag      = int.from_bytes(l6[15:16], 'big')
+        self.data = l6[16:268]
+        if self.last_gpst == 0:
+            self.last_gpst = self.gpst
+        self.err = ""
+        csum1, csum2 = libqzsl6tool.checksum(l6)
+        if csum[0] != csum1 or csum[1] != csum2: self.err += "CS "
+        if len_l6 != 264                       : self.err += "Payload "
+        if len_data !=  63                     : self.err += "Data "
+        if flag & 0x01                         : self.err += "RS "
+        if flag & 0x02                         : self.err += "Week "
+        if flag & 0x04                         : self.err += "TOW "
+        return True
+
+    def select_sat(self, s_prn: int) -> None:
+        ''' selects satellite and displays message '''
+        self.p_prn  = 0    # PRN    of satellite that has the strongest C/No
+        self.p_snr  = 0    # C/No   of satellite that has the strongest C/No
+        self.l6 = b''  # L6 msg of satellite that has the strongest C/No
+        disp_msg = ''
+        if self.last_gpst != self.gpst and len(self.dict_snr) != 0:
+            # A change in gpst means possible sats data correction is finished.
+            self.last_gpst = self.gpst
+            if s_prn:  # if specified satellite is used
+                self.p_prn = s_prn
+            else:      # otherwise, we use the satellite that has max C/No
+                self.p_prn = sorted(self.dict_snr.items(),
+                           key=lambda x: x[1], reverse=True)[0][0]
+            self.p_snr = self.dict_snr.get (self.p_prn, 0)
+            self.l6    = self.dict_data.get(self.p_prn, b'')
+            disp_msg  += f"---> prn {self.p_prn} (C/No {self.p_snr} dB)\n"
+            self.dict_snr.clear()
+            self.dict_data.clear()
+        # then, we add the current data to the dictionaries when no errors found
+        if not self.err:
+            self.dict_snr [self.prn] = self.snr
+            self.dict_data[self.prn] = self.data
+        disp_msg += \
+            self.trace.msg(0, f'{self.prn} ', fg='green') + \
+            self.trace.msg(0, libgnsstime.gps2utc(self.gpsw, self.gpst // 1000) , fg='yellow') + \
+            self.trace.msg(0, f' {self.snr}')
+        if self.err:
+            disp_msg += self.trace.msg(0, ' ' + self.err, fg='red')
+        self.trace.show(0, disp_msg)
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(
+        description=f'Allystar HD9310 message read, QZS L6 Tool ver.{libqzsl6tool.VERSION}')
+    parser_group = parser.add_mutually_exclusive_group()
+    parser.add_argument(
+        '-c', '--color', action='store_true',
+        help='apply ANSI color escape sequences even for non-terminal.')
+    parser_group.add_argument(
+        '-l', '--l6', action='store_true',
+        help='send QZS L6 messages to stdout (it also turns off Allystar and u-blox messages).')
+    parser.add_argument(
+        '-m', '--message', action='store_true',
+        help='show Allystar messages to stderr.')
+    parser.add_argument(
+        '-p', '--prn', type=int, default=0,
+        help='satellite PRN to be specified (0, 193-211).')
+    args = parser.parse_args()
+    fp_disp, fp_raw = sys.stdout, None
+    if args.l6:  # QZS L6 raw message output to stdout
+        fp_disp, fp_raw = None, sys.stdout
+    if args.message:  # Allystar message to stderr
+        fp_disp = sys.stderr
+    if (args.prn < 193 or 211 < args.prn) and args.prn != 0:
+        libtrace.warn("QZS L6 PRN is in range of 193-211 or 0")
+        args.prn = 0
+    trace = libtrace.Trace(fp_disp, 0, args.color)
+    rcv = AllystarReceiver(trace)
+    try:
+        while rcv.read():
+            rcv.select_sat(args.prn)
+            if rcv.l6 and fp_raw:
+                fp_raw.buffer.write(rcv.l6)
+                fp_raw.flush()
+    except (BrokenPipeError, IOError):
+        devnull = os.open(os.devnull, os.O_WRONLY)
+        os.dup2(devnull, sys.stdout.fileno())
+        sys.exit(1)
+    except KeyboardInterrupt:
+        libtrace.warn("User break - terminated")
+        sys.exit()
+
+# EOF