artoo 0.1.0

data/lib/artoo/device_event_client.rb

@@ -0,0 +1,27 @@
+module Artoo
+  # The Artoo::DeviceEventClient class is how a websocket client can subscribe
+  # to event notifications for a specific device.
+  # Example: ardrone nav data
+  class DeviceEventClient
+    include Celluloid
+    include Celluloid::Notifications
+    include Celluloid::Logger
+
+    attr_reader :topic
+
+    def initialize(websocket, topic)
+      @topic = topic
+      info "Streaming #{@topic} to websocket..."
+      @socket = websocket
+      subscribe(@topic, :notify_event)
+    end
+
+    def notify_event(topic, *data)
+      # TODO: send which topic sent the notification
+      @socket << data.last.to_s
+    rescue Reel::SocketError, Errno::EPIPE
+      info "Device event notification #{topic} websocket disconnected"
+      terminate
+    end
+  end
+end

data/lib/artoo/drivers/ardrone.rb

@@ -0,0 +1,9 @@
+require 'artoo/drivers/driver'
+
+module Artoo
+  module Drivers
+    # Ardrone driver behaviors
+    class Ardrone < Driver
+    end
+  end
+end

data/lib/artoo/drivers/ardrone_navigation.rb

@@ -0,0 +1,21 @@
+require 'artoo/drivers/driver'
+
+module Artoo
+  module Drivers
+    # Ardrone navigation driver behaviors
+    class ArdroneNavigation < Driver
+      def start_driver
+        every(interval) do
+          handle_update
+        end
+
+        super
+      end
+
+      def handle_update
+        navdata = connection.receive_data
+        publish(event_topic_name("update"), navdata)
+      end
+    end
+  end
+end

data/lib/artoo/drivers/ardrone_video.rb

@@ -0,0 +1,22 @@
+require 'artoo/drivers/driver'
+
+module Artoo
+  module Drivers
+    # Ardrone video driver behaviors
+    class ArdroneVideo < Driver
+      def start_driver
+        every(interval) do
+          handle_frame
+        end
+
+        super
+      end
+
+      def handle_frame(*params)
+        frame = connection.video_parser.get_frame
+        publish(event_topic_name("update"), "frame", frame)
+        publish(event_topic_name("frame"), frame)
+      end
+    end
+  end
+end

data/lib/artoo/drivers/button.rb

@@ -0,0 +1,40 @@
+require 'artoo/drivers/driver'
+
+module Artoo
+  module Drivers
+    # Button driver behaviors for Firmata
+    class Button < Driver
+      DOWN = 1
+      UP = 0
+
+      def is_pressed?
+        (@is_pressed ||= false) == true
+      end
+
+      def start_driver
+        listener = ->(value) { update(value) }
+        connection.on("digital-read-#{pin}", listener)
+        connection.set_pin_mode(pin, Firmata::Board::INPUT)
+        connection.toggle_pin_reporting(pin)
+
+        every(interval) do
+          connection.read_and_process
+        end
+
+        super
+      end
+
+      def update(value)
+        if value == DOWN
+          @is_pressed = true
+          publish(event_topic_name("update"), "push", value)
+          publish(event_topic_name("push"), value)
+        else
+          @is_pressed = false
+          publish(event_topic_name("update"), "release", value)
+          publish(event_topic_name("release"), value)
+        end
+      end
+    end
+  end
+end

data/lib/artoo/drivers/driver.rb

@@ -0,0 +1,48 @@
+module Artoo
+  module Drivers
+    # 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
+    # for a new type of hardware device.
+    class Driver
+      include Celluloid
+      include Celluloid::Notifications
+      
+      attr_reader :parent
+
+      def initialize(params={})
+        @parent = params[:parent]
+      end
+
+      def connection
+        parent.connection
+      end
+
+      def pin
+        parent.pin
+      end
+
+      def interval
+        parent.interval
+      end
+
+      def start_driver
+        Logger.info "Starting driver '#{self.class.name}'..."
+      end
+
+      def event_topic_name(event)
+        parent.event_topic_name(event)
+      end
+
+      def method_missing(method_name, *arguments, &block)
+        connection.send(method_name, *arguments, &block)
+      rescue Exception => e
+        Logger.error e.message
+        Logger.error e.backtrace.inspect
+        return nil
+      end
+    end
+  end
+end

data/lib/artoo/drivers/led.rb

@@ -0,0 +1,37 @@
+require 'artoo/drivers/driver'
+
+module Artoo
+  module Drivers
+    # The LED driver behaviors
+    class Led < Driver
+      def is_on?
+        (@is_on ||= false) == true
+      end
+
+      def is_off?
+        (@is_on ||= false) == false
+      end
+
+      def on
+        @is_on = true
+        connection.set_pin_mode(pin, Firmata::Board::OUTPUT)
+        connection.digital_write(pin, Firmata::Board::HIGH)
+      end
+
+      def off
+        @is_on = false
+        connection.set_pin_mode(pin, Firmata::Board::OUTPUT)
+        connection.digital_write(pin, Firmata::Board::LOW)
+      end
+
+      def toggle
+        is_off? ? on : off
+      end
+
+      def brightness(level=0)
+        connection.set_pin_mode(pin, Firmata::Board::PWM)
+        connection.analog_write(pin, level)
+      end
+    end
+  end
+end

data/lib/artoo/drivers/passthru.rb

@@ -0,0 +1,9 @@
+require 'artoo/drivers/driver'
+
+module Artoo
+  module Drivers
+    # The Passthru driver just passes calls along to the parent's connection.
+    class Passthru < Driver
+    end
+  end
+end

data/lib/artoo/drivers/pinger.rb

@@ -0,0 +1,19 @@
+require 'artoo/drivers/driver'
+
+module Artoo
+  module Drivers
+    # Pings itself
+    class Pinger < Driver
+      def start_driver
+        @count = 1
+        every(interval) do
+          publish(event_topic_name("update"), "alive", @count)
+          publish(event_topic_name("alive"), @count)
+          @count += 1
+        end
+
+        super
+      end
+    end
+  end
+end

data/lib/artoo/drivers/pinger2.rb

@@ -0,0 +1,18 @@
+require 'artoo/drivers/driver'
+
+module Artoo
+  module Drivers
+    # Pings itself
+    class Pinger2 < Driver
+      def start_driver
+        every(interval) do
+          @count = rand(100000)
+          publish(event_topic_name("update"), "alive", @count)
+          publish(event_topic_name("alive"), @count)
+        end
+
+        super
+      end
+    end
+  end
+end

data/lib/artoo/drivers/sphero.rb

@@ -0,0 +1,57 @@
+require 'artoo/drivers/driver'
+
+module Artoo
+  module Drivers
+    # The Sphero driver behaviors
+    class Sphero < Driver
+      def detect_collisions(params={})
+        connection.configure_collision_detection 0x01, 0x20, 0x20, 0x20, 0x20, 0x50
+      end
+
+      def clear_collisions
+        messages = connection.async_messages
+        messages.clear if messages
+      end
+
+      def collisions
+        messages = connection.async_messages
+        return nil unless messages
+        messages.select {|m| m.is_a?(::Sphero::Response::CollisionDetected)}
+      end
+
+      def power_notifications
+        messages = connection.async_messages
+        return nil unless messages
+        messages.select {|m| m.is_a?(::Sphero::Response::PowerNotification)}
+      end
+
+      def sensor_data
+        messages = connection.async_messages
+        return nil unless messages
+        messages.select {|m| m.is_a?(::Sphero::Response::SensorData)}
+      end
+
+      def set_color(r, g=nil, b=nil)
+        r, g, b = color(r, g, b)
+        connection.rgb(r, g, b)
+      end
+
+      def color(r, g=nil, b=nil)
+        case r
+        when :red
+          return 255, 0, 0
+        when :green
+          return 0, 255, 0
+        when :yellow
+          return 255, 255, 0
+        when :blue
+          return 0, 0, 255
+        when :white
+          return 255, 255, 255
+        else
+          return r, g, b
+        end
+      end
+    end
+  end
+end

data/lib/artoo/drivers/wiichuck.rb

@@ -0,0 +1,29 @@
+require 'artoo/drivers/driver'
+
+module Artoo
+  module Drivers
+    # Wiichuck driver behaviors for Firmata
+    class Wiichuck < Driver
+      def address; 0x52; end
+
+      def start_driver
+        listener = ->(value) { update(value) }
+        connection.on("i2c_reply", listener)
+
+        connection.i2c_config(10)
+        connection.i2c_request(address, 0x40, 0x00)
+
+        every(interval) do
+          connection.i2c_request(address, 0x00)
+          connection.read_and_process
+        end
+
+        super
+      end
+
+      def update(value)
+        publish("#{parent.name}_update", value)
+      end
+    end
+  end
+end

data/lib/artoo/drivers/wiiclassic.rb

@@ -0,0 +1,137 @@
+require 'artoo/drivers/driver'
+
+module Artoo
+  module Drivers
+    # Wiichuck driver behaviors for Firmata
+    class Wiiclassic < Driver
+      def address; 0x52; end
+
+      def start_driver
+        begin
+        @joystick = {
+          :ry_offset => 8,
+          :ry_origin => nil,
+          :ly_offset => 20,
+          :lx_offset => 20,
+          :ly_origin => nil,
+          :lx_origin => nil,
+          :rt_origin => nil,
+          :lt_origin => nil,
+          :rt_offset => 5,
+          :lt_offset => 5
+        }
+        listener = ->(value) { update(value) }
+        connection.on("i2c_reply", listener)
+
+        connection.i2c_config(0)
+        every(interval) do
+          connection.i2c_write_request(address, 0x40, 0x00)
+          p
+          connection.i2c_write_request(address, 0x00, 0x00)
+          p
+          connection.i2c_read_request(address, 6)
+          p
+          connection.read_and_process
+        end
+        
+        super
+        rescue Exception => e
+          p "start driver"
+          p e.message
+          p e.backtrace.inspect
+        end
+
+      end
+
+      def update(value)
+        begin
+          #Logger.info "value[:data] #{value[:data].inspect}"
+          if value[:data][0] == value[:data][1] && value[:data][2] == value[:data][3] && value[:data][4] == value[:data][5]
+          #  Logger.error "Encrypted bytes from wiiclassic"
+            break
+          end
+          data = parse_wiiclassic(value)
+          #publish(event_topic_name("_a_button") if data[:a] == 0
+          publish(event_topic_name("a_button")) if data[:a] == 0
+          publish(event_topic_name("b_button")) if data[:b] == 0
+          publish(event_topic_name("x_button")) if data[:x] == 0
+          publish(event_topic_name("y_button")) if data[:y] == 0
+          publish(event_topic_name("home_button")) if data[:h] == 0
+          publish(event_topic_name("start_button")) if data[:+] == 0
+          publish(event_topic_name("select_button")) if data[:-] == 0
+
+          @joystick[:ly_origin] = data[:ly] if @joystick[:ly_origin].nil?
+          @joystick[:lx_origin] = data[:lx] if @joystick[:lx_origin].nil?
+
+          @joystick[:ry_origin] = data[:ry] if @joystick[:ry_origin].nil?
+
+          @joystick[:rt_origin] = data[:rt] if @joystick[:rt_origin].nil?
+          @joystick[:lt_origin] = data[:lt] if @joystick[:lt_origin].nil?
+
+          if data[:ly] > (@joystick[:ly_origin] + @joystick[:ly_offset])
+            publish(event_topic_name("ly_up"))
+          elsif data[:ly] < (@joystick[:ly_origin] - @joystick[:ly_offset])
+            publish(event_topic_name("ly_down"))
+          elsif data[:lx] > (@joystick[:lx_origin] + @joystick[:lx_offset])
+            publish(event_topic_name("lx_right"))
+          elsif data[:lx] < (@joystick[:lx_origin] - @joystick[:lx_offset])
+            publish(event_topic_name("lx_left"))
+          else
+            publish(event_topic_name("reset_pitch_roll"))
+          end
+
+          if data[:ry] > (@joystick[:ry_origin] + @joystick[:ry_offset])
+            publish(event_topic_name("ry_up"))
+          elsif data[:ry] < (@joystick[:ry_origin] - @joystick[:ry_offset])
+            publish(event_topic_name("ry_down"))
+          else
+            publish(event_topic_name("reset_altitude"))
+          end
+
+          if data[:rt] > (@joystick[:rt_origin] + @joystick[:rt_offset])
+            publish(event_topic_name("rotate_right"))
+          elsif data[:lt] > (@joystick[:lt_origin] + @joystick[:lt_offset])
+            publish(event_topic_name("rotate_left"))
+          else
+            publish(event_topic_name("reset_rotate"))
+          end
+
+        rescue Exception => e
+          p "wiiclassic update exception!"
+          p e.message
+          p e.backtrace.inspect
+        end
+      end
+
+      private 
+
+      def decode( x )
+        return ( x ^ 0x17 ) + 0x17
+      end
+
+      def parse_wiiclassic(value)
+        return {
+          :lx => decode(value[:data][0]) & 0x3f,
+          :ly => decode(value[:data][1]) & 0x3f,
+          :rx => ((decode(value[:data][0]) & 0xC0) >> 2)  | ((decode(value[:data][1]) & 0xC0) >> 4) | (decode(value[:data][2])[7]),
+          :ry => decode(value[:data][2]) & 0x1f,
+          :lt => ((decode(value[:data][2]) & 0x60) >> 3) | ((decode(value[:data][3]) & 0xE0) >> 6),
+          :rt => decode(value[:data][3]) & 0x1f,
+          :d_up => decode(value[:data][5])[0],
+          :d_down => decode(value[:data][4])[6],
+          :D_left => decode(value[:data][5])[1],
+          :D_right => decode(value[:data][4])[7],
+          :zr => decode(value[:data][5])[2],
+          :zl => decode(value[:data][5])[7],
+          :a => decode(value[:data][5])[4],
+          :b => decode(value[:data][5])[6],
+          :x => decode(value[:data][5])[3],
+          :y => decode(value[:data][5])[5],
+          :+ => decode(value[:data][4])[2],
+          :- => decode(value[:data][4])[4],
+          :h => decode(value[:data][4])[3],
+        }
+      end
+    end
+  end
+end