hybridgroup-argus 0.2.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Jim Weirich
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,27 @@
+# Argus -- Parrot AR Drone Ruby API
+
+## Current Status
+
+* Experimental
+* Subject to change
+* Use at your own risk
+* May cause cancer
+
+## Example
+
+<pre>
+  require 'argus'
+
+  drone = Argus::Drone.new
+  drone.start
+
+  drone.take_off
+  sleep 5
+  drone.turn_right(1.0)
+  sleep 5
+  drone.turn_left(1.0)
+  sleep 5
+  drone.hover.land
+  sleep 5
+  drone.stop
+</pre>

data/Rakefile

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby"
+
+require 'rake/clean'
+
+task :default => :specs
+
+task :specs do
+  sh "rspec spec"
+end

data/lib/argus/at_commander.rb

@@ -0,0 +1,76 @@
+require 'thread'
+
+module Argus
+  class ATCommander
+    def initialize(sender)
+      @sender = sender
+      @seq = 0
+      @ref_data = "0"
+      @pcmd_data = "0,0,0,0,0"
+      @buffer = ""
+      @thread = nil
+      @interval = 0.020
+      @mutex = Mutex.new
+    end
+
+    def start
+      @running = true
+      @thread = Thread.new do
+        while @running
+          tick
+          sleep @interval
+        end
+      end
+    end
+
+    def tick
+      @mutex.synchronize do
+        packet do
+          command("REF", @ref_data)
+          command("PCMD", @pcmd_data)
+        end
+      end
+    end
+
+    def stop
+      @running = false
+    end
+
+    def join
+      @thread.join if @thread
+    end
+
+    def interval=(new_interval)
+      @mutex.synchronize do @interval = new_interval end
+    end
+
+    def ref(data)
+      @mutex.synchronize do @ref_data = data end
+    end
+
+    def pcmd(data)
+      @mutex.synchronize do @pcmd_data = data end
+    end
+
+    def config(key, value)
+      @buffer << "AT*CONFIG=605,\"#{key}\",\"#{value}\"\r"
+    end
+
+    private
+
+    def packet
+      yield self
+      flush
+    end
+
+    def flush
+      @sender.send_packet(@buffer)
+      @buffer = ""
+    end
+
+    def command(name, args)
+      @seq += 1
+      @buffer << "AT*#{name}=#{@seq},#{args}\r"
+    end
+  end
+end

data/lib/argus/controller.rb

@@ -0,0 +1,130 @@
+module Argus
+  class Controller
+
+    def initialize(at_commander)
+      @at_commander = at_commander
+
+      @emergency = false
+      land
+      hover
+    end
+
+    def take_off
+      @flying = true
+      @emergency = false
+      update_ref
+    end
+
+    def land
+      @flying = false
+      update_ref
+    end
+
+    def emergency
+      @flying = false
+      @emergency = true
+      update_ref
+    end
+
+    def hover
+      @moving = false
+      @roll = 0.0
+      @pitch = 0.0
+      @gaz = 0.0
+      @yaw = 0.0
+      update_pcmd
+    end
+
+    def forward(amount)
+      @moving = true
+      @pitch = -amount
+      update_pcmd
+    end
+
+    def backward(amount)
+      @moving = true
+      @pitch = amount
+      update_pcmd
+    end
+
+    def left(amount)
+      @moving = true
+      @roll = -amount
+      update_pcmd
+    end
+
+    def right(amount)
+      @moving = true
+      @roll = amount
+      update_pcmd
+    end
+
+    def up(amount)
+      @moving = true
+      @gaz = amount
+      update_pcmd
+    end
+
+    def down(amount)
+      @moving = true
+      @gaz = -amount
+      update_pcmd
+    end
+
+    def turn_left(amount)
+      @moving = true
+      @yaw = -amount
+      update_pcmd
+    end
+
+    def turn_right(amount)
+      @moving = true
+      @yaw = amount
+      update_pcmd
+    end
+
+    def front_camera
+      @at_commander.config("video:video_channel", "2")
+    end
+    
+    def bottom_camera
+      @at_commander.config("video:video_channel", "1")
+    end
+
+    private
+
+    REF_BASE = [18, 20, 22, 24, 28].
+      inject(0) { |flag, bitnum| flag | (1 << bitnum) }
+    REF_FLY_BIT = (1 << 9)
+    REF_EMERGENCY_BIT = (1 << 8)
+
+    def update_ref
+      n = REF_BASE
+      n |= REF_FLY_BIT if @flying
+      n |= REF_EMERGENCY_BIT if @emergency
+      @at_commander.ref(n.to_s)
+      self
+    end
+
+    def update_pcmd
+      flags = 0
+      if @moving
+        flags = 1
+        iroll = encode_float(@roll)
+        ipitch = encode_float(@pitch)
+        igaz = encode_float(@gaz)
+        iyaw = encode_float(@yaw)
+        data = "#{flags},#{iroll},#{ipitch},#{igaz},#{iyaw}"
+      else
+        data = "0,0,0,0,0"
+      end
+      @at_commander.pcmd(data)
+      self
+    end
+
+    def encode_float(float)
+      [float].pack('g').unpack("l>").first
+    end
+
+  end
+end

data/lib/argus/drone.rb

@@ -0,0 +1,36 @@
+require 'socket'
+
+module Argus
+  class Drone
+    def initialize(socket=nil, host='192.168.1.1', port='5556')
+      @socket = socket || UDPSocket.new
+      @sender = Argus::UdpSender.new(@socket, host, port)
+      @at = Argus::ATCommander.new(@sender)
+      @controller = Argus::Controller.new(@at)
+    end
+
+    def start
+      @at.start
+    end
+
+    def stop
+      @controller.land
+      @at.stop
+      @at.join
+    end
+
+    %w(
+       take_off land hover emergency
+       forward backward
+       left right
+       up down
+       turn_left turn_right
+       front_camera bottom_camera
+    ).each do |meth|
+      define_method(meth) { |*args|
+        @controller.send(meth, *args)
+      }
+    end
+
+  end
+end

data/lib/argus/nav_data.rb

@@ -0,0 +1,61 @@
+module Argus
+  class NavData
+    attr_accessor :drone_state, :options, :vision_flag, :sequence_number
+    def initialize(data)
+      @data = data
+      parse_nav_data(@data)
+    end
+
+    private 
+    def parse_nav_data(data)
+      state = data.unpack("V").first
+      @drone_state = {
+        :flying=>state[0],  #/*!< FLY MASK : (0) ardrone is landed, (1) ardrone is flying */
+        :videoEnabled=>state[1],  #/*!< VIDEO MASK : (0) video disable, (1) video enable */
+        :visionEnabled=>state[2],  #/*!< VISION MASK : (0) vision disable, (1) vision enable */
+        :controlAlgorithm=>state[3],  #/*!< CONTROL ALGO : (0) euler angles control, (1) angular speed control */
+        :altitudeControlAlgorithm=>state[4],  #/*!< ALTITUDE CONTROL ALGO : (0) altitude control inactive (1) altitude control active */
+        :startButtonState=>state[5],  #/*!< USER feedback : Start button state */
+        :controlCommandAck=>state[6],  #/*!< Control command ACK : (0) None, (1) one received */
+        :cameraReady=>state[7],  #/*!< CAMERA MASK : (0) camera not ready, (1) Camera ready */
+        :travellingEnabled=>state[8],  #/*!< Travelling mask : (0) disable, (1) enable */
+        :usbReady=>state[9],  #/*!< USB key : (0) usb key not ready, (1) usb key ready */
+        :navdataDemo=>state[10], #/*!< Navdata demo : (0) All navdata, (1) only navdata demo */
+        :navdataBootstrap=>state[11], #/*!< Navdata bootstrap : (0) options sent in all or demo mode, (1) no navdata options sent */
+        :motorProblem=>state[12], #/*!< Motors status : (0) Ok, (1) Motors problem */
+        :communicationLost=>state[13], #/*!< Communication Lost : (1) com problem, (0) Com is ok */
+        :softwareFault=>state[14], #/*!< Software fault detected - user should land as quick as possible (1) */
+        :lowBattery=>state[15], #/*!< VBat low : (1) too low, (0) Ok */
+        :userEmergencyLanding=>state[16], #/*!< User Emergency Landing : (1) User EL is ON, (0) User EL is OFF*/
+        :timerElapsed=>state[17], #/*!< Timer elapsed : (1) elapsed, (0) not elapsed */
+        :MagnometerNeedsCalibration=>state[18], #/*!< Magnetometer calibration state : (0) Ok, no calibration needed, (1) not ok, calibration needed */
+        :anglesOutOfRange=>state[19], #/*!< Angles : (0) Ok, (1) out of range */
+        :tooMuchWind=>state[20], #/*!< WIND MASK: (0) ok, (1) Too much wind */
+        :ultrasonicSensorDeaf=>state[21], #/*!< Ultrasonic sensor : (0) Ok, (1) deaf */
+        :cutoutDetected=>state[22], #/*!< Cutout system detection : (0) Not detected, (1) detected */
+        :picVersionNumberOk=>state[23], #/*!< PIC Version number OK : (0) a bad version number, (1) version number is OK */
+        :atCodecThreadOn=>state[24], #/*!< ATCodec thread ON : (0) thread OFF (1) thread ON */
+        :navdataThreadOn=>state[25], #/*!< Navdata thread ON : (0) thread OFF (1) thread ON */
+        :videoThreadOn=>state[26], #/*!< Video thread ON : (0) thread OFF (1) thread ON */
+        :acquisitionThreadOn=>state[27], #/*!< Acquisition thread ON : (0) thread OFF (1) thread ON */
+        :controlWatchdogDelay=>state[28], #/*!< CTRL watchdog : (1) delay in control execution (> 5ms), (0) control is well scheduled */
+        :adcWatchdogDelay=>state[29], #/*!< ADC Watchdog : (1) delay in uart2 dsr (> 5ms), (0) uart2 is good */
+        :comWatchdogProblem=>state[30], #/*!< Communication Watchdog : (1) com problem, (0) Com is ok */
+        :emergencyLanding=>state[31]  #/*!< Emergency landing : (0) no emergency, (1) emergency */
+      }
+      data.slice!(0..3)
+      @sequence_number = data.unpack("V").first
+      data.slice!(0..3)
+      @vision_flag = data.unpack("V").first
+      @options = []
+      option1 = {}
+      data.slice!(0..3)
+      option1[:id] = data.unpack("v").first
+      data.slice!(0..1)
+      option1[:size] = data.unpack("v").first
+      data.slice!(0..1)
+      option1[:data] = data.unpack("V").first
+      @options.push(option1)
+    end
+  end
+end

data/lib/argus/nav_streamer.rb

@@ -0,0 +1,18 @@
+require 'socket'
+
+module Argus
+  class NavStreamer 
+    def initialize(socket=nil, host='192.168.1.1', port='5554')
+      @socket = socket || UDPSocket.new
+      @streamer = Argus::UdpNavStreamer.new(@socket, host, port)
+    end
+
+    def start
+      @streamer.start_stream
+    end
+
+    def receive_data
+      @streamer.receive_packet
+    end
+  end
+end

data/lib/argus/pave_parser.rb

@@ -0,0 +1,39 @@
+module Argus
+  class PaVEParser
+    def initialize(tcp_video_streamer)
+      @tcp_video_streamer = tcp_video_streamer
+    end
+
+    def get_frame
+      frame = {
+        :signature=>(@tcp_video_streamer.read(4)).unpack("A*").first,
+        :version=>(@tcp_video_streamer.read(1)).unpack("C").first,
+        :video_codec=>(@tcp_video_streamer.read(1)).unpack("C").first,
+        :header_size=>(@tcp_video_streamer.read(2)).unpack("v").first,
+        :payload_size=>(@tcp_video_streamer.read(4)).unpack("V").first,
+        :encoded_stream_width=>(@tcp_video_streamer.read(2)).unpack("v").first,
+        :encoded_stream_height=>(@tcp_video_streamer.read(2)).unpack("v").first,
+        :display_width=>(@tcp_video_streamer.read(2)).unpack("v").first,
+        :display_height=>(@tcp_video_streamer.read(2)).unpack("v").first,
+        :frame_number=>(@tcp_video_streamer.read(4)).unpack("V").first,
+        :timestamp=>(@tcp_video_streamer.read(4)).unpack("V").first,
+        :total_chunks=>(@tcp_video_streamer.read(1)).unpack("C").first,
+        :chunk_index=>(@tcp_video_streamer.read(1)).unpack("C").first,
+        :frame_type=>(@tcp_video_streamer.read(1)).unpack("C").first,
+        :control=>(@tcp_video_streamer.read(1)).unpack("C").first,
+        :stream_byte_position_lw=>(@tcp_video_streamer.read(4)).unpack("V").first,
+        :stream_byte_position_uw=>(@tcp_video_streamer.read(4)).unpack("V").first,
+        :stream_id=>(@tcp_video_streamer.read(2)).unpack("v").first,
+        :total_slices=>(@tcp_video_streamer.read(1)).unpack("C").first,
+        :slice_index=>(@tcp_video_streamer.read(1)).unpack("C").first,
+        :header1_size=>(@tcp_video_streamer.read(1)).unpack("C").first,
+        :header2_size=>(@tcp_video_streamer.read(1)).unpack("C").first,
+        :reserved[2]=>(@tcp_video_streamer.read(2)).unpack("H*").first,
+        :advertised_size=>(@tcp_video_streamer.read(4)).unpack("V").first,
+        :reserved[12]=>(@tcp_video_streamer.read(12)).unpack("H*").first
+      }
+      @tcp_video_streamer.read(4)
+      return @tcp_video_streamer.read(frame[:payload_size])
+    end
+  end
+end

data/lib/argus/tcp_video_streamer.rb

@@ -0,0 +1,20 @@
+require 'socket'
+module Argus
+  class TcpVideoStreamer
+    def initialize(tcp_socket=nil, host='192.168.1.1', port=5555)
+      @tcp_socket = tcp_socket || TCPSocket.new(host, port)
+      @host = host
+      @port = port
+    end
+
+    def start_stream(udp_socket=nil)
+      sock = udp_socket || UDPSocket.new
+      sock.send("\x01\x00\x00\x00", 0, @host, @port)
+      sock.close
+    end
+
+    def read(n)
+      @tcp_socket.read(n)
+    end
+  end
+end

data/lib/argus/udp_nav_streamer.rb

@@ -0,0 +1,24 @@
+module Argus
+  class UdpNavStreamer
+    def initialize(udp_socket, host='192.168.1.1', port=5554)
+      @udp_socket = udp_socket
+      @host = host
+      @port = port
+      @udp_socket.bind("0.0.0.0", port)
+    end
+
+    def start_stream
+      @udp_socket.send("\x01\x00\x00\x00", 0, @host, @port)
+    end
+
+    def receive_packet
+      data, from = @udp_socket.recvfrom(1024)
+      if data.unpack("V").first == "0x55667788".hex
+        data.slice!(0..3)
+        return NavData.new(data)
+      else
+        return "Not nav data!"
+      end
+    end
+  end
+end

data/lib/argus/udp_sender.rb

@@ -0,0 +1,13 @@
+module Argus
+  class UdpSender
+    def initialize(udp_socket, host=nil, port=nil)
+      @udp_socket = udp_socket
+      @host = host || '192.168.1.1'
+      @port = port || 5556
+    end
+
+    def send_packet(data)
+      @udp_socket.send(data, 0, @host, @port)
+    end
+  end
+end

data/lib/argus/version.rb

@@ -0,0 +1,10 @@
+module Argus
+  module Version # :nodoc: all
+    NUMBERS = [
+      MAJOR = 0,
+      MINOR = 2,
+      BUILD = 0,
+    ]
+  end
+  VERSION = Version::NUMBERS.join('.')
+end

data/lib/argus.rb

@@ -0,0 +1,9 @@
+require 'argus/at_commander'
+require 'argus/controller'
+require 'argus/udp_sender'
+require 'argus/udp_nav_streamer'
+require 'argus/nav_data'
+require 'argus/nav_streamer'
+require 'argus/drone'
+require 'argus/tcp_video_streamer'
+require 'argus/pave_parser'

data/spec/argus/at_commander_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Argus::ATCommander do
+  Given(:sender) { flexmock(:on, Argus::UdpSender) }
+  Given(:cmdr) { Argus::ATCommander.new(sender) }
+
+  describe "#tick" do
+    When { cmdr.send(:tick) }
+
+    context "with no commands" do
+      Then { sender.should have_received(:send_packet).with(/AT\*REF=\d+,0.*AT\*PCMD=\d+,0,0,0,0,0/) }
+    end
+
+    context "with a ref command" do
+      Given { cmdr.ref("512") }
+      Then { sender.should have_received(:send_packet).with(/AT\*REF=\d+,512.*AT\*PCMD=\d+,0,0,0,0,0/) }
+    end
+
+    context "with a pcmd command" do
+      Given { cmdr.pcmd("1,2,3,4,5") }
+      Then { sender.should have_received(:send_packet).with(/AT\*REF=\d+,0.*AT\*PCMD=\d+,1,2,3,4,5/) }
+    end
+  end
+
+  describe "increasing sequence numbers" do
+    Given(:seq_numbers) { [ ] }
+    Given {
+      sender.should_receive(:send_packet).and_return { |data|
+        data.scan(%r{=(\d+),}) { |seq|
+          seq_numbers << seq.first.to_i }
+      }
+    }
+    When { 2.times { cmdr.tick } }
+    Then { seq_numbers.should == [1, 2, 3, 4] }
+  end
+
+  describe "sending thread" do
+    Given {
+      @count = 0
+      sender.should_receive(:send_packet).and_return {
+        @count += 1
+        cmdr.stop if @count > 5
+      }
+    }
+    When {
+      cmdr.start
+      cmdr.join
+    }
+    Then { sender.should have_received(:send_packet) }
+  end
+
+
+
+end

data/spec/argus/controller_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe Argus::Controller do
+
+  REF_BASE = 0x11540000
+
+  def ref_bits(n=nil)
+    if n.nil?
+      REF_BASE.to_s
+    else
+      (REF_BASE | (1 << n)).to_s
+    end
+  end
+
+  Given(:at) { flexmock(:on, Argus::ATCommander) }
+  Given(:controller) { Argus::Controller.new(at) }
+
+  context "navigating commands" do
+    Invariant { result.should == controller }
+
+    context "when taking off" do
+      When(:result) { controller.take_off }
+      Then { at.should have_received(:ref).with(ref_bits(9)) }
+    end
+
+    context "when landing" do
+      When(:result) { controller.land }
+      Then { at.should have_received(:ref).with(ref_bits).twice }
+    end
+
+    context "when emergency" do
+      Given { controller.take_off }
+      When(:result) { controller.emergency }
+      Then { at.should have_received(:ref).with(ref_bits(8)) }
+    end
+
+    context "when taking off after an emergency" do
+      Given { controller.emergency }
+      When(:result) { controller.take_off }
+      Then { at.should have_received(:ref).with(ref_bits(9)) }
+    end
+
+    context "when hovering" do
+      When(:result) { controller.hover }
+      Then { at.should have_received(:pcmd).with("0,0,0,0,0") }
+    end
+
+    context "when moving forward" do
+      When(:result) { controller.forward(0.80) }
+      Then { at.should have_received(:pcmd).with("1,0,-1085485875,0,0") }
+    end
+
+    context "when moving backward" do
+      When(:result) { controller.backward(0.80) }
+      Then { at.should have_received(:pcmd).with("1,0,1061997773,0,0") }
+    end
+
+    context "when moving to the left" do
+      When(:result) { controller.left(0.80) }
+      Then { at.should have_received(:pcmd).with("1,-1085485875,0,0,0") }
+    end
+
+    context "when moving to the right" do
+      When(:result) { controller.right(0.80) }
+      Then { at.should have_received(:pcmd).with("1,1061997773,0,0,0") }
+    end
+
+    context "when moving up" do
+      When(:result) { controller.up(0.80) }
+      Then { at.should have_received(:pcmd).with("1,0,0,1061997773,0") }
+    end
+
+    context "when moving down" do
+      When(:result) { controller.down(0.80) }
+      Then { at.should have_received(:pcmd).with("1,0,0,-1085485875,0") }
+    end
+
+    context "when turning left" do
+      When(:result) { controller.turn_left(0.80) }
+      Then { at.should have_received(:pcmd).with("1,0,0,0,-1085485875") }
+    end
+
+    context "when turning right" do
+      When(:result) { controller.turn_right(0.80) }
+      Then { at.should have_received(:pcmd).with("1,0,0,0,1061997773") }
+    end
+
+    context "when executing several directions" do
+      When(:result) {
+        controller.forward(1.0).left(0.5).up(0.2).turn_left(0.8)
+      }
+      Then { at.should have_received(:pcmd).with("1,-1090519040,-1082130432,1045220557,-1085485875") }
+    end
+  end
+end

data/spec/argus/udp_sender_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+require 'socket'
+
+describe Argus::UdpSender do
+  Given(:port) { 5500 }
+  Given(:socket) { UDPSocket.new }
+  Given(:sender) { Argus::UdpSender.new(socket, 'localhost', port) }
+  Given!(:server) {
+    server = UDPSocket.new
+    server.bind(nil, port)
+    Thread.new {
+      @data, _ = server.recvfrom(1000)
+    }
+  }
+  When {
+    sender.send_packet("HI")
+    server.join
+  }
+  Then { @data.should == "HI" }
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+#!/usr/bin/ruby -wKU
+
+require 'rspec/given'
+require 'flexmock'
+
+require 'argus'
+
+RSpec.configure do |config|
+  config.mock_with :flexmock
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: hybridgroup-argus
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+  prerelease: 
+platform: ruby
+authors:
+- Jim Weirich
+- Ron Evans
+- Adrian Zankich
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec-given
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.1'
+description: Argus is a Ruby interface to a Parrot AR Drone quadcopter.Argus is extremely
+  experimental at this point.  Use at your own risk.
+email:
+- jim.weirich@gmail.com
+- ron dot evans at gmail dot com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+- MIT-LICENSE
+files:
+- README.md
+- Rakefile
+- lib/argus.rb
+- lib/argus/at_commander.rb
+- lib/argus/controller.rb
+- lib/argus/drone.rb
+- lib/argus/nav_data.rb
+- lib/argus/nav_streamer.rb
+- lib/argus/pave_parser.rb
+- lib/argus/tcp_video_streamer.rb
+- lib/argus/udp_nav_streamer.rb
+- lib/argus/udp_sender.rb
+- lib/argus/version.rb
+- spec/spec_helper.rb
+- spec/argus/at_commander_spec.rb
+- spec/argus/controller_spec.rb
+- spec/argus/udp_sender_spec.rb
+- MIT-LICENSE
+homepage: http://github.com/hybridgroup/argus
+licenses: []
+post_install_message: 
+rdoc_options:
+- --line-numbers
+- --show-hash
+- --main
+- README.md
+- --title
+- Argus -- Parrot AR Drone Ruby API
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '1.9'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '1.0'
+requirements: []
+rubyforge_project: n/a
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Ruby API for a Parrot AD Drone Quadcopter
+test_files: []