gps_pvt 0.9.1 → 0.9.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a75bed6b9453e7fe5b435eb2c10bd82e7c736654b6d34461368b79274ee223e3
-  data.tar.gz: 55577769f09988ce63809f52b14a82bfa7fd958f68547f36263647b147559831
+  metadata.gz: 27cf7edda7d1df217cef7291fffdd3ab5837c8c09854dc8bb169b2bbe2880339
+  data.tar.gz: 2d818aa2d59114445a03417a5382fbc19994bca67cd62c48c9d5a86cbcb05dac
 SHA512:
-  metadata.gz: 01c350f1e321119d0b4693a9b96bc99003b92e37783cdc53f0779e02111ec880d2b26e30e1f1ccec81faaaca16d730b8e17a5d24eb9bacd2934fe0ffaf083284
-  data.tar.gz: 6cab5c290099b0dd7604940822c9399dc93d7656651fe4c38003202745c8b5f561c68cb452ece7c2d9b35740d7621b47e809341cec2228d3551e3238e2648c23
+  metadata.gz: f7f9a5ae7a47195eebf77d8c403cc6ec96596a9389b388aae1f8ec3f0d97c8086505e4c851c09db5aa2469a97b24325d8a644456fc602d931aa234dfaf7f4739
+  data.tar.gz: 191293262a0b1990292416be5c53f65699bd8d8e152534e3ca4b5dd155be665bc73fd6de94a72bcb18fd8f4e24185a612e8a1a6fdbf7899c65cb879923f59bc7

data/README.md

@@ -42,7 +42,7 @@ The format of file is automatically determined with its extension, such as .ubx
 | --sp3=file_or_URI | [Standard Product 3 Orbit Format](https://files.igs.org/pub/data/format/sp3c.txt) (supported gps_pvt version >= 0.6.0) |
 | --antex=file_or_URI | [Antenna Exchange Format](https://igs.org/wg/antenna#files) (supported gps_pvt version >= 0.6.0) |
 | --rinex_clk=file_or_URI | [RINEX clock](https://files.igs.org/pub/data/format/rinex_clock304.txt) file (supported gps_pvt version >= 0.7.0) |
-| <a name=opt_rtcm3>--rtcm3=file_or_URI</a> | [RTCM 10403.x](https://rtcm.myshopify.com/collections/differential-global-navigation-satellite-dgnss-standards), ephemeris and MSM7 are used. (supported gps_pvt version >= 0.9.0) |
+| <a name=opt_rtcm3>--rtcm3=file_or_URI</a> | [RTCM 10403.x](https://rtcm.myshopify.com/collections/differential-global-navigation-satellite-dgnss-standards). (supported gps_pvt version >= 0.9.0) The latest version uses message type Observation(GPS: 1002, 1004; GLONASS: 1010, 1012), Epehemris(GPS: 1019; GLOANSS: 1020; SBAS: 1043; QZSS: 1044), MSM(GPS: 1074..1077; GLONASS: 1084..1087; SBAS: 1104..1107; QZSS: 1114..1117) |
 
 Since version 0.2.0, SBAS and QZSS are supported in addition to GPS. Since version 0.4.0, GLONASS is also available. QZSS ranging is activated in default, however, SBAS is just utilized for ionospheric correction. GLONASS is also turned off by default. If you want to activate SBAS or GLONASS ranging, "--with=(system or PRN)" options are used with gps_pvt executable like
 

data/ext/gps_pvt/GPS/GPS_wrap.cxx

@@ -2406,6 +2406,10 @@ struct GLONASS_Ephemeris
   bool is_consistent() const {
     return has_string == 0x1F;
   }
+  bool is_in_range(const GPS_Time<FloatT> &t) const {
+    // "invalidate()" is used to make raw and converted data inconsistent.
+    return eph_t::is_valid(t);
+  }
   bool is_valid(const GPS_Time<FloatT> &t) const {
     return is_consistent() && eph_t::is_valid(t);
   }
@@ -4375,10 +4379,10 @@ SWIGINTERN double SBAS_Ephemeris_Sl_double_Sg__set_t_0(SBAS_Ephemeris< double >
 SWIGINTERN double const &SBAS_Ephemeris_Sl_double_Sg__get_t_0(SBAS_Ephemeris< double > const *self){
   return self->t_0;
 }
-SWIGINTERN int SBAS_Ephemeris_Sl_double_Sg__set_URA(SBAS_Ephemeris< double > *self,int const &v){
+SWIGINTERN double SBAS_Ephemeris_Sl_double_Sg__set_URA(SBAS_Ephemeris< double > *self,double const &v){
   return self->URA= v;
 }
-SWIGINTERN int const &SBAS_Ephemeris_Sl_double_Sg__get_URA(SBAS_Ephemeris< double > const *self){
+SWIGINTERN double const &SBAS_Ephemeris_Sl_double_Sg__get_URA(SBAS_Ephemeris< double > const *self){
   return self->URA;
 }
 SWIGINTERN double SBAS_Ephemeris_Sl_double_Sg__set_x(SBAS_Ephemeris< double > *self,double const &v){
@@ -4750,10 +4754,6 @@ SWIGINTERN GPS_Ephemeris< double >::constellation_res_t GLONASS_Ephemeris_Sl_dou
         pv.position, pv.velocity, self->clock_error(t_tx), self->clock_error_dot()};
     return res;
   }
-SWIGINTERN bool GLONASS_Ephemeris_Sl_double_Sg__is_in_range(GLONASS_Ephemeris< double > const *self,GPS_Time< double > const &t){
-    // "invalidate()" is used to make raw and converted data inconsistent.
-    return self->is_valid(t);
-  }
 SWIGINTERN void RINEX_Observation_Sl_double_Sg__read(char const *fname){
     std::fstream fin(fname, std::ios::in | std::ios::binary);
     struct reader_t : public RINEX_OBS_Reader<double> {
@@ -18732,7 +18732,7 @@ fail:
   Document-method: GPS_PVT::GPS::Ephemeris_SBAS.URA=
 
   call-seq:
-    URA=(int const & v) -> int
+    URA=(double const & v) -> double
 
 An instance method.
 
@@ -18740,13 +18740,13 @@ An instance method.
 SWIGINTERN VALUE
 _wrap_Ephemeris_SBAS_URAe___(int argc, VALUE *argv, VALUE self) {
   SBAS_Ephemeris< double > *arg1 = (SBAS_Ephemeris< double > *) 0 ;
-  int *arg2 = 0 ;
+  double *arg2 = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  int temp2 ;
-  int val2 ;
+  double temp2 ;
+  double val2 ;
   int ecode2 = 0 ;
-  int result;
+  double result;
   VALUE vresult = Qnil;
   
   if ((argc < 1) || (argc > 1)) {
@@ -18757,15 +18757,15 @@ _wrap_Ephemeris_SBAS_URAe___(int argc, VALUE *argv, VALUE self) {
     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SBAS_Ephemeris< double > *","set_URA", 1, self )); 
   }
   arg1 = reinterpret_cast< SBAS_Ephemeris< double > * >(argp1);
-  ecode2 = SWIG_AsVal_int(argv[0], &val2);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","set_URA", 2, argv[0] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","set_URA", 2, argv[0] ));
   } 
-  temp2 = static_cast< int >(val2);
+  temp2 = static_cast< double >(val2);
   arg2 = &temp2;
   {
     try {
-      result = (int)SBAS_Ephemeris_Sl_double_Sg__set_URA(arg1,(int const &)*arg2);
+      result = (double)SBAS_Ephemeris_Sl_double_Sg__set_URA(arg1,(double const &)*arg2);
     } catch (const native_exception &e) {
       e.regenerate();
       SWIG_fail;
@@ -18773,7 +18773,7 @@ _wrap_Ephemeris_SBAS_URAe___(int argc, VALUE *argv, VALUE self) {
       SWIG_exception_fail(SWIG_RuntimeError, e.what());
     }
   }
-  vresult = SWIG_From_int(static_cast< int >(result));
+  vresult = SWIG_From_double(static_cast< double >(result));
   return vresult;
 fail:
   return Qnil;
@@ -18784,7 +18784,7 @@ fail:
   Document-method: GPS_PVT::GPS::Ephemeris_SBAS.URA
 
   call-seq:
-    URA -> int const &
+    URA -> double const &
 
 An instance method.
 
@@ -18794,7 +18794,7 @@ _wrap_Ephemeris_SBAS_URA(int argc, VALUE *argv, VALUE self) {
   SBAS_Ephemeris< double > *arg1 = (SBAS_Ephemeris< double > *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  int *result = 0 ;
+  double *result = 0 ;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
@@ -18807,7 +18807,7 @@ _wrap_Ephemeris_SBAS_URA(int argc, VALUE *argv, VALUE self) {
   arg1 = reinterpret_cast< SBAS_Ephemeris< double > * >(argp1);
   {
     try {
-      result = (int *) &SBAS_Ephemeris_Sl_double_Sg__get_URA((SBAS_Ephemeris< double > const *)arg1);
+      result = (double *) &SBAS_Ephemeris_Sl_double_Sg__get_URA((SBAS_Ephemeris< double > const *)arg1);
     } catch (const native_exception &e) {
       e.regenerate();
       SWIG_fail;
@@ -18815,7 +18815,7 @@ _wrap_Ephemeris_SBAS_URA(int argc, VALUE *argv, VALUE self) {
       SWIG_exception_fail(SWIG_RuntimeError, e.what());
     }
   }
-  vresult = SWIG_From_int(static_cast< int >(*result));
+  vresult = SWIG_From_double(static_cast< double >(*result));
   return vresult;
 fail:
   return Qnil;
@@ -22603,6 +22603,59 @@ fail:
 }
 
 
+/*
+  Document-method: GPS_PVT::GPS::Ephemeris_GLONASS.in_range?
+
+  call-seq:
+    in_range?(Time t) -> bool
+
+An instance method.
+
+*/
+SWIGINTERN VALUE
+_wrap_Ephemeris_GLONASS_in_rangeq___(int argc, VALUE *argv, VALUE self) {
+  GLONASS_Ephemeris< double > *arg1 = (GLONASS_Ephemeris< double > *) 0 ;
+  GPS_Time< double > *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLONASS_EphemerisT_double_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GLONASS_Ephemeris< double > const *","is_in_range", 1, self )); 
+  }
+  arg1 = reinterpret_cast< GLONASS_Ephemeris< double > * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_GPS_TimeT_double_t,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "GPS_Time< double > const &","is_in_range", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Time< double > const &","is_in_range", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< GPS_Time< double > * >(argp2);
+  {
+    try {
+      result = (bool)((GLONASS_Ephemeris< double > const *)arg1)->is_in_range((GPS_Time< double > const &)*arg2);
+    } catch (const native_exception &e) {
+      e.regenerate();
+      SWIG_fail;
+    } catch (const std::exception& e) {
+      SWIG_exception_fail(SWIG_RuntimeError, e.what());
+    }
+  }
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
 /*
   Document-method: GPS_PVT::GPS::Ephemeris_GLONASS.valid?
 
@@ -26483,59 +26536,6 @@ fail:
 }
 
 
-/*
-  Document-method: GPS_PVT::GPS::Ephemeris_GLONASS.in_range?
-
-  call-seq:
-    in_range?(Time t) -> bool
-
-An instance method.
-
-*/
-SWIGINTERN VALUE
-_wrap_Ephemeris_GLONASS_in_rangeq___(int argc, VALUE *argv, VALUE self) {
-  GLONASS_Ephemeris< double > *arg1 = (GLONASS_Ephemeris< double > *) 0 ;
-  GPS_Time< double > *arg2 = 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  void *argp2 ;
-  int res2 = 0 ;
-  bool result;
-  VALUE vresult = Qnil;
-  
-  if ((argc < 1) || (argc > 1)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
-  }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GLONASS_EphemerisT_double_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GLONASS_Ephemeris< double > const *","is_in_range", 1, self )); 
-  }
-  arg1 = reinterpret_cast< GLONASS_Ephemeris< double > * >(argp1);
-  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_GPS_TimeT_double_t,  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "GPS_Time< double > const &","is_in_range", 2, argv[0] )); 
-  }
-  if (!argp2) {
-    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPS_Time< double > const &","is_in_range", 2, argv[0])); 
-  }
-  arg2 = reinterpret_cast< GPS_Time< double > * >(argp2);
-  {
-    try {
-      result = (bool)GLONASS_Ephemeris_Sl_double_Sg__is_in_range((GLONASS_Ephemeris< double > const *)arg1,(GPS_Time< double > const &)*arg2);
-    } catch (const native_exception &e) {
-      e.regenerate();
-      SWIG_fail;
-    } catch (const std::exception& e) {
-      SWIG_exception_fail(SWIG_RuntimeError, e.what());
-    }
-  }
-  vresult = SWIG_From_bool(static_cast< bool >(result));
-  return vresult;
-fail:
-  return Qnil;
-}
-
-
 SWIGINTERN void
 free_GLONASS_Ephemeris_Sl_double_Sg_(void *self) {
     GLONASS_Ephemeris< double > *arg1 = (GLONASS_Ephemeris< double > *)self;
@@ -28978,6 +28978,7 @@ SWIGEXPORT void Init_GPS(void) {
   rb_define_method(SwigClassEphemeris_GLONASS.klass, "raw", VALUEFUNC(_wrap_Ephemeris_GLONASS_raw_get), -1);
   rb_define_method(SwigClassEphemeris_GLONASS.klass, "invalidate", VALUEFUNC(_wrap_Ephemeris_GLONASS_invalidate), -1);
   rb_define_method(SwigClassEphemeris_GLONASS.klass, "consistent?", VALUEFUNC(_wrap_Ephemeris_GLONASS_consistentq___), -1);
+  rb_define_method(SwigClassEphemeris_GLONASS.klass, "in_range?", VALUEFUNC(_wrap_Ephemeris_GLONASS_in_rangeq___), -1);
   rb_define_method(SwigClassEphemeris_GLONASS.klass, "valid?", VALUEFUNC(_wrap_Ephemeris_GLONASS_validq___), -1);
   rb_define_method(SwigClassEphemeris_GLONASS.klass, "rehash", VALUEFUNC(_wrap_Ephemeris_GLONASS_rehash), -1);
   rb_define_method(SwigClassEphemeris_GLONASS.klass, "svid=", VALUEFUNC(_wrap_Ephemeris_GLONASS_svide___), -1);
@@ -29047,7 +29048,6 @@ SWIGEXPORT void Init_GPS(void) {
   rb_define_method(SwigClassEphemeris_GLONASS.klass, "parse", VALUEFUNC(_wrap_Ephemeris_GLONASS_parse), -1);
   rb_define_method(SwigClassEphemeris_GLONASS.klass, "dump", VALUEFUNC(_wrap_Ephemeris_GLONASS_dump), -1);
   rb_define_method(SwigClassEphemeris_GLONASS.klass, "constellation", VALUEFUNC(_wrap_Ephemeris_GLONASS_constellation), -1);
-  rb_define_method(SwigClassEphemeris_GLONASS.klass, "in_range?", VALUEFUNC(_wrap_Ephemeris_GLONASS_in_rangeq___), -1);
   SwigClassEphemeris_GLONASS.mark = 0;
   SwigClassEphemeris_GLONASS.destroy = (void (*)(void *)) free_GLONASS_Ephemeris_Sl_double_Sg_;
   SwigClassEphemeris_GLONASS.trackObjects = 0;

data/ext/ninja-scan-light/tool/swig/GPS.i

@@ -571,7 +571,7 @@ struct SBAS_Ephemeris : public SBAS_SpaceNode<FloatT>::SatelliteProperties::Ephe
           
   MAKE_ACCESSOR(WN, unsigned int);
   MAKE_ACCESSOR(t_0, FloatT);
-  MAKE_ACCESSOR(URA, int);
+  MAKE_ACCESSOR(URA, FloatT);
   MAKE_ACCESSOR(  x, FloatT); MAKE_ACCESSOR(  y, FloatT); MAKE_ACCESSOR(  z, FloatT);
   MAKE_ACCESSOR( dx, FloatT); MAKE_ACCESSOR( dy, FloatT); MAKE_ACCESSOR( dz, FloatT);
   MAKE_ACCESSOR(ddx, FloatT); MAKE_ACCESSOR(ddy, FloatT); MAKE_ACCESSOR(ddz, FloatT);
@@ -654,6 +654,10 @@ struct GLONASS_Ephemeris
   bool is_consistent() const {
     return has_string == 0x1F;
   }
+  bool is_in_range(const GPS_Time<FloatT> &t) const {
+    // "invalidate()" is used to make raw and converted data inconsistent.
+    return eph_t::is_valid(t);
+  }
   bool is_valid(const GPS_Time<FloatT> &t) const {
     return is_consistent() && eph_t::is_valid(t);
   }
@@ -800,10 +804,6 @@ struct GLONASS_Ephemeris
   %rename("valid?") is_valid;
   %rename("in_range?") is_in_range;
 #endif
-  bool is_in_range(const GPS_Time<FloatT> &t) const {
-    // "invalidate()" is used to make raw and converted data inconsistent.
-    return self->is_valid(t);
-  }
 }
 
 %extend GLONASS_SpaceNode {

data/lib/gps_pvt/receiver/rtcm3.rb

@@ -19,13 +19,88 @@ class Receiver
     end
     leap_sec = ref_time.leap_seconds
     after_run = b || proc{|pvt| puts pvt.to_s if pvt}
-    t_meas, meas = [nil, GPS::Measurement::new]
+    t_meas, meas = [nil, {}]
+    # meas := {msg_num => [[], ...]} due to duplicated observation such as 1074 and 1077
+    run_proc = proc{
+      meas_ = GPS::Measurement::new
+      meas.sort.each{|k, values| # larger msg_num entries have higher priority
+        values.each{|prn_k_v| meas_.add(*prn_k_v)}
+      }
+      after_run.call(run(meas_, t_meas), [meas_, ref_time = t_meas]) if t_meas
+      t_meas, meas = [nil, {}]
+    }
     dt_threshold = GPS::Time::Seconds_week / 2
+    tow2t = proc{|tow_sec|
+      dt = tow_sec - ref_time.seconds 
+      GPS::Time::new(ref_time.week + if dt <= -dt_threshold then; 1
+            elsif dt >= dt_threshold then; -1
+            else; 0; end, tow_sec)
+    }
+    utc2t = proc{|utc_tod|
+      if t_meas then
+        delta = (t_meas.seconds - utc_tod).to_i % (60 * 60 * 24)
+        leap_sec = (delta >= (60 * 60 * 12)) ? delta - (60 * 60 * 12) : delta
+        t_meas
+      else
+        ref_dow, ref_tod = ref_time.seconds.divmod(60 * 60 * 24)
+        tod = utc_tod + leap_sec
+        tod_delta = ref_tod - tod
+        if tod_delta > 12 * 60 * 60 then
+          ref_dow -= 1
+        elsif tod_delta < -12 * 60 * 60 then
+          ref_dow += 1
+        end
+        GPS::Time::new(ref_time.week, 0) + tod + 60 * 60 * 24 * ref_dow
+      end
+    }
 
     while packet = rtcm3.read_packet
       msg_num = packet.message_number
       parsed = packet.parse
+      t_meas2, meas2 = [nil, []] # per_packet
+      add_proc = proc{
+        t_meas ||= t_meas2
+        meas[msg_num] = meas2 unless meas2.empty?
+      }
       case msg_num
+      when 1001..1004
+        t_meas2 = tow2t.call(parsed[2][0]) # DF004
+        ranges = parsed.ranges
+        item_size = ranges[:sat].size
+        [:sat, :pseudo_range, :phase_range, :cn].collect{|k|
+          ranges[k] || ([nil] * item_size)
+        }.transpose.each{|svid, pr, cpr, cn|
+          case svid
+          when 1..32; # GPS
+          when 40..58; svid += 80 # SBAS
+          else; next
+          end
+          meas2 << [svid, :L1_PSEUDORANGE, pr] if pr
+          meas2 << [svid, :L1_CARRIER_PHASE, cpr / GPS::SpaceNode.L1_WaveLength] if cpr
+          meas2 << [svid, :L1_SIGNAL_STRENGTH_dBHz, cn] if cn
+        }
+      when 1009..1012
+        t_meas2 = utc2t.call(parsed[2][0] - 60 * 60 * 3) # DF034 UTC(SU)+3hr, time of day[sec]
+        ranges = parsed.ranges
+        item_size = ranges[:sat].size
+        [:sat, :freq_ch, :pseudo_range, :phase_range, :cn].collect{|k|
+          ranges[k] || ([nil] * item_size)
+        }.transpose.each{|svid, freq_ch, pr, cpr, cn|
+          case svid
+          when 1..24 # GLONASS
+            svid += 0x100
+            freq = GPS::SpaceNode_GLONASS::L1_frequency(freq_ch)
+            len = GPS::SpaceNode_GLONASS.light_speed / freq
+            meas2 << [svid, :L1_FREQUENCY, freq]
+            meas2 << [svid, :L1_CARRIER_PHASE, cpr / len] if cpr
+          when 40..58
+            svid += 80 # SBAS
+            meas2 << [svid, :L1_CARRIER_PHASE, cpr / GPS::SpaceNode.L1_WaveLength] if cpr
+          else; next
+          end
+          meas2 << [svid, :L1_PSEUDORANGE, pr] if pr
+          meas2 << [svid, :L1_SIGNAL_STRENGTH_dBHz, cn] if cn
+        }
       when 1019, 1044
         params = parsed.params
         if msg_num == 1044
@@ -55,55 +130,77 @@ class Receiver
         critical{
           @solver.glonass_space_node.register_ephemeris(eph.svid, eph)
         }
-      when 1077, 1087, 1097, 1117
+      when 1043
+        params = parsed.params
+        eph = GPS::Ephemeris_SBAS::new
+        tod_delta = params[:tod] - (ref_time.seconds % (24 * 60 * 60)) 
+        if tod_delta > (12 * 60 * 60) then
+          tod_delta -= (24 * 60 * 60)
+        elsif tod_delta < -(12 * 60 * 60) then
+          tod_delta += (24 * 60 * 60)
+        end
+        toe = ref_time + tod_delta
+        eph.WN, eph.t_0 = [:week, :seconds].collect{|k| toe.send(k)}
+        params.each{|k, v| eph.send("#{k}=".to_sym, v) unless [:iodn, :tod].include?(k)}
+        critical{
+          @solver.sbas_space_node.register_ephemeris(eph.svid, eph)
+        }
+      when 1071..1077, 1081..1087, 1101..1107, 1111..1117
         ranges = parsed.ranges
-        sig_list, svid_offset = case msg_num
-          when 1077 # GPS
-            t_meas ||= proc{ # update time of measurement
-              t_meas_sec = parsed[2][0] # DF004
-              dt = t_meas_sec - ref_time.seconds 
-              GPS::Time::new(ref_time.week + if dt <= -dt_threshold then; 1
-                  elsif dt >= dt_threshold then; -1
-                  else; 0; end, t_meas_sec)
-            }.call
+        glonass_freq = nil
+        case msg_num / 10 # check time of measurement
+        when 107, 110, 111 # GPS, SBAS, QZSS
+          t_meas2 = tow2t.call(parsed[2][0]) # DF004
+        when 108 # GLONASS
+          t_meas2 = utc2t.call(parsed[3][0] - 60 * 60 * 3) # DF034 UTC(SU)+3hr, time of day[sec]
+          glonass_freq = critical{
+            @solver.glonass_space_node.update_all_ephemeris(t_meas2)
+            Hash[*(ranges[:sat_sig].collect{|svid, sig| svid}.uniq.collect{|svid|
+              eph = @solver.glonass_space_node.ephemeris(svid)
+              next nil unless eph.in_range?(t_meas2)
+              [svid, {:L1 => eph.frequency_L1}]
+            }.compact.flatten(1))]
+          }
+        end
+        sig_list, svid_offset = case msg_num / 10
+          when 107 # GPS
             [{2 => [:L1, GPS::SpaceNode.L1_WaveLength],
                 15 => [:L2CM, GPS::SpaceNode.L2_WaveLength],
                 16 => [:L2CL, GPS::SpaceNode.L2_WaveLength]}, 0]
-          when 1087 # GLONASS
-            proc{
-              utc = parsed[3][0] - 60 * 60 * 3 # DF034 UTC(SU)+3hr
-              delta = (t_meas.seconds - utc).to_i % (60 * 60 * 24)
-              leap_sec = (delta >= (60 * 60 * 12)) ? delta - (60 * 60 * 12) : delta
-            }.call if t_meas
-            [{2 => [:L1, GPS::SpaceNode_GLONASS.light_speed / GPS::SpaceNode_GLONASS.L1_frequency_base]}, 0x100]
-          when 1117 # QZSS
+          when 108 # GLONASS
+            [{2 => [:L1, nil]}, 0x100]
+          when 110 # SBAS
+            [{2 => [:L1, GPS::SpaceNode.L1_WaveLength]}, 120]
+          when 111 # QZSS
             [{2 => [:L1, GPS::SpaceNode.L1_WaveLength],
                 15 => [:L2CM, GPS::SpaceNode.L2_WaveLength],
                 16 => [:L2CL, GPS::SpaceNode.L2_WaveLength]}, 192]
           else; [{}, 0]
         end
-        [:sat_sig, :pseudo_range, :phase_range, :phase_range_rate].collect{|k|
-          ranges[k]
-        }.transpose.each{|(svid, sig), pr, cpr, dr|
+        item_size = ranges[:sat_sig].size
+        [:sat_sig, :pseudo_range, :phase_range, :phase_range_rate, :cn].collect{|k|
+          ranges[k] || ([nil] * item_size)
+        }.transpose.each{|(svid, sig), pr, cpr, dr, cn|
           prefix, len = sig_list[sig]
           next unless prefix
-          if svid_offset > 0 then
-            @solver.glonass_space_node.update_all_ephemeris(t_meas)
-            eph = @solver.glonass_space_node.ephemeris(svid)
-          end
+          proc{
+            next unless freq = (glonass_freq[svid] || {})[prefix]
+            meas2 << [svid, "#{prefix}_FREQUENCY".to_sym, freq]
+            len = GPS::SpaceNode_GLONASS.light_speed / freq
+          }.call if glonass_freq
           svid += svid_offset
-          meas.add(svid, "#{prefix}_PSEUDORANGE".to_sym, pr) if pr
-          meas.add(svid, "#{prefix}_RANGE_RATE".to_sym, dr) if dr
-          meas.add(svid, "#{prefix}_CARRIER_PHASE".to_sym, cpr / len) if cpr
+          meas2 << [svid, "#{prefix}_PSEUDORANGE".to_sym, pr] if pr
+          meas2 << [svid, "#{prefix}_RANGE_RATE".to_sym, dr] if dr
+          meas2 << [svid, "#{prefix}_CARRIER_PHASE".to_sym, cpr / len] if cpr && len
+          meas2 << [svid, "#{prefix}_SIGNAL_STRENGTH_dBHz".to_sym, cn] if cn
         }
       else
         #p({msg_num => parsed})
       end
-      if (1070..1229).include?(msg_num) && 
-          (!parsed.more_data? rescue (packet.decode([1], 24 + 54)[0] == 0)) then
-        after_run.call(run(meas, t_meas), [meas, ref_time = t_meas]) if t_meas
-        t_meas, meas = [nil, GPS::Measurement::new]
-      end
+      
+      run_proc.call if t_meas && t_meas2 && ((t_meas - t_meas2).abs > 1E-3) # fallback for incorrect more_data flag
+      add_proc.call
+      run_proc.call if (1070..1229).include?(msg_num) && (!parsed.more_data?)
     end
   end
 end

data/lib/gps_pvt/rtcm3.rb

@@ -13,6 +13,7 @@ class RTCM3
   end
   module Packet
     def decode(bits_list, offset = nil)
+      # 24 is offset of header in transport layer
       Util::BitOp::extract(self, bits_list, offset || 24)
     end
     def message_number
@@ -56,15 +57,44 @@ class RTCM3
         2 => 12,
         3 => 12,
         4 => unum_gen.call(30, Rational(1, 1000)), # [sec]
+        5 => 1,
+        6 => 5,
+        7 => 1,
+        8 => 3,
         9 => 6,
+        10 => 1,
+        11 => invalidate.call(unum_gen.call(24, Rational(2, 100)), 0x800000), # [m]
+        12 => invalidate.call(num_gen.call(20, Rational(5, 10000)), 0x80000), # [m]
+        13 => 7,
+        14 => unum_gen.call(8, 299_792.458), # [m]
+        15 => invalidate.call(unum_gen.call(8, Rational(1, 4)), 0), # [db-Hz],
+        16 => 2,
+        17 => invalidate.call(num_gen.call(14, Rational(2, 100)), 0x2000), # [m]
+        18 => num_gen.call(20, Rational(5, 10000)), # [m]
+        19 => 7,
+        20 => invalidate.call(unum_gen.call(8, Rational(1, 4)), 0), # [db-Hz]
         21 => 6,
         22 => 1,
         23 => 1,
         24 => 1,
         25 => num_gen.call(38, Rational(1, 10000)), # [m]
         34 => unum_gen.call(27, Rational(1, 1000)), # [sec]
+        35 => 5,
+        36 => 1,
+        37 => 3,
         38 => 6,
-        40 => 5,
+        39 => 1,
+        40 => [5, proc{|v| v - 7}],
+        41 => invalidate.call(unum_gen.call(25, Rational(2, 100)), 0x1000000), # [m]
+        42 => invalidate.call(num_gen.call(20, Rational(5, 10000)), 0x80000), # [m]
+        43 => 7,
+        44 => unum_gen.call(7, 599_584.916), # [m]
+        45 => invalidate.call(unum_gen.call(8, Rational(1, 4)), 0), # [db-Hz],
+        46 => 2,
+        47 => invalidate.call(num_gen.call(14, Rational(2, 100)), 0x2000), # [m]
+        48 => invalidate.call(num_gen.call(20, Rational(5, 10000)), 0x80000), # [m]
+        49 => 7,
+        50 => invalidate.call(unum_gen.call(8, Rational(1, 4)), 0), # [db-Hz]
         71 => 8,
         76 => 10,
         77 => proc{
@@ -146,11 +176,15 @@ class RTCM3
         397 => invalidate.call(unum_gen.call(8, Rational(1, 1000)), 0xFF), # [sec]
         398 => unum_gen.call(10, Rational(1, 1000 << 10)), # [sec]
         399 => invalidate.call(num_gen.call(14), 0x2000), # [m/s]
+        400 => invalidate.call(num_gen.call(15, Rational(1, 1000 << 24)), 0x4000), # [sec],
+        401 => invalidate.call(num_gen.call(22, Rational(1, 1000 << 29)), 0x200000), # [sec],
+        402 => 4,
+        403 => invalidate.call(unum_gen.call(6), 0), # [dB-Hz],
         404 => invalidate.call(num_gen.call(15, Rational(1, 10000)), 0x4000), # [m/s]
         405 => invalidate.call(num_gen.call(20, Rational(1, 1000 << 29)), 0x80000), # [sec]
         406 => invalidate.call(num_gen.call(24, Rational(1, 1000 << 31)), 0x800000), # [sec]
         407 => 10,
-        408 => unum_gen.call(10, Rational(1, 1 << 4)), # [dB-Hz]
+        408 => invalidate.call(unum_gen.call(10, Rational(1, 1 << 4)), 0), # [dB-Hz]
         409 => 3,
         411 => 2,
         412 => 2,
@@ -171,6 +205,20 @@ class RTCM3
         src = (src.to_a rescue [src]).flatten
         (dst.to_a rescue ([dst] * src.size)).flatten.zip(src).each{|i, j| df[i] = df[j]}
       }
+      df.merge!({
+        :SBAS_prn => [6, proc{|v| v + 120}],
+        :SBAS_iodn => 8,
+        :SBAS_tod => num_gen.call(13, 1 << 4),
+        :SBAS_ura => df[77],
+        :SBAS_xy => num_gen.call(30, Rational(8, 100)),
+        :SBAS_z => num_gen.call(25, Rational(4, 10)),
+        :SBAS_dxy => num_gen.call(17, Rational(1, 1600)),
+        :SBAS_dz => num_gen.call(18, Rational(1, 250)),
+        :SBAS_ddxy => num_gen.call(10, Rational(1, 80000)),
+        :SBAS_ddz => num_gen.call(10, Rational(1, 16000)),
+        :SBAS_agf0 => num_gen.call(12, Rational(1, 1 << 31)),
+        :SBAS_agf1 => num_gen.call(8, Rational(1, 1 << 40)),
+      })
       df.define_singleton_method(:generate_prop){|idx_list|
         hash = Hash[*([:bits, :op].collect.with_index{|k, i|
           [k, idx_list.collect{|idx, *args|
@@ -180,21 +228,79 @@ class RTCM3
             [prop].flatten(1)[i]
           }]
         }.flatten(1))].merge({:df => idx_list})
-        hash[:bits_total] = hash[:bits].inject{|a, b| a + b}
+        hash[:bits_total] = hash[:bits].inject{|a, b| a + b} || 0
         hash
       }
       df
     }.call
     MessageType = Hash[*({
+      1001..1004 => (2..8).to_a,
       1005 => [2, 3, 21, 22, 23, 24, 141, 25, 142, [1, 1], 26, 364, 27],
+      1009..1012 => [2, 3, 34, 5, 35, 36, 37],
       1019 => [2, 9, (76..79).to_a, 71, (81..103).to_a, 137].flatten, # 488 bits @see Table 3.5-21
       1020 => [2, 38, 40, (104..136).to_a].flatten, # 360 bits @see Table 3.5-21
+      1043 => [2] + [:prn, :iodn, :tod, :ura, 
+          [:xy] * 2, :z, [:dxy] * 2, :dz, [:ddxy] * 2, :ddz,
+          :agf0, :agf1].flatten.collect{|k| "SBAS_#{k}".to_sym}, # @see BNC Ntrip client RTCM3Decorder.cpp
       1044 => [2, (429..457).to_a].flatten, # 485 bits
-      1077 => [2, 3, 4, 393, 409, [1, 7], 411, 412, 417, 418, 394, 395], # 169 bits @see Table 3.5-78
-      1087 => [2, 3, 416, 34, 393, 409, [1, 7], 411, 412, 417, 418, 394, 395], # 169 bits @see Table 3.5-93
-      1097 => [2, 3, 248, 393, 409, [1, 7], 411, 412, 417, 418, 394, 395], # 169 bits @see Table 3.5-98
-      1117 => [2, 3, 4, 393, 409, [1, 7], 411, 412, 417, 418, 394, 395], # 169 bits
-    }.collect{|mt, df_list| [mt, DataFrame.generate_prop(df_list)]}.flatten(1))]
+      1071..1077 => [2, 3, 4, 393, 409, [1, 7], 411, 412, 417, 418, 394, 395], # 169 bits @see Table 3.5-78
+      1081..1087 => [2, 3, 416, 34, 393, 409, [1, 7], 411, 412, 417, 418, 394, 395], # 169 bits @see Table 3.5-93
+      1091..1097 => [2, 3, 248, 393, 409, [1, 7], 411, 412, 417, 418, 394, 395], # 169 bits @see Table 3.5-98
+      1101..1107 => [2, 3, 4, 393, 409, [1, 7], 411, 412, 417, 418, 394, 395], # 169 bits
+      1111..1117 => [2, 3, 4, 393, 409, [1, 7], 411, 412, 417, 418, 394, 395], # 169 bits
+      1121..1127 => [2, 3, 4, 393, 409, [1, 7], 411, 412, 417, 418, 394, 395], # 169 bits
+    }.collect{|mt_list, df_list|
+      (mt_list.to_a rescue [mt_list]).collect{|mt|
+        [mt, DataFrame.generate_prop(df_list)]
+      }
+    }.flatten(2))]
+    module GPS_Observation
+      def ranges
+        res = {
+          :sat => select{|v, df| df == 9}.transpose[0],
+          :pseudo_range_rem => select{|v, df| df == 11}.transpose[0],
+        }
+        add_proc = proc{|k, df, base|
+          values = select{|v, df_| df_ == df}
+          next if values.empty?
+          res[k] = values.transpose[0]
+          res[k] = res[k].zip(res[base]).collect{|a, b| (a + b) rescue nil} if base
+        }
+        add_proc.call(:pseudo_range, 14, :pseudo_range_rem)
+        suffix = res[:pseudo_range] ? "" : "_rem"
+        base = "pseudo_range#{suffix}".to_sym
+        add_proc.call("phase_range#{suffix}".to_sym, 12, base)
+        add_proc.call(:cn, 15)
+        add_proc.call("pseudo_range_L2#{suffix}".to_sym, 17, base)
+        add_proc.call("phase_range_L2#{suffix}".to_sym, 18, base)
+        add_proc.call(:cn_L2, 20)
+        res
+      end
+    end
+    module GLONASS_Observation
+      def ranges
+        res = {
+          :sat => select{|v, df| df == 38}.transpose[0],
+          :freq_ch => select{|v, df| df == 40}.transpose[0],
+          :pseudo_range_rem => select{|v, df| df == 41}.transpose[0],
+        }
+        add_proc = proc{|k, df, base|
+          values = select{|v, df_| df_ == df}
+          next if values.empty?
+          res[k] = values.transpose[0]
+          res[k] = res[k].zip(res[base]).collect{|a, b| (a + b) rescue nil} if base
+        }
+        add_proc.call(:pseudo_range, 44, :pseudo_range_rem)
+        suffix = res[:pseudo_range] ? "" : "_rem"
+        base = "pseudo_range#{suffix}".to_sym
+        add_proc.call("phase_range#{suffix}".to_sym, 42, base)
+        add_proc.call(:cn, 45)
+        add_proc.call("pseudo_range_L2#{suffix}".to_sym, 47, base)
+        add_proc.call("phase_range_L2#{suffix}".to_sym, 48, base)
+        add_proc.call(:cn_L2, 50)
+        res
+      end
+    end
     module GPS_Ephemeris
       KEY2IDX = {:svid => 1, :WN => 2, :URA => 3, :dot_i0 => 5, :iode => 6, :t_oc => 7,
           :a_f2 => 8, :a_f1 => 9, :a_f0 => 10, :iodc => 11, :c_rs => 12, :delta_n => 13,
@@ -218,6 +324,17 @@ class RTCM3
         res
       end
     end
+    module SBAS_Ephemeris
+      KEY2IDX = {:svid => 1, :iodn => 2, :tod => 3, :URA => 4,
+          :x => 5, :y => 6, :z => 7,
+          :dx => 8, :dy => 9, :dz => 10,
+          :ddx => 11, :ddy => 12, :ddz => 13,
+          :a_Gf0 => 14, :a_Gf1 => 15}
+      def params
+        # TODO WN is required to provide
+        Hash[*(KEY2IDX.collect{|k, i| [k, self[i][0]]}.flatten(1))]
+      end
+    end
     module GLONASS_Ephemeris
       def params
         # TODO insufficient: :n => ?(String4); extra: :P3
@@ -259,30 +376,63 @@ class RTCM3
       def more_data?
         self.find{|v| v[1] == 393}[0] == 1
       end
+      def property
+        idx_sat = self.find_index{|v| v[1] == 394}
+        {
+          :sats => self[idx_sat][0],
+          :cells => self[idx_sat + 2][0], # DF396
+          :header_items => idx_sat + 3,
+        }
+      end
     end
-    module MSM7
+    module MSM
+      include MSM_Header
+      def ranges
+        {:sat_sig => property[:cells]} # expect to be overriden
+      end
       SPEED_OF_LIGHT = 299_792_458
+    end
+    module MSM4_6
+      include MSM
       def ranges
-        idx_sat = self.find_index{|v| v[1] == 394}
-        sats = self[idx_sat][0]
-        nsat = sats.size
-        cells = self[idx_sat + 2][0] # DF396
-        ncell = cells.size
-        offset = idx_sat + 3
+        sats, cells, offset = property.values_at(:sats, :cells, :header_items)
+        nsat, ncell = [sats.size, cells.size]
+        range_rough = self[offset, nsat] # DF397
+        range_rough2 = self[offset + (nsat * 1), nsat] # DF398
+        range_fine = self[offset + (nsat * 2), ncell] # DF400/405
+        phase_fine = self[offset + (nsat * 2) + (ncell * 1), ncell] # DF401/406
+        cn = self[offset + (nsat * 2) + (ncell * 4), ncell] # DF403/408
+        Hash[*([:sat_sig, :pseudo_range, :phase_range, :cn].zip(
+            [cells] + cells.collect.with_index{|(sat, sig), i|
+              i2 = sats.find_index(sat)
+              rough_ms = (range_rough2[i2][0] + range_rough[i2][0]) rescue nil
+              [(((range_fine[i][0] + rough_ms) * SPEED_OF_LIGHT) rescue nil),
+                  (((phase_fine[i][0] + rough_ms) * SPEED_OF_LIGHT) rescue nil),
+                  cn[i][0]]
+            }.transpose).flatten(1))]
+      end
+    end
+    module MSM5_7
+      include MSM
+      def ranges
+        sats, cells, offset = property.values_at(:sats, :cells, :header_items)
+        nsat, ncell = [sats.size, cells.size]
         range_rough = self[offset, nsat] # DF397
         range_rough2 = self[offset + (nsat * 2), nsat] # DF398
         delta_rough = self[offset + (nsat * 3), nsat] # DF399
-        range_fine = self[offset + (nsat * 4), ncell] # DF405
-        phase_fine = self[offset + (nsat * 4) + (ncell * 1), ncell] # DF406
+        range_fine = self[offset + (nsat * 4), ncell] # DF400/405
+        phase_fine = self[offset + (nsat * 4) + (ncell * 1), ncell] # DF401/406
+        cn = self[offset + (nsat * 4) + (ncell * 4), ncell] # DF403/408
         delta_fine = self[offset + (nsat * 4) + (ncell * 5), ncell] # DF404
-        Hash[*([:pseudo_range, :phase_range, :phase_range_rate, :sat_sig].zip(
-            cells.collect.with_index{|(sat, sig), i|
+        Hash[*([:sat_sig, :pseudo_range, :phase_range, :phase_range_rate, :cn].zip(
+            [cells] + cells.collect.with_index{|(sat, sig), i|
               i2 = sats.find_index(sat)
-            rough_ms = (range_rough2[i2][0] + range_rough[i2][0]) rescue nil
+              rough_ms = (range_rough2[i2][0] + range_rough[i2][0]) rescue nil
               [(((range_fine[i][0] + rough_ms) * SPEED_OF_LIGHT) rescue nil),
                   (((phase_fine[i][0] + rough_ms) * SPEED_OF_LIGHT) rescue nil),
-                  ((delta_fine[i][0] + delta_rough[i2][0]) rescue nil)]
-            }.transpose + [cells]).flatten(1))]
+                  ((delta_fine[i][0] + delta_rough[i2][0]) rescue nil),
+                  cn[i][0]]
+            }.transpose).flatten(1))]
       end
     end
     def parse
@@ -298,28 +448,65 @@ class RTCM3
       }
       add_proc.call(mt)
       case msg_num
+      when 1001..1004
+        nsat = values[4]
+        offset = 24 + mt[:bits_total]
+        add_proc.call(DataFrame.generate_prop(([{
+              1001 => (9..13).to_a,
+              1002 => (9..15).to_a,
+              1003 => (9..13).to_a + (16..19).to_a,
+              1004 => (9..20).to_a,
+            }[msg_num]] * nsat).flatten), offset)
+        attributes << GPS_Observation
+      when 1009..1012
+        nsat = values[4]
+        offset = 24 + mt[:bits_total]
+        add_proc.call(DataFrame.generate_prop(([{
+              1009 => (38..43).to_a,
+              1010 => (38..45).to_a,
+              1011 => (38..43).to_a + (46..49).to_a,
+              1012 => (38..50).to_a,
+            }[msg_num]] * nsat).flatten), offset)
+        attributes << GLONASS_Observation
       when 1019
         attributes << GPS_Ephemeris
       when 1020
         attributes << GLONASS_Ephemeris
+      when 1043
+        attributes << SBAS_Ephemeris
       when 1044
         attributes << QZSS_Ephemeris
-      when 1077, 1087, 1097, 1117
-        # 1077(GPS), 1087(GLONASS), 1097(GALILEO), 1117(QZSS)
-        attributes << MSM7
+      when 1071..1077, 1081..1087, 1091..1097, 1101..1107, 1111..1117, 1121..1127
+        # 107X(GPS), 108X(GLONASS), 109X(GALILEO), 110X(SBAS), 111X(QZSS), 112X(Beidou)
         nsat, nsig = [-2, -1].collect{|i| values[i].size}
         offset = 24 + mt[:bits_total]
         df396 = DataFrame.generate_prop([[396, values[-2], values[-1]]])
         add_proc.call(df396, offset)
         ncell = values[-1].size
         offset += df396[:bits_total]
-        msm7_sat = DataFrame.generate_prop(
-            ([[397, [:uint, 4], 398, 399]] * nsat).transpose.flatten(1))
-        add_proc.call(msm7_sat, offset)
-        offset += msm7_sat[:bits_total]
-        msm7_sig = DataFrame.generate_prop(
-            ([[405, 406, 407, 420, 408, 404]] * ncell).transpose.flatten(1))
-        add_proc.call(msm7_sig, offset)
+        msm_proc = proc{|sat_data, signal_data|
+          msm_sat = DataFrame.generate_prop(([sat_data] * nsat).transpose.flatten(1))
+          add_proc.call(msm_sat, offset)
+          offset += msm_sat[:bits_total]
+          msm_sig = DataFrame.generate_prop(([signal_data] * ncell).transpose.flatten(1))
+          add_proc.call(msm_sig, offset)
+        }
+        case msg_num % 10
+        when 4
+          attributes << MSM4_6
+          msm_proc.call([397, 398], [400, 401, 402, 420, 403])
+        when 5
+          attributes << MSM5_7
+          msm_proc.call([397, [:uint, 4], 398, 399], [400, 401, 402, 420, 403, 404])
+        when 6
+          attributes << MSM4_6
+          msm_proc.call([397, 398], [405, 406, 407, 420, 408])
+        when 7
+          attributes << MSM5_7
+          msm_proc.call([397, [:uint, 4], 398, 399], [405, 406, 407, 420, 408, 404])
+        else
+          attributes << MSM # for #range
+        end
       end
       attributes << MSM_Header if (1070..1229).include?(msg_num)
       res = values.zip(df_list)

data/lib/gps_pvt/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module GPS_PVT
-  VERSION = "0.9.1"
+  VERSION = "0.9.2"
   
   def GPS_PVT.version_compare(a, b)
     Gem::Version::new(a) <=> Gem::Version::new(b)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gps_pvt
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 0.9.2
 platform: ruby
 authors:
 - fenrir(M.Naruoka)
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-01-27 00:00:00.000000000 Z
+date: 2023-02-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubyserial