ruby-player 0.3.0 → 0.4.0

data/NEWS.md

@@ -1,6 +1,12 @@
-## 2012-02-17 0.3.0
+## 2012-02-21 0.4.0
 
+* Changed API for Ranger. Now ranger[0].geom intead of ranger.geom[:sensors][0]! Methods #ranger, #intenities is depricated.
+* Added actarray interface
+* Methods #turn_on! ans #turn_off! are renamed to #power_on! and #power_off!. #turn_on! and #turn_off! is deprecated
 * Method Position2d::position is renamed to Position2d::state. Position2d::position is deprecated
+
+## 2012-02-17 0.3.0
+
 * Added gripper interface
 
 ## 2012-02-16 0.2.0

data/README.md

@@ -6,16 +6,6 @@ Ruby Player provide high level client library to access to Player server in pure
 
 Currently (2012-01-07) the Ruby Player are developing and testing with Player 3.1.0 latest svn version
 
-API coverage 
--------------------------------------
-The list of support objects and devices of Player.
-
-* Client object
-* Gripper
-* Position2d
-* Power
-* Ranger
-
 Install
 -------------------------------------
 
@@ -32,15 +22,36 @@ Example
       #main loop
       robot.loop do
         puts "Position: x=%{px}, y=%{py}, a=%{pa}" % pos2d.state
-        puts "Rangers: #{ranger.rangers}"
+        puts "Rangers: #{ranger.collect { |r| r.range }}"
       end
     end
 
+API coverage 
+-------------------------------------
+The list of support objects and devices of Player.
+
+* Client object
+* ActArray
+* Gripper
+* Position2d
+* Power
+* Ranger
+
+
+Requirements
+-------------------------------------
+
+* Ruby 1.9.2 or later 
+* Player 3.1.0 or later
+* For examples Stage 4.1.0 or later
+
 References
 -------------------------------------
 
 [Home page](http://www.github.com/flipback/ruby-player)
 
+[Documentation](http://rubydoc.info/gems/ruby-player/)
+
 [Player project](http://playerstage.sourceforge.net/)
 
 [C API Player](http://playerstage.sourceforge.net/doc/Player-3.0.2/player/group__player__clientlib__libplayerc.html)

data/TODO.md

@@ -8,16 +8,12 @@ Implement PLAYER_RANGER_DATA_RANGESTAMPED and PLAYER_RANGER_DATA_INTNSTAMPED
 Candidates for support
 --------------------------------------
 
-**actarray** - The actarray proxy provides an interface to actuator arrays such as the ActivMedia Pioneer Arm.
-
 **blobfinder** - The blobfinder proxy provides an interface to color blob detectors such as the ACTS vision system.
 
 **graphics2d** - The graphics2d proxy provides an interface to the graphics2d.
 
 **graphics3d** - The graphics3d proxy provides an interface to the graphics3d.
 
-**gripper** - The gripper proxy provides an interface to the gripper.
-
 **simulation** - The simulation proxy is used to interact with objects in a simulation.
 
 Device proxies are not started to develop

data/lib/ruby-player.rb

@@ -1,6 +1,6 @@
 # Ruby Player - Ruby client library for Player (tools for robots) 
 #
-# Copyright (C) 2012  Timin Aleksey
+# Copyright (C) 2012  Aleksey Timin
 #
 # 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
@@ -23,9 +23,12 @@ require "ruby-player/device"
 require "ruby-player/client"
 
 #interfaces
+require "ruby-player/actuator"
+require "ruby-player/actarray"
 require "ruby-player/gripper"
 require "ruby-player/position2d"
 require "ruby-player/power"
+require "ruby-player/sensor"
 require "ruby-player/ranger"
 
 

data/lib/ruby-player/actarray.rb

@@ -0,0 +1,171 @@
+# Ruby Player - Ruby client library for Player (tools for robots) 
+#
+# Copyright (C) 2012  Aleksey Timin
+#
+# 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 3 of the License, or
+# (at your option) any later version.
+#
+# 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.
+
+module Player
+  # The actuator array interface provides access to an array of actuators.
+  class ActArray < Device
+    include Enumerable
+
+    attr_reader :state
+
+    # Geometry of base actarray
+    attr_reader :geom
+
+    def initialize(dev, client)
+      super
+      @actuators = []
+      @state  = { motor_state: 0 }
+      @geom   = { px: 0.0, py: 0.0, pz: 0.0, proll: 0.0, ppitch: 0.0, pyaw: 0.0 }
+    end
+
+    # Turn on power all actuators
+    # Be careful when turning power on that the array is not obstructed 
+    # from its home position in case it moves to it (common behaviour)
+    # @return [ActArray] self
+    def power_on!
+      send_message(PLAYER_MSGTYPE_REQ, PLAYER_ACTARRAY_REQ_POWER, [1].pack("N"))
+      self
+    end
+
+    # Turn off power all actuators
+    # Be careful when turning power on that the array is not obstructed 
+    # from its home position in case it moves to it (common behaviour)
+    # @return [ActArray] self
+    def power_off!
+      send_message(PLAYER_MSGTYPE_REQ, PLAYER_ACTARRAY_REQ_POWER, [0].pack("N"))
+      self
+    end
+
+    # Turn on brakes all actuators
+    # @return [ActArray] self
+    def brakes_on!
+      send_message(PLAYER_MSGTYPE_REQ, PLAYER_ACTARRAY_REQ_BRAKES, [1].pack("N"))
+      self
+    end
+
+    # Turn off brakes all actuators
+    # @return [ActArray] self
+    def brakes_off!
+      send_message(PLAYER_MSGTYPE_REQ, PLAYER_ACTARRAY_REQ_BRAKES, [0].pack("N"))
+      self
+    end
+
+    # Query actarray geometry 
+    # @return [ActArray] self
+    def query_geom
+      send_message(PLAYER_MSGTYPE_REQ, PLAYER_ACTARRAY_REQ_GET_GEOM)
+      self
+    end
+
+    # Get single actuator
+    # @param joint - number of actuator
+    # @return [Actuator] actuator
+    def [](joint)
+      @actuators[joint] ||= Actuator.new(joint, self)
+    end
+
+    # Tells all joints/actuators to attempt to move to the given positions.
+    # @param [Array] poses
+    # @return [ActArray] self
+    def set_positions(poses)
+      send_message(
+        PLAYER_MSGTYPE_CMD, PLAYER_ACTARRAY_CMD_MULTI_POS,
+        ([poses.size] + poses).pack("Ng*")
+      )
+      self
+    end
+
+    # Tells all joints/actuators to attempt to move with the given speed.
+    # @param [Array] speeds
+    # @return [ActArray] self
+    def set_speeds(speeds)
+      send_message(
+        PLAYER_MSGTYPE_CMD, PLAYER_ACTARRAY_CMD_MULTI_SPEED,
+        ([speeds.size] + speeds).pack("Ng*")
+      )
+      self
+    end
+
+    # Command to go to home position for all joints
+    # @return [ActArray] self
+    def go_home!
+      send_message(PLAYER_MSGTYPE_CMD, PLAYER_ACTARRAY_CMD_HOME, [-1].pack("N"))
+      self
+    end
+
+    # Command all joints to attempt to move with the given current
+    # @param curr -current to move with
+    # @return [ActArray] self
+    def set_current_all(curr)
+      send_message(PLAYER_MSGTYPE_CMD, PLAYER_ACTARRAY_CMD_CURRENT, [-1, curr].pack("Ng"))
+      self
+    end
+    
+    # Tells all joints/actuators to attempt to move with the given current.
+    # @param [Array] currents
+    # @return [ActArray] self
+    def set_currents(currents)
+      send_message(
+        PLAYER_MSGTYPE_CMD, PLAYER_ACTARRAY_CMD_MULTI_CURRENT,
+        ([currents.size] + currents).pack("Ng*")
+      )
+      self
+    end
+
+    def each
+      @actuators.each { |a| yield a }
+    end
+
+    def fill(hdr, msg)
+      case hdr.subtype
+      when PLAYER_ACTARRAY_DATA_STATE
+        read_state(msg)
+      else
+        unexpected_message hdr
+      end
+    end
+
+    def handle_response(hdr, msg)
+      case hdr.subtype
+      when PLAYER_ACTARRAY_REQ_GET_GEOM
+        read_geom(msg)
+      else
+        unexpected_message hdr
+      end
+    end
+
+    private
+    def read_state(msg)
+      c = msg[0,4].unpack("NN")[0]
+      msg[8..-5].unpack("a20" * c).each_with_index do |s,i|
+        @actuators[i] ||= Actuator.new(i,self)
+        @actuators[i].read_state(s)
+        debug "Get state for actuator ##{i}: " + hash_to_sft(@actuators[i].state)
+      end
+      @state[:motor_state] = msg[-4,4].unpack("N")[0]
+      debug "Get state: motor_state=%d" % @state[:motor_state]
+    end
+
+    def read_geom(msg)
+      c = msg[0,4].unpack("N")[0]
+      msg[8..-48].unpack("a80" * c).each_with_index do |s, i|
+        @actuators[i] ||= Actuator.new(i,self)
+        @actuators[i].read_geom(s)
+        debug "Get geom for actuator ##{i}: " + hash_to_sft(@actuators[i].geom)
+      end
+      fill_hash!(@geom, msg[-48..-1].unpack("G6"))
+      debug("Get geom: " + hash_to_sft(@geom))
+    end
+  end
+end

data/lib/ruby-player/actuator.rb

@@ -0,0 +1,133 @@
+# Ruby Player - Ruby client library for Player (tools for robots) 
+#
+# Copyright (C) 2012  Aleksey Timin
+#
+# 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 3 of the License, or
+# (at your option) any later version.
+#
+# 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.
+
+module Player
+  # The actuator of actarray
+  # @see Player::ActArray
+  class Actuator
+    include Common
+
+    # Number in actarray
+    # @return [Integer]
+    attr_reader :joint
+
+    # State of actuator
+    #
+    # *:position* - The position of the actuator in m or rad depending on the type. 
+    #
+    # *:speed* - The speed of the actuator in m/s or rad/s depending on the type. 
+    #     
+    # *:acceleration* - The acceleration of the actuator in m/s^2 or rad/s^2 depending on the type.
+    #
+    # *:current* - The current of the actuator in A.
+    #
+    # *:state* - The current state of the actuator. @see #idle?, #moving?, #braked?, #stalled?
+    attr_reader :state
+
+    # Geometry of actuator
+    attr_reader :geom
+
+    def initialize(joint, actarray)
+      @joint, @actarray = joint, actarray
+      @state  = { position: 0.0, speed: 0.0, acceleration: 0.0, current: 0.0, state: 0 }
+      @geom   = { type: 0, length: 0.0, 
+        proll: 0.0, ppitch: 0.0, pyaw: 0.0, 
+        px: 0.0, py: 0.0, pz: 0.0,
+        min: 0.0, centre: 0.0, max: 0.0, home: 0.0,
+        config_speed: 0.0, hasbreaks: 0
+      }
+    end
+
+    # Set speed for a joint for all subsequent movements
+    # @param speed - speed setting in rad/s or m/s
+    # @return [Actuator] self
+    def set_speed_config(speed)
+      @actarray.send_message(PLAYER_MSGTYPE_REQ, PLAYER_ACTARRAY_REQ_SPEED, [@joint, speed].pack("Ng"))
+      self
+    end
+    
+    # Set accelelarion for a joint for all subsequent movements
+    # @param  accel - accelelarion setting in rad/s^2 or m/s^2
+    # @return [Actuator] self
+    def set_accel_config(accel)
+      @actarray.send_message(PLAYER_MSGTYPE_REQ, PLAYER_ACTARRAY_REQ_ACCEL, [@joint, accel].pack("Ng"))
+      self
+    end
+    
+    # Set position for a joint
+    # @param pos - position setting in rad or m
+    # @return [Actuator] self
+    def set_position(pos)
+      @actarray.send_message(PLAYER_MSGTYPE_CMD, PLAYER_ACTARRAY_CMD_POS, [@joint, pos].pack("Ng"))
+      self
+    end
+    
+    # Set speed for a joint
+    # @param seepd - speed setting in rad/s or m/s
+    # @return [Actuator] self
+    def set_speed(speed)
+      @actarray.send_message(PLAYER_MSGTYPE_CMD, PLAYER_ACTARRAY_CMD_SPEED, [@joint, speed].pack("Ng"))
+      self
+    end
+
+    # Command to go to home position
+    # @return [Actuator] self
+    def go_home!
+      @actarray.send_message(PLAYER_MSGTYPE_CMD, PLAYER_ACTARRAY_CMD_HOME, [@joint].pack("N"))
+      self
+    end
+
+    # Command a joint to attempt to move with the given current
+    # @param curr -current to move with
+    # @return [Actuator] self
+    def set_current(curr)
+      @actarray.send_message(PLAYER_MSGTYPE_CMD, PLAYER_ACTARRAY_CMD_CURRENT, [@joint, curr].pack("Ng"))
+      self
+    end
+
+    # Check idle state
+    # @return [Boolean]
+    def idle?
+      state[:state] & PLAYER_ACTARRAY_ACTSTATE_IDLE > 0
+    end
+    
+    # Check moving state
+    # @return [Boolean]
+    def moving?
+      state[:state] & PLAYER_ACTARRAY_ACTSTATE_MOVING > 0
+    end
+    
+    # Check braked state
+    # @return [Boolean]
+    def braked?
+      state[:state] & PLAYER_ACTARRAY_ACTSTATE_BRAKED > 0
+    end
+    
+    # Check braked state
+    # @return [Boolean]
+    def stalled?
+      state[:state] & PLAYER_ACTARRAY_ACTSTATE_STALLED > 0
+    end
+
+    def read_state(msg)
+      data = msg.unpack("g4N")
+      fill_hash!(@state, data)
+    end
+
+    def read_geom(msg)
+      data = msg.unpack("NgG6g5N")
+      fill_hash!(@geom, data)
+    end
+  end
+end 

data/lib/ruby-player/client.rb

@@ -1,6 +1,6 @@
 # Ruby Player - Ruby client library for Player (tools for robots) 
 #
-# Copyright (C) 2012  Timin Aleksey
+# Copyright (C) 2012  Aleksey Timin
 #
 # 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
@@ -155,7 +155,9 @@ module Player
     
     private
     def make_device(dev)
-      instance_eval(dev.interface_name.capitalize).send(:new, dev, self)
+      intf = dev.interface_name
+      klass = Player.constants.each { |c| break c if c.to_s.downcase == intf }
+      instance_eval(klass.to_s).send(:new, dev, self)
     end
 
     def read

data/lib/ruby-player/common.rb

@@ -1,6 +1,6 @@
 # Ruby Player - Ruby client library for Player (tools for robots) 
 #
-# Copyright (C) 2012  Timin Aleksey
+# Copyright (C) 2012  Aleksey Timin
 #
 # 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
@@ -73,16 +73,21 @@ module Player
       warn "Get unexpection message type #{hdr.type_name}::#{hdr.subtype_name} for #@addr"
     end
 
-    def geom_to_s(geom)
-      "px=%.2f, py=%.2f, pz=%.2f, proll=%.2f, ppitch=%.2f, pyaw=%.2f, sw=%.2f, sl=%.2f, sh=%.2f" % geom.values
-    end
-
-    def pose_to_s(pose)
-      "px=%.2f, py=%.2f, pz=%.2f, proll=%.2f, ppitch=%.2f, pyaw=%.2f" % pose.values
-    end
-
-    def size_to_s(size)
-      "sw=%.2f, sl=%.2f, sh=%.2f" % size.values
+    def hash_to_sft(hash)
+      tmpls = []
+      values = []
+      hash.each_pair do |k,v| 
+        tmpls << k.to_s + "=%"  + case v.class
+        when Integer
+          "d"
+        when Float
+          ".2f"
+        else
+          "s"
+        end
+        values << v
+      end
+      tmpls.join(", ") % values
     end
   end
 end