hybridgroup-argus 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 43c7894a41a1033f29b7da584853f6652165ed9c
-  data.tar.gz: 1d8496bc4cb2f4139d62b1e63ddbde9389f9be46
+  metadata.gz: 4aa5b03362c2310d0fc0ab4890c0663fecb0f6e1
+  data.tar.gz: 66d8edfbc9992de265a7de09b09a2c34b59be643
 SHA512:
-  metadata.gz: 3ad023f7f146c1dcd8457734fdeb532f3462439bf24fb1da9872732c05c27d505be576bdd88e0204e5ffac9cdc154e237bda84278fadce24db96d8f4f48496a1
-  data.tar.gz: f162db2640775556506541e8ca6485a337b55d354bd2edd3705be92120d899830839a19492be7344c764497c94c54a3a03c35e8076927612f346cdfad5aa95a2
+  metadata.gz: 14733ed692c008b1ccedec0a1b5c868a12d1c2ab0d7e33494d02121953971798639520ab4622e0935acd980abfa5a9cb6f31d4c4d0aacd5d426b214b0350e7af
+  data.tar.gz: a3c84a2b7f381bc137781a8ef3df7dbb8453d39bd789aee6ba67a34d40f35ee054ca80fd40df512c314e2b02a4c5dc9aa2178c6683359bdbe2235237b35d4d7a

data/README.md

@@ -51,3 +51,7 @@ You can also use Argus by providing an externally created socket. For example, i
   drone.stop
 ```
 
+## Download the SDK
+
+For additional reference, you can download the AR Drone Developer Guide (https://projects.ardrone.org/attachments/download/365/ARDrone_SDK_1_7_Developer_Guide.pdf) after signing up here (https://projects.ardrone.org/).
+

data/lib/argus/ardrone_control_modes.rb

@@ -0,0 +1,14 @@
+module Argus
+  module ArdroneControlModes
+    # ARDRONE_CONTROL_MODE values from the ardrone_api.h file.
+
+    CFG_GET_CONTROL_MODE        = 4 # Send active configuration file
+                                    # to a client through the
+                                    # 'control' socket UDP 5559
+
+    ACK_CONTROL_MODE            = 5 # Reset command mask in navdata
+
+    CUSTOM_CFG_GET_CONTROL_MODE = 6 # Requests the list of custom
+                                    # configuration IDs
+  end
+end

data/lib/argus/at_commander.rb

@@ -3,6 +3,7 @@ require 'thread'
 module Argus
   class ATCommander
     attr_reader :timestamps
+    attr_accessor :interval
 
     def initialize(sender)
       @sender = sender
@@ -44,10 +45,6 @@ module Argus
       @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
@@ -62,11 +59,18 @@ module Argus
       end
     end
 
-    def reset_watchdog
+    def comwdg
       @mutex.synchronize do
         command("COMWDG")
       end
     end
+    alias reset_watchdog comwdg # For backward compatibility
+
+    def ctrl(mode)
+      @mutex.synchronize do
+        command("CTRL", "#{mode},0")
+      end
+    end
 
     private
 

data/lib/argus/cfields.rb

@@ -22,7 +22,7 @@ module Argus
       end
 
       def format_string
-        @format_string ||= "x4"
+        @format_string ||= (defined?(initial_format) ? initial_format : "")
       end
 
       def allot(n=1)

data/lib/argus/controller.rb

@@ -1,4 +1,5 @@
 require 'argus/float_encoding'
+require 'argus/ardrone_control_modes'
 
 module Argus
   class Controller
@@ -23,9 +24,15 @@ module Argus
       update_ref
     end
 
-    def emergency
+    def enable_emergency(state=false)
+      @flying = true
+      @emergency = state
+      update_ref
+    end
+
+    def disable_emergency(state=true)
       @flying = false
-      @emergency = true
+      @emergency = state
       update_ref
     end
 
@@ -97,6 +104,16 @@ module Argus
       self
     end
 
+    def animate(selection, duration)
+      selection = FlightAnimation.lookup_value(selection)
+      value = [
+        selection,
+        duration
+      ].join(',')
+      @at_commander.config("control:flight_anim",value)
+      self
+    end
+
     def enable_detection(colors, type=10, select=32)
       config("detect:enemy_colors",colors.to_s)
       config("detect:detect_type", type.to_s)
@@ -106,22 +123,29 @@ module Argus
 
     def config(key, value)
       @at_commander.config(key, value)
+      self
     end
 
     def demo_mode
-      @at_commander.config("general:navdata_demo", "TRUE")
+      config("general:navdata_demo", "TRUE")
     end
 
     def front_camera
-      @at_commander.config("video:video_channel", "2")
+      config("video:video_channel", "2")
     end
 
     def bottom_camera
-      @at_commander.config("video:video_channel", "1")
+      config("video:video_channel", "1")
     end
 
     def reset_watchdog
-      @at_commander.reset_watchdog
+      @at_commander.comwdg
+      self
+    end
+
+    def ack_control_mode
+      @at_commander.ctrl(ArdroneControlModes::ACK_CONTROL_MODE)
+      self
     end
 
     private

data/lib/argus/drone.rb

@@ -4,17 +4,21 @@ require 'argus/nav_monitor'
 module Argus
 
   class Drone
-    attr_reader :controller, :enable_nav_monitor
+    attr_reader :controller, :nav
 
     def initialize(opts={})
-      @host = opts[:remote_host] || '192.168.1.1'
-      @port = opts[:post] || '5556'
-      @socket = opts[:socket] || UDPSocket.new
-      @sender = opts[:sender] || Argus::UdpSender.new(socket: @socket, remote_host: @host, port: @port)
-      @at = Argus::ATCommander.new(@sender)
-      @controller = Argus::Controller.new(@at)
-      
-      @enable_nav_monitor = false
+      host = opts[:remote_host] || '192.168.1.1'
+      port = opts[:post] || '5556'
+      @sender = opts[:sender] || Argus::UdpSender.new(socket: opts[:socket], remote_host: host, port: port)
+      @at = opts[:commander] || Argus::ATCommander.new(@sender)
+      @controller = opts[:controller] || Argus::Controller.new(@at)
+      if opts[:nav_monitor]
+        @nav = opts[:nav_monitor]
+      elsif opts.fetch(:enable_nav_monitor, true)
+        @nav =  NavMonitor.new(@controller, host)
+      else
+        @nav = NullNavMonitor.new
+      end
     end
 
     def commander
@@ -22,13 +26,7 @@ module Argus
     end
 
     def start(enable_nav_monitor=true)
-      @enable_nav_monitor = enable_nav_monitor
-      
-      if enable_nav_monitor
-        @nav = NavMonitor.new(@controller, @host)
-        @nav.start
-      end
-
+      @nav.start
       @at.start
     end
 
@@ -36,10 +34,10 @@ module Argus
       @controller.land
 
       @at.stop
-      @nav.stop if enable_nav_monitor
+      @nav.stop
 
       @at.join
-      @nav.join if enable_nav_monitor
+      @nav.join
     end
 
     def nav_callback(*args, &block)
@@ -47,14 +45,14 @@ module Argus
     end
 
     %w(
-       take_off land hover emergency
+       take_off land hover disable_emergency enable_emergency
        forward backward
        left right
        up down
        turn_left turn_right
        front_camera bottom_camera
        config
-       led
+       led animate
        reset_watchdog
     ).each do |meth|
       define_method(meth) { |*args|

data/lib/argus/flight_animation.rb

@@ -0,0 +1,47 @@
+module Argus
+
+  module FlightAnimation
+    NAMES = [
+      :phi_m30_deg,
+      :phi_30_deg,
+      :theta_m30_deg,
+      :theta_30_deg,
+      :theta_20_deg_yaw_200_deg,
+      :theta_20_deg_yaw_m_200_deg,
+      :turnaround,
+      :turnaround_go_down,
+      :yaw_shake,
+      :yaw_dance,
+      :phi_dance,
+      :theta_dance,
+      :vz_dance,
+      :wave,
+      :phi_theta_mixed,
+      :double_phi_theta_mixed,
+      :flip_ahead,
+      :flip_behind,
+      :flip_left,
+      :flip_right,
+    ]
+
+    VALUES = {}
+    NAMES.each.with_index { |name, index| VALUES[name] = index }
+
+    def self.lookup_name(numeric_value)
+      NAMES[numeric_value]
+    end
+
+    def self.lookup_value(symbolic_name)
+      case symbolic_name
+      when Symbol
+        VALUES[symbolic_name]
+      when Integer
+        symbolic_name
+      when /^\d+/
+        symbolic_name.to_i
+      when String
+        VALUES[symbolic_name.intern]
+      end
+    end
+  end
+end

data/lib/argus/nav_monitor.rb

@@ -3,9 +3,9 @@ module Argus
   class NavMonitor
     attr_reader :streamer
 
-    def initialize(controller, remote_host)
+    def initialize(controller, remote_host, opts={})
       @controller = controller
-      @streamer = NavStreamer.new(remote_host: remote_host)
+      @streamer = opts.fetch(:streamer) { NavStreamer.new(remote_host: remote_host) }
       @callbacks = []
       @mutex = Mutex.new
       @nav_data = nil
@@ -28,6 +28,7 @@ module Argus
     end
 
     def join
+      stop
       @nav_thread.join
     end
 
@@ -46,8 +47,6 @@ module Argus
       @mutex.synchronize { @nav_options[tag] }
     end
 
-    private
-
     def update_nav_data(data)
       @mutex.synchronize do
         update_internal_nav_data(data)
@@ -60,11 +59,16 @@ module Argus
       $stdout.flush
     end
 
+    private
+
     def update_internal_nav_data(data)
       @nav_data = data
       if @nav_data.bootstrap?
         @controller.demo_mode
       end
+      if @nav_data.control_command_ack?
+        @controller.ack_control_mode
+      end
       data.options.each do |opt|
         @nav_options[opt.tag] = opt if opt.tag < 100
       end

data/lib/argus/nav_option.rb

@@ -24,6 +24,12 @@ module Argus
       option = options[tag] || NavOptionUnknown
       option.new(raw_data)
     end
+
+    # Skip the tag and size fields, We've already handled them in the
+    # base class.
+    def self.initial_format
+      "x4"
+    end
   end
 
 end

data/lib/argus/nav_streamer.rb

@@ -25,8 +25,8 @@ module Argus
       @remote_host  = opts.fetch(:remote_host)
       @local_host   = opts[:local_host]  || '0.0.0.0'
       @port         = opts[:port]        || 5554
-      @socket_class = opts[:socket]   || UDPSocket
-      start_timer
+      @socket_class = opts[:UDPSocket]   || UDPSocket
+      start_timer unless opts[:disable_timer]
     end
 
     def start
@@ -51,7 +51,7 @@ module Argus
      data, from = @socket.recvfrom(1024)
       if data.unpack("V").first == 0x55667788
         received_data
-        nav_data = NavData.new(data)
+        NavData.new(data)
       else
         nil
       end

data/lib/argus/null_nav_monitor.rb

@@ -0,0 +1,13 @@
+module Argus
+
+  class NullNavMonitor
+    UsageError = Class.new(StandardError)
+    def callback(*)
+      fail UsageError, "Callbacks are not supported when the NavMonitor is disabled."
+    end
+    def method_missing(*)
+      # Noop
+    end
+  end
+
+end

data/lib/argus/udp_sender.rb

@@ -1,7 +1,7 @@
 module Argus
   class UdpSender
     def initialize(opts={})
-      @udp_socket = opts.fetch(:socket)
+      @udp_socket = opts[:socket] || UDPSocket.new
       @host = opts.fetch(:remote_host)
       @port = opts.fetch(:port, 5556)
     end

data/lib/argus/version.rb

@@ -2,7 +2,7 @@ module Argus
   module Version # :nodoc: all
     NUMBERS = [
       MAJOR = 0,
-      MINOR = 4,
+      MINOR = 5,
       BUILD = 0,
     ]
   end

data/spec/argus/at_commander_spec.rb

@@ -5,20 +5,48 @@ describe Argus::ATCommander do
   Given(:cmdr) { Argus::ATCommander.new(sender) }
 
   describe "#tick" do
+    Given(:expected_commands) {
+      [
+        "AT\\*REF=\\d+,0",
+        "AT\\*PCMD=\\d+,0,0,0,0,0",
+      ]
+    }
+    Given(:command_pattern) { Regexp.new('\A' + expected_commands.map { |s| "#{s}\r" }.join + '\Z') }
+
     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/) }
+      Then { sender.should have_received(:send_packet).with(command_pattern) }
     end
 
     context "with a ref command" do
+      Given { expected_commands[0] = 'AT\*REF=\d+,512' }
       Given { cmdr.ref("512") }
-      Then { sender.should have_received(:send_packet).with(/AT\*REF=\d+,512.*AT\*PCMD=\d+,0,0,0,0,0/) }
+      Then { sender.should have_received(:send_packet).with(command_pattern) }
     end
 
     context "with a pcmd command" do
+      Given { expected_commands[1] = 'AT\*PCMD=\d+,1,2,3,4,5' }
       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/) }
+      Then { sender.should have_received(:send_packet).with(command_pattern) }
+    end
+
+    context "with a config command" do
+      Given { expected_commands.unshift('AT\*CONFIG=\d+,"general:navdata_demo","TRUE"') }
+      Given { cmdr.config("general:navdata_demo", "TRUE") }
+      Then { sender.should have_received(:send_packet).with(command_pattern) }
+    end
+
+    context "with a reset watchdog command" do
+      Given { expected_commands.unshift('AT\*COMWDG=\d+') }
+      Given { cmdr.comwdg }
+      Then { sender.should have_received(:send_packet).with(command_pattern) }
+    end
+
+    context "with a contrl command" do
+      Given { expected_commands.unshift('AT\*CTRL=\d+,4,0') }
+      Given { cmdr.ctrl(4) }
+      Then { sender.should have_received(:send_packet).with(command_pattern) }
     end
   end
 
@@ -49,6 +77,9 @@ describe Argus::ATCommander do
     Then { sender.should have_received(:send_packet) }
   end
 
-
+  describe "setting the interval" do
+    Given { cmdr.interval = 1.0 }
+    Then { cmdr.interval == 1.0 }
+  end
 
 end

data/spec/argus/cfields_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+module CFieldsSpec
+  describe Argus::CFields do
+    class Example < Argus::NavOption
+      include Argus::CFields
+      uint32_t :u32
+      uint16_t :u16
+      float32_t :f32
+      int32_t   :i32
+      matrix33_t :m33
+      vector31_t :v31
+
+      def self.tag
+        14263
+      end
+
+      Argus::NavOption.register(self)
+    end
+
+    Given(:raw_data) {
+      [
+        Bytes.int16(Example.tag),
+        Bytes.int16(10),
+        Bytes.int32(1),
+        Bytes.int16(2),
+        Bytes.float32(3.4),
+      ].flatten.pack("C*")
+    }
+
+    When(:data) { Example.new(raw_data) }
+
+    Then { data.size == 10 }
+    Then { data.tag == Example.tag }
+    Then { data.u32 == 1 }
+    Then { data.u16 == 2 }
+    Then { data.f32 == about(3.4).percent(1) }
+  end
+end

data/spec/argus/controller_spec.rb

@@ -15,129 +15,153 @@ describe Argus::Controller do
   Given(:at) { flexmock(:on, Argus::ATCommander) }
   Given(:controller) { Argus::Controller.new(at) }
 
-  context "navigating commands" do
+  describe "controller 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
-
-  describe "led command" do
-    Invariant { result.should == controller }
-
-    context "when setting with numeric sequence" do
-      When(:result) { controller.led(3, 2.0, 4) }
-      Then {
-        at.should have_received(:config)
-          .with("leds:leds_anim", "3,1073741824,4")
-      }
-    end
-
-    context "when setting with symbolic sequence" do
-      When(:result) { controller.led(:blink_orange, 2.0, 4) }
-      Then {
-        at.should have_received(:config)
-          .with("leds:leds_anim", "3,1073741824,4")
-      }
-    end
-  end
-
-  describe "enabled detection command" do
-    Invariant { result.should == controller }
-
-    context "when setting all parameters" do
-      Given(:enemy)  { 2 }
-      Given(:type)   { 11 }
-      Given(:select) { 33 }
-
-      When(:result) { controller.enable_detection(enemy, type, select) }
-
-      Then { at.should have_received(:config).with("detect:enemy_colors", enemy.to_s) }
-      Then { at.should have_received(:config).with("detect:detect_type", type.to_s) }
-      Then { at.should have_received(:config).with("detect:detections_select_h", select.to_s) }
-    end
-
-    context "when setting with only enemy" do
-      Given(:enemy)  { 2 }
-      Given(:type)   { 10 }
-      Given(:select) { 32 }
-
-      When(:result) { controller.enable_detection(enemy) }
-
-      Then { at.should have_received(:config).with("detect:enemy_colors", enemy.to_s) }
-      Then { at.should have_received(:config).with("detect:detect_type", type.to_s) }
-      Then { at.should have_received(:config).with("detect:detections_select_h", select.to_s) }
+    context "navigating commands" do
+      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 enable_emergency" do
+        Given { controller.enable_emergency }
+        When(:result) { controller.take_off }
+        Then { at.should have_received(:ref).with(ref_bits(9)) }
+      end
+
+      context "when taking off after a disable_emergency" do
+        Given { controller.disable_emergency }
+        When(:result) { controller.take_off }
+        Then { at.should have_received(:ref).with(ref_bits(8)) }
+      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
+
+    describe "config command" do
+      context "when setting with numeric sequence" do
+        When(:result) { controller.led(3, 2.0, 4) }
+        Then {
+          at.should have_received(:config)
+            .with("leds:leds_anim", "3,1073741824,4")
+        }
+      end
+
+      context "when setting with symbolic sequence" do
+        When(:result) { controller.led(:blink_orange, 2.0, 4) }
+        Then {
+          at.should have_received(:config)
+            .with("leds:leds_anim", "3,1073741824,4")
+        }
+      end
+    end
+
+    describe "enabled detection command" do
+      context "when setting all parameters" do
+        Given(:enemy)  { 2 }
+        Given(:type)   { 11 }
+        Given(:select) { 33 }
+
+        When(:result) { controller.enable_detection(enemy, type, select) }
+
+        Then { at.should have_received(:config).with("detect:enemy_colors", enemy.to_s) }
+        Then { at.should have_received(:config).with("detect:detect_type", type.to_s) }
+        Then { at.should have_received(:config).with("detect:detections_select_h", select.to_s) }
+      end
+
+      context "when setting with only enemy" do
+        Given(:enemy)  { 2 }
+        Given(:type)   { 10 }
+        Given(:select) { 32 }
+
+        When(:result) { controller.enable_detection(enemy) }
+
+        Then { at.should have_received(:config).with("detect:enemy_colors", enemy.to_s) }
+        Then { at.should have_received(:config).with("detect:detect_type", type.to_s) }
+        Then { at.should have_received(:config).with("detect:detections_select_h", select.to_s) }
+      end
+
+      context "when doing demo mode" do
+        When(:result) { controller.demo_mode }
+        Then { at.should have_received(:config).with("general:navdata_demo", "TRUE") }
+      end
+
+      context "when selecting the forward camera" do
+        When(:result) { controller.front_camera }
+        Then { at.should have_received(:config).with("video:video_channel", "2") }
+      end
+
+      context "when selecting the bottom camera" do
+        When(:result) { controller.bottom_camera }
+        Then { at.should have_received(:config).with("video:video_channel", "1") }
+      end
+
+    end
+
+    describe "reset watchdog command" do
+      When(:result) { controller.reset_watchdog}
+      Then { at.should have_received(:comwdg).with() }
+    end
+
+    describe "ack control mode command" do
+      When(:result) { controller.ack_control_mode }
+      Then { at.should have_received(:ctrl).with(5) }
     end
   end
 

data/spec/argus/drone_spec.rb

@@ -1,24 +1,53 @@
 require 'spec_helper'
+require 'argus'
 
-module Argus
-  describe Drone do
+describe Argus::Drone do
+  Given(:controller) { flexmock("controller", :on, Argus::Controller) }
+  Given(:commander) { flexmock("commander", :on, Argus::ATCommander) }
+  Given(:nav_monitor) { flexmock("navmonitor", :on, Argus::NavMonitor) }
+  Given(:drone) {
+    Argus::Drone.new(
+      nav_monitor: nav_monitor,
+      commander: commander,
+      controller: controller)
+    }
 
-    Given(:socket) { flexmock("Socket", send: nil).should_ignore_missing }
-    Given(:drone) { Drone.new(socket: socket) }
+  Then { drone.commander == commander }
 
-    describe "default navigation monitor enabled" do
-      Then { drone.enable_nav_monitor == false }
-    end
+  context "when starting the drone" do
+    When { drone.start }
+    Then { commander.should have_received(:start).once }
+    Then { nav_monitor.should have_received(:start).once }
 
-    describe "default navigation monitor enabled when started" do
-      When { drone.start }
-      Then { drone.enable_nav_monitor == true }
+    context "and then stopped" do
+      When { drone.stop }
+      Then { controller.should have_received(:land).once }
+      Then { commander.should have_received(:stop).once }
+      Then { commander.should have_received(:join).once }
+      Then { nav_monitor.should have_received(:stop).once }
+      Then { nav_monitor.should have_received(:join).once }
     end
+  end
 
-    describe "navigation monitor can be disabled when started" do
-      When { drone.start(false) }
-      Then { drone.enable_nav_monitor == false }
-    end
+  describe "setting nav callbacks" do
+    When { drone.nav_callback(:a) }
+    Then { nav_monitor.should have_received(:callback).with(:a).once }
+  end
+
+  describe "flight controls" do
+    When { drone.take_off }
+    Then { controller.should have_received(:take_off).once }
+  end
+
+  context "when created normally" do
+    Given { flexmock(Argus::NavMonitor).should_receive(:new => nil) }
+    When { Argus::Drone.new }
+    Then { Argus::NavMonitor.should have_received(:new).with(Argus::Controller, String).once }
   end
-end
 
+  context "when NavMonitor is disabled" do
+    Given { flexmock(Argus::NullNavMonitor).should_receive(:new => nil) }
+    When { Argus::Drone.new(enable_nav_monitor: false) }
+    Then { Argus::NullNavMonitor.should have_received(:new).with().once }
+  end
+end

data/spec/argus/flight_animation_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+module Argus
+
+  describe FlightAnimation do
+    describe ".lookup_name" do
+      Then { FlightAnimation.lookup_name(3) == :theta_30_deg }
+    end
+
+    describe ".lookup_value" do
+      Then { FlightAnimation.lookup_value(:flip_ahead) == 16 }
+      Then { FlightAnimation.lookup_value("flip_ahead") == 16 }
+      Then { FlightAnimation.lookup_value(16) == 16 }
+      Then { FlightAnimation.lookup_value("16") == 16 }
+
+      Then { FlightAnimation.lookup_value(:unknown) == nil }
+      Then { FlightAnimation.lookup_value("UNKNOWN") == nil }
+    end
+  end
+
+end

data/spec/argus/nav_data_spec.rb

@@ -12,6 +12,7 @@ module Argus
 
     Then { nav_data.sequence_number == 173064 }
     Then { nav_data.vision_flag == 0 }
+    Then { nav_data.raw == raw_nav_bytes }
 
     describe "sequence number" do
       Given(:seq_num) { 1234 }

data/spec/argus/nav_monitor_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+require 'thread'
+
+describe Argus::NavMonitor do
+  Given(:streamer) { flexmock("streamer", :on, Argus::NavStreamer) }
+  Given(:controller) { flexmock("controller", :on, Argus::Controller) }
+  Given(:nav) {
+    Argus::NavMonitor.new(controller, "localhost", streamer: streamer)
+  }
+
+  context "when the monitor is started" do
+    after do nav.join end
+    When { nav.start; Thread.pass }
+    Then { streamer.should have_received(:start).once }
+  end
+
+  context "when data is received" do
+    Given(:bootstrap) { false }
+    Given(:ack) { false }
+    Given(:nav_options) { [ ] }
+    Given(:nav_data) {
+      flexmock("NavData",
+        :bootstrap? => bootstrap,
+        :control_command_ack? => ack,
+        :options => nav_options)
+    }
+
+    When {
+      capture_io { nav.update_nav_data(nav_data) }
+    }
+
+    context "when typical data is received" do
+      Then { nav.data == nav_data }
+      Then { controller.should have_received(:demo_mode).never }
+      Then { controller.should have_received(:ack_control_mode).never }
+    end
+
+    context "when the bootstrap flag is set" do
+      Given(:bootstrap) { true }
+      Then { controller.should have_received(:demo_mode).once }
+    end
+
+    context "when the control command ack is set" do
+      Given(:ack) { true }
+      Then { controller.should have_received(:ack_control_mode).once }
+    end
+
+    context "with nav option sections" do
+      Given(:opt) { flexmock("option", tag: 0) }
+      Given(:nav_options) { [ opt ] }
+      Then { nav.data == nav_data }
+      Then { nav.option(0) == opt }
+    end
+
+    context "with a callback" do
+      Given { nav.callback { |data| @cb_data = data } }
+      Then { @cb_data == nav_data }
+    end
+
+    context "with a callback with errors" do
+      Given { nav.callback { |data| fail "OUCH" } }
+      Then { captured_out =~ /OUCH/ }
+    end
+  end
+end

data/spec/argus/nav_option_demo_spec.rb

@@ -3,10 +3,6 @@ require 'base64'
 
 module Argus
   describe NavOptionDemo do
-    def f(float)
-      FloatEncoding.encode_float(float)
-    end
-
     # NOTE: This is a Base 64 encoded NavData packet recorded directly from the drone.
     Given(:base64_data) {
       "iHdmVdAEgA/5iwAAAAAAAAAAlAAAAAIAPAAAAADwREUAgCNFQFEiyAAAAABk" +
@@ -28,7 +24,8 @@ module Argus
     When(:demo) { nav_data.options.first }
 
     Then { ! demo.nil? }
-    Then { demo.tag == 0 }
+    Then { demo.tag == Argus::NavTag::DEMO }
+    Then { demo.size == 148 }
 
     Then { demo.ctrl_state == 0x20000 }
     Then { demo.control_state_name == :default }

data/spec/argus/nav_option_vision_detect_spec.rb

@@ -56,6 +56,7 @@ module Argus
       Then { d0.y == 20 }
       Then { d0.width == 30 }
       Then { d0.height == 40 }
+      Then { d0.distance == 50 }
       Then { d0.orientation_angle == 60.0 }
       Then { d0.camera_source == 70 }
     end

data/spec/argus/nav_streamer_spec.rb

@@ -5,7 +5,7 @@ module Argus
     Given(:remote_host) { '192.168.1.1' }
     Given(:port) { 5554 }
     Given(:socket) { flexmock("Socket", send: nil).should_ignore_missing }
-    Given(:streamer) { NavStreamer.new(remote_host: remote_host, socket: flexmock(new: socket)) }
+    Given(:streamer) { NavStreamer.new(remote_host: remote_host, UDPSocket: flexmock(new: socket, disabled_timer: true)) }
 
     context "after starting" do
       Given { streamer.start }
@@ -23,6 +23,11 @@ module Argus
         When(:nav_data) { streamer.receive_data }
         Then { nav_data.nil? }
       end
+
+      context "when receiving and extra start event" do
+        Given { streamer.start }
+        Then { socket.should have_received(:close) }
+      end
     end
 
     describe "State Transitions" do

data/spec/argus/null_nav_monitor_spec.rb

@@ -0,0 +1,17 @@
+require 'rspec/given'
+require 'argus/null_nav_monitor'
+
+describe Argus::NullNavMonitor do
+  Given(:nav) { Argus::NullNavMonitor.new }
+
+  context "when calling a regular method" do
+    When(:result) { nav.start }
+    Then { result.should_not have_raised }
+  end
+
+  context "when calling a regular method" do
+    When(:result) { nav.callback { } }
+    Then { result.should have_raised(Argus::NullNavMonitor::UsageError) }
+  end
+
+end

data/spec/argus/udp_sender_spec.rb

@@ -3,18 +3,31 @@ require 'socket'
 
 describe Argus::UdpSender do
   Given(:port) { '5500' }
-  Given(:socket) { UDPSocket.new }
-  Given(:sender) { Argus::UdpSender.new(socket: socket, remote_host: 'localhost', port: port) }
-  Given!(:server) {
-    server = UDPSocket.new
-    server.bind(nil, port)
-    Thread.new {
-      @data, _ = server.recvfrom(1000)
+  Given(:host) { 'localhost' }
+
+  context "with real socket" do
+    Given(:socket) { UDPSocket.new }
+    Given(:sender) { Argus::UdpSender.new(remote_host: host, port: port) }
+    Given!(:server) {
+      server = UDPSocket.new
+      server.bind(nil, port)
+      Thread.new {
+        @data, _ = server.recvfrom(1000)
+      }
+    }
+    When {
+      sender.send_packet("HI")
+      server.join
     }
-  }
-  When {
-    sender.send_packet("HI")
-    server.join
-  }
-  Then { @data.should == "HI" }
+    Then { @data.should == "HI" }
+  end
+
+  context "with provided socket" do
+    Given(:socket) { flexmock(send: nil) }
+    Given(:sender) { Argus::UdpSender.new(socket: socket, remote_host: host, port: port) }
+
+    When { sender.send_packet("HI") }
+
+    Then { socket.should have_received(:send).with("HI", 0, host, port).once }
+  end
 end

data/spec/argus/video_data_envelope_spec.rb

@@ -21,6 +21,6 @@ module Argus
       Then { video_data_envelope.payload_size == 2048 }
     end
 
-    pending "TODO: handle invalid envelope"
+    # TODO: handle invalid envelope
   end
 end

data/spec/argus/video_data_spec.rb

@@ -11,8 +11,7 @@ module Argus
       Then {video_data.envelope.signature == "PaVE"}
     end
 
-    pending "TODO: handle invalid envelope"
-    pending "TODO: handle valid envelope but invalid frame"
-    
+    # TODO: handle invalid envelope
+    # TODO: handle valid envelope but invalid frame
   end
 end

data/spec/argus/video_streamer_spec.rb

@@ -12,5 +12,10 @@ module Argus
       Then { udp_socket.should have_received(:close) }
     end
 
+    describe "receiving data" do
+      Given { streamer.start(udp_socket) }
+      When(:result) { streamer.receive_data }
+      Then { result.is_a?(VideoData) }
+    end
   end
 end

data/spec/spec_helper.rb

@@ -1,10 +1,14 @@
 #!/usr/bin/ruby -wKU
+require 'simplecov'
+SimpleCov.start do
+  add_filter "spec/"
+end
 
 require 'rspec/given'
 require 'flexmock'
-
 require 'argus'
 require 'support/bytes'
+require 'support/capture_io'
 
 RSpec.configure do |config|
   config.mock_with :flexmock

data/spec/support/bytes.rb

@@ -9,6 +9,10 @@ module Bytes
     [n].pack("V").unpack("C*")
   end
 
+  def float32(f)
+    [f].pack("e").unpack("C*")
+  end
+
   def make_nav_data(*options)
     result = options.flatten
     add_checksum(result)

data/spec/support/capture_io.rb

@@ -0,0 +1,32 @@
+module CaptureIO
+  def capture_io
+    old_out = $stdout
+    sio_out = StringIO.new
+    $stdout = sio_out
+
+    old_err = $stderr
+    sio_err = StringIO.new
+    $stderr = sio_err
+
+    yield
+
+  ensure
+    $stdout = old_out
+    $stderr = old_err
+
+    captured_out << sio_out.string
+    captured_err << sio_err.string
+  end
+
+  def captured_out
+    @captured_out ||= ""
+  end
+
+  def captured_err
+    @captured_err ||= ""
+  end
+end
+
+RSpec.configure do |config|
+  config.include CaptureIO
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hybridgroup-argus
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Jim Weirich
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-20 00:00:00.000000000 Z
+date: 2013-10-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec-given
@@ -40,11 +40,13 @@ files:
 - README.md
 - Rakefile
 - lib/argus.rb
+- lib/argus/ardrone_control_modes.rb
 - lib/argus/at_commander.rb
 - lib/argus/cad_type.rb
 - lib/argus/cfields.rb
 - lib/argus/controller.rb
 - lib/argus/drone.rb
+- lib/argus/flight_animation.rb
 - lib/argus/float_encoding.rb
 - lib/argus/led_animation.rb
 - lib/argus/nav_data.rb
@@ -56,6 +58,7 @@ files:
 - lib/argus/nav_option_vision_detect.rb
 - lib/argus/nav_streamer.rb
 - lib/argus/nav_tag.rb
+- lib/argus/null_nav_monitor.rb
 - lib/argus/time_queue.rb
 - lib/argus/udp_sender.rb
 - lib/argus/version.rb
@@ -64,26 +67,32 @@ files:
 - lib/argus/video_streamer.rb
 - spec/spec_helper.rb
 - spec/argus/at_commander_spec.rb
+- spec/argus/cfields_spec.rb
 - spec/argus/controller_spec.rb
 - spec/argus/drone_spec.rb
+- spec/argus/flight_animation_spec.rb
 - spec/argus/float_encoding_spec.rb
 - spec/argus/led_animation_spec.rb
 - spec/argus/nav_data_spec.rb
+- spec/argus/nav_monitor_spec.rb
 - spec/argus/nav_option_checksum_spec.rb
 - spec/argus/nav_option_demo_spec.rb
 - spec/argus/nav_option_spec.rb
 - spec/argus/nav_option_unknown_spec.rb
 - spec/argus/nav_option_vision_detect_spec.rb
 - spec/argus/nav_streamer_spec.rb
+- spec/argus/null_nav_monitor_spec.rb
 - spec/argus/time_queue_spec.rb
 - spec/argus/udp_sender_spec.rb
 - spec/argus/video_data_envelope_spec.rb
 - spec/argus/video_data_spec.rb
 - spec/argus/video_streamer_spec.rb
 - spec/support/bytes.rb
+- spec/support/capture_io.rb
 - MIT-LICENSE
 homepage: http://github.com/jimweirich/argus
-licenses: []
+licenses:
+- MIT-LICENSE
 metadata: {}
 post_install_message: 
 rdoc_options: