ruby-player 0.0.1 → 0.1.0

data/.gitignore

@@ -7,3 +7,4 @@ html/
 doc/
 Gemfile.lock
 .rvmrc
+tags

data/.travis.yml

@@ -0,0 +1,5 @@
+rvm:
+  - 1.9.2
+  - 1.9.3
+  
+script: "bundle exec rake spec"

data/Guardfile

@@ -0,0 +1,5 @@
+guard 'rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$}) { "spec" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end

data/README.md

@@ -1,9 +1,9 @@
-Ruby Player - Ruby client library for Player (tools for robots) 
+Ruby Player - Ruby client library for Player (tools for robots) [![Build Status](https://secure.travis-ci.org/flipback/ruby-player.png)](http://travis-ci.org/flipback/ruby-player)
 
 Summary
 -------------------------------------
-Ruby Player provide high level client library to access to Player server. 
-It are using the FFI for binding with playerc C client library. 
+Ruby Player provide high level client library to access to Player server in pure Ruby
+Currently (2012-01-07) the Ruby Player are developing and testing with Player 3.1.0 latest svn version
 
 API coverage 
 -------------------------------------
@@ -14,27 +14,21 @@ The list of support objects and devices of Player.
 
 Install
 -------------------------------------
-Currently (2012-01-07) the Ruby Player are developing and testing with Player 3.1.0 latest svn version
-and Stage v4.1.0. See them user guides for installation. 
-
-After installation Player/Stage run:
 
 `gem install ruby-player`
 
-For testing library in root dir library:
-
-    player spec/world/test.cfg
-    bundle exec rake spec
-
 Example
 -------------------------------------
 
     require 'ruby-player'
     Player::Client.connect("localhost") do |robot|
-      pos2d = robot[:position2d, 0]
-      pos2d.set_vel(1, 0, 0.2)
+      pos2d = robot.subscribe("position2d", index: 0)
+      ranger = robot.subscribe(:ranger)
+      pos2d.set_speed(vx: 1, vy: 0, va: 0.2)
+      #main loop
       robot.loop do
-        puts "Position: x=#{pos2d.px}, y=#{pos2d.py}, a=#{pos2d.pa}
+        puts "Position: x=%{px}, y=%{py}, a=%{pa}" % pos2d.position
+        puts "Rangers: #{ranger.rangers}"
       end
     end
 
@@ -45,10 +39,9 @@ References
 
 [Player project](http://playerstage.sourceforge.net/)
 
-[Stage project](https://github.com/rtv/Stage)
-
 [C API Player](http://playerstage.sourceforge.net/doc/Player-3.0.2/player/group__player__clientlib__libplayerc.html)
 
 Authors
 -------------------------------------
+
 Aleksey Timin <atimin@gmail.com>

data/TODO.md

@@ -3,12 +3,7 @@ For supported devices
 -------------------------------------
 **ranger** - The ranger proxy provides an interface to ranger sensor devices.
 
-1. Get geometry of device and sensors
-2. Get 3d scan points (x,y,z)
-
-**position2d** - The position2d proxy provides an interface to a mobile robot base, such as the ActiveMedia Pioneer series.
-1. Set speed and heading - wrap C `func playerc_position2d_set_cmd_vel_head`
-2. Move to point - wrap C funcs `playerc_position2d_set_cmd_pose_with_vel` and `playerc_position2d_set_cmd_pose`
+Implement PLAYER_RANGER_DATA_RANGESTAMPED and PLAYER_RANGER_DATA_INTNSTAMPED
 
 Candidates for support
 --------------------------------------
@@ -44,12 +39,8 @@ Device proxies are not started to develop
 
 **health** - The health proxy provides an interface to the HEALTH Module.
 
-**ir** - The ir proxy provides an interface to the ir sensors built into robots such as the RWI B21R.
-
 **joystick** - The joystick proxy can be used to get images from a joystick.
 
-**laser** - The laser proxy provides an interface to scanning laser range finders such as the sicklms200.
-
 **limb** - The limb proxy provides an interface to limbs using forward/inverse kinematics, such as the ActivMedia Pioneer Arm.
 
 **localize** - The localize proxy provides an interface to localization drivers.
@@ -72,8 +63,6 @@ Device proxies are not started to develop
 
 **ptz** - The ptz proxy provides an interface to pan-tilt units such as the Sony PTZ camera.
 
-**sonar** - The sonar proxy provides an interface to the sonar range sensors built into robots such as the ActiveMedia Pioneer series.
-
 **wifi** - The wifi proxy is used to query the state of a wireless network.
 
 **speech** - The speech proxy provides an interface to a speech synthesis system.

data/examples/simple_example.rb

@@ -0,0 +1,27 @@
+require 'ruby-player'
+Player::Client.connect("localhost") do |robot|
+  pos2d = robot.subscribe(:position2d)
+  ranger = robot.subscribe(:ranger)
+  #main loop
+  robot.loop(0.05) do
+    puts "Position: x=%{px}, y=%{py}, a=%{pa}" % pos2d.position
+    r = ranger.rangers
+    puts "Rangers: #{r}"
+
+    if r[0] < 2.5
+      pos2d.set_car vx: 0.2*r[0], a: -1 / r[0]
+      puts "Turn right"
+      next
+    end
+    
+    if r[1] <  2.5
+      pos2d.set_car vx: 0.2*r[1], a: 1 / r[1]
+      puts "Turn left"
+      next
+    end
+
+    if r[0] > 2.5 && r[1] > 2.5
+      pos2d.set_car vx: 0.4, a: 0
+    end
+  end
+end

data/{spec → examples}/world/test.world

@@ -75,11 +75,11 @@ define bender2dx position
   size [1 1 1]
 )
 
-#carton
-#(
-#  name "c0"
-#  pose [ 1 0 0 0.0]
-#)
+carton
+(
+  name "c0"
+  pose [ 3 0 0 0.0]
+)
 
 bender2dx
 (

data/lib/ruby-player.rb

@@ -12,12 +12,19 @@
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 
-require "ffi"
-
-require "ruby-player/c_type"
-
 require "ruby-player/version"
+require "ruby-player/constants"
 require "ruby-player/common"
+
+#basic classes
+require "ruby-player/dev_addr"
+require "ruby-player/header"
+require "ruby-player/device"
+require "ruby-player/client"
+
+#interfaces
 require "ruby-player/position2d"
 require "ruby-player/ranger"
-require "ruby-player/client"
+
+
+

data/lib/ruby-player/client.rb

@@ -17,39 +17,38 @@ module Player
   #
   # @example
   #
-  #   Player::Client.connect("localhost") do |cl|
-  #     pos2d = cl[:position2d, 0]
-  #     pos2d.set_vel(1, 0, 0.2)
-  #     cl.loop do
-  #       puts "Position: x=#{pos2d.px}, y=#{pos2d.py}, a=#{pos2d.pa}
+  #   require 'ruby-player'
+  #   Player::Client.connect("localhost") do |robot|
+  #     pos2d = robot.subscribe("position2d", index: 0)
+  #     pos2d.set_speed(vx: 1, vy: 0, va: 0.2)
+  #     #main loop
+  #     robot.loop do
+  #       puts "Position: x=%{px}, y=%{py}, a=%{pa}" % pos2d.position
   #     end
   #   end
-  class Client
-    include CType
+  class Client < Device
     include Common 
 
-    module C
-      extend FFI::Library
-      ffi_lib "playerc"
-
-      attach_function :playerc_client_create, [:pointer, :string, :int], :pointer
-      attach_function :playerc_client_destroy, [:pointer],  :void
-      attach_function :playerc_client_connect, [:pointer], :int
-      attach_function :playerc_client_disconnect, [:pointer],  :int
+    # Initialize client
+    # @param [String] host host of Player server 
+    # @param [Hash] opts client options
+    # @option opts :port port of connection
+    # @option opts :log_level level of log messages [:debug,:notice, :warn, :error] default :notice
+    def initialize(host, opts = {})
+      port = opts[:port] || 6665
+      @log_level = (opts[:log_level] || :notice).to_sym
 
+      @socket = TCPSocket.new(host, port)
+      @addr = DevAddr.new(host: 0, robot: 0, interface: PLAYER_PLAYER_CODE, index: 0)
+      @client = self
+      @devices = []
 
-      attach_function :playerc_client_read, [:pointer],  :void
-    end
-
-    # Initialize client
-    # @param [String] host host address
-    # @param port number of port default 6665  
-    def initialize(host, port=6665)
-      @client = ClientStruct.new(C.playerc_client_create(nil, host, port.to_i))
+      banner = @socket.read(PLAYER_IDENT_STRLEN)
+      notice "Connect with #{banner} in #{host}:#{port}"
+      send_message PLAYER_MSGTYPE_REQ, PLAYER_PLAYER_REQ_DATAMODE, [PLAYER_DATAMODE_PULL].pack("N")
 
-      try_with_error C.playerc_client_connect(@client)
+      debug "Set delivery mode in PULL"
 
-      ObjectSpace.define_finalizer(self, Client.finilazer(@client))
       if block_given?
         yield self
         close
@@ -63,31 +62,44 @@ module Player
     end
 
     # Read data from server and update all subscribed proxy objects
-    def read
-      C.playerc_client_read(@client) 
+    def read!
+      send_message PLAYER_MSGTYPE_REQ, PLAYER_PLAYER_REQ_DATA, ""
+      while read[0].type != PLAYER_MSGTYPE_SYNCH
+      end
+      nil
     end
 
     # Get proxy object
     #
     # @example 
-    #   pos2d = client[:position2d, 0]
-    #
-    # @param type type name of proxy object
-    # @param index index of proxy object
-    # @return proxy object
-    def [](type, index)
-      type_name = type.to_s.capitalize
-      (eval type_name).send(:new, @client, index)
+    #   pos2d = client.subscribe(:position2d, index: 0)
+    # 
+    # @param [String,Symbol] type interface type name 
+    # @param [Hash] opts of subscribing
+    # @option opts :index index of device (default 0)
+    # @option opts :access access level (default PLAYER_OPEN_MODE)
+    def subscribe(type, opts = {})
+      code = instance_eval("PLAYER_#{type.to_s.upcase}_CODE")
+      index = opts[:index] || 0
+      access = opts[:access] || PLAYER_OPEN_MODE
+
+      notice "Subscribing to #{type}:#{index}"
+      data = DevAddr.new(interface: code, index: index).to_a + [access, 0, 0]
+      send_message PLAYER_MSGTYPE_REQ, PLAYER_PLAYER_REQ_DEV, data.pack("N*")
+
+      read!
+      
+      @devices.select { |d| d.addr.interface == code && d.addr.index == index}.first
     end
 
     # Check connection
     def closed?
-      @client[:connected] == 0
+      @socket.closed?
     end
 
     # Close connection
     def close
-      try_with_error C.playerc_client_disconnect(@client)
+      @socket.close
     end
 
     # Loop for control code
@@ -100,17 +112,99 @@ module Player
     # @param period period cicles in seconds
     def loop(period=1.0)
       while(true) do
-        read
+        read!
         yield
         sleep(period.to_f)
       end
     end
 
-    def Client.finilazer(client)
-      lambda do
-        C.playerc_client_disconnect(client) if client[:connected] > 0
-        C.playerc_client_destroy(client)
+    def write(hdr, msg)
+      send_header hdr
+      @socket.write msg 
+      @socket.flush
+    end
+
+    def handle_response(hdr, msg)
+      case hdr.subtype
+      when 0
+        nil
+      when PLAYER_PLAYER_REQ_DEV
+        # read device identifier
+        dev = DevAddr.decode(msg[0,PLAYERXDR_DEVADDR_SIZE])
+        # read the granted access and driver name
+        data = msg[PLAYERXDR_DEVADDR_SIZE,8].unpack("N*")
+        access = data[0]
+        # read driver name
+        drv_name = msg[-data[1]-2..-1]
+
+        if access == PLAYER_ERROR_MODE
+          raise_error "Error subscribing to " + dev.interface_name + ":" + dev.index 
+        end
+        
+        debug "Got response: #{dev.interface_name}:#{dev.index} (driver name - #{drv_name})"
+
+        @devices << make_device(dev)
+      when PLAYER_PLAYER_REQ_DATAMODE, PLAYER_PLAYER_REQ_DATA
+        nil
+      else
+        warn "Don't implement ACK for subtype = #{hdr.subtype}"  
       end
     end
+    
+    private
+    def make_device(dev)
+      instance_eval(dev.interface_name.capitalize).send(:new, dev, self, @log_level)
+    end
+
+    def read
+      hdr = read_header
+      msg = @socket.read(hdr.size)
+
+      case hdr.type
+      # Data message
+      when PLAYER_MSGTYPE_DATA
+        debug "Data for #{hdr.dev_addr.interface_name}:#{hdr.dev_addr.index}"
+        fill_device hdr, msg
+
+      # Acknowledgement response message
+      when PLAYER_MSGTYPE_RESP_ACK
+        if hdr.dev_addr.interface != PLAYER_PLAYER_CODE
+          handle_response_device(hdr, msg)
+        else
+          handle_response(hdr, msg)
+        end
+      when PLAYER_MSGTYPE_RESP_NACK
+        warn "NACK for subtype = #{hdr.subtype} from #{hdr}"
+      when PLAYER_MSGTYPE_SYNCH
+        nil
+      else
+        warn "Unknow message type = #{hdr.type} received in read()"
+      end
+      [hdr, msg]
+    end
+
+    def handle_response_device(hdr, msg)
+      @devices.each do |dev|
+        dev.handle_response(hdr, msg) if dev.addr == hdr.dev_addr
+      end
+    end
+
+    def fill_device(hdr, msg)
+      @devices.each do |dev|
+        dev.fill(hdr, msg) if dev.addr == hdr.dev_addr
+      end
+    end
+
+    def send_header(hdr)
+      @socket.write hdr.encode
+      @socket.flush
+      debug "Send #{hdr}"
+    end
+
+    def read_header
+      hdr = Header.decode(@socket.read(PLAYERXDR_MSGHDR_SIZE))
+      debug "Read #{hdr}"
+      hdr
+    end
   end
 end

data/lib/ruby-player/common.rb

@@ -12,18 +12,55 @@
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 
+require "isna"
+
 module Player
   module Common
-    module C
-      extend FFI::Library
-      ffi_lib "playerc"
+    private
+    def debug(msg)
+      if @log_level == :debug
+        puts log_msg(:debug, msg)
+      end
+    end
 
-      attach_function :playerc_error_str, [],  :string
+    def notice(msg)
+      if [:debug, :notice].include?(@log_level)
+        puts log_msg(:notice, msg).to_ansi.normal
+      end
     end
 
-    private
-    def try_with_error(result)
-      raise StandardError.new(C.playerc_error_str) if result != 0
+    def warn(msg)
+      if [:debug, :log, :warn].include?(@log_level)
+        puts log_msg(:warn, msg).to_ansi.blue
+      end
+    end
+
+    def error(msg)
+      if [:debug, :log, :warn, :debug].include?(@log_level)
+        puts log_msg(:error, msg).to_ansi.red
+      end
+    end
+
+    def log_msg(level, msg)
+        "[ruby-player][#{level}]\t #{@addr.interface_name}:#{@addr.index}\t#{msg}"
+    end
+
+    def raise_error(err_msg)
+      error err_msg
+      raise StandardError.new(err_msg)
+    end
+
+    def search_const_name(value, tmpl)
+      tmpl = Regexp.new(tmpl.to_s)
+      consts = Player.constants.select { |c| c =~ tmpl}
+      consts.each do |c|
+        return c.to_s if Player.module_eval(c.to_s) == value
+      end
+      ""
+    end
+
+    def unexpected_message(hdr)
+      warn "Get unexpection message type #{hdr.type_name}::#{hdr.subtype_name} for #@addr"
     end
   end
 end