hybridgroup-sphero 1.1.6 → 1.2.0

data/README.markdown

@@ -77,6 +77,23 @@ sleep 1
 s.stop
 ```
 
+## Pairing sphero with ubuntu
+Add your user to the `dialout` group
+```
+$ sudo usermod -a -G dialout <user>
+```
+Then logout or restart your computer. Once your user is logged back in, pair the sphero with the ubuntu bluetooth manager.
+
+Once paired, you may now bind your sphero to a rfcomm port
+```
+$ sudo hcitool scan 
+Scanning ...
+<address>		Sphero
+$ sudo rfcomm bind /dev/rfcomm0 <address> 1
+```
+
+You may now access the sphero from `/dev/rfcomm0`
+
 ## REQUIREMENTS:
 
 * A Sphero ball connected to your computer

data/Rakefile

@@ -14,7 +14,6 @@ Hoe.spec 'hybridgroup-sphero' do
   self.readme_file   = 'README.markdown'
   self.history_file  = 'CHANGELOG.rdoc'
   self.extra_rdoc_files  = FileList['*.{rdoc,markdown}']
-  self.extra_deps << ['hybridgroup-serialport']
 
   self.spec_extras = {
     :required_ruby_version => '>= 1.9.2'

data/lib/sphero/request.rb

@@ -113,5 +113,73 @@ class Sphero
         @data.pack 'nC'
       end
     end
+
+    class SetPowerNotification < Sphero
+      def initialize seq, enable
+        super(seq, [enable])
+        @cid = 0x21
+      end
+    end
+
+    GYRO_AXIS_H_FILTERED = 0x0000_0001
+    GYRO_AXIS_M_FILTERED = 0x0000_0002
+    GYRO_AXIS_L_FILTERED = 0x0000_0004 
+    LEFT_MOTOR_BACK_EMF_FILTERED = 0x0000_0020
+    RIGHT_MOTOR_BACK_EMF_FILTERED = 0x0000_0040 
+    MAGNETOMETER_AXIS_Z_FILTERED = 0x0000_0080
+    MAGNETOMETER_AXIS_Y_FILTERED = 0x0000_0100
+    MAGNETOMETER_AXIS_X_FILTERED = 0x0000_0200
+    GYRO_AXIS_Z_FILTERED = 0x0000_0400
+    GYRO_AXIS_Y_FILTERED = 0x0000_0800
+    GYRO_AXIS_X_FILTERED = 0x0000_1000
+    ACCELEROMETER_AXIS_Z_FILTERED = 0x0000_2000
+    ACCELEROMETER_AXIS_Y_FILTERED = 0x0000_4000
+    ACCELEROMETER_AXIS_X_FILTERED = 0x0000_8000
+    IMU_YAW_ANGLE_FILTERED = 0x0001_0000
+    IMU_ROLL_ANGLE_FILTERED = 0x0002_0000
+    IMU_PITCH_ANGLE_FILTERED = 0x0004_0000
+    LEFT_MOTOR_BACK_EMF_RAW = 0x0020_0000
+    RIGHT_MOTOR_BACK_EMF_RAW = 0x0040_0000
+    MAGNETOMETER_AXIS_Z_RAW = 0x0080_0000
+    MAGNETOMETER_AXIS_Y_RAW = 0x0100_0000
+    MAGNETOMETER_AXIS_X_RAW = 0x0200_0000
+    GYRO_AXIS_Z_RAW = 0x0400_0000
+    GYRO_AXIS_Y_RAW = 0x0800_0000
+    GYRO_AXIS_X_RAW = 0x1000_0000
+    ACCELEROMETER_AXIS_Z_RAW = 0x2000_0000
+    ACCELEROMETER_AXIS_Y_RAW = 0x4000_0000
+    ACCELEROMETER_AXIS_X_RAW = 0x8000_0000
+
+    QUATERNION_Q0 = 0x0000_0001
+    QUATERNION_Q1 = 0x0000_0002
+    QUATERNION_Q2 = 0x0000_0004
+    QUATERNION_Q3 = 0x0000_0008
+    ODOMETER_X = 0x0000_0010
+    ODOMETER_Y = 0x0000_0020
+    ACCELONE = 0x0000_0040
+    VELOCITY_X = 0x0000_0080
+    VELOCITY_Y = 0x0000_0100
+
+    class SetDataStreaming < Sphero
+      def initialize seq, n, m, mask, pcnt, mask2
+        super(seq, [n, m, mask, pcnt, mask2])
+        @cid = 0x12
+        @mask = mask
+        @mask2 = mask2
+      end
+
+      private
+
+      def packet_body
+        @data.pack 'nnNCN'
+      end
+    end
+
+    class ConfigureCollisionDetection < Sphero
+      def initialize seq, meth, x_t, y_t, x_spd, y_spd, dead
+        super(seq, [meth, x_t, y_t, x_spd, y_spd, dead])
+        @cid = 0x12
+      end
+    end
   end
 end

data/lib/sphero/response.rb

@@ -7,22 +7,36 @@ class Sphero
     DLEN = 4
 
     CODE_OK = 0
+    SIMPLE_RESPONSE = 0xFF
+    ASYNC_RESPONSE = 0xFE
+
+    def self.simple?(header)
+      header[SOP2] == SIMPLE_RESPONSE
+    end
+
+    def self.async?(header)
+      header[SOP2] == ASYNC_RESPONSE
+    end
 
     def initialize header, body
       @header = header
       @body   = body
     end
 
+    def valid?
+      @header && @body  
+    end
+
     def empty?
-      @header[DLEN] == 1
+      valid? && @header[DLEN] == 1
     end
 
     def success?
-      @header[MRSP] == CODE_OK
+      valid? && @header[MRSP] == CODE_OK
     end
 
     def seq
-      @header[SEQ]
+      valid? && @header[SEQ]
     end
 
     def body
@@ -84,5 +98,106 @@ class Sphero
       def g; body[1]; end
       def b; body[2]; end
     end
+
+    class AsyncResponse < Response
+      ID_CODE = 2
+      DLEN_MSB = 3
+      DLEN_LSB = 4
+
+      POWER_NOTIFICATION = 0x01
+      LEVEL_1_DIAGNOSTIC = 0x02
+      SENSOR_DATA = 0x03
+      CONFIG_BLOCK = 0x04
+      PRESLEEP_WARNING = 0x05
+      MACRO_MARKERS = 0x06
+      COLLISION_DETECTED = 0x07
+
+      VALID_REPONSES = {POWER_NOTIFICATION => 'Sphero::Response::PowerNotification',
+                        #LEVEL_1_DIAGNOSTIC => 'AsyncResponse',
+                        SENSOR_DATA => 'Sphero::Response::SensorData',
+                        #CONFIG_BLOCK => 'AsyncResponse',
+                        #PRESLEEP_WARNING => 'AsyncResponse',
+                        #MACRO_MARKERS => 'AsyncResponse',
+                        COLLISION_DETECTED => 'Sphero::Response::CollisionDetected'}
+
+      def self.valid?(header)
+        VALID_REPONSES.keys.include?(header[ID_CODE])
+      end
+
+      def self.response header, body
+        raise "no good" unless self.valid?(header)
+        constantize(VALID_REPONSES[header[ID_CODE]]).new(header, body)
+      end
+
+      def self.constantize(camel_cased_word)
+        names = camel_cased_word.split('::')
+        names.shift if names.empty? || names.first.empty?
+
+        constant = Object
+        names.each do |name|
+          constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
+        end
+        constant
+      end
+
+      def empty?
+        @header[DLEN_LSB] == 1
+      end
+
+      def success?
+        AsyncResponse.valid?(@header)
+      end
+
+      def seq
+        1
+      end
+    end
+
+    class PowerNotification < GetPowerState
+    end
+
+    class SensorData < AsyncResponse
+      def body
+        @body.unpack 's*'
+      end
+    end
+
+    class CollisionDetected < AsyncResponse
+      def body
+        @body.unpack 'nnnCnnCN'
+      end
+
+      def x
+        body[0]
+      end
+
+      def y
+        body[1]
+      end
+
+      def z
+        body[2]
+      end
+
+      def axis
+        body[3]
+      end
+
+      def x_magnitude
+        body[4]
+      end
+
+      def y_magnitude
+        body[5]
+      end
+
+      def speed
+        body[6]
+      end
+
+      def timestamp
+        body[7]
+      end
+    end
   end
 end

data/lib/sphero.rb

@@ -1,18 +1,22 @@
-require 'serialport'
 require 'sphero/request'
 require 'sphero/response'
 require 'thread'
 
 class Sphero
-  VERSION = '1.1.6'
+  VERSION = '1.2.0'
 
   FORWARD = 0
   RIGHT = 90
   BACKWARD = 180
   LEFT = 270
 
+  DEFAULT_RETRIES = 3
+
+  attr_accessor :connection_types, :async_messages
+
   class << self
     def start(dev, &block)
+      retries_left = DEFAULT_RETRIES
       sphero = self.new dev
       if (block_given?)
         begin
@@ -24,15 +28,23 @@ class Sphero
       end
       return sphero
     rescue Errno::EBUSY
-      retry
+      puts retries_left
+      retries_left = retries_left - 1
+      retry unless retries_left > 0
     end
   end
 
   def initialize dev
-    initialize_serialport dev
+    if dev.is_a?(String)
+      initialize_serialport dev
+    else
+      @sp = dev
+    end
+
     @dev  = 0x00
     @seq  = 0x00
     @lock = Mutex.new
+    @async_messages = []
   end
   
   def close
@@ -110,6 +122,42 @@ class Sphero
     Kernel::sleep duration
   end
 
+  ## async messages
+
+  # configure power notification messages
+  def set_power_notification enable=true
+    write Request::SetPowerNotification.new(@seq, enable ? 0x01 : 0x00)
+  end
+
+  # configure data streaming notification messages
+  def set_data_streaming n, m, mask, pcnt, mask2
+    write Request::SetDataStreaming.new(@seq, n, m, mask, pcnt, mask2)
+  end
+
+  # configure collision detection messages
+  def configure_collision_detection meth, x_t, y_t, x_spd, y_spd, dead
+    write Request::ConfigureCollisionDetection.new(@seq, meth, x_t, y_t, x_spd, y_spd, dead)
+  end
+
+  # read all outstanding async packets and store in async_responses
+  # would not do well to receive simple responses this way...
+  def read_async_messages
+    header, body = nil
+    new_responses = []
+
+    @lock.synchronize do
+      header, body = read_next_response
+
+      while header && Response.async?(header)
+        new_responses << Response::AsyncResponse.response(header, body)
+        header, body = read_next_response
+      end
+    end
+    
+    async_messages.concat(new_responses) unless new_responses.empty?
+    return !new_responses.empty?
+  end
+
   private
   
   def is_windows?
@@ -122,24 +170,39 @@ class Sphero
   end
 
   def initialize_serialport dev
+    require 'serialport'
     @sp = SerialPort.new dev, 115200, 8, 1, SerialPort::NONE
     if is_windows?
       @sp.read_timeout=1000
       @sp.write_timeout=0
       @sp.initial_byte_offset=5
     end
+  rescue LoadError
+    puts "Please 'gem install hybridgroup-serialport' for serial port support."
   end
 
   def write packet
-    header = nil
-    body   = nil
+    header, body = nil
 
     @lock.synchronize do
+      rs, ws = IO.select([], [@sp], [], 20)
       @sp.write packet.to_str
       @seq += 1
 
-      header   = @sp.read(5).unpack 'C5'
-      body     = @sp.read header.last
+      header = nil
+      loop do
+        header = read_header(true)
+        break if header
+      end
+
+      body = read_body(header.last, true) if header
+
+      # pick off asynch packets and store, till we get to the message response
+      while header && Response.async?(header)
+        async_messages << Response::AsyncResponse.response(header, body)
+        header = read_header(true)
+        body = read_body(header.last, true) if header
+      end
     end
 
     response = packet.response header, body
@@ -147,8 +210,58 @@ class Sphero
     if response.success?
       response
     else
-      raise response
+      raise "Unable to write to Sphero!"
     end
   end
+
+  def read_header(blocking=false)
+    begin
+      data = read_next_chunk(5, blocking)
+      return nil unless data && data.length == 5
+      header = data.unpack 'C5'
+    rescue Errno::EBUSY
+      retry
+    rescue Exception => e
+      puts e.message
+      puts e.backtrace.inspect
+      retry
+    end
+
+    header
+  end
+
+  def read_body(len, blocking=false)
+    begin
+      data = read_next_chunk(len, blocking)
+      return nil unless data && data.length == len
+    rescue Errno::EBUSY
+      retry
+    rescue Exception => e
+      puts e.message
+      puts e.backtrace.inspect
+      retry
+    end
+
+    data
+  end
+
+  def read_next_chunk(len, blocking=false)
+    begin
+      if blocking || is_windows?
+        rs, ws, = IO.select([@sp], [], [], 20)
+        data = @sp.read(len)
+        return nil unless data && data.length == len
+      else
+        data = @sp.read_nonblock(len)
+      end
+    rescue Errno::EBUSY
+      retry
+    rescue Exception => e
+      puts e.message
+      puts e.backtrace.inspect
+      return nil
+    end
+    data
+  end  
 end
 

data/test/test_sphero.rb

@@ -3,11 +3,12 @@ require 'sphero'
 require 'mocha/setup'
 
 class TestSphero < MiniTest::Unit::TestCase
-	def setup
-		Sphero.any_instance.stubs(:initialize_serialport)
-		@sphero = Sphero.new 'port123'
-		@seq = 0x00
-	end
+  def setup
+    Sphero.any_instance.stubs(:initialize_serialport)
+    Sphero.any_instance.stubs(:initialize_socket)
+    @sphero = Sphero.new 'port123'
+    @seq = 0x00
+  end
 
   def test_start_returns_new_sphero
     assert_kind_of Sphero, Sphero.start('someport')
@@ -22,77 +23,77 @@ class TestSphero < MiniTest::Unit::TestCase
   end
 
   def test_ping
-  	Sphero::Request::Ping.expects(:new).with(@seq)
-  	@sphero.expects(:write)
-  	@sphero.ping
+    Sphero::Request::Ping.expects(:new).with(@seq)
+    @sphero.expects(:write)
+    @sphero.ping
   end
 
   def test_version
-  	Sphero::Request::GetVersioning.expects(:new).with(@seq)
-  	@sphero.expects(:write)
-  	@sphero.version
+    Sphero::Request::GetVersioning.expects(:new).with(@seq)
+    @sphero.expects(:write)
+    @sphero.version
   end
 
   def test_bluetooth_info
-  	Sphero::Request::GetBluetoothInfo.expects(:new).with(@seq)
-  	@sphero.expects(:write)
-  	@sphero.bluetooth_info
+    Sphero::Request::GetBluetoothInfo.expects(:new).with(@seq)
+    @sphero.expects(:write)
+    @sphero.bluetooth_info
   end
 
   def test_auto_reconnect=
-  	@time_s = "10"
-  	Sphero::Request::SetAutoReconnect.expects(:new).with(@seq, @time_s)
-  	@sphero.expects(:write)
-  	@sphero.auto_reconnect = @time_s
+    @time_s = "10"
+    Sphero::Request::SetAutoReconnect.expects(:new).with(@seq, @time_s)
+    @sphero.expects(:write)
+    @sphero.auto_reconnect = @time_s
   end
 
   def test_auto_reconnect
-  	@time_s = "10"
-  	packet = mock 'packet'
-  	packet.stubs(:time).returns(@time_s)
+    @time_s = "10"
+    packet = mock 'packet'
+    packet.stubs(:time).returns(@time_s)
  
-  	Sphero::Request::GetAutoReconnect.expects(:new).with(@seq)
-  	@sphero.expects(:write).returns(packet)
-  	assert_equal @sphero.auto_reconnect, @time_s
+    Sphero::Request::GetAutoReconnect.expects(:new).with(@seq)
+    @sphero.expects(:write).returns(packet)
+    assert_equal @sphero.auto_reconnect, @time_s
   end
 
   def test_disable_auto_reconnect
-  	Sphero::Request::SetAutoReconnect.expects(:new).with(@seq, 0, 0x00)
-  	@sphero.expects(:write)
-  	@sphero.disable_auto_reconnect
+    Sphero::Request::SetAutoReconnect.expects(:new).with(@seq, 0, 0x00)
+    @sphero.expects(:write)
+    @sphero.disable_auto_reconnect
   end
 
   def test_power_state
-  	Sphero::Request::GetPowerState.expects(:new).with(@seq)
-  	@sphero.expects(:write)
-  	@sphero.power_state
+    Sphero::Request::GetPowerState.expects(:new).with(@seq)
+    @sphero.expects(:write)
+    @sphero.power_state
   end
   
   def test_sphero_sleep
-  	wakeup = 1
-  	macro = 2
-  	Sphero::Request::Sleep.expects(:new).with(@seq, wakeup, macro)
-  	@sphero.expects(:write)
-  	@sphero.sphero_sleep wakeup, macro
+    wakeup = 1
+    macro = 2
+    Sphero::Request::Sleep.expects(:new).with(@seq, wakeup, macro)
+    @sphero.expects(:write)
+    @sphero.sphero_sleep wakeup, macro
   end
 
   def test_roll
-  	speed = 1
-  	heading = 2
-  	state = 1
-  	Sphero::Request::Roll.expects(:new).with(@seq, speed, heading, state)
-  	@sphero.expects(:write)
-  	@sphero.roll speed, heading, true
+    speed = 1
+    heading = 2
+    state = 1
+    Sphero::Request::Roll.expects(:new).with(@seq, speed, heading, state)
+    @sphero.expects(:write)
+    @sphero.roll speed, heading, true
   end
 
   def test_stop
-  	@sphero.expects(:roll).with(0, 0)
-  	@sphero.stop
+    @sphero.expects(:roll).with(0, 0)
+    @sphero.stop
   end
 
   def test_keepgoing
-  	Kernel.expects(:sleep).with(3)
-  	@sphero.keep_going 3
+    Kernel.expects(:sleep).with(3)
+    @sphero.keep_going 3
   end
 
   def test_directions

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hybridgroup-sphero
 version: !ruby/object:Gem::Version
-  version: 1.1.6
+  version: 1.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,24 +9,8 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-14 00:00:00.000000000 Z
+date: 2013-02-23 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: hybridgroup-serialport
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement