cssrlib 0.8.0__tar.gz → 1.0.1__tar.gz

{cssrlib-0.8.0/src/cssrlib.egg-info → cssrlib-1.0.1}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: cssrlib
-Version: 0.8.0
-Summary: Compact SSR Library for PPP/PPP-RTK
+Version: 1.0.1
+Summary: Python Toolkit for PPP/PPP-RTK positioning
 Home-page: https://github.com/hirokawa/cssrlib
 Author: Rui Hirokawa
 Author-email: rui.hirokawa@gmail.com
@@ -30,7 +30,7 @@ It supports the following open format:
 ************************************************
 Click this button for a quick demo in Google Colab
 
-<a target="_blank" href="https://colab.research.google.com/github/rtklibexplorer/cssrlib/blob/new_sig/tutorials/cssrlib.ipynb">
+<a target="_blank" href="https://colab.research.google.com/github/hirokawa/cssrlib/blob/main/tutorials/cssrlib.ipynb">
   <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/>
 </a>
 
@@ -38,17 +38,10 @@ Click this button for a quick demo in Google Colab
 
 Prerequisites
 =============
-Additional python packages are required as prerequisites and can be installed via the following commands
+Additional python packages are required as prerequisites and can be installed via the following command
 
 ```
-pip install bitstruct galois crccheck
-pip install notebook numpy matplotlib
-```
-
-Optionally, on linux, users can install the `cartopy` package
-
-```
-pip install cartopy
+pip install -r requirements.txt
 ```
 
 If the installation of `cartopy` fails, try installing `libgeos++-dev` first.
@@ -89,9 +82,14 @@ Run RTK sample.
  python test_rtk.py
 ```
 
-Other samples are also available in a separate repository [`cssrlib-data`](https://github.com/hirokawa/cssrlib-data) including :
+Other samples with dataset are also available in a separate repository [`cssrlib-data`](https://github.com/hirokawa/cssrlib-data) including :
+
+- Galileo-HAS PPP (SIS/IDD) processing example
+- BDS-PPP processing example
+- QZSS MADOCA-PPP processing example
+- QZSS CLAS PPP-RTK processing example
+- IGS (SP3+BIAS) PPP-AR processing example
+- (experimental) PPP via SouthPAN (PVS) processing example
+- Binary message parser for Septentrio receiver (Mosaic/PolaRX5)
 
-- Galileo-HAS decoder
-- BDS-PPP decoder
-- Jupyter-Notebook including samples for RTK/PPP-RTK.
 

{cssrlib-0.8.0 → cssrlib-1.0.1}/README.md

@@ -15,7 +15,7 @@ It supports the following open format:
 ************************************************
 Click this button for a quick demo in Google Colab
 
-<a target="_blank" href="https://colab.research.google.com/github/rtklibexplorer/cssrlib/blob/new_sig/tutorials/cssrlib.ipynb">
+<a target="_blank" href="https://colab.research.google.com/github/hirokawa/cssrlib/blob/main/tutorials/cssrlib.ipynb">
   <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/>
 </a>
 
@@ -23,17 +23,10 @@ Click this button for a quick demo in Google Colab
 
 Prerequisites
 =============
-Additional python packages are required as prerequisites and can be installed via the following commands
+Additional python packages are required as prerequisites and can be installed via the following command
 
 ```
-pip install bitstruct galois crccheck
-pip install notebook numpy matplotlib
-```
-
-Optionally, on linux, users can install the `cartopy` package
-
-```
-pip install cartopy
+pip install -r requirements.txt
 ```
 
 If the installation of `cartopy` fails, try installing `libgeos++-dev` first.
@@ -74,9 +67,14 @@ Run RTK sample.
  python test_rtk.py
 ```
 
-Other samples are also available in a separate repository [`cssrlib-data`](https://github.com/hirokawa/cssrlib-data) including :
+Other samples with dataset are also available in a separate repository [`cssrlib-data`](https://github.com/hirokawa/cssrlib-data) including :
+
+- Galileo-HAS PPP (SIS/IDD) processing example
+- BDS-PPP processing example
+- QZSS MADOCA-PPP processing example
+- QZSS CLAS PPP-RTK processing example
+- IGS (SP3+BIAS) PPP-AR processing example
+- (experimental) PPP via SouthPAN (PVS) processing example
+- Binary message parser for Septentrio receiver (Mosaic/PolaRX5)
 
-- Galileo-HAS decoder
-- BDS-PPP decoder
-- Jupyter-Notebook including samples for RTK/PPP-RTK.
 

{cssrlib-0.8.0 → cssrlib-1.0.1}/setup.cfg

@@ -1,9 +1,9 @@
 [metadata]
 name = cssrlib
-version = 0.8.0
+version = 1.0.1
 author = Rui Hirokawa
 author_email = rui.hirokawa@gmail.com
-description = Compact SSR Library for PPP/PPP-RTK
+description = Python Toolkit for PPP/PPP-RTK positioning
 long_description = file: README.md
 long_description_content_type = text/markdown
 url = https://github.com/hirokawa/cssrlib

{cssrlib-0.8.0 → cssrlib-1.0.1}/src/cssrlib/cssr_bds.py

@@ -19,6 +19,8 @@ class cssr_bds(cssr):
         self.nsig_max = 8
         self.iodp = -1
         self.iodp_p = -1
+        self.cb_blen = 12
+        self.cb_scl = 0.017
 
     def ssig2rsig(self, sys: sGNSS, utyp: uTYP, ssig):
         gps_tbl = {
@@ -156,47 +158,61 @@ class cssr_bds(cssr):
             self.add_gnss(mask_glo, 37, sGNSS.GLO)
 
             inet = 0
-            self.lc[inet].dclk = np.ones(self.nsat_n)*np.nan
-            self.lc[inet].dorb = np.ones((self.nsat_n, 3))*np.nan
-            self.lc[inet].iode = np.zeros(self.nsat_n, dtype=int)
-            self.lc[inet].iodc = np.zeros(self.nsat_n, dtype=int)
-            self.lc[inet].iodc_c = np.zeros(self.nsat_n, dtype=int)
-            self.lc[inet].cbias = np.ones((self.nsat_n, self.nsig_max))*np.nan
+            self.lc[inet].dclk = {}
+            self.lc[inet].dorb = {}
+            self.lc[inet].iode = {}
+            self.lc[inet].iodc = {}
+            self.lc[inet].iodc_c = {}
+            self.lc[inet].cbias = {}
             self.nsig_n = np.ones(self.nsat_n, dtype=int)*self.nsig_max
-            self.sig_n = -1*np.ones((self.nsat_n, self.nsig_max), dtype=int)
-            self.ura = np.zeros(self.nsat_n)
+            self.sig_n = {}
+            self.ura = {}
 
             # fallback for inconsistent clock update
-            self.lc[inet].dclk_p = np.ones(self.nsat_n)*np.nan
-            self.lc[inet].iodc_c_p = np.zeros(self.nsat_n, dtype=int)
+            self.lc[inet].dclk_p = {}
+            self.lc[inet].iodc_c_p = {}
 
         self.iodssr = head['iodssr']
 
         self.lc[0].cstat |= (1 << sCType.MASK)
-        self.lc[0].t0[sCType.MASK] = self.time
+        # self.lc[0].t0[0][sCType.MASK] = self.time
         return i
 
     def decode_cssr_orb_sat(self, msg, i, inet, sat_n):
-        slot, iodn, iodc, dx, dy, dz, ucls, uval = \
-            bs.unpack_from('u9u10u3s15s13s13u3u3', msg, i)
-        i += 69
+        slot, iodn, iodc = bs.unpack_from('u9u10u3', msg, i)
+        i += 22
+
+        dx, dy, dz = bs.unpack_from('s{:d}s{:d}s{:d}'.format(
+            self.dorb_blen[0], self.dorb_blen[1], self.dorb_blen[2]), msg, i)
+        i += self.dorb_blen[0] + self.dorb_blen[1] + self.dorb_blen[2]
+
+        ucls, uval = bs.unpack_from('u3u3', msg, i)
+        i += 6
+
         sys, prn = self.slot2prn(slot)
         if sys == uGNSS.NONE:
             return i
         sat = prn2sat(sys, prn)
         if sat not in sat_n:
             return i
-        idx = np.where(sat == sat_n)[0][0]
 
         if (sys == uGNSS.GPS) or (sys == uGNSS.BDS):
             iodn = iodn & 0xff  # IODC -> IODE
 
-        self.lc[inet].iode[idx] = iodn
-        self.lc[inet].iodc[idx] = iodc
-        self.lc[inet].dorb[idx, 0] = self.sval(dx, 15, self.dorb_scl[0])
-        self.lc[inet].dorb[idx, 1] = self.sval(dy, 13, self.dorb_scl[1])
-        self.lc[inet].dorb[idx, 2] = self.sval(dz, 13, self.dorb_scl[2])
-        self.ura[idx] = self.quality_idx(ucls, uval)
+        dorb = np.zeros(3)
+        dorb[0] = self.sval(dx, self.dorb_blen[0], self.dorb_scl[0])
+        dorb[1] = self.sval(dy, self.dorb_blen[1], self.dorb_scl[1])
+        dorb[2] = self.sval(dz, self.dorb_blen[2], self.dorb_scl[2])
+
+        self.lc[inet].iode[sat] = iodn
+        self.lc[inet].iodc[sat] = iodc
+        self.lc[inet].dorb[sat] = dorb
+        self.ura[sat] = self.quality_idx(ucls, uval)
+
+        if sat not in self.lc[inet].t0:
+            self.lc[inet].t0[sat] = {}
+
+        self.lc[inet].t0[sat][sCType.ORBIT] = self.time
         return i
 
     def decode_cssr_orb(self, msg, i, inet=0):
@@ -212,8 +228,8 @@ class cssr_bds(cssr):
 
         self.iodssr_c[sCType.ORBIT] = head['iodssr']
         self.lc[inet].cstat |= (1 << sCType.ORBIT)
-        self.lc[inet].t0[sCType.ORBIT] = self.time
-        i += 19
+
+        i += 19  # reserve
         return i
 
     def decode_cssr_cbias(self, msg, i, inet=0):
@@ -233,30 +249,39 @@ class cssr_bds(cssr):
             i += 13
             sys, prn = self.slot2prn(slot)
             sat = prn2sat(sys, prn)
-            idx = np.where(sat == sat_n)[0]
-            if len(idx) == 0:
+            if sat not in sat_n:
                 continue
+            if sat not in self.lc[inet].t0:
+                self.lc[inet].t0[sat] = {}
+            self.lc[inet].t0[sat][sCType.CBIAS] = self.time
+
+            self.lc[inet].cbias[sat] = {}
             for j in range(0, nsig):
-                sig, cb = bs.unpack_from('u4s12', msg, i)
-                i += 16
-                self.sig_n[idx, j] = sig
-                self.lc[inet].cbias[idx, j] = self.sval(cb, 12, self.cb_scl)
+                sig, cb = bs.unpack_from(
+                    'u4s{:d}'.format(self.cb_blen), msg, i)
+                i += 4+self.cb_blen
+                sig_ = self.ssig2rsig(sys, uTYP.C, sig)
+                self.lc[inet].cbias[sat][sig_] = self.sval(
+                    cb, self.cb_blen, self.cb_scl)
 
         self.iodssr_c[sCType.CBIAS] = head['iodssr']
         self.lc[inet].cstat |= (1 << sCType.CBIAS)
-        self.lc[inet].t0[sCType.CBIAS] = self.time
+
         return i
 
-    def decode_cssr_clk_sat(self, msg, i, inet, idx):
+    def decode_cssr_clk_sat(self, msg, i, inet, sat):
         """ decode clock correction for satellite """
-        iodc, dclk = bs.unpack_from('u3s15', msg, i)
-        i += 18
-        if iodc != self.lc[inet].iodc_c[idx]:
-            self.lc[inet].iodc_c_p[idx] = self.lc[inet].iodc_c[idx]
-            self.lc[inet].dclk_p[idx] = self.lc[inet].dclk[idx]
-        self.lc[inet].iodc_c[idx] = iodc
+        iodc, dclk = bs.unpack_from('u3s{:d}'.format(self.dclk_blen), msg, i)
+        i += 3+self.dclk_blen
+
+        if sat in self.lc[inet].iodc_c.keys() and \
+                iodc != self.lc[inet].iodc_c[sat]:
+            self.lc[inet].iodc_c_p[sat] = self.lc[inet].iodc_c[sat]
+            self.lc[inet].dclk_p[sat] = self.lc[inet].dclk[sat]
+        self.lc[inet].iodc_c[sat] = iodc
         # note: the sign of the clock correction reversed
-        self.lc[inet].dclk[idx] = -self.sval(dclk, 15, self.dclk_scl)
+        self.lc[inet].dclk[sat] = - \
+            self.sval(dclk, self.dclk_blen, self.dclk_scl)
         return i
 
     def decode_cssr_clk(self, msg, i, inet=0):
@@ -273,11 +298,15 @@ class cssr_bds(cssr):
         for k in range(23):
             idx = st1*23+k
             if idx < self.nsat_n:
-                i = self.decode_cssr_clk_sat(msg, i, inet, idx)
+                sat = self.sat_n[idx]
+                i = self.decode_cssr_clk_sat(msg, i, inet, sat)
+                if sat not in self.lc[inet].t0:
+                    self.lc[inet].t0[sat] = {}
+                self.lc[inet].t0[sat][sCType.CLOCK] = self.time
 
         self.iodssr_c[sCType.CLOCK] = head['iodssr']
         self.lc[inet].cstat |= (1 << sCType.CLOCK)
-        self.lc[inet].t0[sCType.CLOCK] = self.time
+
         i += 10
         return i
 
@@ -295,10 +324,11 @@ class cssr_bds(cssr):
             i += 6
             idx = st2*70+k
             if idx < self.nsat_n:
-                self.ura[idx] = self.quality_idx(v['class'], v['val'])
+                sat = self.sat_n[idx]
+                self.ura[sat] = self.quality_idx(v['class'], v['val'])
 
         self.lc[0].cstat |= (1 << sCType.URA)
-        self.lc[0].t0[sCType.URA] = self.time
+        # self.lc[0].t0[0][sCType.URA] = self.time
         return i
 
     def decode_cssr_comb1(self, msg, i, inet=0):
@@ -312,7 +342,8 @@ class cssr_bds(cssr):
             i += 36
             for k in range(numc):
                 idx = slot_s+k
-                i = self.decode_cssr_clk_sat(msg, i, inet, idx)
+                sat = self.sat_n[idx]
+                i = self.decode_cssr_clk_sat(msg, i, inet, sat)
 
         if numo > 0:
             tod, _, iodssr = bs.unpack_from('u17u4u2', msg, i)
@@ -335,8 +366,7 @@ class cssr_bds(cssr):
                 i += 9
                 sys, prn = self.slot2prn(slot)
                 sat = prn2sat(sys, prn)
-                idx = np.where(sat == sat_n)[0]
-                i = self.decode_cssr_clk_sat(msg, i, inet, idx)
+                i = self.decode_cssr_clk_sat(msg, i, inet, sat)
 
         if numo > 0:
             tod, _, iodssr = bs.unpack_from('u17u4u2', msg, i)

{cssrlib-0.8.0 → cssrlib-1.0.1}/src/cssrlib/cssr_has.py

@@ -75,13 +75,20 @@ class cssr_has(cssr):
         return head, i
 
     def decode_cssr(self, msg, i=0):
-        if self.msgtype != 1:  # only MT=1 defined
+        # Galileo HAS-SIS only defines MT=1, MT=4073 is CSSR message used in the
+        # Galileo HAS test dataset
+        #
+        if self.msgtype != 1 and self.msgtype != 4073:
             print(f"invalid MT={self.msgtype}")
             return False
         # time of hour
         # flags: mask,orbit,clock,clock subset,cbias,pbias,mask_id,iodset_id
-        self.toh, flags, res, mask_id, self.iodssr = \
-            bs.unpack_from('u12u6u4u5u5', msg, i)
+        try:
+            self.toh, flags, res, mask_id, self.iodssr = \
+                bs.unpack_from('u12u6u4u5u5', msg, i)
+        except:
+            print(f"invalid content={self.msgtype}")
+            return False
         i += 32
 
         if self.monlevel > 0 and self.fh is not None:

cssrlib-1.0.1/src/cssrlib/cssr_pvs.py

@@ -0,0 +1,176 @@
+"""
+PVS (PPP via SouthPAN) correction data decoder
+
+[1] Service Definition Document for Open Services, SBAS-STN-0001,
+    Revision 02, December 2022
+
+[2] Service Definition Document for Data Access Services, SBAS-STN-0002,
+    Revision 01, November 2023
+
+"""
+
+import numpy as np
+import bitstruct as bs
+from cssrlib.cssrlib import cssr, sCSSR, sCSSRTYPE, prn2sat, sCType
+from cssrlib.cssrlib import sat2id
+from cssrlib.gnss import uGNSS, rCST, gpst2time, timediff, timeadd, time2gpst
+from binascii import unhexlify
+
+
+def decode_sinca_line(line):
+    """ SINCA (SISNeT compression algorithm) decoder  """
+    if line[0:4] != '*MSG':
+        return None
+    v = line.split(',')
+    s = v[3]
+    week, tow = int(v[1]), int(v[2])
+    t = gpst2time(week, tow)
+    for key in '|/':
+        if key in s:
+            while True:
+                pos = s.find(key)
+                if pos < 0:
+                    break
+                c = s[pos-1]
+                k = 2 if key == '|' else 3
+                n = int(s[pos+1:pos+k], 16)
+                s = s.replace(s[pos-1:pos+k], c*n, 1)
+
+    sb = unhexlify(s.split('*')[0])
+    return t, sb
+
+
+class cssr_pvs(cssr):
+    def __init__(self, foutname=None):
+        super().__init__(foutname)
+        self.MAXNET = 1
+        self.cssrmode = sCSSRTYPE.PVS_PPP
+        self.nsig_max = 0
+        self.sat_n = []
+
+        self.lc[0].dclk = {}
+        self.lc[0].ddft = {}
+        self.lc[0].dorb = {}
+        self.lc[0].dvel = {}
+        self.lc[0].iode = {}
+        self.lc[0].t0 = {}
+
+        self.tmax = {sCType.CLOCK: 120.0, sCType.ORBIT: 120.0}
+
+        # GPS LNAV, Galileo F/NAV
+        self.nav_mode = {uGNSS.GPS: 0, uGNSS.GAL: 1}
+
+    def slot2sat(self, slot):
+        sat = 0
+        if slot >= 1 and slot <= 32:
+            prn = slot
+            sat = prn2sat(uGNSS.GPS, prn)
+        elif slot >= 38 and slot <= 69:
+            prn = slot-37
+            sat = prn2sat(uGNSS.GLO, prn)
+        elif slot >= 75 and slot <= 110:
+            prn = slot-74
+            sat = prn2sat(uGNSS.GAL, prn)
+        elif slot >= 120 and slot <= 158:
+            prn = slot
+            sat = prn2sat(uGNSS.SBS, prn)
+        elif slot >= 159 and slot <= 195:
+            prn = slot-158
+            sat = prn2sat(uGNSS.BDS, prn)
+        return sat
+
+    def adjust_time_week(self, time, time0):
+        dt = timediff(time, time0)
+        if dt > rCST.HALFWEEK_SEC:
+            time = timeadd(time, -rCST.WEEK_SEC)
+        elif dt < -rCST.HALFWEEK_SEC:
+            time = timeadd(time,  rCST.WEEK_SEC)
+        return time
+
+    def check_validity(self, time):
+        for sat in self.sat_n:
+            if timediff(time, self.lc[0].t0[sat][sCType.CLOCK]) > \
+                    self.tmax[sCType.CLOCK]:
+                self.lc[0].dclk[sat] = 0.0
+            if timediff(time, self.lc[0].t0[sat][sCType.ORBIT]) > \
+                    self.tmax[sCType.ORBIT]:
+                self.lc[0].iode[sat] = -1
+                self.lc[0].dorb[sat] = np.zeros(3)
+
+    def decode_cssr_orb(self, msg, i, inet=0):
+        """ Types 32 clock-ephemeris correction and covariance matrix """
+        slot, iodn = bs.unpack_from('u8u10', msg, i)
+        i += 18
+        dx, dy, dz, db = bs.unpack_from('s11s11s11s12', msg, i)
+        i += 45
+        dxd, dyd, dzd, dbd, t0 = bs.unpack_from('s8s8s8s9u13', msg, i)
+        i += 46
+
+        # i, C = self.decode_cov(msg, i)
+        i += 99
+        # dfrei, dRcorr = bs.unpack_from('u4u4', msg, i)
+        i += 8
+
+        sat = self.slot2sat(slot)
+
+        if sat == 0 or t0 % 2 == 0:  # for DFMC SBAS only
+            return
+
+        if sat not in self.sat_n:
+            self.sat_n.append(sat)
+
+        dorb = np.zeros(3)
+        dvel = np.zeros(3)
+
+        dorb[0] = dx*0.0625
+        dorb[1] = dy*0.0625
+        dorb[2] = dz*0.0625
+
+        dclk = db*0.03125
+
+        dvel[0] = dxd*0.00048828
+        dvel[1] = dyd*0.00048828
+        dvel[2] = dzd*0.00048828
+
+        ddft = dbd*0.00024414
+
+        tow = self.tow0 + t0*16.0
+        self.time = self.adjust_time_week(
+            gpst2time(self.week, tow), self.time0)
+
+        self.lc[0].iode[sat] = iodn
+        self.lc[0].dorb[sat] = -dorb
+        self.lc[0].dclk[sat] = dclk
+        self.lc[0].dvel[sat] = -dvel
+        self.lc[0].ddft[sat] = ddft
+
+        self.iodssr = 0
+        self.lc[0].cstat |= (1 << sCType.CLOCK) | (1 << sCType.ORBIT)
+        self.lc[0].t0[sat] = {
+            sCType.CLOCK: self.time0, sCType.ORBIT: self.time0}
+
+        self.iodssr_c[sCType.CLOCK] = self.iodssr
+        self.iodssr_c[sCType.ORBIT] = self.iodssr
+
+        if self.monlevel > 0:
+            self.fh.write("{:.1f} {:3s} {:3d}\n"
+                          .format(tow, sat2id(sat), iodn))
+
+        return i
+
+    def decode_cssr(self, msg, i=0):
+
+        _, mt = bs.unpack_from('u4u6', msg, i)
+        i += 10
+
+        if mt == 32:
+            self.subtype = sCSSR.ORBIT
+            i = self.decode_cssr_orb(msg, i)
+
+        if self.monlevel > 3:
+            if self.time != -1:
+                _, tow = time2gpst(self.time)
+            else:
+                tow = -1
+            self.fh.write("mt={:2d} tow={:6.1f}\n"
+                          .format(mt, tow))