gps_pvt 0.9.3 → 0.9.4

data/lib/gps_pvt/receiver/rtcm3.rb

@@ -81,7 +81,7 @@ class Receiver
             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.dist(ref_pos) - (clk_err * c_1ms * 1E3)
+              sv_pos.distance(ref_pos) - (clk_err * c_1ms * 1E3)
             end, t]
           }
         }
@@ -259,9 +259,9 @@ class Receiver
         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].collect{|k|
+        [: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{
@@ -274,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

@@ -509,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
@@ -553,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
             }],
@@ -629,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))]
 
@@ -644,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
@@ -662,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

@@ -421,6 +421,7 @@ class RTCM3
         }
         add_proc.call(0)
         add_proc.call(1)
+        res[:halfc_amb] = self[-ncell, ncell].transpose[0] if self[-1][1] == 420
         res
       end
     end
@@ -433,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
@@ -454,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

data/lib/gps_pvt/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module GPS_PVT
-  VERSION = "0.9.3"
+  VERSION = "0.9.4"
   
   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.3
+  version: 0.9.4
 platform: ruby
 authors:
 - fenrir(M.Naruoka)
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-03-07 00:00:00.000000000 Z
+date: 2023-07-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubyserial
@@ -66,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: github_changelog_generator
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: This module calculate PVT by using raw observation obtained from a GPS
   receiver
 email:
@@ -163,7 +177,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.3.5
 signing_key: 
 specification_version: 4
 summary: GPS position, velocity, and time (PVT) solver