artoo 0.4.0 → 0.4.1

data/lib/artoo/drivers/ardrone.rb

@@ -3,7 +3,11 @@ require 'artoo/drivers/driver'
 module Artoo
   module Drivers
     # Ardrone driver behaviors
+    # @see https://github.com/hybridgroup/argus/blob/master/lib/argus/drone.rb Argus::Drone docs for supported actions
     class Ardrone < Driver
+      def start
+        connection.start(false) # send false, so Argus does not use NavMonitor
+      end
     end
   end
-end
+end

data/lib/artoo/drivers/ardrone_navigation.rb

@@ -4,6 +4,8 @@ module Artoo
   module Drivers
     # Ardrone navigation driver behaviors
     class ArdroneNavigation < Driver
+
+      # Starts driver and handle updates from device
       def start_driver
         every(interval) do
           handle_update
@@ -12,10 +14,12 @@ module Artoo
         super
       end
 
+      # Receives data from navigation and publishes
+      # and event in update topic for it
       def handle_update
         navdata = connection.receive_data
         publish(event_topic_name("update"), navdata)
       end
     end
   end
-end
+end

data/lib/artoo/drivers/ardrone_video.rb

@@ -4,6 +4,8 @@ module Artoo
   module Drivers
     # Ardrone video driver behaviors
     class ArdroneVideo < Driver
+
+      # Starts drives and handles video frame
       def start_driver
         every(interval) do
           handle_frame
@@ -12,11 +14,14 @@ module Artoo
         super
       end
 
+      # Retrieves frame from video connection
+      # and publishes data to update and frame
+      # event topics
       def handle_frame(*params)
-        frame = connection.video_parser.get_frame
-        publish(event_topic_name("update"), "frame", frame)
-        publish(event_topic_name("frame"), frame)
+        video = connection.receive_data
+        publish(event_topic_name("update"), "video", video)
+        publish(event_topic_name("frame"), video.frame)
       end
     end
   end
-end
+end

data/lib/artoo/drivers/button.rb

@@ -4,13 +4,18 @@ module Artoo
   module Drivers
     # Button driver behaviors for Firmata
     class Button < Driver
+      COMMANDS = [:is_pressed?].freeze
+
       DOWN = 1
       UP = 0
 
+      # @return [Boolean] True if pressed
       def is_pressed?
         (@is_pressed ||= false) == true
       end
 
+      # Sets values to read and write from button
+      # and starts driver
       def start_driver
         listener = ->(value) { update(value) }
         connection.on("digital-read-#{pin}", listener)
@@ -24,6 +29,7 @@ module Artoo
         super
       end
 
+      # Publishes events according to the button feedback
       def update(value)
         if value == DOWN
           @is_pressed = true
@@ -37,4 +43,4 @@ module Artoo
       end
     end
   end
-end
+end

data/lib/artoo/drivers/driver.rb

@@ -1,7 +1,7 @@
 module Artoo
   module Drivers
-    # The Driver class is the base class used to  
-    # implement behavior for a specific kind of hardware devices. Examples 
+    # The Driver class is the base class used to
+    # implement behavior for a specific kind of hardware devices. Examples
     # would be an Arduino, a Sphero, or an ARDrone.
     #
     # Derive a class from this class, in order to implement behavior
@@ -9,33 +9,73 @@ module Artoo
     class Driver
       include Celluloid
       include Celluloid::Notifications
-      
+
       attr_reader :parent
 
+      COMMANDS = [].freeze
+
+      # Create new driver
+      # @param [Hash] params
+      # @option params [Object] :parent
       def initialize(params={})
         @parent = params[:parent]
       end
 
+      # @return [Connection] parent connection
       def connection
         parent.connection
       end
 
+      # @return [String] parent pin
       def pin
         parent.pin
       end
 
+      # @return [String] parent interval
       def interval
         parent.interval
       end
 
+      # Generic driver start
       def start_driver
         Logger.info "Starting driver '#{self.class.name}'..."
       end
 
+      # @return [String] parent topic name
       def event_topic_name(event)
         parent.event_topic_name(event)
       end
 
+      # @return [Collection] commands
+      def commands
+        self.class.const_get('COMMANDS')
+      end
+
+      # Execute command
+      # @param [Symbol] method_name
+      # @param [Array]  arguments
+      def command(method_name, *arguments)
+        known_command?(method_name)
+        if arguments.first
+          self.send(method_name, *arguments)
+        else
+          self.send(method_name)
+        end
+      rescue Exception => e
+        Logger.error e.message
+        Logger.error e.backtrace.inspect
+        return nil
+      end
+
+      # @return [Boolean] True if command exists
+      def known_command?(method_name)
+        return true if commands.include?(method_name.intern)
+
+        Logger.warn("Calling unknown command '#{method_name}'...")
+        return false
+      end
+
+      # Sends missing methods to connection
       def method_missing(method_name, *arguments, &block)
         connection.send(method_name, *arguments, &block)
       rescue Exception => e
@@ -45,4 +85,4 @@ module Artoo
       end
     end
   end
-end
+end

data/lib/artoo/drivers/led.rb

@@ -4,34 +4,45 @@ module Artoo
   module Drivers
     # The LED driver behaviors
     class Led < Driver
+
+      COMMANDS = [:is_on?, :is_off?, :on, :off, :toggle, :brightness].freeze
+
+      # @return [Boolean] True if on
       def is_on?
         (@is_on ||= false) == true
       end
 
+      # @return [Boolean] True if off
       def is_off?
         (@is_on ||= false) == false
       end
 
+      # Sets led to on status
       def on
         @is_on = true
         connection.set_pin_mode(pin, Firmata::Board::OUTPUT)
         connection.digital_write(pin, Firmata::Board::HIGH)
       end
 
+      # Sets led to off status
       def off
         @is_on = false
         connection.set_pin_mode(pin, Firmata::Board::OUTPUT)
         connection.digital_write(pin, Firmata::Board::LOW)
       end
 
+      # Toggle status
+      # @example on > off, off > on
       def toggle
         is_off? ? on : off
       end
 
+      # Change brightness level
+      # @param [Integer] level
       def brightness(level=0)
         connection.set_pin_mode(pin, Firmata::Board::PWM)
         connection.analog_write(pin, level)
       end
     end
   end
-end
+end

data/lib/artoo/drivers/motor.rb

@@ -4,8 +4,11 @@ module Artoo
   module Drivers
     # L293 or other H-bridge style motor driver behaviors for Firmata
     class Motor < Driver
+      COMMANDS = [:forward, :backward, :stop, :speed, :current_speed].freeze
+
       attr_reader :leg1_pin, :leg2_pin, :speed_pin, :current_speed
 
+      # Create new Motor
       def initialize(params={})
         super
 
@@ -16,6 +19,7 @@ module Artoo
         @current_speed = 0
       end
 
+      # Starts connection to read and process and driver
       def start_driver
         every(interval) do
           connection.read_and_process
@@ -24,20 +28,27 @@ module Artoo
         super
       end
 
+      # Sets movement forward
+      # @param [Integer] s speed
       def forward(s)
         set_legs(Firmata::Board::LOW, Firmata::Board::HIGH)
         speed(s)
       end
 
+      # Sets movement backward
+      # @param [Integer] s speed
       def backward(s)
         set_legs(Firmata::Board::HIGH, Firmata::Board::LOW)
         speed(s)
       end
 
+      # Stops
       def stop
         speed(0)
       end
 
+      # Set motor speed
+      # @param [Integer] s speed (must be an integer between 0-255)
       def speed(s)
         raise "Motor speed must be an integer between 0-255" unless (s.is_a?(Numeric) && s >= 0 && s <= 255)
         @current_speed = s
@@ -55,4 +66,4 @@ module Artoo
       end
     end
   end
-end
+end

data/lib/artoo/drivers/pinger.rb

@@ -4,6 +4,11 @@ module Artoo
   module Drivers
     # Pings itself
     class Pinger < Driver
+
+      COMMANDS = [:ping].freeze
+
+      # Publishes events to update and alive event topics
+      # with incremental count
       def start_driver
         @count = 1
         every(interval) do
@@ -14,6 +19,10 @@ module Artoo
 
         super
       end
+
+      def ping
+        "pong"
+      end
     end
   end
-end
+end

data/lib/artoo/drivers/pinger2.rb

@@ -4,6 +4,11 @@ module Artoo
   module Drivers
     # Pings itself
     class Pinger2 < Driver
+
+      COMMANDS = [:ping].freeze
+
+      # Publishes events to update and alive event topics
+      # with random number
       def start_driver
         every(interval) do
           @count = rand(100000)
@@ -13,6 +18,10 @@ module Artoo
 
         super
       end
+
+      def ping
+        "pong"
+      end
     end
   end
-end
+end

data/lib/artoo/drivers/roomba.rb

@@ -4,12 +4,19 @@ module Artoo
   module Drivers
     # The Roomba driver behaviors
     class Roomba < Driver
+
+      COMMANDS = [:start, :safe_mode, :full_mode, :forward, :stop, :fast_forward,
+                  :backwards, :nudge_left, :nudge_right, :turn_left, :turn_right,
+                  :turn_around, :drive, :play, :song, :beep].freeze
+
+      # Sets Direction constant values
       module Direction
         STRAIGHT = 32768
         CLOCKWISE = 65535
         COUNTERCLOCKWISE = 1
       end
 
+      # Sets speed constant values
       module Speed
         MAX = 500
         SLOW = 250
@@ -17,6 +24,7 @@ module Artoo
         ZERO = 0
       end
 
+      # Sets notes constant values
       module Note
         B = 95
         D = 98
@@ -28,104 +36,144 @@ module Artoo
         WHOLE = 114
       end
 
+      # Sets mode constant values
       module Mode
         FULL = 132
         SAFE = 131
         START = 128
       end
-      
+
+      # Sets song constant values
       module Song
         SONG = 140
         PLAY = 141
       end
 
+      # Sends start mode
       def start
         send_bytes(Mode::START)
         sleep 0.2
       end
-      
+
+      # Sends safe mode
       def safe_mode
         start
         send_bytes(Mode::SAFE)
         sleep 0.1
       end
-      
+
+      # Sends full mode
       def full_mode
         start
         send_bytes(Mode::FULL)
         sleep 0.1
       end
-      
+
+      # Move forward
+      # @param [Integer] seconds
+      # @param [Constant] velocity
+      # @see Speed
       def forward(seconds, velocity = Speed::SLOW)
         drive(velocity, Direction::STRAIGHT, seconds)
         stop if seconds > 0
       end
-  
+
+      # Stop movement
       def stop
         drive(Speed::ZERO, Direction::STRAIGHT)
       end
-  
+
+      # Move forward with fast speed
+      # @param [Integer] seconds
       def fast_forward(seconds)
         drive(Speed::MAX, Direction::STRAIGHT, seconds)
         stop if seconds > 0
       end
-  
+
+      # Move backward
+      # @param [Integer] seconds
       def backwards(seconds)
         drive(Speed::NEG, Direction::STRAIGHT, seconds)
         stop if seconds > 0
       end
-  
+
+      # Nudge left
       def nudge_left
         turn_left(0.25)
       end
-  
+
+      # Turn left
+      # @param [Integer] seconds
       def turn_left(seconds = 1)
         drive(Speed::SLOW, Direction::COUNTERCLOCKWISE, seconds)
         stop if seconds > 0
       end
-  
+
+      # Turn right
+      # @param [Integer] seconds
       def turn_right(seconds = 1)
         drive(Speed::SLOW, Direction::CLOCKWISE, seconds)
         stop if seconds > 0
       end
-  
+
+      # Nudge right
       def nudge_right
         turn_right(0.25)
       end
-  
+
+      # Turn around
       def turn_around
         turn_left(1.6)
       end
 
+      # Drive
+      # @param [Integer] v speed
+      # @param [Integer] r direction
+      # @param [Integer] s seconds (waiting time)
+      # @see Speed
+      # @see Direction
       def drive(v, r, s = 0)
         vH,vL = split_bytes(v)
         rH,rL = split_bytes(r)
         send_bytes([137, vH, vL, rH, rL])
         sleep(s) if s > 0
       end
-      
+
+      # Split bytes (hex)
+      # @param [Integer] num
       def split_bytes(num)
         [num >> 8, num & 255]
       end
-  
+
+      # Play song
+      # @param [Integer] song_number
       def play(song_number = 0)
         send_bytes([Song::PLAY, song_number])
       end
 
+      # Save song
+      # @param [Collection] notes
+      # @param [Integer]    song_number
+      # @see Notes
       def song(notes, song_number = 0)
         note_group = notes.flatten.compact
         l = note_group.length / 2
         send_bytes([Song::SONG, song_number, l] + note_group)
       end
-      
+
+      # Play song
+      # @param [Collection] notes
+      # @param [Integer]    song_number
+      # @see Notes
       def play_song(notes, song_number = 0)
         song(notes, song_number)
         play(song_number)
       end
 
+      # Beeps with a G note
       def beep
         play_song([Note::G, Note::WHOLE])
-      end      
+      end
     end
   end
-end
+end