gps_pvt 0.9.1 → 0.9.3

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,51 @@ 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]
+        51 => 16,
+        52 => 17,
+        53 => 5,
+        54 => 8,
+        55 => 12,
+        56 => 1,
+        57 => 16,
         71 => 8,
         76 => 10,
         77 => proc{
@@ -146,11 +183,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 +212,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 +235,81 @@ 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],
+      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
-      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))]
+      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
+      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 +333,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 +385,86 @@ 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 MSM1_2_3
+      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]
+        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
+      end
+    end
+    module MSM4_6
+      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 * 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 +480,77 @@ 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 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
         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 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])
+        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.3"
   
   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.3
 platform: ruby
 authors:
 - fenrir(M.Naruoka)
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-01-27 00:00:00.000000000 Z
+date: 2023-03-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubyserial