irobotcreate 0.1.0

data/examples/push_to_drive.rb

@@ -0,0 +1,29 @@
+require 'irobotcreate'
+
+# Hit Ctrl-C to end
+
+irc = IRobotCreate::Robot.new
+irc.start
+irc.full
+
+moving = false
+
+while true
+  if irc.sensor_buttons[:play]
+    unless moving == :forward
+      moving = :forward
+      irc.drive_direct(100, 100)
+    end
+  elsif irc.sensor_buttons[:advance]
+    unless moving == :backwards
+      moving = :backwards
+      irc.drive_direct(-100, -100)
+    end
+  else
+    if moving
+      irc.drive_direct(0, 0)
+      moving = false
+    end
+  end
+  print "\rVelocity: #{irc.sensor_requested_right_velocity}, #{irc.sensor_requested_left_velocity}        "
+end

data/lib/irobotcreate.rb

@@ -0,0 +1,7 @@
+require 'irobotcreate/robot'
+require 'irobotcreate/command'
+require 'irobotcreate/command/sensor'
+
+module IRobotCreate
+  DEBUG = false
+end

data/lib/irobotcreate/command.rb

@@ -0,0 +1,159 @@
+module IRobotCreate
+
+  class Command
+
+    attr_reader :code, :argument_options
+
+    @@commands = {}
+
+    class << self
+
+      def register(name, *args)
+        @@commands[name] = new(*args)
+      end
+
+      def [](name)
+        @@commands[name.to_sym]
+      end
+
+    end
+
+    def initialize(code, argument_options = [])
+      @code = code
+
+      if argument_options != :inf
+        case argument_options
+        when Integer
+          argument_options = [{ :type => :integer }] * argument_options
+        when Symbol
+          argument_options = [{ :type => argument_options }]
+        when Array
+          argument_options.map!{|ao| ao.is_a?(Hash) ? ao : { :type => ao } }
+        when Hash
+          argument_options = [argument_options]
+        else
+          raise "Can't handle argument options: #{argument_options}"
+        end
+      end
+
+      @argument_options = argument_options
+    end
+
+    def run(robot, *args)
+      if argument_options == :inf
+        array = args
+      else
+        if IRobotCreate::DEBUG
+          puts "args: #{args.inspect}"
+          puts "argument_options: #{argument_options.inspect}"
+        end
+        if args.size != argument_options.size
+          raise ArgumentError, "Requires #{argument_options.size} arguments"
+        end
+
+        array = []
+        args.each_with_index do |arg, i|
+          opts = argument_options[i]
+
+          value = arg
+          puts "starting value: #{value.inspect}" if IRobotCreate::DEBUG
+
+          size = opts[:size] || 1
+
+          if opts[:inverse_map]
+            opts[:map] = opts[:inverse_map]
+            for k,v in opts[:inverse_map]
+              opts[:map]["not_#{k}".to_sym] = 256**size - v
+            end
+            puts "inverse_map: #{opts[:map.inspect]}" if IRobotCreate::DEBUG
+          end
+
+          if opts[:map]
+            value = opts[:map][value]
+            puts "mapped: #{value}" if IRobotCreate::DEBUG
+            raise "Couldn't map value" if value.nil?
+          end
+
+          if opts[:compound]
+            raise "Compound size must be 1!" unless size == 1
+
+            value_array = value.is_a?(Array) ? value : [value]
+            value = 0
+
+            compound_size = opts[:compound].size
+            compound_size.times do |j|
+              compound_value = opts[:compound][j]
+              puts "checking for #{compound_value}" if IRobotCreate::DEBUG
+              if compound_value && value_array.include?(compound_value)
+                bit = (compound_size - 1) - j
+                puts "Adding bit: #{bit}" if IRobotCreate::DEBUG
+                value += 2 ** bit
+              end
+            end
+          elsif opts[:type] == :boolean
+            value = value ? 1 : 0
+          end
+
+          puts "preprocessed value: #{value.inspect}" if IRobotCreate::DEBUG
+
+          if value < 0
+            value += 256 ** size
+            puts "converted negative: #{value.inspect}" if IRobotCreate::DEBUG
+          end
+
+          size.times do |j|
+            base = 256 ** ((size - 1) - j)
+            current = value / base
+            value %= base
+            array << current
+          end
+
+          puts "array: #{array.inspect}" if IRobotCreate::DEBUG
+        end
+      end
+
+      puts "final array: #{array.inspect}" if IRobotCreate::DEBUG
+
+      robot.send([code] + array)
+    end
+
+  end
+
+  Command.class_eval do
+    register :start,          128
+    register :baud,           129, :map => { 300 => 0, 600 => 1, 1200 => 2, 2400 => 3, 4800 => 4, 9600 => 5, 14440 => 6,
+                                             19200 => 7, 28800 => 8, 38400 => 9, 57600 => 10, 115200 => 11 }
+    register :safe,           131
+    register :full,           132
+    register :demo,           136, :map => { :abort => -1, :cover => 0, :cover_and_dock => 1, :spot_cover => 2, :mouse => 3,
+                                             :figure_eight => 4, :wimp => 5, :home => 6, :tag => 7, :pachelbel => 8, :banjo => 9 }
+    register :cover,          135
+    register :cover_and_dock, 143
+    register :spot,           134
+    register :drive,          137, [{ :size => 2 }, { :size => 2 }]
+    register :drive_direct,   145, [{ :size => 2 }, { :size => 2 }]
+    register :leds,           139, [{ :compound => [:advance, nil, :play, nil ]}, :integer, :integer]
+    register :digital,        147, :compound => [:output2, :output1, :output0 ]
+    register :pwm,            144, 3
+    register :driver,         138, :compound => [:side_driver2, :low_side_driver1, :low_side_driver0]
+    register :ir,             151, 1
+    register :song,           140, :inf
+    register :play_song,      141, 1
+    register :sensors,        142, 1
+    register :query,          149, :inf
+    register :stream,         148, :inf
+    register :stream_playing, 150, :boolean
+    register :script,         152, :inf
+    register :play_script,    153
+    register :show_script,    154
+    register :wait_time,      155, 1
+    register :wait_distance,  156, :size => 2
+    register :wait_angle,     157, :size => 2
+    register :wait_event,     158, :inverse_map => { :wheel_drop => 1, :front_wheel_drop => 2, :left_wheel_drop => 3, :right_wheel_drop => 4,
+                                                      :bump => 5, :left_bump => 6, :right_bump => 7, :virtual_wall => 8, :wall => 9,
+                                                      :cliff => 10, :left_cliff => 11, :front_left_cliff => 12, :front_right_cliff => 13,
+                                                      :right_cliff => 14, :home_base => 15, :advance_button => 16, :play_button => 17,
+                                                      :digital0 => 18, :digital1 => 19, :digital2 => 20, :digital3 => 21, :oi_passive => 22 }
+  end
+
+end

data/lib/irobotcreate/command/sensor.rb

@@ -0,0 +1,108 @@
+module IRobotCreate
+  class SensorCommand < Command
+
+    attr_reader :sensor_code, :response_size, :response_type, :response_options
+
+    @@sensor_commands = {}
+
+    class << self
+
+      def register(name, *args)
+        @@sensor_commands[name] = new(*args)
+      end
+
+      def [](name)
+        @@sensor_commands[name.to_sym]
+      end
+
+    end
+
+    def initialize(sensor_code, response_size, response_type, response_options = nil)
+      super(142, 1)
+      @sensor_code = sensor_code
+      @response_size = response_size
+      @response_type = response_type
+      @response_options = response_options
+    end
+
+    def run(robot)
+      super(robot, sensor_code)
+
+      response = robot.read_response(response_size)
+
+      case response_type
+      when :boolean
+        response.first == 1
+      when :integer, :signed_integer
+        integer = 0
+        response_size.times do |i|
+          integer += response[i] * (256 ** ((response_size - 1) - i))
+        end
+
+        if response_type == :signed_integer
+          max = 256 ** response_size
+          if integer > max / 2
+            integer -= max
+          end
+        end
+
+        integer
+      when :map
+        response_options[response.first]
+      when :compound
+        hash = {}
+        options_size = response_options.size
+        options_size.times do |i|
+          item = response_options[i]
+          next unless item
+          hash[item] = response.first & 2**((options_size - 1) - i) != 0
+        end
+        hash
+      else
+        response
+      end
+    end
+
+  end
+
+  SensorCommand.class_eval do
+    register :bump_drop,                7,  1, :compound, [:wheeldrop_caster, :wheeldrop_left, :wheeldrop_right, :bump_left, :bump_right]
+    register :wall,                     8,  1, :boolean
+    register :cliff_left,               9,  1, :boolean
+    register :cliff_front_left,         10, 1, :boolean
+    register :cliff_front_right,        11, 1, :boolean
+    register :cliff_right,              12, 1, :boolean
+    register :virtual_wall,             13, 1, :boolean
+    register :low_side_and_wheels,      14, 1, :compound, [:left_wheel, :right_wheel, :ld2, :ld0, :ld1]
+    register :ir,                       17, 1, :map, { 129 => :left, 130 => :forward, 131 => :right, 132 => :spot, 133 => :max, 
+                                                        134 => :small, 135 => :medium, 136 => :large, 137 => :pause, 138 => :power,
+                                                        139 => :arc_left, 140 => :arc_right, 141 => :drive_stop }
+    register :buttons,                  18, 1, :compound, [:advance, nil, :play]
+    register :distance,                 19, 2, :signed_integer
+    register :angle,                    20, 2, :signed_integer
+    register :charging,                 21, 1, :map, { 0 => :not_charging, 1 => :reconditioning, 2 => :full, 3 => :trickle,
+                                                        4 => :waiting, 5 => :fault }
+    register :voltage,                  22, 2, :integer
+    register :current,                  23, 2, :signed_integer
+    register :battery_temperature,      24, 1, :signed_integer
+    register :battery_charge,           25, 2, :integer
+    register :battery_capacity,         26, 2, :integer
+    register :wall_signal,              27, 2, :integer
+    register :cliff_left_signal,        28, 2, :integer
+    register :cliff_front_left_signal,  29, 2, :integer
+    register :cliff_front_right_signal, 30, 2, :integer
+    register :cliff_right_signal,       31, 2, :integer
+    register :cargo_bay_digital,        32, 1, :compound, [:detect, :input3, :input2, :input1, :input0]
+    register :cargo_bay_analog,         33, 2, :integer
+    register :charging_sources,         34, 1, :compound, [:home_base, :internal]
+    register :oi_mode,                  35, 1, :map, { 0 => :off, 1 => :passive, 2 => :safe, 3 => :full }
+    register :song_number,              36, 1, :integer
+    register :song_playing,             37, 1, :boolean
+    register :stream_packets_count,     38, 1, :integer
+    register :requested_velocity,       39, 2, :signed_integer
+    register :requested_radius,         40, 2, :signed_integer
+    register :requested_right_velocity, 41, 2, :signed_integer
+    register :requested_left_velocity,  42, 2, :signed_integer
+  end
+
+end

data/lib/irobotcreate/robot.rb

@@ -0,0 +1,57 @@
+require 'serialport'
+
+module IRobotCreate
+
+  class Robot
+
+    DEFAULT_PORT = '/dev/tty.ElementSerial-ElementSe'
+
+    attr_reader :serial
+
+    def initialize(port = DEFAULT_PORT, args = {})
+      args = { :baudrate => 57600, :databits => 8, :stopbits => 1 }.merge(args)
+      @serial = SerialPort.new(port, args)
+    end
+
+    def format_bytes(arg)
+      array = case arg
+        when String
+          arg.split(/\s+/).map(&:to_i)
+        when Array
+          arg
+        else
+          [arg]
+      end
+
+      array.pack('C*')
+    end
+
+    def send(cmd)
+      serial.write format_bytes(cmd)
+    end
+
+    def read_response(size=1)
+      (0...size).map{|_| serial.getc }.join.unpack('C*')
+    end
+
+    def run_command(name, *args)
+      Command[name].run(self, *args)
+    end
+
+    def check_sensor(name)
+      SensorCommand[name].run(self)
+    end
+
+    def method_missing(sym, *args, &block)
+      if sym.to_s =~ /^sensor_(.*)$/ && SensorCommand[$1]
+        check_sensor($1)
+      elsif Command[sym]
+        run_command(sym, *args, &block)
+      else
+        super
+      end
+    end
+
+  end
+
+end

data/lib/irobotcreate/version.rb

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

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification 
+name: irobotcreate
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Peter Wagenet
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-06-06 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: serialport
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 0
+        version: "1.0"
+  type: :runtime
+  version_requirements: *id001
+description: Connect to the IRobotCreate with Ruby via a serial connection.
+email: 
+- peter.wagenet@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/irobotcreate/command/sensor.rb
+- lib/irobotcreate/command.rb
+- lib/irobotcreate/robot.rb
+- lib/irobotcreate/version.rb
+- lib/irobotcreate.rb
+- examples/push_to_drive.rb
+has_rdoc: true
+homepage: http://github.com/peterwagenet/irobotcreate
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: irobotcreate
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Ruby interface for the IRobotCreate
+test_files: []
+