artoo 0.5.0 → 1.0.0.pre

data/lib/artoo/drivers/roomba.rb

@@ -1,179 +0,0 @@
-require 'artoo/drivers/driver'
-
-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
-        NEG = (65536 - 250)
-        ZERO = 0
-      end
-
-      # Sets notes constant values
-      module Note
-        B = 95
-        D = 98
-        G = 91
-        C = 96
-        A = 93
-        QUARTER = 16
-        HALF = 57
-        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

data/lib/artoo/drivers/servo.rb

@@ -1,59 +0,0 @@
-require 'artoo/drivers/driver'
-
-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
-        end
-
-        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

data/lib/artoo/drivers/sphero.rb

@@ -1,105 +0,0 @@
-require 'artoo/drivers/driver'
-
-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]
-
-      COMMANDS = [:detect_collisions, :clear_collisions, :collisions,
-                  :power_notifications, :sensor_data, :set_color, :color].freeze
-
-      # Starts drives and required connections
-      def start_driver
-        begin
-          detect_collisions
-
-          every(interval) do
-            handle_collision_events
-          end
-
-          super
-        rescue Exception => e
-          Logger.error "Error starting Sphero driver!"
-          Logger.error e.message
-          Logger.error e.backtrace.inspect
-        end
-      end
-
-      def handle_collision_events
-        while i = find_event(::Sphero::Response::CollisionDetected) do
-          update_collision(messages.slice!(i))
-        end
-      end
-
-      # Publish collision events
-      def update_collision(data)
-        publish(event_topic_name("collision"), data)
-      end
-
-      # 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
-        when :green  then GREEN
-        when :yellow then YELLOW
-        when :blue   then BLUE
-        when :white  then WHITE
-        else colors
-        end
-      end
-
-      private
-
-      def find_event(response_klass)
-        messages.index {|m| m.is_a? response_klass}
-      end
-
-      def matching_response_types(responses, respone_klass)
-        responses.select { |m| m.is_a? respone_klass } if responses
-      end
-
-      def messages
-        connection.async_messages
-      end
-    end
-  end
-end

data/lib/artoo/drivers/wiichuck.rb

@@ -1,61 +0,0 @@
-require 'artoo/drivers/wiidriver'
-
-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
-
-          adjust_origins
-          update_buttons
-          update_joystick
-
-        rescue Exception => e
-          Logger.error "wiichuck update exception!"
-          Logger.error e.message
-          Logger.error e.backtrace.inspect
-        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
-
-      def get_defaults
-        {
-          :sy_origin => nil,
-          :sx_origin => nil
-        }
-      end
-
-      def parse(value)
-        return {
-          :sx => decode_value(value, 0),
-          :sy => decode_value(value, 1),
-          :z => generate_bool(decode_value(value, 5) & 0x01),
-          :c => generate_bool(decode_value(value, 5) & 0x02)
-        }
-      end
-    end
-  end
-end

data/lib/artoo/drivers/wiiclassic.rb

@@ -1,139 +0,0 @@
-require 'artoo/drivers/wiidriver'
-
-module Artoo
-  module Drivers
-    # Wiiclassic driver behaviors for Firmata
-    class Wiiclassic < Wiidriver
-
-      # Update buttons and joysticks values
-      # @param [Object] value
-      def update(value)
-        begin
-          super
-
-          adjust_origins
-          update_buttons
-          update_left_joystick
-          update_right_joystick
-          update_triggers
-
-        rescue Exception => e
-          Logger.error "wiiclassic update exception!"
-          Logger.error e.message
-          Logger.error e.backtrace.inspect
-        end
-      end
-
-      # Adjust all origins
-      def adjust_origins
-        set_joystick_default_value(:ly_origin, data[:ly])
-        set_joystick_default_value(:lx_origin, data[:lx])
-        set_joystick_default_value(:ry_origin, data[:ry])
-        set_joystick_default_value(:rx_origin, data[:rx])
-        set_joystick_default_value(:rt_origin, data[:rt])
-        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)
-        update_button("x_button", :x)
-        update_button("y_button", :y)
-        update_button("home_button", :h)
-        update_button("start_button", :+)
-        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,
-          :rx_origin => nil,
-          :ly_origin => nil,
-          :lx_origin => nil,
-          :rt_origin => nil,
-          :lt_origin => nil
-        }
-      end
-
-      def parse(value)
-        return parse_joysticks(value).
-          merge(parse_buttons(value)).
-          merge(parse_triggers(value)).
-          merge(parse_dpad(value)).
-          merge(parse_zbuttons(value))
-      end
-
-      def parse_joysticks(value)
-        {
-          :lx => decode_value(value, 0) & 0x3f,
-          :ly => decode_value(value, 1) & 0x3f,
-          :rx => ((decode_value(value, 0) & 0xC0) >> 2)  | ((decode_value(value, 1) & 0xC0) >> 4) | (decode_value(value, 2)[7]),
-          :ry => decode_value(value, 2) & 0x1f
-        }
-      end
-
-      def parse_buttons(value)
-        {
-          :a => get_bool_decoded_value(value, 5, 4),
-          :b => get_bool_decoded_value(value, 5, 6),
-          :x => get_bool_decoded_value(value, 5, 3),
-          :y => get_bool_decoded_value(value, 5, 5),
-          :+ => get_bool_decoded_value(value, 4, 2),
-          :- => get_bool_decoded_value(value, 4, 4),
-          :h => get_bool_decoded_value(value, 4, 3)
-        }
-      end
-
-      def parse_triggers(value)
-        {
-          :lt => ((decode_value(value, 2) & 0x60) >> 3) | ((decode_value(value, 3) & 0xC0) >> 6),
-          :rt => decode_value(value, 3) & 0x1f
-        }
-      end
-
-      def parse_dpad(value)
-        {
-          :d_up => get_bool_decoded_value(value, 5, 0),
-          :d_down => get_bool_decoded_value(value, 4, 6),
-          :d_left => get_bool_decoded_value(value, 5, 1),
-          :d_right => get_bool_decoded_value(value, 4, 7)
-        }
-      end
-
-      def parse_zbuttons(value)
-        {
-          :zr => get_bool_decoded_value(value, 5, 2),
-          :zl => get_bool_decoded_value(value, 5, 7)
-        }
-      end
-
-      def get_bool_decoded_value(value, offset1, offset2)
-        generate_bool(decode_value(value, offset1)[offset2])
-      end
-    end
-  end
-end