gps_pvt 0.8.1 → 0.8.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fb3abd803cfe1b0b5199c4187fe17c2595eb603ab27e09f71b66fde11eeafce0
-  data.tar.gz: 351d46d74583346750aec426c087c33bc13f9e9e9adff746567e40df7eb1e39e
+  metadata.gz: b87c77fbb3844eb0fd835ef079b8a379708a6fe24e3de4ceeb6934206573f489
+  data.tar.gz: a280c1aa82bed41319e13069907940a062a073a0b01c95eefa3d3d8c1b32c517
 SHA512:
-  metadata.gz: 0fb78d49675fbbcb3fcfeb80debd7ca15f351be478ed5716f94a61b23f26af7ff957ee446a5ab6c4cc2e67abf2f251cf62845a347ea3810282987da04fa9a2e8
-  data.tar.gz: ac74ba61920cad427d6e848f4621227d150bfe9a30a2f1465bd6d87681cfdd935e20e8e141575306b87c770b485f8dad1555766b7281980ba1f412adddff4e7c
+  metadata.gz: 761d7e99868e04d93adb48fac0345ff71467068657c544efe857ed4f6206ed8d11698871ad7dc73c232f4bd51094cf13c6752d96fc17307caccb4a2eab8dbe03
+  data.tar.gz: fd70c1d59dbf3885e7a2286726a9c16e0cfbec3097a105bbffde59e3a65ee22eb09f1d0b4032b371faf2d1695b074b0752f37763ef6b5716dd4214fed4566755

data/exe/to_ubx

@@ -74,6 +74,17 @@ proc{|src|
   rcv.attach_online_ephemeris(src) if src
 }.call(misc_options[:online_ephemeris])
 
+proc{
+  cache = nil
+  rcv.define_singleton_method(:leap_seconds){|t_meas|
+    cache ||= if self.solver.gps_space_node.is_valid_utc then
+      self.solver.gps_space_node.iono_utc.delta_t_LS
+    else
+      t_meas.leap_seconds
+    end
+  }
+}.call
+
 # parse RINEX NAV
 files.each{|fname, ftype|
   case ftype
@@ -236,13 +247,14 @@ gen_rawx = proc{|t_meas, meas| # Convert to RXM-RAWX(0x15)
   ubx = [0xB5, 0x62, 0x02, 0x15, 0, 0]
   ubx += [t_meas.seconds, t_meas.week].pack("Ev").unpack("C*")
   ubx += [0] * 6
-  meas_ubx = meas.collect{|sat, items|
+  gen_packet = proc{|sys, svid, sig, items|
     res = [0] * 32
     setter = proc{|value, offset, len, str, pre_proc|
       array = case value
       when Array; value
       when Symbol
-        [items[GPS_PVT::GPS::Measurement.const_get(value)]]
+        k = [sig, value].join('_').to_sym
+        [items[GPS_PVT::GPS::Measurement.const_get(k)]]
       else
         next nil
       end
@@ -251,50 +263,73 @@ gen_rawx = proc{|t_meas, meas| # Convert to RXM-RAWX(0x15)
       array = array.pack(str).unpack("C*") if str
       res[offset - 16, len] = array
     }
-    sys, svid = case sat
-    when 1..32 # GPS
-      [0, sat]
-    when 120..158 # SBAS
-      [1, sat]
-    when 193..202 # QZSS
-      [5, sat]
-    when (0x100 + 1)..(0x100 + 32) # GLONASS
-      setter.call(:L1_FREQUENCY,
-          39, 1, nil, proc{|v| v.replace([(v[0] ? glonass_freq_ch.call(v[0]) : 0) + 7])} )
-      [6, sat - 0x100]
-    else
-      next nil # TODO Galileo, Beidou, ...
-    end
-    setter.call([sys, svid], 36, 2)
     
+    setter.call([sys, svid], 36, 2)
+
     trk_stat = 0
-    setter.call(:L1_PSEUDORANGE,
+    setter.call(:PSEUDORANGE,
         16, 8, "E", proc{|v| v[0] ? (trk_stat |= 0x1) : v.clear})
-    setter.call(:L1_PSEUDORANGE_SIGMA,
+    setter.call(:PSEUDORANGE_SIGMA,
         43, 1, nil, proc{|v|
           b = (Math::log2(v[0] / 1E-2).to_i & 0xF) rescue 0x8
           v.replace((trk_stat & 0x1 == 0x1) ? [b] : [])
         })
-    setter.call(:L1_DOPPLER, 32, 4, "e") rescue next nil
-    setter.call(:L1_DOPPLER_SIGMA,
+    setter.call(:DOPPLER, 32, 4, "e") rescue next nil
+    setter.call(:DOPPLER_SIGMA,
         45, 1, nil, proc{|v| v.replace(v[0] ? [Math::log2(v[0] / 2E-3).to_i & 0xF] : [0x8])})
-    setter.call(:L1_CARRIER_PHASE,
+    setter.call(:CARRIER_PHASE,
         24, 8, "E", proc{|v| v[0] ? (trk_stat |= 0x2) : v.clear})
-    setter.call(:L1_CARRIER_PHASE_SIGMA,
+    setter.call(:CARRIER_PHASE_SIGMA,
         44, 1, nil, proc{|v|
           b = ((v[0] / 0.004).to_i & 0xF) rescue 0x8
           v.replace((trk_stat & 0x2 == 0x2) ? [b] : [])
         })
-    setter.call(:L1_SIGNAL_STRENGTH_dBHz,
+    setter.call(:SIGNAL_STRENGTH_dBHz,
         42, 1, nil, proc{|v| v.replace(v[0] ? [v[0].to_i] : [])})
-    setter.call(:L1_LOCK_SEC,
+    setter.call(:LOCK_SEC,
         40, 2, "v", proc{|v| v.replace(v[0] ? [(v[0] / 1E-3).to_i] : [])})
     setter.call([trk_stat], 46, 1)
+    res.define_singleton_method(:set, &setter)
 
     res
+  }
+  meas_ubx = meas.inject([]){|packets, (sat, items)|
+    case sat
+    when 1..32 # GPS
+      packets << gen_packet.call(0, sat, :L1, items)
+      packets += {:L2CL => 3, :L2CM => 4}.collect{|sig, sigid|
+        next nil unless packet = gen_packet.call(0, sat, sig, items)
+        packet[38 - 16] = sigid
+        packet
+      }
+    when 120..158 # SBAS
+      packets << gen_packet.call(1, sat, :L1, items)
+    when 193..202 # QZSS
+      packets << gen_packet.call(5, sat, :L1, items)
+      packets += {:L2CL => 5, :L2CM => 4}.collect{|sig, sigid|
+        next nil unless packet = gen_packet.call(5, sat, sig, items)
+        packet[38 - 16] = sigid
+        packet
+      }
+    when (0x100 + 1)..(0x100 + 32) # GLONASS
+      packet = gen_packet.call(6, sat - 0x100, :L1, items)
+      packet.set(:FREQUENCY,
+          39, 1, nil,
+          proc{|v| v.replace([(v[0] ? glonass_freq_ch.call(v[0]) : 0) + 7])} ) if packet
+      packets << packet
+    else
+      # TODO Galileo, Beidou, ...
+    end
   }.compact
+  
+  proc{|ls| # leap seconds
+    next unless ls
+    ubx[6 + 10] = ls
+    ubx[6 + 12] |= 0x01
+  }.call(rcv.leap_seconds(t_meas))
   ubx[6 + 11] = meas_ubx.size
-  ubx += meas_ubx.flatten(1)
+  ubx[6 + 13] = 1 # version
+  ubx += meas_ubx.flatten
   ubx += [0, 0]
   GPS_PVT::UBX::update(ubx).pack("C*")
 }

data/ext/gps_pvt/GPS/GPS_wrap.cxx

@@ -1862,61 +1862,60 @@ int SWIG_Ruby_arity( VALUE proc, int minimal )
 #define SWIGTYPE_p_GPS_SolverOptionsT_double_t swig_types[12]
 #define SWIGTYPE_p_GPS_SolverOptions_CommonT_double_t swig_types[13]
 #define SWIGTYPE_p_GPS_SolverT_double_t swig_types[14]
-#define SWIGTYPE_p_GPS_Solver_GeneralOptionsT_double_t swig_types[15]
-#define SWIGTYPE_p_GPS_SpaceNodeT_double_t swig_types[16]
-#define SWIGTYPE_p_GPS_SpaceNodeT_double_t__Ionospheric_UTC_Parameters swig_types[17]
-#define SWIGTYPE_p_GPS_SpaceNodeT_double_t__SatelliteProperties__Ephemeris swig_types[18]
-#define SWIGTYPE_p_GPS_TimeT_double_t swig_types[19]
-#define SWIGTYPE_p_GPS_TimeT_double_t__leap_second_event_t swig_types[20]
-#define SWIGTYPE_p_GPS_TimeT_double_t__leap_year_prop_res_t swig_types[21]
-#define SWIGTYPE_p_GPS_User_PVTT_double_t swig_types[22]
-#define SWIGTYPE_p_MatrixT_ComplexT_double_t_Array2D_DenseT_ComplexT_double_t_t_MatrixViewBaseT_t_t swig_types[23]
-#define SWIGTYPE_p_MatrixT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t swig_types[24]
-#define SWIGTYPE_p_MatrixViewBaseT_t swig_types[25]
-#define SWIGTYPE_p_MatrixViewFilterT_MatrixViewBaseT_t_t swig_types[26]
-#define SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t swig_types[27]
-#define SWIGTYPE_p_PushableData swig_types[28]
-#define SWIGTYPE_p_RINEX_ClockT_double_t swig_types[29]
-#define SWIGTYPE_p_RINEX_ObservationT_double_t swig_types[30]
-#define SWIGTYPE_p_SBAS_EphemerisT_double_t swig_types[31]
-#define SWIGTYPE_p_SBAS_SolverOptionsT_double_t swig_types[32]
-#define SWIGTYPE_p_SBAS_SpaceNodeT_double_t swig_types[33]
-#define SWIGTYPE_p_SBAS_SpaceNodeT_double_t__SatelliteProperties__Ephemeris swig_types[34]
-#define SWIGTYPE_p_SP3T_double_t swig_types[35]
-#define SWIGTYPE_p_System_ENUT_double_WGS84_t swig_types[36]
-#define SWIGTYPE_p_System_LLHT_double_WGS84_t swig_types[37]
-#define SWIGTYPE_p_System_XYZT_double_WGS84_t swig_types[38]
-#define SWIGTYPE_p_available_satellites_t swig_types[39]
-#define SWIGTYPE_p_char swig_types[40]
-#define SWIGTYPE_p_double swig_types[41]
-#define SWIGTYPE_p_enu_t swig_types[42]
-#define SWIGTYPE_p_eph_t swig_types[43]
-#define SWIGTYPE_p_float_t swig_types[44]
-#define SWIGTYPE_p_gps_space_node_t swig_types[45]
-#define SWIGTYPE_p_gps_time_t swig_types[46]
-#define SWIGTYPE_p_int swig_types[47]
-#define SWIGTYPE_p_int_t swig_types[48]
-#define SWIGTYPE_p_llh_t swig_types[49]
-#define SWIGTYPE_p_p_GPS_Solver_RAIM_LSRT_double_GPS_Solver_Base_DebugT_double_GPS_Solver_BaseT_double_t_t_t__user_pvt_t__detection_t swig_types[50]
-#define SWIGTYPE_p_p_GPS_Solver_RAIM_LSRT_double_GPS_Solver_Base_DebugT_double_GPS_Solver_BaseT_double_t_t_t__user_pvt_t__exclusion_t swig_types[51]
-#define SWIGTYPE_p_p_double swig_types[52]
-#define SWIGTYPE_p_range_correction_list_t swig_types[53]
-#define SWIGTYPE_p_s16_t swig_types[54]
-#define SWIGTYPE_p_s32_t swig_types[55]
-#define SWIGTYPE_p_s8_t swig_types[56]
-#define SWIGTYPE_p_satellites_t swig_types[57]
-#define SWIGTYPE_p_self_t swig_types[58]
-#define SWIGTYPE_p_std__vectorT_std__pairT_int_SBAS_SpaceNodeT_double_t__Satellite_const_p_t_t swig_types[59]
-#define SWIGTYPE_p_super_t swig_types[60]
-#define SWIGTYPE_p_swig__GC_VALUE swig_types[61]
-#define SWIGTYPE_p_u16_t swig_types[62]
-#define SWIGTYPE_p_u32_t swig_types[63]
-#define SWIGTYPE_p_u8_t swig_types[64]
-#define SWIGTYPE_p_uint_t swig_types[65]
-#define SWIGTYPE_p_unsigned_int swig_types[66]
-#define SWIGTYPE_p_xyz_t swig_types[67]
-static swig_type_info *swig_types[69];
-static swig_module_info swig_module = {swig_types, 68, 0, 0, 0, 0};
+#define SWIGTYPE_p_GPS_SpaceNodeT_double_t swig_types[15]
+#define SWIGTYPE_p_GPS_SpaceNodeT_double_t__Ionospheric_UTC_Parameters swig_types[16]
+#define SWIGTYPE_p_GPS_SpaceNodeT_double_t__SatelliteProperties__Ephemeris swig_types[17]
+#define SWIGTYPE_p_GPS_TimeT_double_t swig_types[18]
+#define SWIGTYPE_p_GPS_TimeT_double_t__leap_second_event_t swig_types[19]
+#define SWIGTYPE_p_GPS_TimeT_double_t__leap_year_prop_res_t swig_types[20]
+#define SWIGTYPE_p_GPS_User_PVTT_double_t swig_types[21]
+#define SWIGTYPE_p_MatrixT_ComplexT_double_t_Array2D_DenseT_ComplexT_double_t_t_MatrixViewBaseT_t_t swig_types[22]
+#define SWIGTYPE_p_MatrixT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t swig_types[23]
+#define SWIGTYPE_p_MatrixViewBaseT_t swig_types[24]
+#define SWIGTYPE_p_MatrixViewFilterT_MatrixViewBaseT_t_t swig_types[25]
+#define SWIGTYPE_p_Matrix_FrozenT_double_Array2D_DenseT_double_t_MatrixViewBaseT_t_t swig_types[26]
+#define SWIGTYPE_p_PushableData swig_types[27]
+#define SWIGTYPE_p_RINEX_ClockT_double_t swig_types[28]
+#define SWIGTYPE_p_RINEX_ObservationT_double_t swig_types[29]
+#define SWIGTYPE_p_SBAS_EphemerisT_double_t swig_types[30]
+#define SWIGTYPE_p_SBAS_SolverOptionsT_double_t swig_types[31]
+#define SWIGTYPE_p_SBAS_SpaceNodeT_double_t swig_types[32]
+#define SWIGTYPE_p_SBAS_SpaceNodeT_double_t__SatelliteProperties__Ephemeris swig_types[33]
+#define SWIGTYPE_p_SP3T_double_t swig_types[34]
+#define SWIGTYPE_p_System_ENUT_double_WGS84_t swig_types[35]
+#define SWIGTYPE_p_System_LLHT_double_WGS84_t swig_types[36]
+#define SWIGTYPE_p_System_XYZT_double_WGS84_t swig_types[37]
+#define SWIGTYPE_p_available_satellites_t swig_types[38]
+#define SWIGTYPE_p_char swig_types[39]
+#define SWIGTYPE_p_double swig_types[40]
+#define SWIGTYPE_p_enu_t swig_types[41]
+#define SWIGTYPE_p_eph_t swig_types[42]
+#define SWIGTYPE_p_float_t swig_types[43]
+#define SWIGTYPE_p_gps_space_node_t swig_types[44]
+#define SWIGTYPE_p_gps_time_t swig_types[45]
+#define SWIGTYPE_p_int swig_types[46]
+#define SWIGTYPE_p_int_t swig_types[47]
+#define SWIGTYPE_p_llh_t swig_types[48]
+#define SWIGTYPE_p_p_GPS_Solver_RAIM_LSRT_double_GPS_Solver_Base_DebugT_double_GPS_Solver_BaseT_double_t_t_t__user_pvt_t__detection_t swig_types[49]
+#define SWIGTYPE_p_p_GPS_Solver_RAIM_LSRT_double_GPS_Solver_Base_DebugT_double_GPS_Solver_BaseT_double_t_t_t__user_pvt_t__exclusion_t swig_types[50]
+#define SWIGTYPE_p_p_double swig_types[51]
+#define SWIGTYPE_p_range_correction_list_t swig_types[52]
+#define SWIGTYPE_p_s16_t swig_types[53]
+#define SWIGTYPE_p_s32_t swig_types[54]
+#define SWIGTYPE_p_s8_t swig_types[55]
+#define SWIGTYPE_p_satellites_t swig_types[56]
+#define SWIGTYPE_p_self_t swig_types[57]
+#define SWIGTYPE_p_std__vectorT_std__pairT_int_SBAS_SpaceNodeT_double_t__Satellite_const_p_t_t swig_types[58]
+#define SWIGTYPE_p_super_t swig_types[59]
+#define SWIGTYPE_p_swig__GC_VALUE swig_types[60]
+#define SWIGTYPE_p_u16_t swig_types[61]
+#define SWIGTYPE_p_u32_t swig_types[62]
+#define SWIGTYPE_p_u8_t swig_types[63]
+#define SWIGTYPE_p_uint_t swig_types[64]
+#define SWIGTYPE_p_unsigned_int swig_types[65]
+#define SWIGTYPE_p_xyz_t swig_types[66]
+static swig_type_info *swig_types[68];
+static swig_module_info swig_module = {swig_types, 67, 0, 0, 0, 0};
 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
 
@@ -1965,6 +1964,7 @@ static VALUE mGPS;
 #include "navigation/GPS_Solver_Base.h"
 #include "navigation/GPS_Solver.h"
 #include "navigation/GPS_Solver_RAIM.h"
+#include "navigation/GPS_Solver_MultiFrequency.h"
 #include "navigation/SBAS_Solver.h"
 #include "navigation/GLONASS_Solver.h"
 
@@ -2538,6 +2538,16 @@ struct GPS_Measurement {
     L1_SIGNAL_STRENGTH_dBHz,
     L1_LOCK_SEC,
     L1_FREQUENCY,
+
+
+    L2CM_PSEUDORANGE, L2CL_PSEUDORANGE, L2CM_PSEUDORANGE_SIGMA, L2CL_PSEUDORANGE_SIGMA,
+    L2CM_CARRIER_PHASE, L2CL_CARRIER_PHASE, L2CM_CARRIER_PHASE_SIGMA, L2CL_CARRIER_PHASE_SIGMA,
+    L2CM_DOPPLER, L2CL_DOPPLER, L2CM_DOPPLER_SIGMA, L2CL_DOPPLER_SIGMA,
+    L2CM_RANGE_RATE, L2CL_RANGE_RATE, L2CM_RANGE_RATE_SIGMA, L2CL_RANGE_RATE_SIGMA,
+    L2CM_SIGNAL_STRENGTH_dBHz, L2CL_SIGNAL_STRENGTH_dBHz,
+    L2CM_LOCK_SEC, L2CL_LOCK_SEC,
+
+
     ITEMS_PREDEFINED,
   };
   void add(const int &prn, const int &key, const FloatT &value){
@@ -2556,12 +2566,14 @@ struct GPS_SolverOptions_Common {
 
 template <class FloatT>
 struct GPS_SolverOptions 
-    : public GPS_SinglePositioning<FloatT>::options_t, 
+    : public GPS_Solver_MultiFrequency<GPS_SinglePositioning<FloatT> >::options_t, 
     GPS_SolverOptions_Common<FloatT> {
-  typedef typename GPS_SinglePositioning<FloatT>::options_t base_t;
+  typedef typename GPS_Solver_MultiFrequency<GPS_SinglePositioning<FloatT> >::options_t base_t;
   void exclude(const int &prn){base_t::exclude_prn.set(prn);}
   void include(const int &prn){base_t::exclude_prn.reset(prn);}
   std::vector<int> excluded() const {return base_t::exclude_prn.excluded();}
+  bool get_exclude_L2C() {return base_t::exclude_L2C;}
+  bool set_exclude_L2C(const bool &b) {return base_t::exclude_L2C = b;}
   GPS_Solver_GeneralOptions<FloatT> *cast_general(){return this;}
   const GPS_Solver_GeneralOptions<FloatT> *cast_general() const {return this;}
 };
@@ -2617,7 +2629,8 @@ template <class BaseT, class HookT>
 struct HookableSolver : public BaseT {
   typedef BaseT base_t;
   HookT *hook;
-  HookableSolver(const BaseT &base) : BaseT(base), hook(NULL) {}
+  template <class ArgT>
+  HookableSolver(const ArgT &);
   virtual typename base_t::relative_property_t relative_property(
       const typename base_t::prn_t &prn,
       const typename base_t::measurement_t::mapped_type &measurement,
@@ -2659,7 +2672,9 @@ struct GPS_Solver
   struct gps_t {
     GPS_SpaceNode<FloatT> space_node;
     GPS_SolverOptions<FloatT> options;
-    HookableSolver<GPS_SinglePositioning<FloatT>, GPS_Solver<FloatT> > solver;
+    HookableSolver<
+        GPS_Solver_MultiFrequency<GPS_SinglePositioning<FloatT> >,
+        GPS_Solver<FloatT> > solver;
     struct ephemeris_proxy_t {
       struct item_t {
         const void *impl;
@@ -2681,19 +2696,21 @@ struct GPS_Solver
         solver.satellites.impl_select = forward;
       }
     } ephemeris_proxy;
-    gps_t() : space_node(), options(), solver(GPS_SinglePositioning<FloatT>(space_node)), ephemeris_proxy(solver) {}
+    gps_t() : space_node(), options(), solver(space_node), ephemeris_proxy(solver) {
+      options.exclude_L2C = true;
+    }
   } gps;
   struct sbas_t {
     SBAS_SpaceNode<FloatT> space_node;
     SBAS_SolverOptions<FloatT> options;
     HookableSolver<SBAS_SinglePositioning<FloatT>, GPS_Solver<FloatT> > solver;
-    sbas_t() : space_node(), options(), solver(SBAS_SinglePositioning<FloatT>(space_node)) {}
+    sbas_t() : space_node(), options(), solver(space_node) {}
   } sbas;
   struct glonass_t {
     GLONASS_SpaceNode<FloatT> space_node;
     GLONASS_SolverOptions<FloatT> options;
     HookableSolver<GLONASS_SinglePositioning<FloatT>, GPS_Solver<FloatT> > solver;
-    glonass_t() : space_node(), options(), solver(GLONASS_SinglePositioning<FloatT>(space_node)) {}
+    glonass_t() : space_node(), options(), solver(space_node) {}
   } glonass;
   VALUE hooks;
   typedef std::vector<GPS_RangeCorrector<FloatT> > user_correctors_t;
@@ -4057,6 +4074,20 @@ SWIGINTERN double const &GPS_SolverOptions_Common_Sl_double_Sg__get_residual_mas
   return self->cast_general()->residual_mask;
 }
 
+    template <> template <>
+    HookableSolver<
+          GPS_Solver_MultiFrequency<GPS_SinglePositioning<double> >,
+          GPS_Solver<double> >
+        ::HookableSolver<GPS_SpaceNode<double> >(const GPS_SpaceNode<double> &sn)
+          : GPS_Solver_MultiFrequency<GPS_SinglePositioning<double> >(sn), hook(NULL) {}
+    template <> template <>
+    HookableSolver<SBAS_SinglePositioning<double>, GPS_Solver<double> >
+        ::HookableSolver<SBAS_SpaceNode<double> >(const SBAS_SpaceNode<double> &sn)
+          : SBAS_SinglePositioning<double>(sn), hook(NULL) {}
+    template <> template <>
+    HookableSolver<GLONASS_SinglePositioning<double>, GPS_Solver<double> >
+        ::HookableSolver<GLONASS_SpaceNode<double> >(const GLONASS_SpaceNode<double> &sn)
+          : GLONASS_SinglePositioning<double>(sn), hook(NULL) {}
     template <>
     GPS_Solver<double>::base_t::relative_property_t
         GPS_Solver<double>::relative_property(
@@ -16602,6 +16633,186 @@ A class method.
 
 A class method.
 
+*/
+/*
+  Document-method: GPS_PVT::GPS.L2CM_PSEUDORANGE
+
+  call-seq:
+    L2CM_PSEUDORANGE -> int
+
+A class method.
+
+*/
+/*
+  Document-method: GPS_PVT::GPS.L2CL_PSEUDORANGE
+
+  call-seq:
+    L2CL_PSEUDORANGE -> int
+
+A class method.
+
+*/
+/*
+  Document-method: GPS_PVT::GPS.L2CM_PSEUDORANGE_SIGMA
+
+  call-seq:
+    L2CM_PSEUDORANGE_SIGMA -> int
+
+A class method.
+
+*/
+/*
+  Document-method: GPS_PVT::GPS.L2CL_PSEUDORANGE_SIGMA
+
+  call-seq:
+    L2CL_PSEUDORANGE_SIGMA -> int
+
+A class method.
+
+*/
+/*
+  Document-method: GPS_PVT::GPS.L2CM_CARRIER_PHASE
+
+  call-seq:
+    L2CM_CARRIER_PHASE -> int
+
+A class method.
+
+*/
+/*
+  Document-method: GPS_PVT::GPS.L2CL_CARRIER_PHASE
+
+  call-seq:
+    L2CL_CARRIER_PHASE -> int
+
+A class method.
+
+*/
+/*
+  Document-method: GPS_PVT::GPS.L2CM_CARRIER_PHASE_SIGMA
+
+  call-seq:
+    L2CM_CARRIER_PHASE_SIGMA -> int
+
+A class method.
+
+*/
+/*
+  Document-method: GPS_PVT::GPS.L2CL_CARRIER_PHASE_SIGMA
+
+  call-seq:
+    L2CL_CARRIER_PHASE_SIGMA -> int
+
+A class method.
+
+*/
+/*
+  Document-method: GPS_PVT::GPS.L2CM_DOPPLER
+
+  call-seq:
+    L2CM_DOPPLER -> int
+
+A class method.
+
+*/
+/*
+  Document-method: GPS_PVT::GPS.L2CL_DOPPLER
+
+  call-seq:
+    L2CL_DOPPLER -> int
+
+A class method.
+
+*/
+/*
+  Document-method: GPS_PVT::GPS.L2CM_DOPPLER_SIGMA
+
+  call-seq:
+    L2CM_DOPPLER_SIGMA -> int
+
+A class method.
+
+*/
+/*
+  Document-method: GPS_PVT::GPS.L2CL_DOPPLER_SIGMA
+
+  call-seq:
+    L2CL_DOPPLER_SIGMA -> int
+
+A class method.
+
+*/
+/*
+  Document-method: GPS_PVT::GPS.L2CM_RANGE_RATE
+
+  call-seq:
+    L2CM_RANGE_RATE -> int
+
+A class method.
+
+*/
+/*
+  Document-method: GPS_PVT::GPS.L2CL_RANGE_RATE
+
+  call-seq:
+    L2CL_RANGE_RATE -> int
+
+A class method.
+
+*/
+/*
+  Document-method: GPS_PVT::GPS.L2CM_RANGE_RATE_SIGMA
+
+  call-seq:
+    L2CM_RANGE_RATE_SIGMA -> int
+
+A class method.
+
+*/
+/*
+  Document-method: GPS_PVT::GPS.L2CL_RANGE_RATE_SIGMA
+
+  call-seq:
+    L2CL_RANGE_RATE_SIGMA -> int
+
+A class method.
+
+*/
+/*
+  Document-method: GPS_PVT::GPS.L2CM_SIGNAL_STRENGTH_dBHz
+
+  call-seq:
+    L2CM_SIGNAL_STRENGTH_dBHz -> int
+
+A class method.
+
+*/
+/*
+  Document-method: GPS_PVT::GPS.L2CL_SIGNAL_STRENGTH_dBHz
+
+  call-seq:
+    L2CL_SIGNAL_STRENGTH_dBHz -> int
+
+A class method.
+
+*/
+/*
+  Document-method: GPS_PVT::GPS.L2CM_LOCK_SEC
+
+  call-seq:
+    L2CM_LOCK_SEC -> int
+
+A class method.
+
+*/
+/*
+  Document-method: GPS_PVT::GPS.L2CL_LOCK_SEC
+
+  call-seq:
+    L2CL_LOCK_SEC -> int
+
+A class method.
+
 */
 /*
   Document-method: GPS_PVT::GPS.ITEMS_PREDEFINED
@@ -16900,121 +17111,6 @@ free_GPS_SolverOptions_Common_Sl_double_Sg_(void *self) {
     delete arg1;
 }
 
-/*
-  Document-method: GPS_PVT::GPS::SolverOptionsCommon.cast_general
-
-  call-seq:
-    cast_general -> GPS_Solver_GeneralOptions< double > *
-    cast_general -> GPS_Solver_GeneralOptions< double > const
-
-An instance method.
-
-*/
-SWIGINTERN VALUE
-_wrap_SolverOptionsCommon_cast_general__SWIG_0(int argc, VALUE *argv, VALUE self) {
-  GPS_SolverOptions_Common< double > *arg1 = (GPS_SolverOptions_Common< double > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  GPS_Solver_GeneralOptions< double > *result = 0 ;
-  VALUE vresult = Qnil;
-  
-  if ((argc < 0) || (argc > 0)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
-  }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_SolverOptions_CommonT_double_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_SolverOptions_Common< double > *","cast_general", 1, self )); 
-  }
-  arg1 = reinterpret_cast< GPS_SolverOptions_Common< double > * >(argp1);
-  {
-    try {
-      result = (GPS_Solver_GeneralOptions< double > *)(arg1)->cast_general();
-    } catch (const native_exception &e) {
-      e.regenerate();
-      SWIG_fail;
-    } catch (const std::exception& e) {
-      SWIG_exception_fail(SWIG_RuntimeError, e.what());
-    }
-  }
-  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GPS_Solver_GeneralOptionsT_double_t, 0 |  0 );
-  return vresult;
-fail:
-  return Qnil;
-}
-
-
-SWIGINTERN VALUE
-_wrap_SolverOptionsCommon_cast_general__SWIG_1(int argc, VALUE *argv, VALUE self) {
-  GPS_SolverOptions_Common< double > *arg1 = (GPS_SolverOptions_Common< double > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  GPS_Solver_GeneralOptions< double > *result = 0 ;
-  VALUE vresult = Qnil;
-  
-  if ((argc < 0) || (argc > 0)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
-  }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_SolverOptions_CommonT_double_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_SolverOptions_Common< double > const *","cast_general", 1, self )); 
-  }
-  arg1 = reinterpret_cast< GPS_SolverOptions_Common< double > * >(argp1);
-  {
-    try {
-      result = (GPS_Solver_GeneralOptions< double > *)((GPS_SolverOptions_Common< double > const *)arg1)->cast_general();
-    } catch (const native_exception &e) {
-      e.regenerate();
-      SWIG_fail;
-    } catch (const std::exception& e) {
-      SWIG_exception_fail(SWIG_RuntimeError, e.what());
-    }
-  }
-  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GPS_Solver_GeneralOptionsT_double_t, 0 |  0 );
-  return vresult;
-fail:
-  return Qnil;
-}
-
-
-SWIGINTERN VALUE _wrap_SolverOptionsCommon_cast_general(int nargs, VALUE *args, VALUE self) {
-  int argc;
-  VALUE argv[2];
-  int ii;
-  
-  argc = nargs + 1;
-  argv[0] = self;
-  if (argc > 2) SWIG_fail;
-  for (ii = 1; (ii < argc); ++ii) {
-    argv[ii] = args[ii-1];
-  }
-  if (argc == 1) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GPS_SolverOptions_CommonT_double_t, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      return _wrap_SolverOptionsCommon_cast_general__SWIG_0(nargs, args, self);
-    }
-  }
-  if (argc == 1) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_GPS_SolverOptions_CommonT_double_t, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      return _wrap_SolverOptionsCommon_cast_general__SWIG_1(nargs, args, self);
-    }
-  }
-  
-fail:
-  Ruby_Format_OverloadedError( argc, 2, "SolverOptionsCommon.cast_general", 
-    "    GPS_Solver_GeneralOptions< double > SolverOptionsCommon.cast_general()\n"
-    "    GPS_Solver_GeneralOptions< double > const * SolverOptionsCommon.cast_general()\n");
-  
-  return Qnil;
-}
-
-
 /*
   Document-method: GPS_PVT::GPS::SolverOptionsCommon.elevation_mask=
 
@@ -17359,6 +17455,100 @@ fail:
 }
 
 
+/*
+  Document-method: GPS_PVT::GPS::SolverOptions.exclude_L2C?
+
+  call-seq:
+    exclude_L2C? -> bool
+
+An instance method.
+
+*/
+SWIGINTERN VALUE
+_wrap_SolverOptions_exclude_L2Cq___(int argc, VALUE *argv, VALUE self) {
+  GPS_SolverOptions< double > *arg1 = (GPS_SolverOptions< double > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_GPS_SolverOptionsT_double_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_SolverOptions< double > *","get_exclude_L2C", 1, self )); 
+  }
+  arg1 = reinterpret_cast< GPS_SolverOptions< double > * >(argp1);
+  {
+    try {
+      result = (bool)(arg1)->get_exclude_L2C();
+    } 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::SolverOptions.exclude_L2C=
+
+  call-seq:
+    exclude_L2C=(bool const & b) -> bool
+
+An instance method.
+
+*/
+SWIGINTERN VALUE
+_wrap_SolverOptions_exclude_L2Ce___(int argc, VALUE *argv, VALUE self) {
+  GPS_SolverOptions< double > *arg1 = (GPS_SolverOptions< double > *) 0 ;
+  bool *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool temp2 ;
+  bool val2 ;
+  int ecode2 = 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_GPS_SolverOptionsT_double_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "GPS_SolverOptions< double > *","set_exclude_L2C", 1, self )); 
+  }
+  arg1 = reinterpret_cast< GPS_SolverOptions< double > * >(argp1);
+  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","set_exclude_L2C", 2, argv[0] ));
+  } 
+  temp2 = static_cast< bool >(val2);
+  arg2 = &temp2;
+  {
+    try {
+      result = (bool)(arg1)->set_exclude_L2C((bool 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 VALUE
 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
 _wrap_SolverOptions_allocate(VALUE self)
@@ -27276,7 +27466,6 @@ static swig_type_info _swigt__p_GPS_MeasurementT_double_t = {"_p_GPS_Measurement
 static swig_type_info _swigt__p_GPS_SolverOptionsT_double_t = {"_p_GPS_SolverOptionsT_double_t", "GPS_SolverOptions< double > *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_GPS_SolverOptions_CommonT_double_t = {"_p_GPS_SolverOptions_CommonT_double_t", "GPS_SolverOptions_Common< double > *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_GPS_SolverT_double_t = {"_p_GPS_SolverT_double_t", "GPS_Solver< double > *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_GPS_Solver_GeneralOptionsT_double_t = {"_p_GPS_Solver_GeneralOptionsT_double_t", "GPS_Solver_GeneralOptions< double > *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_GPS_SpaceNodeT_double_t = {"_p_GPS_SpaceNodeT_double_t", "GPS_SpaceNode< double >::self_t *|GPS_SpaceNode< double > *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_GPS_SpaceNodeT_double_t__Ionospheric_UTC_Parameters = {"_p_GPS_SpaceNodeT_double_t__Ionospheric_UTC_Parameters", "GPS_SpaceNode< double >::Ionospheric_UTC_Parameters *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_GPS_SpaceNodeT_double_t__SatelliteProperties__Ephemeris = {"_p_GPS_SpaceNodeT_double_t__SatelliteProperties__Ephemeris", "GPS_SpaceNode< double >::SatelliteProperties::Ephemeris *", 0, 0, (void*)0, 0};
@@ -27346,7 +27535,6 @@ static swig_type_info *swig_type_initial[] = {
   &_swigt__p_GPS_SolverOptionsT_double_t,
   &_swigt__p_GPS_SolverOptions_CommonT_double_t,
   &_swigt__p_GPS_SolverT_double_t,
-  &_swigt__p_GPS_Solver_GeneralOptionsT_double_t,
   &_swigt__p_GPS_SpaceNodeT_double_t,
   &_swigt__p_GPS_SpaceNodeT_double_t__Ionospheric_UTC_Parameters,
   &_swigt__p_GPS_SpaceNodeT_double_t__SatelliteProperties__Ephemeris,
@@ -27416,7 +27604,6 @@ static swig_cast_info _swigc__p_GPS_MeasurementT_double_t[] = {  {&_swigt__p_GPS
 static swig_cast_info _swigc__p_GPS_SolverOptionsT_double_t[] = {  {&_swigt__p_GPS_SolverOptionsT_double_t, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_GPS_SolverOptions_CommonT_double_t[] = {  {&_swigt__p_GPS_SolverOptions_CommonT_double_t, 0, 0, 0},  {&_swigt__p_GPS_SolverOptionsT_double_t, _p_GPS_SolverOptionsT_double_tTo_p_GPS_SolverOptions_CommonT_double_t, 0, 0},  {&_swigt__p_SBAS_SolverOptionsT_double_t, _p_SBAS_SolverOptionsT_double_tTo_p_GPS_SolverOptions_CommonT_double_t, 0, 0},  {&_swigt__p_GLONASS_SolverOptionsT_double_t, _p_GLONASS_SolverOptionsT_double_tTo_p_GPS_SolverOptions_CommonT_double_t, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_GPS_SolverT_double_t[] = {  {&_swigt__p_GPS_SolverT_double_t, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_GPS_Solver_GeneralOptionsT_double_t[] = {  {&_swigt__p_GPS_Solver_GeneralOptionsT_double_t, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_GPS_SpaceNodeT_double_t[] = {  {&_swigt__p_GPS_SpaceNodeT_double_t, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_GPS_SpaceNodeT_double_t__Ionospheric_UTC_Parameters[] = {  {&_swigt__p_GPS_Ionospheric_UTC_ParametersT_double_t, _p_GPS_Ionospheric_UTC_ParametersT_double_tTo_p_GPS_SpaceNodeT_double_t__Ionospheric_UTC_Parameters, 0, 0},  {&_swigt__p_GPS_SpaceNodeT_double_t__Ionospheric_UTC_Parameters, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_GPS_SpaceNodeT_double_t__SatelliteProperties__Ephemeris[] = {  {&_swigt__p_GPS_SpaceNodeT_double_t__SatelliteProperties__Ephemeris, 0, 0, 0},  {&_swigt__p_GPS_EphemerisT_double_t, _p_GPS_EphemerisT_double_tTo_p_GPS_SpaceNodeT_double_t__SatelliteProperties__Ephemeris, 0, 0},{0, 0, 0, 0}};
@@ -27486,7 +27673,6 @@ static swig_cast_info *swig_cast_initial[] = {
   _swigc__p_GPS_SolverOptionsT_double_t,
   _swigc__p_GPS_SolverOptions_CommonT_double_t,
   _swigc__p_GPS_SolverT_double_t,
-  _swigc__p_GPS_Solver_GeneralOptionsT_double_t,
   _swigc__p_GPS_SpaceNodeT_double_t,
   _swigc__p_GPS_SpaceNodeT_double_t__Ionospheric_UTC_Parameters,
   _swigc__p_GPS_SpaceNodeT_double_t__SatelliteProperties__Ephemeris,
@@ -28067,6 +28253,26 @@ SWIGEXPORT void Init_GPS(void) {
   rb_define_const(SwigClassMeasurement.klass, "L1_SIGNAL_STRENGTH_dBHz", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L1_SIGNAL_STRENGTH_dBHz)));
   rb_define_const(SwigClassMeasurement.klass, "L1_LOCK_SEC", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L1_LOCK_SEC)));
   rb_define_const(SwigClassMeasurement.klass, "L1_FREQUENCY", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L1_FREQUENCY)));
+  rb_define_const(SwigClassMeasurement.klass, "L2CM_PSEUDORANGE", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L2CM_PSEUDORANGE)));
+  rb_define_const(SwigClassMeasurement.klass, "L2CL_PSEUDORANGE", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L2CL_PSEUDORANGE)));
+  rb_define_const(SwigClassMeasurement.klass, "L2CM_PSEUDORANGE_SIGMA", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L2CM_PSEUDORANGE_SIGMA)));
+  rb_define_const(SwigClassMeasurement.klass, "L2CL_PSEUDORANGE_SIGMA", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L2CL_PSEUDORANGE_SIGMA)));
+  rb_define_const(SwigClassMeasurement.klass, "L2CM_CARRIER_PHASE", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L2CM_CARRIER_PHASE)));
+  rb_define_const(SwigClassMeasurement.klass, "L2CL_CARRIER_PHASE", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L2CL_CARRIER_PHASE)));
+  rb_define_const(SwigClassMeasurement.klass, "L2CM_CARRIER_PHASE_SIGMA", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L2CM_CARRIER_PHASE_SIGMA)));
+  rb_define_const(SwigClassMeasurement.klass, "L2CL_CARRIER_PHASE_SIGMA", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L2CL_CARRIER_PHASE_SIGMA)));
+  rb_define_const(SwigClassMeasurement.klass, "L2CM_DOPPLER", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L2CM_DOPPLER)));
+  rb_define_const(SwigClassMeasurement.klass, "L2CL_DOPPLER", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L2CL_DOPPLER)));
+  rb_define_const(SwigClassMeasurement.klass, "L2CM_DOPPLER_SIGMA", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L2CM_DOPPLER_SIGMA)));
+  rb_define_const(SwigClassMeasurement.klass, "L2CL_DOPPLER_SIGMA", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L2CL_DOPPLER_SIGMA)));
+  rb_define_const(SwigClassMeasurement.klass, "L2CM_RANGE_RATE", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L2CM_RANGE_RATE)));
+  rb_define_const(SwigClassMeasurement.klass, "L2CL_RANGE_RATE", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L2CL_RANGE_RATE)));
+  rb_define_const(SwigClassMeasurement.klass, "L2CM_RANGE_RATE_SIGMA", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L2CM_RANGE_RATE_SIGMA)));
+  rb_define_const(SwigClassMeasurement.klass, "L2CL_RANGE_RATE_SIGMA", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L2CL_RANGE_RATE_SIGMA)));
+  rb_define_const(SwigClassMeasurement.klass, "L2CM_SIGNAL_STRENGTH_dBHz", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L2CM_SIGNAL_STRENGTH_dBHz)));
+  rb_define_const(SwigClassMeasurement.klass, "L2CL_SIGNAL_STRENGTH_dBHz", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L2CL_SIGNAL_STRENGTH_dBHz)));
+  rb_define_const(SwigClassMeasurement.klass, "L2CM_LOCK_SEC", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L2CM_LOCK_SEC)));
+  rb_define_const(SwigClassMeasurement.klass, "L2CL_LOCK_SEC", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::L2CL_LOCK_SEC)));
   rb_define_const(SwigClassMeasurement.klass, "ITEMS_PREDEFINED", SWIG_From_int(static_cast< int >(GPS_Measurement< double >::ITEMS_PREDEFINED)));
   rb_define_method(SwigClassMeasurement.klass, "add", VALUEFUNC(_wrap_Measurement_add), -1);
   rb_define_method(SwigClassMeasurement.klass, "each", VALUEFUNC(_wrap_Measurement_each), -1);
@@ -28078,7 +28284,6 @@ SWIGEXPORT void Init_GPS(void) {
   SwigClassSolverOptionsCommon.klass = rb_define_class_under(mGPS, "SolverOptionsCommon", rb_cObject);
   SWIG_TypeClientData(SWIGTYPE_p_GPS_SolverOptions_CommonT_double_t, (void *) &SwigClassSolverOptionsCommon);
   rb_undef_alloc_func(SwigClassSolverOptionsCommon.klass);
-  rb_define_method(SwigClassSolverOptionsCommon.klass, "cast_general", VALUEFUNC(_wrap_SolverOptionsCommon_cast_general), -1);
   rb_define_method(SwigClassSolverOptionsCommon.klass, "elevation_mask=", VALUEFUNC(_wrap_SolverOptionsCommon_elevation_maske___), -1);
   rb_define_method(SwigClassSolverOptionsCommon.klass, "elevation_mask", VALUEFUNC(_wrap_SolverOptionsCommon_elevation_mask), -1);
   rb_define_method(SwigClassSolverOptionsCommon.klass, "residual_mask=", VALUEFUNC(_wrap_SolverOptionsCommon_residual_maske___), -1);
@@ -28094,6 +28299,8 @@ SWIGEXPORT void Init_GPS(void) {
   rb_define_method(SwigClassSolverOptions.klass, "exclude", VALUEFUNC(_wrap_SolverOptions_exclude), -1);
   rb_define_method(SwigClassSolverOptions.klass, "include", VALUEFUNC(_wrap_SolverOptions_include), -1);
   rb_define_method(SwigClassSolverOptions.klass, "excluded", VALUEFUNC(_wrap_SolverOptions_excluded), -1);
+  rb_define_method(SwigClassSolverOptions.klass, "exclude_L2C?", VALUEFUNC(_wrap_SolverOptions_exclude_L2Cq___), -1);
+  rb_define_method(SwigClassSolverOptions.klass, "exclude_L2C=", VALUEFUNC(_wrap_SolverOptions_exclude_L2Ce___), -1);
   SwigClassSolverOptions.mark = 0;
   SwigClassSolverOptions.destroy = (void (*)(void *)) free_GPS_SolverOptions_Sl_double_Sg_;
   SwigClassSolverOptions.trackObjects = 0;

data/ext/ninja-scan-light/tool/navigation/GLONASS_Solver.h

@@ -57,13 +57,15 @@ struct GLONASS_SinglePositioning_Options : public GPS_Solver_GeneralOptions<Floa
 
 template <class FloatT, class SolverBaseT = GPS_Solver_Base<FloatT> >
 class GLONASS_SinglePositioning : public SolverBaseT {
-  private:
-    GLONASS_SinglePositioning<FloatT> &operator=(const GLONASS_SinglePositioning<FloatT> &);
   public:
-    typedef GLONASS_SinglePositioning<FloatT> self_t;
+    typedef GLONASS_SinglePositioning<FloatT, SolverBaseT> self_t;
     typedef SolverBaseT base_t;
     typedef SolverBaseT super_t;
+  private:
+    self_t &operator=(const self_t &);
+    GLONASS_SinglePositioning(const self_t &);
 
+  public:
 #if defined(__GNUC__) && (__GNUC__ < 5)
 #define inheritate_type(x) typedef typename base_t::x x;
 #else

data/ext/ninja-scan-light/tool/navigation/GPS_Solver.h

@@ -77,12 +77,14 @@ struct GPS_SinglePositioning_Options : public GPS_Solver_GeneralOptions<FloatT>
 
 template <class FloatT, class SolverBaseT = GPS_Solver_Base<FloatT> >
 class GPS_SinglePositioning : public SolverBaseT {
-  private:
-    GPS_SinglePositioning<FloatT> &operator=(const GPS_SinglePositioning<FloatT> &);
   public:
-    typedef GPS_SinglePositioning<FloatT> self_t;
+    typedef GPS_SinglePositioning<FloatT, SolverBaseT> self_t;
     typedef SolverBaseT base_t;
+  private:
+    self_t &operator=(const self_t &);
+    GPS_SinglePositioning(const self_t &);
 
+  public:
 #if defined(__GNUC__) && (__GNUC__ < 5)
 #define inheritate_type(x) typedef typename base_t::x x;
 #else

data/ext/ninja-scan-light/tool/navigation/GPS_Solver_MultiFrequency.h

@@ -52,6 +52,7 @@ class GPS_Solver_MultiFrequency : public BaseSolver {
     typedef BaseSolver super_t;
   private:
     self_t &operator=(const self_t &);
+    GPS_Solver_MultiFrequency(const self_t &);
   public:
 #if defined(__GNUC__) && (__GNUC__ < 5)
 #define inheritate_type(x) typedef typename super_t::x x;

data/ext/ninja-scan-light/tool/navigation/SBAS_Solver.h

@@ -56,12 +56,14 @@ struct SBAS_SinglePositioning_Options : public GPS_Solver_GeneralOptions<FloatT>
 
 template <class FloatT, class SolverBaseT = GPS_Solver_Base<FloatT> >
 class SBAS_SinglePositioning : public SolverBaseT {
-  private:
-    SBAS_SinglePositioning<FloatT> &operator=(const SBAS_SinglePositioning<FloatT> &);
   public:
-    typedef SBAS_SinglePositioning<FloatT> self_t;
+    typedef SBAS_SinglePositioning<FloatT, SolverBaseT> self_t;
     typedef SolverBaseT base_t;
+  private:
+    self_t &operator=(const self_t &);
+    SBAS_SinglePositioning(const self_t &);
 
+  public:
 #if defined(__GNUC__) && (__GNUC__ < 5)
 #define inheritate_type(x) typedef typename base_t::x x;
 #else

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

@@ -29,6 +29,7 @@
 #include "navigation/GPS_Solver_Base.h"
 #include "navigation/GPS_Solver.h"
 #include "navigation/GPS_Solver_RAIM.h"
+#include "navigation/GPS_Solver_MultiFrequency.h"
 #include "navigation/SBAS_Solver.h"
 #include "navigation/GLONASS_Solver.h"
 
@@ -1119,6 +1120,16 @@ struct GPS_Measurement {
     L1_SIGNAL_STRENGTH_dBHz,
     L1_LOCK_SEC,
     L1_FREQUENCY,
+#define make_entry(key) L2CM_ ## key, L2CL_ ## key
+#define make_entry2(key) make_entry(key), make_entry(key ## _SIGMA)
+    make_entry2(PSEUDORANGE),
+    make_entry2(CARRIER_PHASE),
+    make_entry2(DOPPLER),
+    make_entry2(RANGE_RATE),
+    make_entry(SIGNAL_STRENGTH_dBHz),
+    make_entry(LOCK_SEC),
+#undef make_entry2
+#undef make_entry
     ITEMS_PREDEFINED,
   };
   void add(const int &prn, const int &key, const FloatT &value){
@@ -1142,7 +1153,7 @@ const type &get_ ## name () const {
   MAKE_ACCESSOR2(residual_mask, FloatT);
 #undef MAKE_ACCESSOR2
   MAKE_VECTOR2ARRAY(int);
-  %ignore cast_base;
+  %ignore cast_general;
 }
 %inline %{
 template <class FloatT>
@@ -1156,17 +1167,23 @@ struct GPS_SolverOptions_Common {
 %extend GPS_SolverOptions {
   %ignore base_t;
   %ignore cast_general;
+#ifdef SWIGRUBY
+  %rename("exclude_L2C?") get_exclude_L2C;
+  %rename("exclude_L2C=") set_exclude_L2C;
+#endif
   MAKE_VECTOR2ARRAY(int);
 }
 %inline %{
 template <class FloatT>
 struct GPS_SolverOptions 
-    : public GPS_SinglePositioning<FloatT>::options_t, 
+    : public GPS_Solver_MultiFrequency<GPS_SinglePositioning<FloatT> >::options_t, 
     GPS_SolverOptions_Common<FloatT> {
-  typedef typename GPS_SinglePositioning<FloatT>::options_t base_t;
+  typedef typename GPS_Solver_MultiFrequency<GPS_SinglePositioning<FloatT> >::options_t base_t;
   void exclude(const int &prn){base_t::exclude_prn.set(prn);}
   void include(const int &prn){base_t::exclude_prn.reset(prn);}
   std::vector<int> excluded() const {return base_t::exclude_prn.excluded();}
+  bool get_exclude_L2C() {return base_t::exclude_L2C;}
+  bool set_exclude_L2C(const bool &b) {return base_t::exclude_L2C = b;}
   GPS_Solver_GeneralOptions<FloatT> *cast_general(){return this;}
   const GPS_Solver_GeneralOptions<FloatT> *cast_general() const {return this;}
 };
@@ -1236,7 +1253,8 @@ template <class BaseT, class HookT>
 struct HookableSolver : public BaseT {
   typedef BaseT base_t;
   HookT *hook;
-  HookableSolver(const BaseT &base) : BaseT(base), hook(NULL) {}
+  template <class ArgT>
+  HookableSolver(const ArgT &);
   virtual typename base_t::relative_property_t relative_property(
       const typename base_t::prn_t &prn,
       const typename base_t::measurement_t::mapped_type &measurement,
@@ -1289,6 +1307,20 @@ struct HookableSolver : public BaseT {
       fragment=SWIG_From_frag(int),
       fragment=SWIG_Traits_frag(FloatT),
       fragment=SWIG_Traits_frag(GPS_Measurement<FloatT>)){
+    template <> template <>
+    HookableSolver<
+          GPS_Solver_MultiFrequency<GPS_SinglePositioning<FloatT> >,
+          GPS_Solver<FloatT> >
+        ::HookableSolver<GPS_SpaceNode<FloatT> >(const GPS_SpaceNode<FloatT> &sn)
+          : GPS_Solver_MultiFrequency<GPS_SinglePositioning<FloatT> >(sn), hook(NULL) {}
+    template <> template <>
+    HookableSolver<SBAS_SinglePositioning<FloatT>, GPS_Solver<FloatT> >
+        ::HookableSolver<SBAS_SpaceNode<FloatT> >(const SBAS_SpaceNode<FloatT> &sn)
+          : SBAS_SinglePositioning<FloatT>(sn), hook(NULL) {}
+    template <> template <>
+    HookableSolver<GLONASS_SinglePositioning<FloatT>, GPS_Solver<FloatT> >
+        ::HookableSolver<GLONASS_SpaceNode<FloatT> >(const GLONASS_SpaceNode<FloatT> &sn)
+          : GLONASS_SinglePositioning<FloatT>(sn), hook(NULL) {}
     template <>
     GPS_Solver<FloatT>::base_t::relative_property_t
         GPS_Solver<FloatT>::relative_property(
@@ -1581,7 +1613,9 @@ struct GPS_Solver
   struct gps_t {
     GPS_SpaceNode<FloatT> space_node;
     GPS_SolverOptions<FloatT> options;
-    HookableSolver<GPS_SinglePositioning<FloatT>, GPS_Solver<FloatT> > solver;
+    HookableSolver<
+        GPS_Solver_MultiFrequency<GPS_SinglePositioning<FloatT> >,
+        GPS_Solver<FloatT> > solver;
     struct ephemeris_proxy_t {
       struct item_t {
         const void *impl;
@@ -1603,19 +1637,21 @@ struct GPS_Solver
         solver.satellites.impl_select = forward;
       }
     } ephemeris_proxy;
-    gps_t() : space_node(), options(), solver(GPS_SinglePositioning<FloatT>(space_node)), ephemeris_proxy(solver) {}
+    gps_t() : space_node(), options(), solver(space_node), ephemeris_proxy(solver) {
+      options.exclude_L2C = true;
+    }
   } gps;
   struct sbas_t {
     SBAS_SpaceNode<FloatT> space_node;
     SBAS_SolverOptions<FloatT> options;
     HookableSolver<SBAS_SinglePositioning<FloatT>, GPS_Solver<FloatT> > solver;
-    sbas_t() : space_node(), options(), solver(SBAS_SinglePositioning<FloatT>(space_node)) {}
+    sbas_t() : space_node(), options(), solver(space_node) {}
   } sbas;
   struct glonass_t {
     GLONASS_SpaceNode<FloatT> space_node;
     GLONASS_SolverOptions<FloatT> options;
     HookableSolver<GLONASS_SinglePositioning<FloatT>, GPS_Solver<FloatT> > solver;
-    glonass_t() : space_node(), options(), solver(GLONASS_SinglePositioning<FloatT>(space_node)) {}
+    glonass_t() : space_node(), options(), solver(space_node) {}
   } glonass;
   SWIG_Object hooks;
   typedef std::vector<GPS_RangeCorrector<FloatT> > user_correctors_t;

data/ext/ninja-scan-light/tool/swig/spec/GPS_spec.rb

@@ -924,6 +924,9 @@ __RINEX_CLK_TEXT__
       }}.not_to raise_error
       expect(solver.correction[:gps_ionospheric]).to include(:no_correction)
       expect(solver.correction[:options][:f_10_7]).to eq(10)
+      expect(solver.gps_options.exclude_L2C?).to eq(true) #default
+      solver.gps_options.exclude_L2C = false
+      expect(solver.gps_options.exclude_L2C?).to eq(false)
       sn.read(input[:rinex_nav])
       t_meas = GPS::Time::new(1849, 172413)
       sn.update_all_ephemeris(t_meas)

data/lib/gps_pvt/receiver.rb

@@ -290,6 +290,11 @@ class Receiver
       when :fault_exclusion
         @solver.options = {:skip_exclusion => !(output_options[:FDE] = v.to_b)}
         next true
+      when :use_signal
+        {
+          :GPS_L2C => proc{@solver.gps_options.exclude_L2C = false},
+        }[v.to_sym].call rescue next false
+        next true
       end
       false
     }
@@ -334,9 +339,9 @@ class Receiver
         }.flatten(1))]
       }
     }.call
-    alias_method(:add_orig, :add)
+    add_orig = instance_method(:add)
     define_method(:add){|prn, key, value|
-      add_orig(prn, key.kind_of?(Symbol) ? GPS::Measurement.const_get(key) : key, value)
+      add_orig.bind(self).call(prn, key.kind_of?(Symbol) ? GPS::Measurement.const_get(key) : key, value)
     }
   }
 
@@ -523,33 +528,39 @@ class Receiver
             v
           }
           sys, svid = gnss_serial.call(*loader.call(36, 2).reverse)
-          # sigID check to restrict signal to L1 if version(>0); @see UBX-18010854
-          next if (packet[6 + 13] != 0) && (loader.call(38, 1, "C") != 0)
+          sigid = (packet[6 + 13] != 0) ? loader.call(38, 1, "C") : 0 # sigID if version(>0); @see UBX-18010854 
           case sys
-          when :GPS, :SBAS, :QZSS;
+          when :GPS
+            sigid = {0 => :L1, 3 => :L2CL, 4 => :L2CM}[sigid]
+          when :SBAS
+            sigid = :L1
+          when :QZSS
+            sigid = {0 => :L1, 5 => :L2CL, 4 => :L2CM}[sigid]
           when :GLONASS
             svid += 0x100
+            sigid = {0 => :L1}[sigid] # TODO: to support {2 -> :L2}
             meas.add(svid, :L1_FREQUENCY, 
                 GPS::SpaceNode_GLONASS::L1_frequency(loader.call(39, 1, "C") - 7))
           else; next
           end
+          next unless sigid
           trk_stat = loader.call(46, 1)[0]
           {
-            :L1_PSEUDORANGE => [16, 8, "E", proc{|v| (trk_stat & 0x1 == 0x1) ? v : nil}],
-            :L1_PSEUDORANGE_SIGMA => [43, 1, nil, proc{|v|
+            :PSEUDORANGE => [16, 8, "E", proc{|v| (trk_stat & 0x1 == 0x1) ? v : nil}],
+            :PSEUDORANGE_SIGMA => [43, 1, nil, proc{|v|
               (trk_stat & 0x1 == 0x1) ? (1E-2 * (1 << (v[0] & 0xF))) : nil
             }],
-            :L1_DOPPLER => [32, 4, "e"],
-            :L1_DOPPLER_SIGMA => [45, 1, nil, proc{|v| 2E-3 * (1 << (v[0] & 0xF))}],
-            :L1_CARRIER_PHASE => [24, 8, "E", proc{|v| (trk_stat & 0x2 == 0x2) ? v : nil}],
-            :L1_CARRIER_PHASE_SIGMA => [44, 1, nil, proc{|v|
+            :DOPPLER => [32, 4, "e"],
+            :DOPPLER_SIGMA => [45, 1, nil, proc{|v| 2E-3 * (1 << (v[0] & 0xF))}],
+            :CARRIER_PHASE => [24, 8, "E", proc{|v| (trk_stat & 0x2 == 0x2) ? v : nil}],
+            :CARRIER_PHASE_SIGMA => [44, 1, nil, proc{|v|
               (trk_stat & 0x2 == 0x2) ? (0.004 * (v[0] & 0xF)) : nil
             }],
-            :L1_SIGNAL_STRENGTH_dBHz => [42, 1, "C"],
-            :L1_LOCK_SEC => [40, 2, "v", proc{|v| 1E-3 * v}],
+            :SIGNAL_STRENGTH_dBHz => [42, 1, "C"],
+            :LOCK_SEC => [40, 2, "v", proc{|v| 1E-3 * v}],
           }.each{|k, prop|
             next unless v = loader.call(*prop)
-            meas.add(svid, k, v)
+            meas.add(svid, "#{sigid}_#{k}".to_sym, v) rescue nil # unsupported signal
           }
         }
         after_run.call(run(meas, t_meas), [meas, t_meas])
@@ -605,18 +616,19 @@ class Receiver
 
       types ||= Hash[*(item[:meas_types].collect{|sys, values|
         [sys, values.collect.with_index{|type_, i|
-          case type_
-          when "C1", "C1C"
-            [i, :L1_PSEUDORANGE]
-          when "L1", "L1C"
-            [i, :L1_CARRIER_PHASE]
-          when "D1", "D1C"
-            [i, :L1_DOPPLER]
-          when "S1", "S1C"
-            [i, :L1_SIGNAL_STRENGTH_dBHz]
-          else
-            nil 
-          end
+          sig_obs_type = [case type_[1..-1]
+            when /^1C?$/; :L1
+            when /^2[XL]$/; :L2CL
+            when /^2S$/; :L2CM
+            else; nil
+          end, {
+            'C' => :PSEUDORANGE,
+            'L' => :CARRIER_PHASE,
+            'D' => :DOPPLER,
+            'S' => :SIGNAL_STRENGTH_dBHz,
+          }[type_[0]]]
+          next nil unless sig_obs_type.all?
+          [i, sig_obs_type.join('_').to_sym]
         }.compact]
       }.flatten(1))]
 

data/lib/gps_pvt/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module GPS_PVT
-  VERSION = "0.8.1"
+  VERSION = "0.8.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gps_pvt
 version: !ruby/object:Gem::Version
-  version: 0.8.1
+  version: 0.8.2
 platform: ruby
 authors:
 - fenrir(M.Naruoka)
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-11-17 00:00:00.000000000 Z
+date: 2022-11-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubyserial