artoo 0.4.0 → 0.4.1

data/lib/artoo/drivers/servo.rb

@@ -4,14 +4,18 @@ module Artoo
   module Drivers
     # Servo behaviors for Firmata
     class Servo < Driver
+      COMMANDS = [:move, :min, :center, :max].freeze
+
       attr_reader :current_angle
 
+      # Create new Servo with angle=0
       def initialize(params={})
         super
 
         @current_angle = 0
       end
 
+      # Starts connection to read and process and driver
       def start_driver
         every(interval) do
           connection.read_and_process
@@ -20,30 +24,36 @@ module Artoo
         super
       end
 
+      # Moves to specified angle
+      # @param [Integer] angle must be between 0-180
       def move(angle)
         raise "Servo angle must be an integer between 0-180" unless (angle.is_a?(Numeric) && angle >= 0 && angle <= 180)
-        
+
         @current_angle = angle
         connection.set_pin_mode(pin, Firmata::Board::SERVO)
         connection.analog_write(pin, angle_to_span(angle))
       end
 
+      # Moves to min position
       def min
         move(0)
       end
 
+      # Moves to center position
       def center
         move(90)
       end
 
+      # Moves to max position
       def max
         move(180)
       end
 
       # converts an angle to a span between 0-255
+      # @param [Integer] angle
       def angle_to_span(angle)
         (angle * 255 / 180).to_i
       end
     end
   end
-end
+end

data/lib/artoo/drivers/sphero.rb

@@ -4,36 +4,50 @@ module Artoo
   module Drivers
     # The Sphero driver behaviors
     class Sphero < Driver
-      RED = [255, 0, 0]
-      GREEN = [0, 255, 0]
-      YELLOW = [255, 255, 0]
-      BLUE = [0, 0, 255]
-      WHITE = [255, 255, 255]
 
+      RED     = [255, 0,   0]
+      GREEN   = [0,   255, 0]
+      YELLOW  = [255, 255, 0]
+      BLUE    = [0,   0,   255]
+      WHITE   = [255, 255, 255]
+
+      COMMANDS = [:detect_collisions, :clear_collisions, :collisions,
+                  :power_notifications, :sensor_data, :set_color, :color].freeze
+
+      # Detects collisions
+      # @param [Hash] params
       def detect_collisions(params={})
         connection.configure_collision_detection 0x01, 0x20, 0x20, 0x20, 0x20, 0x50
       end
 
+      # Clears collisions
       def clear_collisions
         messages.clear if responses = messages
       end
 
+      # @return [CollisionDetected] collision
       def collisions
         matching_response_types messages, ::Sphero::Response::CollisionDetected
       end
 
+      # @return [PowerNotification] power notification
       def power_notifications
         matching_response_types messages, ::Sphero::Response::PowerNotification
       end
 
+      # @return [SensorData] sensor data
       def sensor_data
         matching_response_types messages, ::Sphero::Response::SensorData
       end
 
+      # Set color
+      # @param [Collection] colors
       def set_color(*colors)
         connection.rgb(*color(*colors))
       end
 
+      # Retrieves color
+      # @param [Collection] colors
       def color(*colors)
         case colors.first
         when :red    then RED

data/lib/artoo/drivers/wiichuck.rb

@@ -4,6 +4,9 @@ module Artoo
   module Drivers
     # Wiichuck driver behaviors for Firmata
     class Wiichuck < Wiidriver
+
+      # Update button and joystick values
+      # @param [Object] value
       def update(value)
         begin
           super
@@ -19,21 +22,24 @@ module Artoo
         end
       end
 
+      # Adjust x, y origin values
       def adjust_origins
         set_joystick_default_value(:sy_origin, data[:sy])
         set_joystick_default_value(:sx_origin, data[:sx])
       end
 
+      # Publishes events for c and z buttons
       def update_buttons
         publish(event_topic_name("c_button")) if data[:c] == true
         publish(event_topic_name("z_button")) if data[:z] == true
       end
 
+      # Publishes event for joystick
       def update_joystick
         publish(event_topic_name("joystick"), {:x => calculate_joystick_value(:sx, :sx_origin), :y => calculate_joystick_value(:sy, :sy_origin)})
       end
 
-      private 
+      private
 
       def get_defaults
         {

data/lib/artoo/drivers/wiiclassic.rb

@@ -3,11 +3,14 @@ require 'artoo/drivers/wiidriver'
 module Artoo
   module Drivers
     # Wiiclassic driver behaviors for Firmata
-    class Wiiclassic < Wiidriver      
+    class Wiiclassic < Wiidriver
+
+      # Update buttons and joysticks values
+      # @param [Object] value
       def update(value)
         begin
           super
-          
+
           adjust_origins
           update_buttons
           update_left_joystick
@@ -21,6 +24,7 @@ module Artoo
         end
       end
 
+      # Adjust all origins
       def adjust_origins
         set_joystick_default_value(:ly_origin, data[:ly])
         set_joystick_default_value(:lx_origin, data[:lx])
@@ -30,6 +34,7 @@ module Artoo
         set_joystick_default_value(:lt_origin, data[:lt])
       end
 
+      # Update button values
       def update_buttons
         update_button("a_button", :a)
         update_button("b_button", :b)
@@ -40,25 +45,29 @@ module Artoo
         update_button("select_button", :-)
       end
 
+      # Publish button event
       def update_button(name, key)
         publish(event_topic_name(name)) if data[key] == true
       end
 
+      # Publish left joystick event
       def update_left_joystick
         publish(event_topic_name("left_joystick"), {:x => calculate_joystick_value(:lx, :lx_origin), :y => calculate_joystick_value(:ly, :ly_origin)})
       end
 
+      # Publish right joystick event
       def update_right_joystick
         publish(event_topic_name("right_joystick"), {:x => calculate_joystick_value(:rx, :rx_origin), :y => calculate_joystick_value(:ry, :ry_origin)})
       end
 
+      # Publish triggers events
       def update_triggers
         publish(event_topic_name("right_trigger"), calculate_joystick_value(:rt, :rt_origin))
         publish(event_topic_name("left_trigger"), calculate_joystick_value(:lt, :lt_origin))
       end
 
       private
-      
+
       def get_defaults
         {
           :ry_origin => nil,
@@ -67,8 +76,8 @@ module Artoo
           :lx_origin => nil,
           :rt_origin => nil,
           :lt_origin => nil
-        }  
-      end      
+        }
+      end
 
       def parse(value)
         return parse_joysticks(value).

data/lib/artoo/drivers/wiidriver.rb

@@ -8,12 +8,14 @@ module Artoo
 
       def address; 0x52; end
 
+      # Create new Wiidriver
       def initialize(params={})
         @joystick = get_defaults
         @data = {}
         super
       end
 
+      # Starts drives and required connections
       def start_driver
         begin
           listener = ->(value) { update(value) }
@@ -38,6 +40,7 @@ module Artoo
         end
       end
 
+      # Get and update data
       def update(value)
         if encrypted?(value)
           Logger.error "Encrypted bytes from wii device!"
@@ -47,7 +50,7 @@ module Artoo
         @data = parse(value)
       end
 
-      protected 
+      protected
 
       def get_defaults
         {}

data/lib/artoo/events.rb

@@ -1,6 +1,10 @@
 module Artoo
+  # Class that handles events
   module Events
+
     # Subscribe to an event from a device
+    # @param [Device] device
+    # @param [Hash]   events
     def on(device, events={})
       events.each do |k, v|
         subscribe("#{safe_name}_#{device.name}_#{k}", create_proxy_method(k, v))
@@ -10,8 +14,10 @@ module Artoo
     # Create an anonymous subscription method so we can wrap the
     # subscription method fire into a valid method regardless
     # of where it is defined
-    def create_proxy_method(k, v)
-      proxy_method_name(k).tap do |name|
+    # @param [String] base_name
+    # @param [String] v
+    def create_proxy_method(base_name, v)
+      proxy_method_name(base_name).tap do |name|
         self.class.send :define_method, name do |*args|
           case v
           when Symbol
@@ -24,9 +30,10 @@ module Artoo
     end
 
     # A simple loop to create a 'fake' anonymous method
-    def proxy_method_name(k)
+    # @return [Method] created method
+    def proxy_method_name(base_name)
       begin
-        meth = "#{k}_#{Random.rand(999)}"
+        meth = "#{base_name}_#{Random.rand(999)}"
       end while respond_to?(meth)
       meth
     end

data/lib/artoo/ext/actor.rb

@@ -1,4 +1,4 @@
-# monkeypatches for Celluloid Actor class
+# Monkeypatches for Celluloid Actor class
 module Celluloid
   def timers
     Actor.timers

data/lib/artoo/ext/timers.rb

@@ -1,4 +1,4 @@
-# monkeypatches for Timers & Timer classes used by Celluloid
+# Monkeypatches for Timers & Timer classes used by Celluloid
 class Timers
   def initialize
     @timers = SortedSet.new

data/lib/artoo/main.rb

@@ -6,27 +6,16 @@ module Artoo
   # DSL methods executed on main are delegated to this class like Sinatra
   class MainRobot < Artoo::Robot
 
-    # we assume that the first file that requires 'artoo' is the
+    # We assume that the first file that requires 'artoo' is the
     # app_file. all other path related options are calculated based
     # on this path by default.
     set :app_file, caller_files.first || $0
     set :start_work, Proc.new { File.expand_path($0) == File.expand_path(app_file) }
-
-    # if run? && ARGV.any?
-    #   require 'optparse'
-    #   OptionParser.new { |op|
-    #     op.on('-p port',   'set the port (default is 4567)')                { |val| set :port, Integer(val) }
-    #     op.on('-o addr',   'set the host (default is 0.0.0.0)')             { |val| set :bind, val }
-    #     op.on('-e env',    'set the environment (default is development)')  { |val| set :environment, val.to_sym }
-    #     op.on('-s server', 'specify rack server/handler (default is thin)') { |val| set :server, val }
-    #     op.on('-x',        'turn on the mutex lock (default is off)')       {       set :lock, true }
-    #   }.parse!(ARGV.dup)
-    # end
   end
 
   at_exit { MainRobot.work! if $!.nil? && MainRobot.start_work? }
 end
 
-# include would include the module in Object
+# include would include the module in Object,
 # extend only extends the `main` object
 extend Artoo::Delegator

data/lib/artoo/master.rb

@@ -3,36 +3,52 @@ module Artoo
   # of all the running robots
   class Master
     include Celluloid
-		attr_reader :robots
+    attr_reader :robots
 
+    # Create new master
+    # @param [Collection] robots
     def initialize(bots)
       @robots = bots
     end
 
+    # @param  [String] name
+    # @return [Robot]  robot
     def robot(name)
       robots.find {|r| r.name == name}
     end
 
+    # @param  [String]     name
+    # @return [Collection] robot devices
     def robot_devices(name)
       robot(name).devices
     end
 
+    # @param  [String] name
+    # @param  [String] device_id
+    # @return [Device] robot device
     def robot_device(name, device_id)
       robot_devices(name)[device_id.intern]
     end
 
+    # @param  [String]     name
+    # @return [Collection] robot connections
     def robot_connections(name)
       robot(name).connections
     end
 
+    # @param  [String] robot_id
+    # @param  [String] connection_id
+    # @return [Device] robot connection
     def robot_connection(robot_id, connection_id)
       robot_connections(robot_id)[connection_id.intern]
     end
 
+    # Do asynchronous work for each robot
     def start_work
       robots.each {|r| r.async.work} unless Artoo::Robot.is_running?
     end
 
+    # Pause work for each robot
     def pause_work
       robots.each {|r|
         Logger.info "pausing #{r.name}"
@@ -40,12 +56,14 @@ module Artoo
       }
     end
 
+    # Continue work for each robot
     def continue_work
       robots.each {|r| r.async.continue_work}
     end
 
+    # @deprecated
     def stop_work
       #robots.each {|r| r.async.stop_work} unless !Artoo::Robot.is_running?
     end
   end
-end
+end

data/lib/artoo/port.rb

@@ -1,28 +1,33 @@
 module Artoo
-  # The Artoo::Port class represents port and/or host to be used to connect 
+  # The Artoo::Port class represents port and/or host to be used to connect
   # tp a specific individual hardware device.
   class Port
     attr_reader :port, :host
 
+    # Create new port
+    # @param [Object] data
     def initialize(data)
       @is_tcp, @is_serial = false
       parse(data)
     end
 
+    # @return [Boolean] True if serial port
     def is_serial?
       @is_serial == true
     end
 
+    # @return [Boolean] True if tcp port
     def is_tcp?
       @is_tcp == true
     end
 
+    # @return [String] port
     def to_s
       if is_serial?
         port
       else
         "#{host}:#{port}"
-      end  
+      end
     end
 
     private
@@ -48,4 +53,4 @@ module Artoo
       end
     end
   end
-end
+end