ruby-player 0.4.1 → 0.5.0

data/lib/ruby-player/position2d.rb

@@ -14,6 +14,7 @@
 
 module Player
   # The position2d proxy provides an interface to a mobile robot base
+  # TODO: Implement PLAYER_POSITION2D_CMD_POS command
   #
   # @example
   #   # get proxy object
@@ -43,6 +44,54 @@ module Player
       @geom = {px: 0.0, py: 0.0, pz: 0.0, proll: 0.0, ppitch: 0.0, pyaw: 0.0, sw: 0.0, sl: 0.0, sh: 0.0}
     end
 
+    # X position [m]
+    # @return [Float]
+    def px
+      state[:px]
+    end
+    
+    # Y position [m]
+    # @return [Float]
+    def py
+      state[:py]
+    end
+    
+    # Yaw [rad]
+    # @return [Float]
+    def pa
+      state[:pa]
+    end
+
+    # X speed [m/s]
+    # @return [Float]
+    def vx
+      state[:vx]
+    end
+    
+    # Y speed [m/s]
+    # @return [Float]
+    def vy
+      state[:vy]
+    end
+    
+    # Yaw speed [rad/s]
+    # @return [Float]
+    def va
+      state[:va]
+    end
+
+    # State of motor
+    # @return [Boolean] true - on
+    def power?
+      state[:stall] != 0 
+    end
+
+    # @deprecated Use {#power?}
+    def power
+      warn "Method `power` is deprecated. Pleas use `power?`"
+      power?
+    end
+
     # @deprecated Use {#state}
     def position
       warn "Method `position` is deprecated. Pleas use `data` for access to position"
@@ -50,14 +99,14 @@ module Player
     end
 
     # Query robot geometry 
-    # @return self
+    # @return [Position2d] self
     def query_geom
       send_message(PLAYER_MSGTYPE_REQ, PLAYER_POSITION2D_REQ_GET_GEOM)
       self
     end
    
     # Turn on motor
-    # @return self
+    # @return [Position2d] self
     def power_on!
       send_message(PLAYER_MSGTYPE_REQ, PLAYER_POSITION2D_REQ_MOTOR_POWER, [1].pack("N")) 
       self
@@ -70,6 +119,7 @@ module Player
     end
 
     # Turn off motor
+    # @return [Position2d] self
     def power_off!
       send_message(PLAYER_MSGTYPE_REQ, PLAYER_POSITION2D_REQ_MOTOR_POWER, [0].pack("N")) 
       self
@@ -81,21 +131,25 @@ module Player
       power_off!
     end
 
+    # @return [Position2d] self
     def direct_speed_control!
       send_message(PLAYER_MSGTYPE_REQ, PLAYER_POSITION2D_REQ_VELOCITY_MODE, [0].pack("N"))
       self
     end
 
+    # @return [Position2d] self
     def separate_speed_control!
       send_message(PLAYER_MSGTYPE_REQ, PLAYER_POSITION2D_REQ_VELOCITY_MODE, [1].pack("N"))
       self
     end
 
+    # @return [Position2d] self
     def position_control!
       send_message(PLAYER_MSGTYPE_REQ, PLAYER_POSITION2D_REQ_POSITION_MODE, [0].pack("N"))
       self
     end
 
+    # @return [Position2d] self
     def speed_control!
       send_message(PLAYER_MSGTYPE_REQ, PLAYER_POSITION2D_REQ_POSITION_MODE, [1].pack("N"))
       self
@@ -106,7 +160,7 @@ module Player
     # @option odom :px x position (m)
     # @option odom :py y position (m)
     # @option odom :pa angle (rad).     
-    # @return self
+    # @return [Position2d] self
     def set_odometry(odom)
       data = [
         odom[:px].to_f,
@@ -123,7 +177,7 @@ module Player
     # @option params :kp P
     # @option params :ki I
     # @option params :kd D
-    # @return self
+    # @return [Position2d] self
     def set_speed_pid(params={})
       data = [
         params[:kp].to_f,
@@ -139,7 +193,7 @@ module Player
     # @option params :kp P
     # @option params :ki I
     # @option params :kd D
-    # @return self
+    # @return [Position2d] self
     def set_position_pid(params={})
       data = [
         params[:kp].to_f,
@@ -154,7 +208,7 @@ module Player
     # @param [Hash] params profile prarams
     # @option params :spped max speed (m/s)
     # @option params :acc max acceleration (m/s^2)
-    # @return self
+    # @return [Position2d] self
     def set_speed_profile(params={})
       data = [
         params[:speed].to_f,
@@ -166,7 +220,7 @@ module Player
     end
 
     # Reset odometry to zero
-    # @return self
+    # @return [Position2d] self
     def reset_odometry
       send_message(PLAYER_MSGTYPE_REQ, PLAYER_POSITION2D_REQ_RESET_ODOM)
       self
@@ -178,7 +232,7 @@ module Player
     # @option speeds :vy sideways speed (m/s); this field is used by omni-drive robots only. 
     # @option speeds :va rotational speed (rad/s).     
     # @option speeds :stall state of motor
-    # @return self
+    # @return [Position2d] self
     def set_speed(speeds)
       data = [
         speeds[:vx] || @state[:vx],
@@ -194,6 +248,7 @@ module Player
     # @param [Hash] speeds 
     # @option speeds :vx forward speed (m/s)
     # @option speeds :a turning angle (rad).     
+    # @return [Position2d] self
     def set_car(speeds)
       data = [ 
         speeds[:vx] || @state[:vx],
@@ -208,6 +263,7 @@ module Player
     # @param [Hash] speeds 
     # @option speeds :vx forward speed (m/s)
     # @option speeds :a absolutle angle (rad).     
+    # @return [Position2d] self
     def set_speed_head(speeds)
       data = [ 
         speeds[:vx] || @state[:vx],
@@ -217,15 +273,8 @@ module Player
       self
     end
 
-
-    # State of motor
-    # @return [Boolean] true - on
-    def power
-      @state[:stall] == 1 
-    end
-
     # Stop robot set speed to 0
-    # @return self
+    # @return [Position2d] self
     def stop!
       set_speed(vx: 0, vy: 0, va: 0)
     end
@@ -260,12 +309,12 @@ module Player
     private
     def read_state(msg)
       fill_hash!(@state, msg.unpack("GGGGGGN"))
-      debug "Get state: " + hash_to_sft(@state)
+      debug "Got state: " + hash_to_sft(@state)
     end
 
     def read_geom(msg)
       fill_hash!(@geom, msg.unpack("G*"))
-      debug "Get geom: " + hash_to_sft(@geom)
+      debug "Got geom: " + hash_to_sft(@geom)
     end
   end
 end

data/lib/ruby-player/power.rb

@@ -37,17 +37,47 @@ module Player
       super
       @state = { valid: 0, volts: 0.0, percent: 0.0, joules: 0.0, watts: 0.0, charging: 0 }
     end
+
+    # Battery voltage [V]. 
+    # @see #state
+    # @retrun [Float]
+    def volts
+      state[:volts]
+    end
+    
+    # Percent of full charge [%].
+    # @see #state
+    # @retrun [Float]
+    def percent
+      state[:percent]
+    end
     
+    # Energy stored [J]. 
+    # @see #state
+    # @retrun [Float]
+    def joules
+      state[:joules]
+    end
+    
+    # Estimated current energy consumption (negative values) or aquisition (positive values) [W]. 
+    # @see #state
+    # @retrun [Float]
+    def watts
+      state[:watts]
+    end
+
     # Request to change the charging policy
     # @param [Hash] policy
     # @option policy [Boolean] :enable_input boolean controlling recharging
     # @option policy [Boolean] :enable_output bolean controlling whether others can recharge from this device
+    # @return [Power] self
     def set_charging_policy(policy={})
       data = [
         policy[:enable_input] ? 1 : 0,
         policy[:enable_output] ? 1 : 0
       ]
       send_message(PLAYER_MSGTYPE_REQ, PLAYER_POWER_REQ_SET_CHARGING_POLICY, data.pack("NN"))
+      self
     end
 
     # Check volts valid
@@ -96,7 +126,7 @@ module Player
     private
     def read_state(msg)
       fill_hash!(@state, msg.unpack("NggggN"))
-      debug "Get state: " + hash_to_sft(@state)
+      debug "Got state: " + hash_to_sft(@state)
     end
   end
 end

data/lib/ruby-player/ranger.rb

@@ -41,25 +41,25 @@ module Player
 
     # @deprecated use `ranger.collect { |r| r.range }
     def rangers
-      warn "Method `rangers` is deprecated. Pleas use `ranger.collect { |r| r.state[:range] }`"
+      warn "Method `rangers` is deprecated. Pleas use `ranger.collect { |r| r.range }`"
       @sensors.collect { |s| s.range }
     end
     
     # @deprecated use `ranger.collect { |r| r.intensity }
     def intensities
-      warn "Method `intensities` is deprecated. Pleas use `ranger.collect { |r| r.state[:intensity] }`"
+      warn "Method `intensities` is deprecated. Pleas use `ranger.collect { |r| r.intensity }`"
       @sensors.collect { |s| s.intensity }
     end
 
     # Query ranger geometry 
-    # @return self
+    # @return [Ranger] self
     def query_geom
       send_message(PLAYER_MSGTYPE_REQ, PLAYER_RANGER_REQ_GET_GEOM)
       self
     end
 
     # Turn on ranger
-    # @return self
+    # @return [Ranger] self
     def power_on!
       send_message(PLAYER_MSGTYPE_REQ, PLAYER_RANGER_REQ_POWER, [1].pack("N")) 
       self
@@ -72,6 +72,7 @@ module Player
     end
 
     # Turn off ranger
+    # @return [Ranger] self
     def power_off!
       send_message(PLAYER_MSGTYPE_REQ, PLAYER_RANGER_REQ_POWER, [0].pack("N")) 
       self
@@ -83,17 +84,20 @@ module Player
       power_off!
     end
 
+    # @return [Ranger] self
     def intensity_enable!
       send_message(PLAYER_MSGTYPE_REQ, PLAYER_RANGER_REQ_INTNS, [1].pack("N"))
       self
     end
 
+    # @return [Ranger] self
     def intensity_disable!
       send_message(PLAYER_MSGTYPE_REQ, PLAYER_RANGER_REQ_INTNS, [0].pack("N"))
       self
     end
 
     # Query ranger configuration
+    # @return [Ranger] self
     def query_config
       send_message(PLAYER_MSGTYPE_REQ, PLAYER_RANGER_REQ_GET_CONFIG)
       self
@@ -108,18 +112,11 @@ module Player
     # @option config :max_range minimum range [m]
     # @option config :range_res range resolution [m]
     # @option config :frequency scanning frequency [Hz]
-    def set_config(config)
-      data = [
-        config[:min_angle].to_f || @ranger[:min_angle],
-        config[:max_angle].to_f || @ranger[:max_angle],            
-        config[:angular_res].to_f || @ranger[:angular_res],            
-        config[:min_range].to_f || @ranger[:min_range],
-        config[:max_range].to_f || @ranger[:max_range],
-        config[:range_res].to_f || @ranger[:range_res],
-        config[:frequecy].to_f || @ranger[:frequecy] 
-      ]
-
+    # @return [Ranger] self
+    def set_config(config={})
+      data = to_a_by_default(config, @config)
       send_message(PLAYER_MSGTYPE_REQ, PLAYER_RANGER_REQ_SET_CONFIG, data.pack("G*"))
+      self
     end
 
     def fill(hdr, msg)
@@ -130,14 +127,14 @@ module Player
           self[i].state[:range] = r
         end
 
-        debug "Get rangers #{@sensors.collect { |s| s.state[:range] }}"
+        debug "Got rangers #{@sensors.collect { |s| s.state[:range] }}"
       when PLAYER_RANGER_DATA_INTNS
         data = msg.unpack("NNG*")
         data[2..-1].each_with_index do |ints, i|
           self[i].state[:intensity] = ints
         end
 
-        debug "Get intensities #{@sensors.collect { |s| s.state[:intensity]}}"
+        debug "Got intensities #{@sensors.collect { |s| s.state[:intensity]}}"
       when PLAYER_RANGER_DATA_GEOM
         read_geom(msg)
       else
@@ -158,6 +155,9 @@ module Player
       end
     end
 
+    # Get sensor
+    # @param [Integer] index
+    # @retrun [Sensor] sensor
     def [](index)
       @sensors[index] ||= Sensor.new(index, self)
     end
@@ -174,7 +174,7 @@ module Player
     def read_geom(msg)
       data = msg[0,72].unpack("G*")
       fill_hash!(@geom, data)
-      debug "Get geom: " + hash_to_sft(@geom)
+      debug "Got geom: " + hash_to_sft(@geom)
 
 
       p_count =  msg[72,8].unpack("NN")
@@ -188,13 +188,13 @@ module Player
       p_count.times do |i|
         [:px, :py, :pz, :proll, :ppitch, :pyaw]
           .each_with_index { |k,j| self[i].geom[k] = poses[6*i + j] }
-        debug("Get poses for ##{i} sensor: px=%.2f, py=%.2f, pz=%.2f, proll=%.2f, ppitch=%.2f, pyaw=%.2f" % @sensors[i].geom.values[0,6])
+        debug("Got poses for ##{i} sensor: px=%.2f, py=%.2f, pz=%.2f, proll=%.2f, ppitch=%.2f, pyaw=%.2f" % @sensors[i].geom.values[0,6])
       end
       
       s_count.times do |i|
         [:sw, :sl, :sh]
           .each_with_index { |k,j| self[i].geom[k] = sizes[3*i + j] }
-        debug("Get sizes for ##{i} sensor: sw=%.2f, sl=%.2f, sh=%.2f" % @sensors[i].geom.values[6,3])
+        debug("Got sizes for ##{i} sensor: sw=%.2f, sl=%.2f, sh=%.2f" % @sensors[i].geom.values[6,3])
       end
 
     end

data/lib/ruby-player/version.rb

@@ -13,5 +13,5 @@
 # GNU General Public License for more details.
 
 module Player
-  VERSION = "0.4.1"
+  VERSION = "0.5.0"
 end

data/lib/ruby-player.rb

@@ -25,6 +25,8 @@ require "ruby-player/client"
 #interfaces
 require "ruby-player/actuator"
 require "ruby-player/actarray"
+require "ruby-player/blob"
+require "ruby-player/blob_finder"
 require "ruby-player/gripper"
 require "ruby-player/position2d"
 require "ruby-player/power"

data/spec/actarray_spec.rb

@@ -18,6 +18,14 @@ describe Player::ActArray do
     @actarray.geom.should eql(px: 0.0, py: 0.0, pz: 0.0, proll: 0.0, ppitch: 0.0, pyaw: 0.0)
   end
 
+  it 'should have :power? method' do
+    @actarray.should_receive(:state).and_return(motor_state: 0)
+    @actarray.power?.should be_false
+    
+    @actarray.should_receive(:state).and_return(motor_state: 1)
+    @actarray.power?.should be_true
+  end
+
   it 'should set power state for all actuators' do
     should_send_message(PLAYER_MSGTYPE_REQ, PLAYER_ACTARRAY_REQ_POWER, [0].pack("N"))
     @actarray.power_off!

data/spec/actuator_spec.rb

@@ -28,6 +28,26 @@ describe Player::Actuator do
     )
   end
 
+  it 'should have #position attr' do
+    @act.should_receive(:state).and_return(position: 1.2)
+    @act.position.should eql(1.2)
+  end
+
+  it 'should have #speed attr' do
+    @act.should_receive(:state).and_return(speed: 1.8)
+    @act.speed.should eql(1.8)
+  end
+
+  it 'should have #acceleration attr' do
+    @act.should_receive(:state).and_return(acceleration: 0.2)
+    @act.acceleration.should eql(0.2)
+  end
+
+  it 'should have #current attr' do
+    @act.should_receive(:state).and_return(current: 3.2)
+    @act.current.should eql(3.2)
+  end
+
   it 'should set speed config ' do
     should_send_message(PLAYER_MSGTYPE_REQ, PLAYER_ACTARRAY_REQ_SPEED, [0, 0.2].pack("Ng"))
     @act.set_speed_config(0.2)

data/spec/blob_finder_spec.rb

@@ -0,0 +1,96 @@
+require File.dirname(__FILE__) + "/spec_helper"
+
+include Player
+describe Player::BlobFinder do
+  before do
+    client = mock_client
+
+    @bf = Player::BlobFinder.new(
+      Player::DevAddr.new(host: 0, robot:0, interface: PLAYER_BLOBFINDER_CODE, index: 0),
+      client
+    )
+
+    mock_sending_message(@bf)
+  end
+
+  it 'should have default state' do
+    @bf.state.should eql(width: 0, height: 0, blobs: [])
+    @bf.color.should eql(channel: 0, rmin: 0, rmax: 0, gmin: 0, gmax: 0, bmin: 0, bmax: 0)
+    @bf.imager_params.should eql(brightness: 0, contrast: 0, colormode: 0, autogain: 0)
+  end
+
+  it 'should query color' do
+    should_send_message(PLAYER_MSGTYPE_REQ, PLAYER_BLOBFINDER_REQ_GET_COLOR)
+    @bf.query_color
+  end
+
+  it 'should set color' do
+    color = [0, 1, 251, 2, 252, 3, 253] 
+    should_send_message(PLAYER_MSGTYPE_REQ, PLAYER_BLOBFINDER_REQ_SET_COLOR, color.pack("N*"))
+    @bf.set_color(channel: 0, rmin: 1, rmax: 251, gmin: 2, gmax: 252, bmin: 3, bmax: 253)
+  end
+  
+  it 'should set imager params' do
+    params = [100, 200, 3, 1]
+    should_send_message(PLAYER_MSGTYPE_REQ, PLAYER_BLOBFINDER_REQ_SET_IMAGER_PARAMS, params.pack("N*"))
+    @bf.set_imager_params(brightness: 100, contrast: 200, colormode: 3, autogain: 1)
+  end
+
+  it 'should have #width attr' do
+    @bf.should_receive(:state).and_return(width: 23)
+    @bf.width.should eql(23)
+  end
+
+  it 'should have #height attr' do
+    @bf.should_receive(:state).and_return(height: 40)
+    @bf.height.should eql(40)
+  end
+
+  it 'should have #blobs attr' do
+    @bf.should_receive(:state).and_return(blobs: [nil])
+    @bf.blobs.should eql([nil])
+  end
+
+  it 'should fill blobs data' do
+    blobs = [10, 20, 2, 0,
+      0, 222, 20, 5, 4, 10, 10, 20, 20, 0.5,
+      1, 111, 40, 5, 8, 20, 30, 40, 50, 2.5]
+    msg = blobs.pack("NNNNN9gN9g")
+
+    @bf.fill(
+      Player::Header.from_a([0,0,PLAYER_BLOBFINDER_CODE, 0, 
+                            PLAYER_MSGTYPE_DATA, PLAYER_BLOBFINDER_DATA_BLOBS, 0.0, 0, msg.bytesize]),
+        msg
+      )
+    @bf.width.should eql(10)
+    @bf.height.should eql(20)
+    @bf[0].state.values.should eql(blobs[4,10])
+    @bf[1].state.values.should eql(blobs[14,10])
+  end
+
+  it 'should include Enumerable' do
+    @bf.state[:blobs] = Array.new(10) { |i| Blob.new(i, nil) }
+    @bf.map { |b| b.should be_kind_of(Blob) }
+  end
+
+  it 'should get color config by request' do
+   color = [1, 1, 2, 3, 4, 5, 6 ]
+
+    msg = color.pack("N*")
+    @bf.handle_response(
+      Player::Header.from_a([0,0,PLAYER_BLOBFINDER_CODE, 0, PLAYER_MSGTYPE_RESP_ACK, PLAYER_BLOBFINDER_REQ_GET_COLOR, 0.0, 0, msg.bytesize]),
+      msg
+    )
+
+    @bf.color.should eql(channel: 1, rmin: 1, rmax: 2, gmin: 3, gmax: 4, bmin: 5, bmax: 6)
+  end
+
+  it 'should not puts warn message for ACK subtypes 1,2' do  
+    @bf.should_not_receive(:unexpected_message)
+    (1..2).each do |i|
+      @bf.handle_response(
+        Player::Header.from_a([0,0,PLAYER_BLOBFINDER_CODE,0, PLAYER_MSGTYPE_RESP_ACK, i, 0.0, 0, 0]),
+        "")
+    end
+  end
+end

data/spec/blob_spec.rb

@@ -0,0 +1,63 @@
+require File.dirname(__FILE__) + "/spec_helper"
+
+describe Player::Blob do
+  before do
+    @blob = Player::Blob.new(nil, nil)
+  end
+
+  it 'should have default values' do
+    @blob.state.should eql(id: 0, color: 0, area: 0, x: 0, y: 0, left: 0, right: 0, top: 0, bottom: 0, range: 0.0) 
+  end
+
+  it 'should have #id attr' do
+    @blob.should_receive(:state).and_return(id: 23)
+    @blob.id.should eql(23)
+  end
+
+  it 'should have #color attr' do
+    @blob.should_receive(:state).and_return(color: 0xfff)
+    @blob.color.should eql(0xfff)
+  end
+
+  it 'should have #area attr' do
+    @blob.should_receive(:state).and_return(area: 100)
+    @blob.area.should eql(100)
+  end
+
+  it 'should have #x attr' do
+    @blob.should_receive(:state).and_return(x: 10)
+    @blob.x.should eql(10)
+  end
+
+  it 'should have #y attr' do
+    @blob.should_receive(:state).and_return(y: 20)
+    @blob.y.should eql(20)
+  end
+
+  it 'should have #left attr' do
+    @blob.should_receive(:state).and_return(left: 15)
+    @blob.left.should eql(15)
+  end
+
+  it 'should have #right attr' do
+    @blob.should_receive(:state).and_return(right: 30)
+    @blob.right.should eql(30)
+  end
+
+  it 'should have #top attr' do
+    @blob.should_receive(:state).and_return(top: 45)
+    @blob.top.should eql(45)
+  end
+
+  it 'should have #bottom attr' do
+    @blob.should_receive(:state).and_return(bottom: 35)
+    @blob.bottom.should eql(35)
+  end
+
+  it 'should have #ranger attr' do
+    @blob.should_receive(:state).and_return(range: 0.2)
+    @blob.range.should eql(0.2)
+  end
+end
+
+