sgslib 0.1.0

data/lib/sgs/otto.rb

@@ -0,0 +1,163 @@
+#
+# Copyright (c) 2013, Kalopa Research.  All rights reserved.  This is free
+# software; you can redistribute it and/or modify it under the terms of the
+# GNU General Public License as published by the Free Software Foundation;
+# either version 2, or (at your option) any later version.
+#
+# It is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this product; see the file COPYING.  If not, write to the Free
+# Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+#
+# THIS SOFTWARE IS PROVIDED BY KALOPA RESEARCH "AS IS" AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL KALOPA RESEARCH BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+
+##
+# Routines for interfacing with the low-level microcontroller.
+#
+module SGS
+  class Otto < RedisBase
+    attr_reader :rudder, :sail, :compass, :twa
+    attr_accessor :bvcal, :bical, :btcal, :svcal
+
+    def initialize
+      @bvcal = 0.0
+      @bical = 0.0
+      @btcal = 0.0
+      @svcal = 0.0
+      @rudder = read_rudder
+      @sail = read_sail
+      @compass = read_compass
+      @twa = read_twa
+      super
+    end
+
+    #
+    # Set the required rudder angle. Input values range from +/- 40 degrees
+    def rudder=(val)
+      val = -39.9 if val < -39.9
+      val = 39.9 if val > 39.9
+      return if @rudder == val
+      @rudder = val
+      intval = (@rudder * 120.0 / 40.0).to_int + 128
+      puts "New rudder value: #{intval} (#{@rudder} degrees)"
+      send_command(SET_RUDDER, intval)
+    end
+
+    #
+    # Set the required sail angle. Input values range from 0 -> 90 degrees.
+    def sail=(val)
+      val = 0.0 if val < 0.0
+      val = 90.0 if val > 90.0
+      return if @sail == val
+      @sail = val
+      intval = (@sail * 256.0 / 90.0).to_int
+      puts "New sail angle: #{intval} (#{@sail} degrees)"
+      send_command(SET_SAIL, intval)
+    end
+
+    #
+    # Set the required compass reading. Input values range from 0 -> 359 degrees
+    def compass=(val)
+      while val < 0.0
+        val += 360.0
+      end
+      val %= 360.0
+      return if @compass == val
+      @compass = val
+      intval = (@compass * 256.0 / 360.0).to_int
+      puts "New compass heading: #{intval} (#{@compass} degrees)"
+      send_command(SET_COMPASS, intval)
+    end
+
+    #
+    # Set the required true wind angle. Input values range from +/- 180 degrees
+    def twa=(val)
+      val = -179.9 if val < -179.9
+      val = 179.9 if val > 179.9
+      return if @twa == val
+      @twa = val
+      val = 360.0 + val if val < 0.0
+      intval = (val * 256.0 / 360.0).to_int
+      puts "New TWA: #{intval} (#{@twa} degrees)"
+      send_command(SET_TWA, intval)
+    end
+
+    #
+    # Read the uptime clock
+    def read_uptime
+      intval = send_command(READ_UPTIME)
+    end
+
+    #
+    # Read the battery voltage
+    def read_battery_volts
+      intval = send_command(READ_BATTERY_VOLTAGE)
+      intval.to_f * @bvcal / 1024.0
+    end
+
+    #
+    # Read the battery current
+    def read_battery_current
+      intval = send_command(READ_BATTERY_CURRENT)
+      intval.to_f * @bical / 1024.0
+    end
+
+    #
+    # Read the boat temperature
+    def read_boat_temperature
+      intval = send_command(READ_BOAT_TEMPERATURE)
+      intval.to_f * @btcal / 1024.0
+    end
+
+    #
+    # Read the solar voltage
+    def read_solar_volts
+      intval = send_command(READ_SOLAR_VOLTAGE)
+      intval.to_f * @svcal / 1024.0
+    end
+
+    #
+    # Read the actual compass value
+    def read_compass
+      intval = send_command(GET_COMPASS)
+      intval.to_f * 360.0 / 256.0
+    end
+
+    #
+    # Read the actual TWA value
+    def read_twa
+      intval = send_command(GET_TWA)
+      val = intval.to_f * 180.0 / 128.0
+      val = val - 360.0 if val > 180.0
+      val
+    end
+
+    #
+    # Read the actual boat pitch
+    def read_pitch
+      intval = send_command(GET_PITCH)
+      intval.to_f
+    end
+
+    #
+    # Read the actual boat heel
+    def read_heel
+      intval = send_command(GET_HEEL)
+      intval.to_f
+    end
+  end
+end

data/lib/sgs/polar.rb

@@ -0,0 +1,86 @@
+#
+# Copyright (c) 2013, Kalopa Research.  All rights reserved.  This is free
+# software; you can redistribute it and/or modify it under the terms of the
+# GNU General Public License as published by the Free Software Foundation;
+# either version 2, or (at your option) any later version.
+#
+# It is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this product; see the file COPYING.  If not, write to the Free
+# Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+#
+# THIS SOFTWARE IS PROVIDED BY KALOPA RESEARCH "AS IS" AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL KALOPA RESEARCH BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+
+##
+# Routines for handling sailboat navigation and route planning.
+#
+# The code on this page was derived from formulae on the Movable Type site:
+# http://www.movable-type.co.uk/scripts/latlong.html
+#
+
+require 'date'
+
+module SGS
+  ##
+  #
+  # A class to handle boat polar calculations. It takes a range of polars
+  # as polynomials and then applies them.
+  class Polar
+    # Right now, we have one polar - from a Catalina 22.
+    # Note that the speed is the same, regardless of the tack.
+    STANDARD = [
+       -3.15994,
+       23.8741,
+      -27.4595,
+       16.4868,
+       -5.15663,
+        0.743936,
+       -0.0344716
+    ].freeze
+
+    #
+    # set up the default values
+    def initialize
+      @curve = STANDARD
+    end
+
+    #
+    # Compute the hull speed from the polar
+    # :awa: is the apparent wind angle (in radians)
+    # :wspeed: is the wind speed (in knots)
+    def speed(awa, wspeed = 0.0)
+      awa = awa.to_f.abs
+      ap = 1.0
+      @speed = 0.0
+      @curve.each do |poly_val|
+        @speed += poly_val * ap
+        ap *= awa
+      end
+      @speed /= 1.529955
+      if @speed < 0.0
+        @speed = 0.0
+      end
+      @speed
+    end
+
+    #
+    # Calculate the VMG from the angle to the mark.
+    def vmg(alpha)
+      Math::cos(alpha) * @speed
+    end
+  end
+end

data/lib/sgs/redis_base.rb

@@ -0,0 +1,251 @@
+#
+# Copyright (c) 2013, Kalopa Research.  All rights reserved.  This is free
+# software; you can redistribute it and/or modify it under the terms of the
+# GNU General Public License as published by the Free Software Foundation;
+# either version 2, or (at your option) any later version.
+#
+# It is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this product; see the file COPYING.  If not, write to the Free
+# Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+#
+# THIS SOFTWARE IS PROVIDED BY KALOPA RESEARCH "AS IS" AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL KALOPA RESEARCH BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+
+##
+# Routines for manipulating data in Redis.
+#
+require 'redis'
+
+module SGS
+  class RedisBase
+    ##
+    # The base (inherited) class for dealing with Redis data for
+    # the navigation system. Each model class inherits this parent,
+    # and gets an update count for free.
+
+    #
+    # Initialize the base class.
+    def initialize
+      $redis = Redis.new unless $redis
+    end
+
+    #
+    # Initialize the (sub-)class variables in Redis.
+    def self.setup
+      cls = new
+      cls.instance_variables.each do |var|
+        val = cls.instance_variable_get var
+        if val.kind_of? Array
+          #
+          # Arrays are handled separately. We instead
+          # use the index to create a series of 'fooN'
+          # variables.
+          val.size.times do |idx|
+            var_init var, val, idx
+          end
+        else
+          var_init var, val
+        end
+      end
+    end
+
+    #
+    # Initialize a Redis variable.
+    def self.var_init(var, val, idx = nil)
+      cls = new
+      $redis.setnx cls.make_redis_name(var, :idx => idx), self.to_redis(var, val, idx)
+    end
+
+    #
+    # Load the instance variables for the class.
+    def self.load()
+      cls = new
+      cls.load
+      cls
+    end
+
+    #
+    # Load the instance variables for the class.
+    def load
+      instance_variables.each do |var|
+        lval = instance_variable_get var
+        if lval.kind_of? Array
+          #
+          # It's an array - iterate and read the values.
+          lval.size.times do |idx|
+            idx_val = lval[idx]
+            lval[idx] = redis_read_var var, idx_val.class, :idx => idx
+          end
+        elsif lval.kind_of? Location
+          #
+          # ::FIXME:: Yes. this is a hack.
+          # This belongs in the Location class itself. It's arguable that a lot
+          # of the stuff belongs in the parent class. Perhaps the thing to do
+          # is ask the class to return a hash of names and values, and then
+          # set them accordingly.
+          lval.latitude = redis_read_var var, Float, :name => 'latitude'
+          lval.longitude = redis_read_var var, Float, :name => 'longitude'
+        else
+          lval = redis_read_var var, lval.class
+        end
+        instance_variable_set var, lval
+      end
+      true
+    end
+
+    #
+    # Write the instance to Redis. IWe produce a Hash of keys and values. From
+    # this and inside a Redis "multi" block, we set all the values and finally
+    # increment the count. @count is actually an instance variable of redis_base
+    def save
+      #
+      # Get the Hash of settable values (including count).
+      var_list = {}
+      self.instance_variables.each do |var|
+        lval = self.instance_variable_get var
+        if lval.kind_of? Array
+          lval.size.times do |idx|
+            var_list[make_redis_name(var, :idx => idx)] = self.class.to_redis var, lval, idx
+          end
+        elsif lval.kind_of? Location
+          #
+          # ::FIXME:: Yes. this is a hack. see 'load' above.
+          var_list[make_redis_name(var, :name => 'latitude')] = lval.latitude
+          var_list[make_redis_name(var, :name => 'longitude')] = lval.longitude
+        else
+          var_list[make_redis_name(var)] = self.class.to_redis var, lval
+        end
+      end
+      #
+      # Inside a multi-block, set all the variables and increment
+      # the count.
+      $redis.multi do
+        var_list.each do |key, value|
+          $redis.set key, value
+        end
+        $redis.incr count_name
+      end
+    end
+
+    #
+    # Publish the count onto a Redis pub/sub channel. The trick to subscribing
+    # to a channel is that whenever there's a publish, the new count is
+    # published as a string. If you subscribe to the channel (usually the
+    # class name), you can remember the last received count and decide if
+    # there is fresh data. Or, you can just act anyway.
+    def publish
+      $redis.publish self.class.redis_handle, count.to_s
+    end
+
+    #
+    # Subscribe to messages from this particular channel. Each count is sent
+    # to the code block. It's up to the called code block to decide if the
+    # count has changed and if so, to read the data from Redis.
+    def self.subscribe
+      redis = Redis.new
+      redis.subscribe(redis_handle) do |on|
+        on.message do |channel, count|
+          yield count.to_i
+        end
+      end
+    end
+
+    #
+    # Combined save and publish
+    def save_and_publish
+      save && publish
+    end
+
+    #
+    # Retrieve the count
+    def count
+      $redis.get count_name
+    end
+
+    #
+    # What is the official name of the count instance variable
+    def count_name
+      make_redis_name "@count"
+    end
+
+    #
+    # Get an instance variable value from a Redis value.
+    def redis_read_var(var, klass, opts = {})
+      redis_name = make_redis_name var, opts
+      redis_val = $redis.get redis_name
+      redis_val = nil if redis_val == ""
+      if redis_val
+        if not klass or klass == NilClass
+          redis_val = true if redis_val == "true"
+          redis_val = false if redis_val == "false"
+          klass = Float if redis_val =~ /[0-9+-\.]+/
+        end
+        case
+        when klass == Time
+          redis_val = Time.at(redis_val.to_f).gmtime
+        when klass == Fixnum
+          redis_val = redis_val.to_i
+        when klass == Float
+          redis_val = redis_val.to_f
+        when klass == FalseClass
+          redis_val = false
+        when klass == TrueClass
+          redis_val = true
+        end
+      end
+      redis_val
+    end
+
+    #
+    # Set a variable - convert from Ruby format to Redis format.
+    # As of now, we only convert times. Floats and integers are
+    # dealt with by Redis (converted to strings, unfortunately).
+    def self.to_redis(var, local_val, idx = nil)
+      if local_val
+        local_val = local_val[idx] if idx
+        if local_val.class == Time
+          local_val = local_val.to_f
+        end
+      end
+      local_val
+    end
+
+    #
+    # Translate an instance variable into a Redis key name.
+    # This is simply the class name, a dot and the instance
+    # variable. A bit of jiggery-pokery to convert the
+    # instance variable into a proper name. Probably an easier
+    # way to do this, but...
+    #
+    # Instance method for above
+    def make_redis_name(var, opts = {})
+      var_name = opts[:name] || var.to_s.gsub(/^@/, '')
+      prefix = opts[:prefix] || self.class.redis_handle
+      if opts[:idx]
+        "#{prefix}.#{var_name}#{opts[:idx] + 1}"
+      else
+        "#{prefix}.#{var_name}"
+      end
+    end
+
+    #
+    # Convert the class name into something suitable for Redis
+    def self.redis_handle
+      self.name.downcase.gsub(/^sgs::/, 'sgs_')
+    end
+  end
+end

data/lib/sgs/setup.rb

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+#
+# Copyright (c) 2013, Kalopa Research.  All rights reserved.  This is free
+# software; you can redistribute it and/or modify it under the terms of the
+# GNU General Public License as published by the Free Software Foundation;
+# either version 2, or (at your option) any later version.
+#
+# It is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this product; see the file COPYING.  If not, write to the Free
+# Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+#
+# THIS SOFTWARE IS PROVIDED BY KALOPA RESEARCH "AS IS" AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL KALOPA RESEARCH BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+$: << '../sgslib'
+
+require 'sgslib'
+
+##
+# Initialise the REDIS system.
+#
+SGS::Alarm.setup
+SGS::GPS.setup
+SGS::Otto.setup
+SGS::Timing.setup
+SGS::Waypoint.setup
+#SGS::Mission.setup

data/lib/sgs/timing.rb

@@ -0,0 +1,45 @@
+#
+# Copyright (c) 2013, Kalopa Research.  All rights reserved.  This is free
+# software; you can redistribute it and/or modify it under the terms of the
+# GNU General Public License as published by the Free Software Foundation;
+# either version 2, or (at your option) any later version.
+#
+# It is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this product; see the file COPYING.  If not, write to the Free
+# Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+#
+# THIS SOFTWARE IS PROVIDED BY KALOPA RESEARCH "AS IS" AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL KALOPA RESEARCH BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+
+##
+# Routines for handling sailboat navigation and route planning.
+#
+module SGS
+  class Timing < RedisBase
+    attr_accessor :status, :boot, :briefing, :m_start, :m_abort, :m_complete
+
+    def initialize
+      @status = nil
+      @boot = Time.at(0)
+      @briefing = nil
+      @m_start = nil
+      @m_abort = nil
+      @m_complete = nil
+      super
+    end
+  end
+end

data/lib/sgs/version.rb

@@ -0,0 +1,3 @@
+module SGS
+  VERSION = "0.1.0"
+end

data/lib/sgs/waypoint.rb

@@ -0,0 +1,115 @@
+#
+# Copyright (c) 2013, Kalopa Research.  All rights reserved.  This is free
+# software; you can redistribute it and/or modify it under the terms of the
+# GNU General Public License as published by the Free Software Foundation;
+# either version 2, or (at your option) any later version.
+#
+# It is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this product; see the file COPYING.  If not, write to the Free
+# Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+#
+# THIS SOFTWARE IS PROVIDED BY KALOPA RESEARCH "AS IS" AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL KALOPA RESEARCH BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+
+##
+# Routines for handling sailboat navigation and route planning.
+#
+require 'date'
+
+module SGS
+  #
+  # Waypoint, Attractor, and Repellor definitions
+  class Waypoint < RedisBase
+    attr_accessor :location, :chord, :type, :name, :bearing, :distance
+
+    #
+    # Types of waypoints
+    START_LINE = 0
+    FINISH_LINE = 1
+    WAYPOINT = 2
+    REPELLOR = 3
+
+    def initialize(location = nil, chord = nil, name = "", type = WAYPOINT)
+      @location = location || Location.new
+      @chord = chord
+      @type = type
+      @name = name
+    end
+
+    #
+    # Calculate the back-vector from the waypoint to the specified position
+    # Calculate the adjusted distance between the mark and the set location.
+    # Check to see if our back-bearing from the waypoint to our location is
+    # inside the chord of the waypoint. If so, reduce the distance to the
+    # waypoint by the length of the chord.
+    def compute_bearing(loc)
+      @bearing = Bearing.calculate(loc, @location)
+      @distance = @bearing.distance
+      d = Bearing.new(@bearing.back_angle - @chord.angle, @distance)
+      # A chord angle of 0 gives a semicircle from 180 to 360 degrees
+      # (inclusive). If our approach angle is within range, then reduce our
+      # distance to the mark by the chord distance (radius).
+      unless d.angle > 0.0 and d.angle < Math::PI
+        @distance -= @chord.distance
+      end
+      @distance
+    end
+
+    #
+    # Is the waypoint in scope? In other words, is our angle inside the chord.
+    def in_scope?
+      puts "In-scope distance is %f..." % @distance
+      @distance <= 0.0
+    end
+
+    #
+    # Pretty version of the waypoint.
+    def to_s
+      "'#{@name}' at #{@location} => #{chord}"
+    end
+
+    #
+    # Display a string for a KML file
+    def to_kml
+      c2 = @chord.clone
+      c2.angle += Math::PI
+      pos1 = @location.calculate(@chord)
+      pos2 = @location.calculate(c2)
+      "#{pos1.to_kml(',')} #{pos2.to_kml(',')}"
+    end
+
+    #
+    # Show the axis line for the waypoint (as a KML)
+    def to_axis_kml
+      c2 = @chord.clone
+      c2.angle += 1.5 * Math::PI
+      pos1 = @location.calculate(c2)
+      "#{@location.to_kml(',')} #{pos1.to_kml(',')}"
+    end
+  end
+
+  #
+  # Store the track over the ground.
+  class Track
+    attr_accessor :time, :location
+
+    def initialize(time, location)
+      @time = time
+      @location = location
+    end
+  end
+end