artoo-arduino 1.1.0 → 1.2.0

data/lib/artoo/drivers/maxbotix.rb

@@ -1,44 +0,0 @@
-require 'artoo/drivers/driver'
-
-module Artoo
-  module Drivers
-    # Maxbotix ultrasonic range finder driver behaviors for Firmata
-    class Maxbotix < Driver
-      COMMANDS = [:range].freeze
-
-      attr_accessor :last_reading
-
-      def initialize(params={})
-        @last_reading = 0.0
-        super
-      end
-
-      # @return [float] last range reading in inches
-      def range
-        return ( 254.0 / 1024.0 ) * 2.0 * last_reading
-      end
-
-      # @return [float] last range reading in cm
-      def range_cm
-        return (last_reading / 2.0) * 2.54
-      end
-
-      # Sets values to read from ultrasonic range finder
-      # and starts driver
-      def start_driver
-        every(interval) do
-          update(connection.analog_read(pin))
-        end
-
-        super
-      end
-
-      # Publishes events according to the ultrasonic rangefinder value
-      def update(value)
-        last_reading = value
-        publish(event_topic_name("update"), "range", range)
-        publish(event_topic_name("range"), range)
-      end
-    end
-  end
-end

data/lib/artoo/drivers/motor.rb

@@ -1,167 +0,0 @@
-require 'artoo/drivers/driver'
-
-module Artoo
-  module Drivers
-    class Motor < Driver
-
-      COMMANDS = [:stop, :start, :on?, :off?, :toggle, :speed, :min, :max, :forward, :backward, :current_speed].freeze
-
-      attr_reader :speed_pin, :switch_pin, :current_speed
-
-      def initialize(params={})
-        super
-        
-        additional_params = params[:additional_params]
-        @speed_pin = additional_params[:speed_pin]
-        @switch_pin = additional_params[:switch_pin] if additional_params[:switch_pin]
-
-        @forward_pin = additional_params[:forward_pin]
-        @backward_pin = additional_params[:backward_pin]
-
-        @current_state = :low
-        @current_speed = 0
-
-        # digital: just to switch the motor on or off, no speed control
-        # analog: speed control
-        @current_mode = :digital
-
-        @current_direction = :forward
-
-        @@modules_to_include = modules_to_include
-
-        class << self
-          @@modules_to_include.each do |m|
-            include m
-          end if @@modules_to_include
-        end
-
-      end
-
-      def digital?
-        @current_mode == :digital
-      end
-      
-      def analog?
-        @current_mode == :analog
-      end
-
-      def stop
-        if digital?
-          change_state(:low)
-        else
-          speed(0)
-        end
-      end
-
-      def start
-        if digital?
-          change_state(:high)
-        else
-          speed(@current_speed.zero? ? 255 : @current_speed)
-        end
-      end
-
-      def min
-        stop
-      end
-
-      def max
-        speed(255)
-      end
-
-      def on?
-        if digital?
-          @current_state == :high
-        else
-          @current_speed > 0
-        end
-      end
-
-      def off?
-        !on?
-      end
-
-      def toggle
-        on? ? stop : start
-      end
-
-      def change_state(state)
-        @current_state = state
-        @current_speed = state == :low ? 0 : 255
-        connection.digital_write(@speed_pin, state)
-      end
-
-      # Set motor speed
-      # @param [Integer] value (must be an integer between 0-255)
-      def speed(value)
-        @current_mode = :analog
-        raise "Motor speed must be an integer between 0-255" unless (value.is_a?(Numeric) && value >= 0 && value <= 255)
-        @current_speed = value
-        connection.pwm_write(speed_pin, value)
-      end
-
-      private
-      def modules_to_include
-        if @forward_pin and @backward_pin
-          [BidirectionalWithForwardBackwardPins]
-        end
-      end
-    end
-
-    module BidirectionalWithForwardBackwardPins
-
-      # Sets movement forward
-      # @param [Integer] speed
-      def forward(speed = nil)
-        direction(:forward)
-        speed ? self.speed(speed) : start
-      end
-
-      # Sets movement backward
-      # @param [Integer] speed
-      def backward(speed = nil)
-        direction(:backward)
-        speed ? self.speed(speed) : start
-      end
-
-      def forward?
-        @current_direction == :forward
-      end
-
-      def backward?
-        (not forward?)
-      end
-
-      private
-      def change_state(state)
-        @current_state = state
-        @current_speed = state.zero? ? 0 : 255
-        if state == :high
-          direction(@current_direction)
-          speed(@current_speed) if speed_pin
-        elsif state == :low
-          direction(:none)
-        end
-      end
-
-      def direction(direction)
-        @current_direction = direction
-        case direction
-        when :forward
-          forward_pin_level = :high
-          backward_pin_level = :low
-        when :backward
-          forward_pin_level = :low
-          backward_pin_level = :high
-        when :none
-          forward_pin_level = :low
-          backward_pin_level = :low
-        end
-        
-        connection.digital_write(@forward_pin, forward_pin_level)
-        connection.digital_write(@backward_pin, backward_pin_level)
-      end
-
-    end
-  end
-end

data/lib/artoo/drivers/servo.rb

@@ -1,49 +0,0 @@
-require 'artoo/drivers/driver'
-
-module Artoo
-  module Drivers
-    # Servo behaviors for Firmata
-    class Servo < Driver
-      COMMANDS = [:move, :min, :center, :max, :current_angle].freeze
-
-      attr_reader :current_angle
-
-      # Create new Servo with angle=0
-      def initialize(params={})
-        super
-
-        @current_angle = 0
-      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.servo_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/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) >> 3)  | ((decode_value(value, 1) & 0xC0) >> 5) | (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