ruby-nxt 0.8.1

data/lib/commands/light_sensor.rb

@@ -0,0 +1,82 @@
+# ruby-nxt Control Mindstorms NXT via Bluetooth Serial Port Connection
+# Copyright (C) 2006 Tony Buser <tbuser@gmail.com> - http://juju.org
+#
+# This program 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 of the License
+#
+# This program 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 program; if not, write to the Free Software Foundation,
+# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+require "commands/mixins/sensor"
+require "nxt_comm"
+
+# Implements (and extens) the "Light Sensor" block in NXT-G
+class Commands::LightSensor
+  
+  include Commands::Mixins::Sensor
+  
+  attr_reader :port, :generate_light
+  attr_accessor :trigger_point, :comparison
+  
+  def initialize(nxt)
+    @nxt      = nxt
+    
+    # defaults the same as NXT-G
+    @port           = 3
+    @trigger_point  = 50
+    @comparison     = ">"
+    @generate_light = true
+    set_mode
+  end
+  
+  # Turns off the sensor's LED light.
+  def ambient_mode
+    self.generate_light = false
+  end
+  
+  # Turns on the sensor's LED light.
+  def illuminated_mode
+    self.generate_light = true
+  end
+  
+  # Turns the sensor's LED on or off.
+  # Takes true or false as the argument; if true, light will be turned on,
+  # if false, light will be turned off.
+  def generate_light=(on)
+    @generate_light = on
+    set_mode
+  end
+  
+  # intensity of light detected 0-100 in %
+  def intensity
+    value_scaled
+  end
+  alias light_level intensity
+  
+  # returns the raw value of the sensor
+  def raw_value
+    value_raw
+  end
+  
+  # sets up the sensor port
+  def set_mode
+    @generate_light ? mode = NXTComm::LIGHT_ACTIVE : mode = NXTComm::LIGHT_INACTIVE
+    @nxt.set_input_mode(
+      NXTComm.const_get("SENSOR_#{@port}"),
+      mode,
+      NXTComm::PCTFULLSCALEMODE
+    )
+  end
+  
+  # attempt to return the input_value requested
+  def method_missing(cmd)
+    @nxt.get_input_values(NXTComm.const_get("SENSOR_#{@port}"))[cmd]
+  end
+end

data/lib/commands/mixins/motor.rb

@@ -0,0 +1,84 @@
+# ruby-nxt Control Mindstorms NXT via Bluetooth Serial Port Connection
+# Copyright (c) 2006 Tony Buser <tbuser@gmail.com> - http://juju.org
+# Copyright (c) 2006 Matt Zukowski <matt@roughest.net> - http://blog.roughest.net
+#
+# This program 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 of the License
+#
+# This program 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 program; if not, write to the Free Software Foundation,
+# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+# Common methods used in motor commands.
+module Commands
+  module Mixins
+    module Motor
+      # Sets the duration of the motor movement.
+      # The parameter should be a Hash like one of the following:
+      #   m.duration = {:seconds => 4 }
+      #   m.duration = {:degrees => 180 }
+      #   m.duration = {:rotations => 2 }
+      # To set the duration to unlimited (i.e. rotate indefinitely) you should set 
+      # the duration to :unlimited, although this is equivalent to simply setting it to nil;
+      # the following expressions are equivalent:
+      #   m.duration = nil
+      #   m.duration = :unlimited
+      # If you assign an integer, it will be assumed that you are specifying seconds;
+      # the following are equivalent:
+      #   m.duration = 4
+      #   m.duration = {:seconds => 4}
+      # If you assign a float, it will be assumed that youa re specifying rotations;
+      # the following expressions are equivalent:
+      #   m.duration = 2.0
+      #   m.duration = {:rotations => 2}
+      def duration=(duration)
+        if duration.kind_of? Hash
+          @duration = duration
+        elsif duration.kind_of? Integer
+          @duration = {:seconds => duration}
+        elsif duration.kind_of? Float
+          @duration = {:rotations => duration}
+        elsif duration == :unlimited
+          @duration = nil
+        else
+          @duration = duration
+        end
+      end
+      
+      def duration
+        if duration.nil?
+          :unlimited
+        else
+          @duration
+        end
+      end
+
+      protected
+      def tacho_limit
+        if @duration.kind_of? Hash
+          if @duration[:rotations]
+            tacho_limit = @duration[:rotations] * 360
+          end
+        
+          if @duration[:degrees]
+            tacho_limit = @duration[:degrees]
+          end
+        
+          if @duration[:seconds]
+            tacho_limit = 0
+          end
+        else
+          tacho_limit = 0
+        end
+
+        tacho_limit
+      end
+    end
+  end
+end

data/lib/commands/mixins/sensor.rb

@@ -0,0 +1,38 @@
+# ruby-nxt Control Mindstorms NXT via Bluetooth Serial Port Connection
+# Copyright (c) 2006 Tony Buser <tbuser@gmail.com> - http://juju.org
+# Copyright (c) 2006 Matt Zukowski <matt@roughest.net> - http://blog.roughest.net
+#
+# This program 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 of the License
+#
+# This program 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 program; if not, write to the Free Software Foundation,
+# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+# Common methods used in sensor commands.
+module Commands
+  module Mixins
+    module Sensor
+      def port=(port)
+        @port = port
+        set_mode
+      end
+      
+      def comparison=(op)
+        raise ArgumentError, "'#{op}' is not a valid comparison operator." unless op =~ /^([<>=]=?|!=)$/
+        @comparison = op
+      end
+      
+      # Returns true or false based on comparison and trigger point.
+      def logic
+        eval "value_scaled #{@comparison} @trigger_point"
+      end
+    end
+  end
+end

data/lib/commands/motor.rb

@@ -0,0 +1,136 @@
+# ruby-nxt Control Mindstorms NXT via Bluetooth Serial Port Connection
+# Copyright (C) 2006 Tony Buser <tbuser@gmail.com> - http://juju.org
+#
+# This program 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 of the License
+#
+# This program 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 program; if not, write to the Free Software Foundation,
+# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+require "nxt_comm"
+require "commands/mixins/motor"
+
+# Implements the "Motor" block in NXT-G
+class Commands::Motor
+  
+  include Commands::Mixins::Motor 
+
+  attr_accessor :port
+  attr_accessor :direction
+  attr_accessor :steering
+  attr_accessor :action
+  attr_accessor :power
+  attr_accessor :control_power
+  attr_accessor :wait
+  attr_accessor :next_action
+  
+  def initialize(nxt = NXTComm.new($DEV))
+    @nxt          = nxt
+    
+    # defaults the same as NXT-G
+    @port           = :a
+    @direction      = :forward
+    @action         = :constant
+    @power          = 75
+    @control_power  = false
+    @duration       = nil # Same as :unlimited
+    @wait           = false
+    @next_action    = :brake
+  end
+  
+  # execute the Motor command based on the properties specified
+  def start
+    @nxt.reset_motor_position(NXTComm.const_get("MOTOR_#{@port.to_s.upcase}"))
+
+    if @direction == :stop
+      motor_power = 0
+      mode        = NXTComm::COAST
+      run_state   = NXTComm::MOTOR_RUN_STATE_IDLE
+    else
+      @direction == :forward ? motor_power = @power : motor_power = -@power
+      mode        = NXTComm::MOTORON | NXTComm::BRAKE
+      run_state   = NXTComm::MOTOR_RUN_STATE_RUNNING
+    end
+
+    turn_ratio = 0
+
+    if @control_power
+      mode |= NXTComm::REGULATED
+      reg_mode = NXTComm::REGULATION_MODE_MOTOR_SPEED
+    else
+      reg_mode = NXTComm::REGULATION_MODE_IDLE
+    end
+    
+    if @duration
+      if @duration[:degrees] or @duration[:seconds]
+        case @action
+          when :constant
+            run_state = NXTComm::MOTOR_RUN_STATE_RUNNING
+          when :ramp_up
+            run_state = NXTComm::MOTOR_RUN_STATE_RAMPUP
+          when :ramp_down
+            run_state = NXTComm::MOTOR_RUN_STATE_RAMPDOWN
+        end
+      end
+    end
+
+    @nxt.set_output_state(
+      NXTComm.const_get("MOTOR_#{@port.to_s.upcase}"),
+      motor_power,
+      mode,
+      reg_mode,
+      turn_ratio,
+      run_state,
+      tacho_limit
+    )
+    
+    if (@duration and @duration[:seconds]) or @wait
+      if @duration and @duration[:seconds]
+        sleep(@duration[:seconds])
+      else
+        until self.run_state == NXTComm::MOTOR_RUN_STATE_IDLE
+          sleep(0.25)
+        end
+      end
+      self.stop
+    end
+  end
+  
+  # stop the Motor command based on the next_action property
+  def stop
+    if @next_action == :brake
+      @nxt.set_output_state(
+        NXTComm.const_get("MOTOR_#{@port.to_s.upcase}"),
+        0,
+        NXTComm::MOTORON | NXTComm::BRAKE | NXTComm::REGULATED,
+        NXTComm::REGULATION_MODE_MOTOR_SPEED,
+        0,
+        NXTComm::MOTOR_RUN_STATE_RUNNING,
+        0
+      )
+    else
+      @nxt.set_output_state(
+        NXTComm.const_get("MOTOR_#{@port.to_s.upcase}"),
+        0,
+        NXTComm::COAST,
+        NXTComm::REGULATION_MODE_IDLE,
+        0,
+        NXTComm::MOTOR_RUN_STATE_IDLE,
+        0
+      )
+    end
+  end
+  
+  # attempt to return the output_state requested
+  def method_missing(cmd)
+    @nxt.get_output_state(NXTComm.const_get("MOTOR_#{@port.to_s.upcase}"))[cmd]
+  end
+  
+end

data/lib/commands/move.rb

@@ -0,0 +1,210 @@
+# ruby-nxt Control Mindstorms NXT via Bluetooth Serial Port Connection
+# Copyright (C) 2006 Tony Buser <tbuser@gmail.com> - http://juju.org
+#
+# This program 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 of the License
+#
+# This program 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 program; if not, write to the Free Software Foundation,
+# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+require "nxt_comm"
+require "commands/mixins/motor"
+
+# Implements the "Move" block in NXT-G
+class Commands::Move
+
+  include Commands::Mixins::Motor 
+  
+  attr_reader   :ports
+  attr_accessor :direction
+  attr_accessor :left_motor, :right_motor
+  attr_accessor :power
+  attr_accessor :next_action
+  
+  def initialize(nxt = NXTComm.new($DEV))
+    @nxt          = nxt
+    
+    # defaults the same as NXT-G
+    @ports        = [:b, :c]
+    @direction    = :forward
+    @power        = 75
+    @duration     = {:rotations => 1}
+    @next_action  = :brake
+    self.turn_ratio = :straight
+  end
+
+  def ports=(value)
+    # make it flexible, let them specify just :a, or "A", or :a,:b to do two etc.
+    case value.class.to_s
+      when "Symbol" then @ports = [value]
+      when "String" then @ports = [value.intern]
+      when "Array"  then @ports = value
+      else raise "Invalid port type #{value.class}"
+    end
+  end
+  alias port= ports=
+
+  def turn_ratio=(turn_ratio)
+    # simplified steering... if the user wants fine control, they should just specify -100 to 100
+    case turn_ratio
+      when :straight then @turn_ratio = 0
+      when :spin_left then @turn_ratio = -100
+      when :spin_right then @turn_ratio = 100
+      when :left then @turn_ratio = -50
+      when :right then @turn_ration = 50
+      else @turn_ratio = turn_ratio
+    end
+
+    # DEPRECATED: for backwards compatibility we parse the argument as a hash... I think though that this should be deprecated
+    if turn_ratio.kind_of? Hash
+      old_steering = turn_ratio
+      self.left_motor = old_steering[:left_motor] if old_steering.has_key? :left_motor
+      self.right_motor = old_steering[:right_motor] if old_steering.has_key? :right_motor
+      if old_steering[:power]
+        self.turn_ratio = old_steering[:power] * (old_steering[:direction] == :left ? -1 : 1)
+      else
+        self.turn_ratio = old_steering[:direction]
+      end
+    end
+  end
+  alias steering= turn_ratio=
+
+  def turn_ratio
+    if @ports.size > 1
+      @turn_ratio
+    else
+      0
+    end
+  end
+  alias steering turn_ratio
+  
+
+  # execute the Move command based on the properties specified
+  def start
+    @ports.each do |p|
+      @nxt.reset_motor_position(NXTComm.const_get("MOTOR_#{p.to_s.upcase}"))
+    end
+
+    if @direction == :stop
+      motor_power = 0
+      mode        = NXTComm::COAST
+      run_state   = NXTComm::MOTOR_RUN_STATE_IDLE
+    else
+      @direction == :forward ? motor_power = @power : motor_power = -@power
+      mode        = NXTComm::MOTORON | NXTComm::BRAKE
+      run_state   = NXTComm::MOTOR_RUN_STATE_RUNNING
+    end
+
+    if @ports.size == 2
+      mode |= NXTComm::REGULATED
+      reg_mode = NXTComm::REGULATION_MODE_MOTOR_SYNC
+    else
+      reg_mode = NXTComm::REGULATION_MODE_IDLE
+    end
+    
+    if @ports.include?(:a) and @ports.include?(:b) and @ports.include?(:c)
+      @nxt.set_output_state(
+        NXTComm::MOTOR_ALL,
+        motor_power,
+        mode,
+        reg_mode,
+        turn_ratio,
+        run_state,
+        tacho_limit
+      )
+    else
+      @ports.each do |p|
+        @nxt.set_output_state(
+          NXTComm.const_get("MOTOR_#{p.to_s.upcase}"),
+          motor_power,
+          mode,
+          reg_mode,
+          turn_ratio,
+          run_state,
+          tacho_limit
+        )
+      end
+    end
+    
+    unless @duration.nil?
+      if @duration[:seconds]
+        sleep(@duration[:seconds])
+      else
+        until self.run_state[@ports[0]] == NXTComm::MOTOR_RUN_STATE_IDLE
+          sleep(0.25)
+        end
+      end
+      self.stop
+    end
+  end
+  
+  # stop the Move command based on the next_action property
+  def stop
+    if @next_action == :brake
+      if @ports.include?(:a) and @ports.include?(:b) and @ports.include?(:c)
+        @nxt.set_output_state(
+          NXTComm::MOTOR_ALL,
+          0,
+          NXTComm::MOTORON | NXTComm::BRAKE | NXTComm::REGULATED,
+          NXTComm::REGULATION_MODE_MOTOR_SPEED,
+          0,
+          NXTComm::MOTOR_RUN_STATE_RUNNING,
+          0
+        )
+      else
+        @ports.each do |p|
+          @nxt.set_output_state(
+            NXTComm.const_get("MOTOR_#{p.to_s.upcase}"),
+            0,
+            NXTComm::MOTORON | NXTComm::BRAKE | NXTComm::REGULATED,
+            NXTComm::REGULATION_MODE_MOTOR_SPEED,
+            0,
+            NXTComm::MOTOR_RUN_STATE_RUNNING,
+            0
+          )
+        end
+      end
+    else
+      if @ports.include?(:a) and @ports.include?(:b) and @ports.include?(:c)
+        @nxt.set_output_state(
+          NXTComm::MOTOR_ALL,
+          0,
+          NXTComm::COAST,
+          NXTComm::REGULATION_MODE_IDLE,
+          0,
+          NXTComm::MOTOR_RUN_STATE_IDLE,
+          0
+        )
+      else
+        @ports.each do |p|
+          @nxt.set_output_state(
+            NXTComm.const_get("MOTOR_#{p.to_s.upcase}"),
+            0,
+            NXTComm::COAST,
+            NXTComm::REGULATION_MODE_IDLE,
+            0,
+            NXTComm::MOTOR_RUN_STATE_IDLE,
+            0
+          )
+        end
+      end
+    end
+  end
+  
+  # attempt to return the output_state requested
+  def method_missing(cmd)
+    states = {}
+    @ports.each do |p|
+      states[p] = @nxt.get_output_state(NXTComm.const_get("MOTOR_#{p.to_s.upcase}"))[cmd]
+    end
+    states
+  end
+  
+end