gps_pvt 0.9.2 → 0.9.4

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

@@ -6,6 +6,8 @@ require 'SylphideMath.so'
 require 'matrix'
 
 shared_examples 'Matrix' do
+  let!(:tolerance){SylphideMath::tolerance}
+  after{SylphideMath::tolerance = tolerance}
   let(:params){{
     :rc => [8, 8],
     :acceptable_delta => 1E-10,
@@ -53,7 +55,7 @@ shared_examples 'Matrix' do
       [:row_size, :column_size].each{|f|
         a = a_gen.call
         a.define_singleton_method(f){-1}
-        expect{ mat_type::new(a) }.to raise_error(RuntimeError)
+        expect{ mat_type::new(a) }.to raise_error(ArgumentError)
       }
     end
     it 'is invoked with I, identity, unit' do
@@ -70,12 +72,12 @@ shared_examples 'Matrix' do
     end
     it 'sets its elements with [], [[]], Matrix' do
       expect( mat_type::new(params[:rc][0], params[:rc][1], compare_with.flatten).to_a ).to eq(compare_with)
-      expect{ mat_type::new(params[:rc][0], params[:rc][1], compare_with.flatten[0..-2]) }.to raise_error(RuntimeError)
+      expect{ mat_type::new(params[:rc][0], params[:rc][1], compare_with.flatten[0..-2]) }.to raise_error(ArgumentError)
       expect( mat_type::new(params[:rc][0], params[:rc][1], compare_with.flatten + [gen_elm.call]).to_a ).to eq(compare_with)
-      expect{ mat_type::new(params[:rc][0], params[:rc][1], compare_with.flatten[0..-2] + [nil]) }.to raise_error(RuntimeError)
+      expect{ mat_type::new(params[:rc][0], params[:rc][1], compare_with.flatten[0..-2] + [nil]) }.to raise_error(ArgumentError)
 
       expect( mat_type::new(params[:rc][0], params[:rc][1], compare_with).to_a ).to eq(compare_with)
-      expect{ mat_type::new(params[:rc][0], params[:rc][1], compare_with[0..-2]) }.to raise_error(RuntimeError)
+      expect{ mat_type::new(params[:rc][0], params[:rc][1], compare_with[0..-2]) }.to raise_error(ArgumentError)
       expect( mat_type::new(params[:rc][0], params[:rc][1], compare_with + [params[:rc][1].times.map{gen_elm.call}]).to_a ).to eq(compare_with)
       expect( mat_type::new(compare_with).to_a ).to eq(compare_with)
 
@@ -83,7 +85,7 @@ shared_examples 'Matrix' do
     end
     it 'sets its elements with {}' do
       expect( mat_type::new(*params[:rc]){|i, j| compare_with[i][j]}.to_a ).to eq(compare_with)
-      expect{ mat_type::new(*params[:rc]){nil}.to_a }.to raise_error(RuntimeError)
+      expect{ mat_type::new(*params[:rc]){nil}.to_a }.to raise_error(ArgumentError)
       expect{ mat_type::new(compare_with){|i, j| compare_with[i][j]} }.to raise_error(ArgumentError)
       expect{ mat_type::new(Matrix[*compare_with]){|i, j| compare_with[i][j]} }.to raise_error(ArgumentError)
 
@@ -92,17 +94,25 @@ shared_examples 'Matrix' do
   end
   
   describe 'property' do
-    let(:mat){{
-      :square => proc{
+    let(:mat_gen){{
+      :square => proc{|r| # example: [[1, 3, 6], [2, 5, 8], [4, 7, 9]]
         k = 0
-        mat_type::new(params[:rc][0], params[:rc][0]){|i, j| k += 1}
-      }.call,
+        res = mat_type::new(r, r)
+        (r * 2 - 1).times{|ij|
+          (([ij - r + 1, 0].max)..([ij, r - 1].min)).each{|i| res[ij - i, i] = (k += 1)}
+        }
+        res
+      }
+    }}
+    let(:mat){{
+      :square => mat_gen[:square].call(params[:rc][0]),
       :not_square => proc{
         k = 0
         mat_type::new(params[:rc][0], params[:rc][0] * 2){|i, j| k += 1}
       }.call,
       :diagonal => mat_type::new(params[:rc][0], params[:rc][0]){|i, j| i == j ? 1 : 0},
       :symmetric => mat_type::new(params[:rc][0], params[:rc][0]){|i, j| i + j},
+      :unit => mat_type::I(params[:rc][0]),
     }}
     describe 'is checked with' do
       it 'square?' do
@@ -117,12 +127,52 @@ shared_examples 'Matrix' do
         expect(mat[:diagonal].diagonal?)    .to eq(true)
         expect(mat[:symmetric].diagonal?)   .to eq(false)
       end
+      it 'lower_triangular?' do
+        expect(mat[:square].lower_triangular?)      .to eq(false)
+        expect(mat[:not_square].lower_triangular?)  .to eq(false)
+        expect(mat[:diagonal].lower_triangular?)    .to eq(true)
+        expect(mat[:symmetric].lower_triangular?)   .to eq(false)
+      end
+      it 'upper_triangular?' do
+        expect(mat[:square].upper_triangular?)      .to eq(false)
+        expect(mat[:not_square].upper_triangular?)  .to eq(false)
+        expect(mat[:diagonal].upper_triangular?)    .to eq(true)
+        expect(mat[:symmetric].upper_triangular?)   .to eq(false)
+      end
       it 'symmetric?' do
         expect(mat[:square].symmetric?)     .to eq(false)
         expect(mat[:not_square].symmetric?) .to eq(false)
         expect(mat[:diagonal].symmetric?)   .to eq(true)
         expect(mat[:symmetric].symmetric?)  .to eq(true)
       end
+      it 'hermitian?' do
+        expect(mat[:square].hermitian?)     .to eq(false)
+        expect(mat[:not_square].hermitian?) .to eq(false)
+        expect(mat[:diagonal].hermitian?)   .to eq(true)
+        expect(mat[:symmetric].hermitian?)  .to eq(true)
+      end
+      it 'skew_symmetric?' do
+        expect(mat[:square].skew_symmetric?)     .to eq(false)
+        expect(mat[:not_square].skew_symmetric?) .to eq(false)
+        expect(mat[:diagonal].skew_symmetric?)   .to eq(true)
+        expect(mat[:symmetric].skew_symmetric?)  .to eq(false)
+      end
+      it 'normal?' do
+        expect(mat[:square].normal?)     .to eq(false)
+        expect(mat[:not_square].normal?) .to eq(false)
+        expect(mat[:diagonal].normal?)   .to eq(true)
+        expect(mat[:symmetric].normal?)  .to eq(true)
+      end
+      it 'orthogonal?' do
+        expect(mat[:square].orthogonal?)    .to eq(false)
+        expect(mat[:not_square].orthogonal?).to eq(false)
+        expect(mat[:unit].orthogonal?)      .to eq(true)
+      end
+      it 'unitary?' do
+        expect(mat[:square].unitary?)     .to eq(false)
+        expect(mat[:not_square].unitary?) .to eq(false)
+        expect(mat[:unit].unitary?)       .to eq(true)
+      end
       it 'different_size?' do
         mat.keys.combination(2).each{|mat1, mat2|
           expect(mat[mat1].different_size?(mat[mat2])).to eq([mat1, mat2].include?(:not_square))
@@ -142,10 +192,40 @@ shared_examples 'Matrix' do
       end
       it 'determinant, det' do
         [:determinant, :det].each{|f|
-          #expect(mat[:square].send(f)).to eq(Matrix[*mat[:square].to_a].det)
+          expect(mat[:square].send(f)).to eq(Matrix[*mat[:square].to_a].det)
           expect{mat[:not_square].send(f)}.to raise_error(RuntimeError)
         }
       end
+      it 'rank' do
+        (5..8).each{|n|
+          orig = mat_gen[:square].call(n)
+          expect(orig.rank).to eq(Matrix[*orig.to_a].rank)
+        }
+        expect(mat[:symmetric].rank).to eq(Matrix[*mat[:symmetric].to_a].rank)
+        expect{mat[:not_square].rank}.to raise_error(RuntimeError)
+      end
+      it 'cofactor' do
+        SylphideMath::tolerance = 1E-10
+        (5..8).each{|n|
+          orig = mat_gen[:square].call(n)
+          cmp = Matrix[*orig.to_a]
+          orig.rows.times{|i|
+            orig.columns.times{|j|
+              a, b = [orig, cmp].collect{|item| item.cofactor(i, j)} #rescue next
+              expect((a - b).abs).to be < params[:acceptable_delta]
+            }
+          }
+        }
+      end
+      it 'adjugate' do
+        SylphideMath::tolerance = 1E-10
+        (5..8).each{|n|
+          orig = mat_gen[:square].call(n)
+          (Matrix[*orig.adjugate.to_a] - Matrix[*orig.to_a].adjugate).each{|v| 
+            expect(v.abs).to be < params[:acceptable_delta]
+          }
+        }
+      end
     end
   end
   
@@ -257,6 +337,8 @@ shared_examples 'Matrix' do
       expect(mat.adjoint.to_a).to eq(Matrix[*compare_with].conj.t.to_a)
     end
     it 'supports submatrix with partial' do
+      expect(mat.partial(params[:rc][0] - 1, params[:rc][1] - 1).to_a) \
+          .to eq(Matrix[*compare_with[0..-2].collect{|values| values[0..-2]}].to_a)
       expect(mat.partial(params[:rc][0] - 1, params[:rc][1] - 1, 1, 1).to_a) \
           .to eq(Matrix[*compare_with[1..-1].collect{|values| values[1..-1]}].to_a)
     end
@@ -280,6 +362,14 @@ shared_examples 'Matrix' do
         }
       }
     end
+    it 'generates minor matrix with first_minor' do
+      params[:rc][0].times{|i|
+        params[:rc][1].times{|j|
+          expect(mat.first_minor(i, j).to_a) \
+              .to eq(Matrix[*compare_with].first_minor(i, j).to_a)
+        }
+      }
+    end
   end
   
   describe 'iterator' do
@@ -310,6 +400,19 @@ shared_examples 'Matrix' do
         }
       }
     end
+    it 'supports index, find_index' do
+      cnd = proc{|v| v.abs >= 0.5}
+      [:index, :find_index].each{|func|
+        opt.each{|k, indices|
+          expect(mat.send(*[func, k].compact, &cnd)).to eq(
+              indices.select{|i, j| cnd.call(compare_with[i][j])}.first)
+          indices.each{|i, j|
+            expect(mat.send(*[func, compare_with[i][j], k].compact)).to eq([i, j])
+          }
+          expect(mat.send(*[func, 1, k].compact)).to be(nil)
+        }
+      }
+    end
     it 'supports map, collect, map_with_index, collect_with_index' do
       [:map, :collect, :map_with_index, :collect_with_index].each{|func|
         opt.each{|k, indices|
@@ -372,7 +475,7 @@ shared_examples 'Matrix' do
     end
     it 'have +(scalar)' do
       expect((mat[0] + 1).to_a).to eq((Matrix[*compare_with[0]] + Matrix::unit(params[:rc][0])).to_a)
-      expect{mat[2] + 1}.to raise_error(RuntimeError)
+      expect{mat[2] + 1}.to raise_error(ArgumentError)
     end
     it 'have +(mat)' do
       [[0, 1], [2, 3]].each{|i, j|
@@ -381,7 +484,7 @@ shared_examples 'Matrix' do
     end
     it 'have -(scalar)' do
       expect((mat[0] - 1).to_a).to eq((Matrix[*compare_with[0]] - Matrix::unit(params[:rc][0])).to_a)
-      expect{mat[2] - 1}.to raise_error(RuntimeError)
+      expect{mat[2] - 1}.to raise_error(ArgumentError)
     end
     it 'have -(mat)' do
       [[0, 1], [2, 3]].each{|i, j|
@@ -395,9 +498,16 @@ shared_examples 'Matrix' do
     end
     it 'have *(mat)' do
       expect((mat[0] * mat[1]).to_a).to eq((Matrix[*compare_with[0]] * Matrix[*compare_with[1]]).to_a)
-      expect{mat[2] * mat[3]}.to raise_error(RuntimeError)
+      expect{mat[2] * mat[3]}.to raise_error(ArgumentError)
       expect((mat[2] * mat[3].t).to_a).to eq((Matrix[*compare_with[2]] * Matrix[*compare_with[3]].t).to_a)
     end
+    it 'have entrywise_product(mat), a.k.a. .*(mat)' do
+      [:entrywise_product, :hadamard_product].each{|func|
+        [[0, 1], [2, 3]].each{|i, j|
+          expect((mat[i].send(func, mat[j])).to_a).to eq((Matrix[*compare_with[i]].send(func, Matrix[*compare_with[j]])).to_a)
+        }
+      } if Gem::Version::create(RUBY_VERSION) >= Gem::Version::create("2.5.0")
+    end
     it 'have /(scalar)' do
       expect((mat[0] / 2).to_a).to eq((Matrix[*compare_with[0]] / 2).to_a)
       expect((mat[2] / 2).to_a).to eq((Matrix[*compare_with[2]] / 2).to_a)

data/gps_pvt.gemspec

@@ -17,7 +17,7 @@ Gem::Specification.new do |spec|
 
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = spec.homepage
-  #spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+  #spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/main/CHANGELOG.md"
     
   spec.extensions = ["ext/gps_pvt/extconf.rb"]
 
@@ -63,6 +63,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake-compiler"
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "matrix" if GPS_PVT::version_compare(RUBY_VERSION, "3.1") >= 0
+  spec.add_development_dependency "github_changelog_generator"
 
   # For more information and examples about making a new gem, checkout our
   # guide at: https://bundler.io/guides/creating_gem.html

data/lib/gps_pvt/ntrip.rb

@@ -54,7 +54,7 @@ class Ntrip < Net::HTTP
       llh0 = Coordinate::LLH::new(D2R * lat_deg, D2R * lng_deg, 0)
       collect{|pt, prop|
         llh = Coordinate::LLH::new(*([:latitude, :longitude].collect{|k| D2R * prop[k].to_f} + [0]))
-        [llh0.xyz.dist(llh.xyz), prop]
+        [llh0.xyz.distance(llh.xyz), prop]
       }.sort{|a, b| a[0] <=> b[0]} # return [distance, property]
     end
   end

data/lib/gps_pvt/receiver/rtcm3.rb

@@ -18,6 +18,13 @@ class Receiver
     else; raise "reference time (#{ref_time}) should be GPS::Time or Time"
     end
     leap_sec = ref_time.leap_seconds
+    ref_pos = opt[:ref_pos] || if src_io.respond_to?(:property) then
+      Coordinate::LLH::new(*(src_io.property.values_at(:latitude, :longitude).collect{|v|
+        v.to_f / 180 * Math::PI
+      } + [0])).xyz
+    else 
+      defined?(@base_station) ? @base_station : nil
+    end
     after_run = b || proc{|pvt| puts pvt.to_s if pvt}
     t_meas, meas = [nil, {}]
     # meas := {msg_num => [[], ...]} due to duplicated observation such as 1074 and 1077
@@ -26,7 +33,9 @@ class Receiver
       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
+      pvt = nil
+      after_run.call(pvt = run(meas_, t_meas), [meas_, ref_time = t_meas]) if t_meas
+      ref_pos = pvt.xyz if pvt && pvt.position_solved?
       t_meas, meas = [nil, {}]
     }
     dt_threshold = GPS::Time::Seconds_week / 2
@@ -53,6 +62,63 @@ class Receiver
         GPS::Time::new(ref_time.week, 0) + tod + 60 * 60 * 24 * ref_dow
       end
     }
+    restore_ranges = proc{
+      c_1ms = 299_792.458
+      threshold = c_1ms / 10 # 100 us =~ 30 km
+      cache = {} # {[sys, svid] => [range, t], ...}
+      get_rough = proc{|t, sys_svid_list|
+        sn_list = sys_svid_list.collect{|sys, svid|
+          case sys
+          when :GPS, :QZSS; @solver.gps_space_node
+          when :SBAS; @solver.sbas_space_node
+          when :GLONASS; @solver.glonass_space_node
+          end
+        }
+        critical{
+          sn_list.uniq.compact{|sn| sn.update_all_ephemeris(t)}
+          sys_svid_list.zip(sn_list).each{|(sys, svid), sn|
+            next unless sn
+            eph = sn.ephemeris(svid)
+            cache[[sys, svid]] = [if eph.valid?(t) then
+              sv_pos, clk_err = eph.constellation(t).values_at(0, 2)
+              sv_pos.distance(ref_pos) - (clk_err * c_1ms * 1E3)
+            end, t]
+          }
+        }
+      }
+      per_kind = proc{|t, sys_svid_list, ranges_rem|
+        get_rough.call(t, sys_svid_list.uniq.reject{|sys, svid|
+          next true unless sys
+          range, t2 = cache[[sys, svid]]
+          range && ((t2 - t).abs <= 60)
+        })
+        ranges_rem.zip(sys_svid_list).collect{|rem_in, (sys, svid)|
+          range_ref, t2 = cache[[sys, svid]]
+          next nil unless range_ref
+          q, rem_ref = range_ref.divmod(c_1ms)
+          delta = rem_in - rem_ref 
+          res = if delta.abs <= threshold then
+            q * c_1ms + rem_in
+          elsif -delta + c_1ms <= threshold
+            (q - 1) * c_1ms + rem_in
+          elsif delta + c_1ms <= threshold
+            (q + 1) * c_1ms + rem_in
+          end
+          #p [sys, svid, q, rem_in, rem_ref, res]
+          (cache[[sys, svid]] = [res, t])[0]
+        }
+      }
+      proc{|t, sys_svid_list, ranges|
+        [
+          :pseudo_range, # for MT 1001/3/9/11, MSM1/3
+          :phase_range, # for MT 1003/11, MSM2/3
+        ].each{|k|
+          next if ranges[k]
+          k_rem = "#{k}_rem".to_sym
+          ranges[k] = per_kind.call(t, sys_svid_list, ranges[k_rem]) if ranges[k_rem]
+        }
+      }
+    }.call
 
     while packet = rtcm3.read_packet
       msg_num = packet.message_number
@@ -66,15 +132,19 @@ class Receiver
       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|
+        sys_svid_list = ranges[:sat].collect{|svid|
           case svid
-          when 1..32; # GPS
-          when 40..58; svid += 80 # SBAS
-          else; next
+          when 1..32; [:GPS, svid]
+          when 40..58; [:SBAS, svid + 80]
+          else; [nil, svid]
           end
+        }
+        restore_ranges.call(t_meas2, sys_svid_list, ranges)
+        item_size = sys_svid_list.size
+        ([sys_svid_list] + [:pseudo_range, :phase_range, :cn].collect{|k|
+          ranges[k] || ([nil] * item_size)
+        }).transpose.each{|(sys, svid), pr, cpr, cn|
+          next unless sys
           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
@@ -82,25 +152,34 @@ class Receiver
       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|
+        sys_svid_list = ranges[:sat].collect{|svid|
           case svid
-          when 1..24 # GLONASS
+          when 1..24; [:GLONASS, svid]
+          when 40..58; [:SBAS, svid + 80]
+          else; [nil, svid]
+          end
+        }
+        restore_ranges.call(t_meas2, sys_svid_list, ranges)
+        item_size = sys_svid_list.size
+        ([sys_svid_list] + [:freq_ch, :pseudo_range, :phase_range, :cn].collect{|k|
+          ranges[k] || ([nil] * item_size)
+        }).transpose.each{|(sys, svid), freq_ch, pr, cpr, cn|
+          case sys
+          when :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
+          when :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 1013
+        leap_sec = parsed[5][0]
       when 1019, 1044
         params = parsed.params
         if msg_num == 1044
@@ -162,25 +241,27 @@ class Receiver
             }.compact.flatten(1))]
           }
         end
-        sig_list, svid_offset = case msg_num / 10
+        sig_list, sys, 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]
+                16 => [:L2CL, GPS::SpaceNode.L2_WaveLength]}, :GPS, 0]
           when 108 # GLONASS
-            [{2 => [:L1, nil]}, 0x100]
+            [{2 => [:L1, nil]}, :GLONASS, 0x100]
           when 110 # SBAS
-            [{2 => [:L1, GPS::SpaceNode.L1_WaveLength]}, 120]
+            [{2 => [:L1, GPS::SpaceNode.L1_WaveLength]}, :SBAS, 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]
+                16 => [:L2CL, GPS::SpaceNode.L2_WaveLength]}, :QZSS, 192]
+          else; [{}, nil, 0]
         end
-        item_size = ranges[:sat_sig].size
-        [:sat_sig, :pseudo_range, :phase_range, :phase_range_rate, :cn].collect{|k|
+        sys_svid_list = ranges[:sat_sig].collect{|sat, sig| [sys, (sat + svid_offset) & 0xFF]}
+        restore_ranges.call(t_meas2, sys_svid_list, ranges)
+        item_size = sys_svid_list.size
+        [:sat_sig, :pseudo_range, :phase_range, :phase_range_rate, :cn, :halfc_amb].collect{|k|
           ranges[k] || ([nil] * item_size)
-        }.transpose.each{|(svid, sig), pr, cpr, dr, cn|
+        }.transpose.each{|(svid, sig), pr, cpr, dr, cn, amb|
           prefix, len = sig_list[sig]
           next unless prefix
           proc{
@@ -193,6 +274,7 @@ class Receiver
           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
+          meas2 << [svid, "#{prefix}_CARRIER_PHASE_AMBIGUITY_SCALE".to_sym, 0.5] if amb && (amb == 1)
         }
       else
         #p({msg_num => parsed})

data/lib/gps_pvt/receiver.rb

@@ -416,6 +416,7 @@ class Receiver
     opt = options[0] || {}
     case sys
     when :GPS, :QZSS
+      return unless bcast_data.size == 10 # 8 for QZSS(SAIF)
       return unless eph = @eph_list[prn]
       sn = @solver.gps_space_node
       subframe, iodc_or_iode = eph.parse(bcast_data)
@@ -508,10 +509,12 @@ class Receiver
           }.each{|k, prop|
             meas.add(prn, k, loader.call(*prop))
           }
+          lli = packet[6 + 31 + (i * 24)]
           # bit 0 of RINEX LLI (loss of lock indicator) shows lost lock
           # between previous and current observation, which maps negative lock seconds
-          meas.add(prn, :L1_LOCK_SEC,
-              (packet[6 + 31 + (i * 24)] & 0x01 == 0x01) ? -1 : 0)
+          meas.add(prn, :L1_LOCK_SEC, (lli & 0x01 == 0x01) ? -1 : 0)
+          # set bit 1 of LLI represents possibility of half cycle ambiguity
+          meas.add(prn, :L1_CARRIER_PHASE_AMBIGUITY_SCALE, 0.5) if (lli & 0x02 == 0x02)
         }
         after_run.call(run(meas, t_meas), [meas, t_meas])
       when [0x02, 0x15] # RXM-RAWX
@@ -552,7 +555,13 @@ class Receiver
             }],
             :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 => [24, 8, "E", proc{|v|
+              case (trk_stat & 0x6)
+              when 0x6; (trk_stat & 0x8 == 0x8) ? (v + 0.5) : v
+              when 0x2; meas.add(svid, "#{sigid}_CARRIER_PHASE_AMBIGUITY_SCALE".to_sym, 0.5); v
+              else; nil
+              end
+            }],
             :CARRIER_PHASE_SIGMA => [44, 1, nil, proc{|v|
               (trk_stat & 0x2 == 0x2) ? (0.004 * (v[0] & 0xF)) : nil
             }],
@@ -628,7 +637,7 @@ class Receiver
             'S' => :SIGNAL_STRENGTH_dBHz,
           }[type_[0]]]
           next nil unless sig_obs_type.all?
-          [i, sig_obs_type.join('_').to_sym]
+          [i, sig_obs_type.join('_').to_sym, *sig_obs_type]
         }.compact]
       }.flatten(1))]
 
@@ -643,8 +652,7 @@ class Receiver
       }.call(item[:header]["GLONASS SLOT / FRQ #"])
 
       meas = GPS::Measurement::new
-      item[:meas].each{|k, v|
-        sys, prn = k
+      item[:meas].each{|(sys, prn), v|
         case sys
         when 'G', ' '
         when 'S'; prn += 100
@@ -661,8 +669,11 @@ class Receiver
         else; next
         end
         types[sys] = (types[' '] || []) unless types[sys]
-        types[sys].each{|i, type_|
-          meas.add(prn, type_, v[i][0]) if v[i]
+        types[sys].each{|i, type_, sig_type, obs_type|
+          next unless v[i]
+          meas.add(prn, type_, v[i][0])
+          meas.add(prn, "#{sig_type}_CARRIER_PHASE_AMBIGUITY_SCALE".to_sym, 0.5) \
+              if (obs_type == :CARRIER_PHASE) && (v[i][1] & 0x2 == 0x2)
         }
       }
       after_run.call(run(meas, t_meas), [meas, t_meas])

data/lib/gps_pvt/rtcm3.rb

@@ -95,6 +95,13 @@ class RTCM3
         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]
+        51 => 16,
+        52 => 17,
+        53 => 5,
+        54 => 8,
+        55 => 12,
+        56 => 1,
+        57 => 16,
         71 => 8,
         76 => 10,
         77 => proc{
@@ -237,12 +244,14 @@ class RTCM3
       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],
+      1013 => [2, 3, 51, 52, 53, 54],
       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
+      1070..1229 => [2, [:uint, 12], [:uint, 30], 393], # 55 bits part of messages will be overwritten
       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
@@ -392,6 +401,30 @@ class RTCM3
       end
       SPEED_OF_LIGHT = 299_792_458
     end
+    module MSM1_2_3
+      include MSM
+      def ranges
+        sats, cells, offset = property.values_at(:sats, :cells, :header_items)
+        nsat, ncell = [sats.size, cells.size]
+        res = {:sat_sig => cells}
+        range_rough = cells.collect{|sat, sig| # DF398
+          self[offset + sats.find_index(sat)][0]
+        }
+        add_proc = proc{|idx_cell|
+          values = self[offset + (nsat * 1) + (ncell * idx_cell), ncell]
+          next if values.empty? 
+          k = {400 => :pseudo_range_rem, 401 => :phase_range_rem}[values[0][1]]
+          next unless k
+          res[k] = values.zip(range_rough).collect{|(v, df), v_base|
+            ((v_base + v) * SPEED_OF_LIGHT) rescue nil
+          }
+        }
+        add_proc.call(0)
+        add_proc.call(1)
+        res[:halfc_amb] = self[-ncell, ncell].transpose[0] if self[-1][1] == 420
+        res
+      end
+    end
     module MSM4_6
       include MSM
       def ranges
@@ -401,14 +434,16 @@ class RTCM3
         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
+        halfc_amb = self[offset + (nsat * 2) + (ncell * 3), ncell] # DF420
         cn = self[offset + (nsat * 2) + (ncell * 4), ncell] # DF403/408
-        Hash[*([:sat_sig, :pseudo_range, :phase_range, :cn].zip(
+        Hash[*([:sat_sig, :pseudo_range, :phase_range, :cn, :halfc_amb].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]]
+                  cn[i][0],
+                  halfc_amb[i][0]]
             }.transpose).flatten(1))]
       end
     end
@@ -422,16 +457,18 @@ class RTCM3
         delta_rough = self[offset + (nsat * 3), nsat] # DF399
         range_fine = self[offset + (nsat * 4), ncell] # DF400/405
         phase_fine = self[offset + (nsat * 4) + (ncell * 1), ncell] # DF401/406
+        halfc_amb = self[offset + (nsat * 4) + (ncell * 3), ncell] # DF420
         cn = self[offset + (nsat * 4) + (ncell * 4), ncell] # DF403/408
         delta_fine = self[offset + (nsat * 4) + (ncell * 5), ncell] # DF404
-        Hash[*([:sat_sig, :pseudo_range, :phase_range, :phase_range_rate, :cn].zip(
+        Hash[*([:sat_sig, :pseudo_range, :phase_range, :phase_range_rate, :cn, :halfc_amb].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),
                   ((delta_fine[i][0] + delta_rough[i2][0]) rescue nil),
-                  cn[i][0]]
+                  cn[i][0],
+                  halfc_amb[i][0]]
             }.transpose).flatten(1))]
       end
     end
@@ -468,6 +505,9 @@ class RTCM3
               1012 => (38..50).to_a,
             }[msg_num]] * nsat).flatten), offset)
         attributes << GLONASS_Observation
+      when 1013
+        add_proc.call(DataFrame.generate_prop(
+            ((55..57).to_a * values[4]).flatten), 24 + mt[:bits_total])
       when 1019
         attributes << GPS_Ephemeris
       when 1020
@@ -492,6 +532,15 @@ class RTCM3
           add_proc.call(msm_sig, offset)
         }
         case msg_num % 10
+        when 1
+          attributes << MSM1_2_3
+          msm_proc.call([398], [400])
+        when 2
+          attributes << MSM1_2_3
+          msm_proc.call([398], [401, 402, 420])
+        when 3
+          attributes << MSM1_2_3
+          msm_proc.call([398], [400, 401, 402, 420])
         when 4
           attributes << MSM4_6
           msm_proc.call([397, 398], [400, 401, 402, 420, 403])

data/lib/gps_pvt/version.rb

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