sgslib 1.5.1 → 1.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b5dffcc970035c48e2b6026c72884b6ab97cc14ac43ba255cb4386244b46287c
-  data.tar.gz: 347c958575c0e9510047c75b997426083d4e3abf8ee479ff9b407c3395bbe118
+  metadata.gz: 3e111aaff75b5c948f935ac6f76747487c2a6acf2c4e661e07b5e670aa48024b
+  data.tar.gz: 8b0dae14c6a69c2222e38522d3f7e562b45c33e754cf5019a9f0b081d6191fc6
 SHA512:
-  metadata.gz: bdee04756fe59509497bc455f7874e9c05ecca6c9031f55133460a28ea987d9a0dd788588e2b449b9fe0630f734f23b6c968722361153b9130fa0362c354b67c
-  data.tar.gz: de267f01e59622938cfb1ad3ebbcb7c08c72bb02a625f1de72c93255b5e3be868cae29a1625383890c4c4aa57292b27942d735adb0abb4f36763dd481ca62893
+  metadata.gz: 101b2c3581effba8bc0fae32d4c68030649104862101336409fdeb4679ff25236adf0b67dfeac588eceb0196a7616175cc1112d1d926ee6d528c95c60cbeed60
+  data.tar.gz: 981bf2364b073ae0d25e0fea03341b289db890836af399c4cee4079d0dcde1ceef20f9669d3fdeb36d2ea143b6566830bcc676ea705bf9bb6439dc8162234e52

data/lib/sgs/alarm.rb

@@ -109,7 +109,7 @@ module SGS
     # Main daemon function (called from executable)
     def self.daemon
       puts  "Alarm daemon starting up..."
-      otto = SGS::RPCClient.new(:otto)
+      otto = RPCClient.new(:otto)
       loop do
         #puts "Check for any alarms..."
         #resp = otto.command "A?"
@@ -126,7 +126,7 @@ module SGS
         f.puts "/*\n * Autogenerated by #{__FILE__}.\n * DO NOT HAND-EDIT!\n */"
         constants.sort.each do |c|
           unless c == :ALARM_NAMES
-            cval = SGS::Alarm.const_get(c)
+            cval = Alarm.const_get(c)
             str = "#define SGS_ALARM_#{c.to_s}"
             str += "\t" if str.length < 32
             str += "\t#{cval}\t/* #{alarm.name(cval)} */"

data/lib/sgs/bearing.rb

@@ -49,7 +49,8 @@ module SGS
     attr_accessor :distance
 
     #
-    # Create the Bearing instance.
+    # Create the Bearing instance. Angle is in radians, distance in nautical
+    # miles.
     def initialize(angle = 0.0, distance = 0.0)
       self.angle = angle.to_f
       self.distance = distance.to_f
@@ -73,6 +74,23 @@ module SGS
       rad.to_f * 180.0 / Math::PI
     end
 
+    #
+    # Convert boat angle (0->255) to radians. The boat uses an 8bit quantity
+    # to represent an angle, where 256 maps to 360 degrees. This makes angle
+    # arithmetic quite simple on an 8 bit processor, but useless for
+    # something which has a proper FPU. These two helper functions convert
+    # to and from radians.
+    def self.xtor(val)
+      val &= 0xff
+      val.to_f * Math::PI / 128.0
+    end
+
+    #
+    # Convert radians to hex-degrees.
+    def self.rtox(rad)
+      (rad.to_f * 128.0 / Math::PI).round.to_i & 0xff
+    end
+
     #
     # Handy function to re-adjust an angle away from negative
     def self.absolute(angle)
@@ -111,7 +129,7 @@ module SGS
       sin_dlon = Math.sin(loc2.longitude - loc1.longitude)
       cos_dlon = Math.cos(loc2.longitude - loc1.longitude)
       bearing.distance = Math.acos(sin_lat1*sin_lat2 + cos_lat1*cos_lat2*cos_dlon) *
-                                SGS::EARTH_RADIUS
+                                EARTH_RADIUS
       y = sin_dlon * cos_lat2
       x = cos_lat1 * sin_lat2 - sin_lat1 * cos_lat2 * cos_dlon
       bearing.angle = Math.atan2(y, x)
@@ -142,10 +160,20 @@ module SGS
       Bearing.absolute(@angle - Math::PI)
     end
 
+    #
+    # Return the distance in metres
+    def distance_m
+      @distance * 1852.0
+    end
+
     #
     # Convert to a string
     def to_s
-      "BRNG %03dd,%.3fnm" % [angle_d, @distance]
+      if @distance > 0.9
+        "BRNG %03dd,%.3fNM" % [angle_d, @distance]
+      else
+        "BRNG %03dd,%.1fm" % [angle_d, distance_m]
+      end
     end
   end
 end

data/lib/sgs/config.rb

@@ -56,7 +56,6 @@ module SGS
       GPS.setup
       Otto.setup
       Timing.setup
-      Waypoint.setup
     end
   end
 end

data/lib/sgs/course.rb

@@ -149,11 +149,21 @@ module SGS
     end
 
     #
-    # Compute a relative VMG based on the waypoint
+    # Compute a relative VMG based on the waypoint. If you're computing
+    # angles to one waypoint, the relative VMG will allow you to compare
+    # against each possible angle. If you're computing to different
+    # waypoints, then the distance from your position to that waypoint is
+    # taken into consideration so that waypoints further away have less
+    # impact on your VMG choice.
     def relative_vmg(waypt)
-      relvmg = @speed * Math::cos(waypt.bearing.angle - @heading) / waypt.distance
-      puts "Relative VMG to WPT: #{waypt.name} is #{relvmg}"
-      relvmg
+      @speed * Math::cos(waypt.bearing.angle - @heading) / waypt.distance
+    end
+
+    #
+    # Compute the wind (as a Bearing) based on the compass heading and the
+    # apparent wind as reported.
+    def compute_wind
+      @wind.angle = @heading + @awa
     end
 
     #
@@ -161,7 +171,10 @@ module SGS
     # fast the boat will travel at the particular apparent wind angle.
     def compute_speed
       awa = @awa.abs
-      return 0.0 if awa < 0.75
+      if awa < 0.75
+        @speed = 0.0
+        return
+      end
       ap = 1.0
       @speed = 0.0
       @polar_curve.each do |poly_val|

data/lib/sgs/diagnostics.rb

@@ -37,7 +37,7 @@
 # Routines for handling sailboat navigation and route planning.
 #
 module SGS
-  class Diagnostics < RedisBase
+  class Diagnostics
     #
     # Main daemon function (called from executable)
     def self.daemon

data/lib/sgs/gps.rb

@@ -36,8 +36,10 @@ require 'serialport'
 
 module SGS
   class GPS < RedisBase
-    attr_accessor :time, :location, :sog, :cmg, :magvar
+    attr_accessor :time, :location, :sog, :cmg, :magvar, :val
 
+    #
+    # Create a new GPS record. Lat/Long are in radians.
     def initialize(lat = nil, long = nil)
       @time = Time.new(2000, 1, 1)
       @location = Location.new(lat, long)
@@ -52,13 +54,13 @@ module SGS
     # Main daemon function (called from executable)
     def self.daemon
       puts "GPS reader starting up..."
-      config = SGS::Config.load
+      config = Config.load
 
       sp = SerialPort.new config.gps_device, config.gps_speed
       sp.read_timeout = 10000
 
       loop do
-        nmea = SGS::NMEA.parse sp.readline
+        nmea = NMEA.parse sp.readline
         if nmea.is_gprmc?
           gps = nmea.parse_gprmc
           p gps
@@ -67,6 +69,14 @@ module SGS
       end
     end
 
+    #
+    # Hard-code a GPS value (usually for debugging purposes)
+    def force(lat, long, time = nil)
+      @time = time || Time.now
+      @location = Location.new(lat, long)
+      @valid = true
+    end
+
     #
     # Set the validity
     def is_valid
@@ -78,5 +88,15 @@ module SGS
     def valid?
       @valid == true
     end
+
+    #
+    # Display the GPS data as a useful string (in degrees)
+    def to_s
+      if valid?
+        "@#{@time.strftime('%Y%m%d-%T')}, #{@location}, SOG:#{@sog}, CMG:#{@cmg}"
+      else
+        "GPS error"
+      end
+    end
   end
 end

data/lib/sgs/location.rb

@@ -56,7 +56,7 @@ module SGS
     attr_accessor :latitude, :longitude
 
     #
-    # Create the Location instance.
+    # Create the Location instance. Latitude and longitude passed in radians.
     def initialize(lat = nil, long = nil)
       @latitude = lat.to_f if lat
       @longitude = long.to_f if long
@@ -65,7 +65,6 @@ module SGS
     #
     # The difference between two locations is a Bearing
     def -(loc)
-      puts "Distance from #{self} to #{loc}"
       Bearing.compute(self, loc)
     end
 
@@ -84,8 +83,8 @@ module SGS
       loc = Location.new
       sin_angle = Math.sin(bearing.angle)
       cos_angle = Math.cos(bearing.angle)
-      sin_dstr = Math.sin(bearing.distance / SGS::EARTH_RADIUS)
-      cos_dstr = Math.cos(bearing.distance / SGS::EARTH_RADIUS)
+      sin_dstr = Math.sin(bearing.distance / EARTH_RADIUS)
+      cos_dstr = Math.cos(bearing.distance / EARTH_RADIUS)
       sin_lat1 = Math.sin(@latitude)
       cos_lat1 = Math.cos(@latitude)
       loc.latitude = Math.asin(sin_lat1*cos_dstr + cos_lat1*sin_dstr*cos_angle)
@@ -113,10 +112,33 @@ module SGS
     end
 
     #
-    # Set the lat/long from a hash.
+    # Parse the lat/long values passed as a string. This function
+    # should be able to handle any type of lat/long string, in most
+    # general formats. See :to_s for examples.
     def parse(data)
-      @latitude = ll_parse(data["latitude"], "NS")
-      @longitude = ll_parse(data["longitude"], "EW")
+      llvals = data.split /,/
+      if llvals.count == 1
+        #
+        # Must be space-separated. Try that...
+        llvals = data.split(/ /)
+        if llvals.count != 2
+          raise ArgumentError.new "Cannot split lat/long values"
+        end
+      elsif llvals.count != 2
+        #
+        # Too many comma separators.
+        raise ArgumentError.new "Invalid lat/long values"
+      end
+      self.latitude_d = _ll_parse(llvals[0], "NS")
+      self.longitude_d = _ll_parse(llvals[1], "EW")
+      true
+    end
+
+    #
+    # Parse the lat/long from a hash object.
+    def parse_hash(data = {})
+      self.latitude_d = _ll_parse(data["latitude"], "NS")
+      self.longitude_d = _ll_parse(data["longitude"], "EW")
     end
 
     #
@@ -128,15 +150,21 @@ module SGS
     #
     # Convert the lat/long to a hash.
     def to_hash
-      {"latitude" => ll_to_s(latitude, "NS"),
-        "longitude" => ll_to_s(longitude, "EW")}
+      {"latitude" => latitude_d.round(6), "longitude" => longitude_d.round(6)}
     end
 
     #
-    # Display the lat/long as a useful string (in degrees).
-    def to_s
+    # Display the lat/long as a useful string (in degrees). Output
+    # formats are as follows (default is :d):
+    # :d    "48.104051, -7.282614"
+    # :dd   "48.104051N, 7.282614W"
+    # :dmm  "48 6.243060N, 7 16.956840W"
+    # :dms  "48 6 14.583600N, 7 16 57.410400W"
+    def to_s(opts = {})
       if valid?
-        "%s, %s" % [ll_to_s(@latitude, "NS"), ll_to_s(@longitude, "EW")]
+        lat_str = _ll_conv(latitude_d.round(6), "NS", opts)
+        lon_str = _ll_conv(longitude_d.round(6), "EW", opts)
+        "#{lat_str}, #{lon_str}"
       else
         "unknown"
       end
@@ -151,29 +179,39 @@ module SGS
     end
 
     #
-    # Helper functions for working in degrees.
+    # Return the latitude in degrees.
     def latitude_d
       Bearing.rtod @latitude
     end
 
+    #
+    # Set the latitude using a value in degrees.
     def latitude_d=(val)
       @latitude = Bearing.dtor val
     end
 
+    #
+    # Produce a latitude array for NMEA output.
     def latitude_array(fmt = nil)
-      make_ll_array latitude_d, "NS", fmt
+      _make_ll_array latitude_d, "NS", fmt
     end
 
+    #
+    # Return the longitude in degrees.
     def longitude_d
       Bearing.rtod @longitude
     end
 
+    #
+    # Set the longitude using a value in degrees.
     def longitude_d=(val)
       @longitude = Bearing.dtor val
     end
 
+    #
+    # Produce a longitude array for NMEA output.
     def longitude_array(fmt = nil)
-      make_ll_array longitude_d, "EW", fmt
+      _make_ll_array longitude_d, "EW", fmt
     end
 
     #
@@ -182,53 +220,72 @@ module SGS
       Bearing.compute(self, loc)
     end
 
-  private
-    #
-    # Parse a string into a lat or long. The latitude or longitude string
-    # should be of the format dd mm ss.sssssC (where C is NS or EW). Note
-    # that latitude and longitude are saved internally in radians.
-    def ll_parse(value, nsew)
-      args = value.split
-      dir = args[-1].gsub(/[\d\. ]+/, '').upcase
-      args.map! {|val| val.to_f}
-      val = args.shift
-      val = val + args.shift / 60.0 if args.length > 0
-      val = val + args.shift / 3600.0 if args.length > 0
-      Bearing.dtor val * ((nsew.index(dir) == 1) ? -1 : 1)
-    end
+    private
+      #
+      # Parse a latitude or longitude value, from a wide range of
+      # formats. Should handle D.ddd, D M.mmm and D M S.sss values.
+      # Can also strip out the special degrees unicode, as well as
+      # single and double quotes.
+      def _ll_parse(arg, nsew)
+        return arg.to_f if arg.kind_of? Float or arg.kind_of? Integer
+        str = arg.chomp.gsub /[\u00B0'"]/, ' '
+        if str[-1].upcase =~ /[#{nsew}]/
+          sign = (str[-1].upcase == nsew[1]) ? -1 : 1
+          str[-1] = ' '
+        else
+          sign = 1
+        end
+        args = str.split
+        raise ArgumentError.new "Cannot parse lat/long value" if args.count > 3
+        value = 0.0
+        (args.count - 1).downto(0).each do |idx|
+          value = args[idx].to_f + value / 60.0
+        end
+        sign * value
+      end
 
-    #
-    # Convert a latitude or longitude into an ASCII string of the form:
-    # dd mm ss.ssssssC (where C is NS or EW). The value should be in
-    # radians.
-    def ll_to_s(val, str)
-      val = Bearing.rtod val
-      if val < 0.0
-        chr = str[1]
-        val = -val
-      else
-        chr = str[0]
+      #
+      # Convert a latitude/longitude to a string. Can specify
+      # multiple output formats such as :d, :dd, :dmm, :dms to
+      # format according to various different styles.
+      def _ll_conv(value, nsew, opts)
+        format = opts[:format] || :d
+        return "%.6f" % value if format == :d
+        if value < 0.0
+          suffix = nsew[1]
+          value = -value
+        else
+          suffix = nsew[0]
+        end
+        case opts[:format] || :d
+        when :dd
+          "%.6f%s" % [value, suffix]
+        when :dmm
+          dd = value.to_i
+          mm = (value - dd.to_f) * 60.0
+          "%d %.6f%s" % [dd, mm, suffix]
+        when :dms
+          dd = value.to_i
+          value = (value - dd.to_f) * 60.0
+          mm = value.to_i
+          ss = (value - mm.to_f) * 60.0
+          "%d %d %.6f%s" % [dd, mm, ss, suffix]
+        end
       end
-      deg = val.to_i
-      val = (val - deg.to_f) * 60.0
-      min = val.to_i
-      sec = (val - min.to_f) * 60.0
-      "%d %d %8.6f%c" % [deg, min, sec, chr]
-    end
 
-    #
-    # Create a Lat/Long array suitable for an NMEA output
-    def make_ll_array(val, nsew, fmt = nil)
-      fmt ||= "%02d%07.4f"
-      if (val < 0)
-        val = -val
-        ne = nsew[1]
-      else
-        ne = nsew[0]
+      #
+      # Create a Lat/Long array suitable for an NMEA output.
+      def _make_ll_array(val, nsew, fmt = nil)
+        fmt ||= "%02d%07.4f"
+        if (val < 0)
+          val = -val
+          suffix = nsew[1]
+        else
+          suffix = nsew[0]
+        end
+        deg = val.to_i
+        val = (val - deg) * 60
+        [fmt % [deg, val], suffix.chr]
       end
-      deg = val.to_i
-      val = (val - deg) * 60
-      [fmt % [deg, val], ne.chr]
-    end
   end
 end

data/lib/sgs/logger.rb

@@ -37,6 +37,6 @@
 # Routines for handling sailboat navigation and route planning.
 #
 module SGS
-  class Logger < RedisBase
+  class Logger
   end
 end