cssrlib 1.0.0__tar.gz → 1.1.0__tar.gz

{cssrlib-1.0.0/src/cssrlib.egg-info → cssrlib-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cssrlib
-Version: 1.0.0
+Version: 1.1.0
 Summary: Python Toolkit for PPP/PPP-RTK positioning
 Home-page: https://github.com/hirokawa/cssrlib
 Author: Rui Hirokawa
@@ -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 pysolid
-pip install notebook numpy matplotlib
-```
-
-Optionally, on linux, users can install the `cartopy` package and the `PySolid` package
-
-```
-pip install cartopy pysolid
+pip install -r requirements.txt
 ```
 
 If the installation of `cartopy` fails, try installing `libgeos++-dev` first.

{cssrlib-1.0.0 → cssrlib-1.1.0}/README.md

@@ -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 pysolid
-pip install notebook numpy matplotlib
-```
-
-Optionally, on linux, users can install the `cartopy` package and the `PySolid` package
-
-```
-pip install cartopy pysolid
+pip install -r requirements.txt
 ```
 
 If the installation of `cartopy` fails, try installing `libgeos++-dev` first.

{cssrlib-1.0.0 → cssrlib-1.1.0}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = cssrlib
-version = 1.0.0
+version = 1.1.0
 author = Rui Hirokawa
 author_email = rui.hirokawa@gmail.com
 description = Python Toolkit for PPP/PPP-RTK positioning

{cssrlib-1.0.0 → cssrlib-1.1.0}/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 = {
@@ -177,9 +179,16 @@ class cssr_bds(cssr):
         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
@@ -191,9 +200,9 @@ class cssr_bds(cssr):
             iodn = iodn & 0xff  # IODC -> IODE
 
         dorb = np.zeros(3)
-        dorb[0] = self.sval(dx, 15, self.dorb_scl[0])
-        dorb[1] = self.sval(dy, 13, self.dorb_scl[1])
-        dorb[2] = self.sval(dz, 13, self.dorb_scl[2])
+        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
@@ -220,7 +229,7 @@ class cssr_bds(cssr):
         self.iodssr_c[sCType.ORBIT] = head['iodssr']
         self.lc[inet].cstat |= (1 << sCType.ORBIT)
 
-        i += 19
+        i += 19  # reserve
         return i
 
     def decode_cssr_cbias(self, msg, i, inet=0):
@@ -248,10 +257,12 @@ class cssr_bds(cssr):
 
             self.lc[inet].cbias[sat] = {}
             for j in range(0, nsig):
-                sig, cb = bs.unpack_from('u4s12', msg, i)
-                i += 16
+                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, 12, self.cb_scl)
+                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)
@@ -260,8 +271,8 @@ class cssr_bds(cssr):
 
     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
+        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]:
@@ -269,7 +280,8 @@ class cssr_bds(cssr):
             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[sat] = -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):

{cssrlib-1.0.0 → cssrlib-1.1.0}/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.0 → cssrlib-1.1.0}/src/cssrlib/cssrlib.py

@@ -18,6 +18,10 @@ class sCSSRTYPE(IntEnum):
     IGS_SSR = 5
     RTCM3_SSR = 6
     PVS_PPP = 7      # PPP via SouthPAN
+    SBAS_L1 = 8      # L1 SBAS
+    SBAS_L5 = 9      # L5 SBAS (DFMC)
+    DGPS = 10        # DGPS (QZSS SLAS)
+    STDPOS = 11
 
 
 class sGNSS(IntEnum):
@@ -61,7 +65,7 @@ class sCType(IntEnum):
     TROP = 6
     URA = 7
     AUTH = 8
-    HCLOCK = 8
+    HCLOCK = 9
     VTEC = 10
     MAX = 11
 
@@ -206,11 +210,12 @@ class local_corr:
         self.inet = -1
         self.inet_ref = -1
         self.ng = -1
-        self.pbias = None
-        self.cbias = None
+        self.pbias = {}
+        self.cbias = {}
         self.iode = None
         self.dorb = None
         self.dclk = None
+        self.hclk = None
         self.stec = None
         self.trph = None
         self.trpw = None
@@ -218,10 +223,14 @@ class local_corr:
         self.ct = None
         self.quality_trp = None
         self.quality_stec = None
-        self.t0 = []
-        for _ in range(sCType.MAX):
-            self.t0.append(gtime_t())
+        self.sat_n = []
+        self.t0 = {}
         self.cstat = 0            # status for receiving CSSR message
+        self.t0s = {}
+        sc_t = [sCType.CLOCK, sCType.ORBIT, sCType.CBIAS, sCType.PBIAS,
+                sCType.HCLOCK]
+        for sc in sc_t:
+            self.t0s[sc] = gtime_t()
 
 
 class cssr:
@@ -272,7 +281,7 @@ class cssr:
         self.lc = []
         self.fcnt = -1
         self.flg_net = False
-        self.time = -1
+        self.time = gtime_t()
         self.nsig_max = 0
         self.ngrid = 0
         self.grid_index = []
@@ -440,9 +449,15 @@ class cssr:
         return False
 
     def set_t0(self, inet=0, sat=0, ctype=0, t=gtime_t()):
-        """ set reference time for correcion to check validity time """
+        """ set reference time for correction to check validity time """
+        sc_t = [sCType.CLOCK, sCType.ORBIT, sCType.CBIAS, sCType.PBIAS,
+                sCType.HCLOCK]
+
         if sat not in self.lc[inet].t0:
             self.lc[inet].t0[sat] = {}
+            for sc in sc_t:
+                self.lc[inet].t0[sat][sc] = gtime_t()
+
         self.lc[inet].t0[sat][ctype] = t
 
     def quality_idx(self, cl, val):
@@ -682,7 +697,6 @@ class cssr:
         self.lc[inet].cbias = {}
         for k in range(nsat):
             sat = self.sat_n[k]
-            sys, _ = sat2prn(sat)
             self.lc[inet].cbias[sat] = {}
             for j in range(len(self.sig_n[sat])):
                 rsig = self.sig_n[sat][j].toTyp(uTYP.C)
@@ -703,7 +717,6 @@ class cssr:
         self.lc[inet].di = {}
         for k in range(nsat):
             sat = self.sat_n[k]
-            sys, _ = sat2prn(sat)
             self.lc[inet].pbias[sat] = {}
             self.lc[inet].di[sat] = {}
             for j in range(len(self.sig_n[sat])):
@@ -904,8 +917,8 @@ class cssr:
     def decode_cssr_comb(self, msg, i, inet=0):
         """decode MT4073,11 Orbit,Clock Combined Correction message """
         head, i = self.decode_head(msg, i)
-        # if self.iodssr != head['iodssr']:
-        #    return -1
+        if self.iodssr != head['iodssr']:
+            return -1
         dfm = bs.unpack_from_dict('b1b1b1', ['orb', 'clk', 'net'], msg, i)
         i += 3
         self.flg_net = dfm['net']
@@ -1122,7 +1135,7 @@ class cssr:
 
         if self.subtype == sCSSR.CLOCK:
             self.fh.write(" {:s}\t{:s}\n".format("SatID", "dclk [m]"))
-            for k, sat_ in enumerate(self.lc[0].dclk.keys()):
+            for sat_ in self.lc[0].dclk.keys():
                 if np.isnan(self.lc[0].dclk[sat_]):
                     continue
                 self.fh.write(" {:s}\t{:8.4f}\n"
@@ -1133,7 +1146,7 @@ class cssr:
             self.fh.write(" {:s}\t{:s}\t{:s}\t{:s}\t{:s}\n"
                           .format("SatID", "IODE", "Radial[m]",
                                   "Along[m]", "Cross[m]"))
-            for k, sat_ in enumerate(self.lc[0].dorb.keys()):
+            for sat_ in self.lc[0].dorb.keys():
                 if np.isnan(self.lc[0].dorb[sat_][0]):
                     continue
                 self.fh.write(" {:s}\t{:3d}\t{:6.3f}\t{:6.3f}\t{:6.3f}\n"
@@ -1147,12 +1160,12 @@ class cssr:
             self.fh.write(" {:s}\t{:s}\t{:s}\t{:s}\t{:s}\t{:s}\n"
                           .format("SatID", "IODE", "Radial[m]",
                                   "Along[m]", "Cross[m]", "dclk[m]"))
-            for k, sat_ in enumerate(self.lc[0].dorb.keys()):
+            for sat_ in self.lc[0].dorb.keys():
                 if np.isnan(self.lc[0].dorb[sat_][0]) or \
                    np.isnan(self.lc[0].dclk[sat_]):
                     continue
                 self.fh.write(
-                    " {:s}\t{:3d}\t{:6.3f}\t{:6.3f}\t{:6.3f}\t{:6.3f}\n"
+                    " {:s}\t{:3d}\t{:6.3f}\t{:6.3f}\t{:6.3f}\t{:8.4f}\n"
                     .format(sat2id(sat_),
                             self.lc[0].iode[sat_],
                             self.lc[0].dorb[sat_][0],
@@ -1163,9 +1176,9 @@ class cssr:
         elif self.subtype == sCSSR.CBIAS:
             self.fh.write(" {:s}\t{:s}\t{:s}\t{:s}\n"
                           .format("SatID", "SigID", "Code Bias[m]", "..."))
-            for k, sat_ in enumerate(self.lc[0].cbias.keys()):
+            for sat_ in self.lc[0].cbias.keys():
                 self.fh.write(" {:s}\t".format(sat2id(sat_)))
-                for sig_ in range(self.lc[0].cbias[sat_].keys()):
+                for sig_ in self.lc[0].cbias[sat_].keys():
                     self.fh.write("{:s}\t{:5.2f}\t"
                                   .format(sig_.str(),
                                           self.lc[0].cbias[sat_][sig_]))
@@ -1174,9 +1187,9 @@ class cssr:
         elif self.subtype == sCSSR.PBIAS:
             self.fh.write(" {:s}\t{:s}\t{:s}\t{:s}\n"
                           .format("SatID", "SigID", "Phase Bias[m]", "..."))
-            for k, sat_ in enumerate(self.lc[0].pbias.keys()):
+            for sat_ in self.lc[0].pbias.keys():
                 self.fh.write(" {:s}\t".format(sat2id(sat_)))
-                for sig_ in range(self.lc[0].pbias[sat_].keys()):
+                for sig_ in self.lc[0].pbias[sat_].keys():
                     self.fh.write("{:s}\t{:5.2f}\t"
                                   .format(sig_.str(),
                                           self.lc[0].pbias[sat_][sig_]))

cssrlib-1.1.0/src/cssrlib/dgps.py

@@ -0,0 +1,289 @@
+"""
+DGPS (QZSS SLAS) correction data decoder
+
+[1] Quasi-Zenith Satellite System Interface Specification
+    Sub-meter Level Augmentation Service (IS-QZSS-L1S-006), 2023
+
+"""
+
+import numpy as np
+import bitstruct as bs
+from cssrlib.cssrlib import cssr, sCSSRTYPE, prn2sat, sCType
+from cssrlib.gnss import uGNSS, rCST, timediff, time2str, \
+    ecef2pos
+
+
+def vardgps(el, nav):
+    """ measurement error varianvce for DGPS [1] """
+    c_el = np.cos(el)
+    pos = ecef2pos(nav.x[0:3])
+    Fpp = 1/np.sqrt(1-(rCST.RE_WGS84*c_el/(rCST.RE_WGS84+pos[2]))**2)
+    s_iono = Fpp*0.004*(nav.baseline+2*100*0.07)
+    s_mp = 0.13+0.53*np.exp(-el/0.1745)
+    v_air = 0.11**2 + s_mp**2
+    v_pr = (0.16+0.107*np.exp(-el/0.271))**2/1+0.08**2
+    v_sig = v_pr + v_air + s_iono**2
+    return v_sig
+
+
+class dgpsDec(cssr):
+    MAX_ST = 64
+    MAX_SAT = 23
+
+    def __init__(self, foutname=None):
+        super().__init__(foutname)
+        self.MAXNET = 1
+        self.cssrmode = sCSSRTYPE.DGPS
+        self.nsig_max = 0
+        self.sat_n = []
+
+        self.sat = []
+
+        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/QZS LNAV, Galileo F/NAV
+        self.nav_mode = {uGNSS.GPS: 0, uGNSS.GAL: 1, uGNSS.QZS: 0,
+                         uGNSS.GLO: 0, uGNSS.BDS: 0}
+
+        self.iodp = -1
+        self.iodi = -1
+        self.iodm = -1
+        self.iodg = -1
+
+        self.iodssr = -1
+        self.iodp_c = {}
+
+        self.baselen = 0  # baseline length [km]
+
+        self.posr = np.zeros((self.MAX_ST, 3))
+        self.posr[0, :] = [43.150, 141.220,  50]
+        self.posr[1, :] = [38.270, 140.740, 200]
+        self.posr[3, :] = [36.580, 140.550, 150]
+        self.posr[5, :] = [36.400, 136.410,  50]
+        self.posr[6, :] = [34.710, 135.040, 200]
+        self.posr[7, :] = [34.350, 132.450,  50]
+        self.posr[8, :] = [33.600, 130.230,  50]
+        self.posr[9, :] = [30.550, 130.940, 100]
+        self.posr[10, :] = [28.420, 129.690,  50]
+        self.posr[11, :] = [26.150, 127.690, 100]
+        self.posr[12, :] = [24.730, 125.350, 100]
+        self.posr[13, :] = [24.370, 124.130, 100]
+        self.posr[14, :] = [27.090, 142.190, 100]
+
+        self.mlen = {uGNSS.GPS: 64, uGNSS.QZS: 9, uGNSS.GLO: 36, uGNSS.GAL: 36,
+                     uGNSS.BDS: 36}
+        self.prn_ofst = {uGNSS.GPS: 0, uGNSS.QZS: 192, uGNSS.GLO: 0,
+                         uGNSS.GAL: 0, uGNSS.BDS: 0}
+
+    def sval(self, u, n, scl):
+        """ calculate signed value based on n-bit int, lsb """
+        invalid = 2**(n-1)-1
+        y = np.nan if u == invalid else u*scl
+        return y
+
+    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_mt43(self, msg, i):
+        """ decode DC report by JMA (TBD) """
+        # i = self.dcr.decode_jma(msg)
+        return i
+
+    def decode_mt44(self, msg, i):
+        """ decode DC report by other organization (TBD) """
+        # i = self.dcr.decode_ews(msg)
+        return i
+
+    def decode_mt47(self, msg, i):
+        """ decode location of reference station """
+        i = 14
+        for k in range(5):
+            code, lat, lon, alt = bs.unpack_from('u6s15s15u6', msg, i)
+            if code == 63:
+                continue
+            self.posr[code, 0] = lat*0.005
+            self.posr[code, 1] = lon*0.005+115
+            self.posr[code, 2] = alt*50.0-100
+
+            i += 42
+        return 0
+
+    def decode_mt48(self, msg, i):
+        """ decode satellite mask """
+        self.iodssr_p = self.iodp
+        self.sat_n_p = self.sat_n
+
+        i = 14
+        self.nsat = 0
+        v = bs.unpack_from('u2u64u9u36u36u36', msg, i)
+
+        self.sat_n = []
+        self.iodp = v[0]
+        sys_t = [uGNSS.GPS, uGNSS.QZS, uGNSS.GLO, uGNSS.GAL, uGNSS.BDS]
+        for k, sys in enumerate(sys_t):
+            prn, nsat_s = self.decode_mask(v[k+1], self.mlen[sys])
+            for j in range(nsat_s):
+                self.sat_n.append(prn2sat(sys, prn[j]+self.prn_ofst[sys]))
+            self.nsat += nsat_s
+
+        self.iodssr = self.iodp
+
+        self.lc[0].cstat |= (1 << sCType.MASK)
+        self.set_t0(ctype=sCType.MASK, t=self.time)
+
+        self.sat = self.sat_n
+
+        return i
+
+    def decode_mt49(self, msg, i):
+        """ decode issue of data """
+        iodp = bs.unpack_from('u2', msg, 223)[0]
+        if iodp != self.iodp:
+            return -1
+        i = 14
+        iodi, mask = bs.unpack_from('u2u23', msg, i)
+        i += 25
+
+        self.iodn = {}
+
+        self.iodi = iodi  # issue of data
+        for k in range(23):
+            if (mask >> (23-k-1)) & 1 == 0 or k >= self.nsat:
+                continue
+            iodn = bs.unpack_from('u8', msg, i)[0]
+            i += 8
+
+            sat = self.sat[k]
+            self.iodn[sat] = iodn
+
+        return i
+
+    def decode_mt50(self, msg, i):
+        """ decode DGPS correction """
+        iodp, iodi, code, h, mask_s = bs.unpack_from('u2u2u6u1u23', msg, i)
+        i += 34
+        if iodp != self.iodp or iodi != self.iodi or h == 1:
+            return i
+
+        nsat = 0
+        inet = code+1
+
+        self.lc[inet].iode = {}
+        self.lc[inet].dclk = {}
+        self.lc[inet].dorb = {}
+        self.lc[inet].sat_n = []
+
+        for k in range(23):
+            if k >= self.nsat:
+                continue
+            sat = self.sat[k]
+            self.lc[inet].dorb[sat] = np.zeros(3)
+
+            if (mask_s >> (23-k-1)) & 1 == 0:
+                # self.lc[inet].iode[sat] = -1
+                # self.lc[inet].dclk[sat] = 0.0
+                continue
+
+            prc = bs.unpack_from('s12', msg, i)[0]*0.04
+            i += 12
+
+            self.lc[inet].sat_n.append(sat)
+            self.lc[inet].iode[sat] = self.iodn[sat]
+            self.lc[inet].dclk[sat] = prc
+
+            self.set_t0(ctype=sCType.CLOCK, sat=sat, inet=inet, t=self.time)
+            self.set_t0(ctype=sCType.ORBIT, sat=sat, inet=inet, t=self.time)
+
+            nsat += 1
+            if nsat > 14:
+                break
+
+        self.iodp_c[inet] = iodp
+
+        self.lc[0].cstat |= (1 << sCType.CLOCK)
+        self.lc[0].cstat |= (1 << sCType.ORBIT)
+
+        return i
+
+    def decode_mt51(self, msg, i):
+        """ decode satellite health """
+        v = bs.unpack_from('u64u9u36u36u36', msg, i)
+        i += 181
+        self.svh[uGNSS.GPS] = v[0]
+        self.svh[uGNSS.QZS] = v[1]
+        self.svh[uGNSS.GLO] = v[2]
+        self.svh[uGNSS.GAL] = v[3]
+        self.svh[uGNSS.BDS] = v[4]
+        return i
+
+    def decode_cssr(self, msg, i=0):
+        """ decode DGPS messages """
+
+        _, mt = bs.unpack_from('u8u6', msg, i)
+        i += 14
+
+        self.msgtype = mt
+
+        if mt == 43:  # DC report (JMA)
+            i = self.decode_mt43(msg, i)
+        elif mt == 44:  # DC report (other source)
+            i = self.decode_mt44(msg, i)
+        elif mt == 47:  #
+            i = self.decode_mt47(msg, i)
+        elif mt == 48:  #
+            i = self.decode_mt48(msg, i)
+        elif mt == 49:  #
+            i = self.decode_mt49(msg, i)
+        elif mt == 50:  #
+            i = self.decode_mt50(msg, i)
+        elif mt == 51:  #
+            i = self.decode_mt51(msg, i)
+        elif mt == 63:  # Null
+            None
+
+        if self.monlevel > 3:
+            self.fh.write("{:s} mt={:2d} \n".format(time2str(self.time), mt))
+
+    def get_station(self, r):
+        """ get the nearest referece station """
+        pos = ecef2pos(r)
+        c_lat = np.cos(pos[0])
+        idx = np.where(self.posr[:, 0]**2+self.posr[:, 1]**2 > 0)[0]
+        if len(idx) == 0:
+            return -1, -1
+        dpos = np.deg2rad(self.posr[idx, 0:2])-pos[0:2]
+        rng = np.sqrt(dpos[:, 0]**2+(dpos[:, 1]*c_lat)**2)*rCST.RE_WGS84
+        kmin = np.argmin(rng)
+        refid = idx[kmin]
+        return refid, rng[kmin]
+
+    def set_dgps_corr(self, rr):
+        """ get DGPS correction """
+        if self.iodp < 0 or self.iodi < 0:
+            return -1
+        refid, rmin = self.get_station(rr)
+        baselen = rmin*1e-3  # baseline length [km]
+        self.inet = refid+1
+        if len(self.lc[self.inet].sat_n) > 0:
+            self.sat_n = self.lc[self.inet].sat_n
+            self.iodssr_c[sCType.ORBIT] = self.iodp_c[self.inet]
+            self.iodssr_c[sCType.CLOCK] = self.iodp_c[self.inet]
+            self.lc[0].t0 = self.lc[self.inet].t0
+            self.lc[0].iode = self.lc[self.inet].iode
+            self.lc[0].dclk = self.lc[self.inet].dclk
+            self.lc[0].dorb = self.lc[self.inet].dorb
+        return baselen