argus 0.0.0 → 0.3.0

data/spec/argus/float_encoding_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+module Argus
+
+  describe FloatEncoding do
+    Given(:f) { 5.0 }
+    Given(:encoded_f) { 1084227584 }
+    Then { FloatEncoding.encode_float(f) == encoded_f }
+    Then { FloatEncoding.decode_float(encoded_f) == f }
+  end
+
+end

data/spec/argus/led_animation_spec.rb

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

data/spec/argus/nav_data_spec.rb

@@ -0,0 +1,147 @@
+require 'spec_helper'
+
+module Argus
+  describe NavData do
+    Given(:state_bits) { 0xcf8a0c94 }
+    Given(:seq_num) { 173064 }
+    Given(:vision_flag) { 0 }
+    Given(:raw_header) { Bytes.make_header(state_bits, seq_num, vision_flag) }
+    Given(:raw_nav_bytes) { Bytes.make_nav_data(raw_header) }
+
+    When(:nav_data) { NavData.new(raw_nav_bytes) }
+
+    Then { nav_data.sequence_number == 173064 }
+    Then { nav_data.vision_flag == 0 }
+
+    describe "sequence number" do
+      Given(:seq_num) { 1234 }
+      Then { nav_data.sequence_number == 1234 }
+    end
+
+    describe "vision flag" do
+      Given(:vision_flag) { 1 }
+      Then { nav_data.vision_flag == 1 }
+    end
+
+    describe "state queries" do
+
+      def bit(n)
+        0x00000001 << n
+      end
+
+      # Matcher for handling the mask testing for the state mask.
+      #
+      # Usage:
+      #    bit(5).should be_the_mask_for(:method [, off_value, on_value])
+      #
+      # If off_value and on_value are not given, then false/true will
+      # be assumed.
+      #
+      matcher :be_the_mask_for do |method, off_result=false, on_result=true|
+        match do |mask|
+          @msg = "OK"
+          try_alternative(method, 0, off_result) &&
+            try_alternative(method, mask, on_result)
+        end
+
+        failure_message_for_should do |mask|
+          @msg
+        end
+
+        # Try one of the alternatives. Sending method to the navdata
+        # constructed with mask should return teh expected value.
+        def try_alternative(method, mask, expected)
+          raw = Bytes.make_nav_data(Bytes.make_header(mask, 1, 0))
+          nav_data = NavData.new(raw)
+          result = nav_data.send(method)
+          return true if result == expected
+          @msg = "expected mask of 0x#{'%08x' % mask} with #{method}\n" +
+            "to return: #{expected.inspect}\n" +
+            "got:       #{result.inspect}"
+          false
+        end
+      end
+
+      Then { bit(0).should be_the_mask_for(:flying?) }
+      Then { bit(1).should be_the_mask_for(:video_enabled?) }
+      Then { bit(2).should be_the_mask_for(:vision_enabled?) }
+      Then { bit(3).should be_the_mask_for(:control_algorithm, :euler, :angular_speed) }
+
+      Then { bit(4).should be_the_mask_for(:altitude_control_algorithm_active?) }
+      Then { bit(5).should be_the_mask_for(:start_button_pressed?) }
+      Then { bit(6).should be_the_mask_for(:control_command_ack?) }
+      Then { bit(7).should be_the_mask_for(:camera_ready?) }
+
+      Then { bit(8).should be_the_mask_for(:travelling_enabled?) }
+      Then { bit(9).should be_the_mask_for(:usb_ready?) }
+      Then { bit(10).should be_the_mask_for(:mode, :all, :demo) }
+      Then { bit(11).should be_the_mask_for(:bootstrap?) }
+
+      Then { bit(12).should be_the_mask_for(:moter_problem?) }
+      Then { bit(13).should be_the_mask_for(:communication_lost?) }
+      Then { bit(14).should be_the_mask_for(:software_fault?) }
+      Then { bit(15).should be_the_mask_for(:low_battery?) }
+
+      Then { bit(16).should be_the_mask_for(:emergency_landing_requested?) }
+      Then { bit(17).should be_the_mask_for(:timer_elapsed?) }
+      Then { bit(18).should be_the_mask_for(:magnometer_needs_calibration?) }
+      Then { bit(19).should be_the_mask_for(:angles_out_of_range?) }
+
+      Then { bit(20).should be_the_mask_for(:too_much_wind?) }
+      Then { bit(21).should be_the_mask_for(:ultrasonic_sensor_deaf?) }
+      Then { bit(22).should be_the_mask_for(:cutout_detected?) }
+      Then { bit(23).should be_the_mask_for(:pic_version_number_ok?) }
+
+      Then { bit(24).should be_the_mask_for(:at_codec_thread_on?) }
+      Then { bit(25).should be_the_mask_for(:navdata_thread_on?) }
+      Then { bit(26).should be_the_mask_for(:video_thread_on?) }
+      Then { bit(27).should be_the_mask_for(:acquisition_thread_on?) }
+
+      Then { bit(28).should be_the_mask_for(:control_watchdog_delayed?) }
+      Then { bit(29).should be_the_mask_for(:adc_watchdog_delayed?) }
+      Then { bit(30).should be_the_mask_for(:com_watchdog_problem?) }
+      Then { bit(31).should be_the_mask_for(:emergency_landing?) }
+    end
+
+    describe "state mask" do
+      context "all zeros" do
+        Given(:state_bits) { 0 }
+        Then { nav_data.state_mask == state_bits }
+      end
+
+      context "non-zero" do
+        Given(:state_bits) { 12345 }
+        Then { nav_data.state_mask == state_bits }
+      end
+    end
+
+    describe "#options" do
+      Then { nav_data.options.size == 1 }
+      Then { nav_data.options.first.is_a?(NavOptionChecksum) }
+    end
+  end
+
+  describe "multiple options" do
+    context "with good data" do
+      Given(:raw_header) { Bytes.make_header(0, 0, 0) }
+      Given(:raw_nav_bytes) {
+        Bytes.make_nav_data(raw_header, Bytes.make_demo_data)
+      }
+      When(:nav_data) { NavData.new(raw_nav_bytes) }
+      Then { nav_data.options.size == 2 }
+      Then { nav_data.options[0].is_a?(NavOptionDemo) }
+      Then { nav_data.options[1].is_a?(NavOptionChecksum) }
+    end
+
+    context "with short data" do
+      Given(:raw_nav_bytes) {
+        Bytes.make_header(0, 0, 0).pack("C*") +
+        [4321, 100, 0].pack("vvV")
+      }
+      When(:nav_data) { NavData.new(raw_nav_bytes) }
+      Then { nav_data.options.size == 1 }
+      Then { nav_data.options[0].is_a?(NavOptionUnknown) }
+    end
+  end
+
+end

data/spec/argus/nav_option_checksum_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+module Argus
+
+  describe NavOptionChecksum do
+    Given(:raw_data) { [NavTag::CHECKSUM, 8, 0x12345678].pack("vvV") }
+    Given(:csum) { NavOptionChecksum.new(raw_data) }
+
+    describe ".tag" do
+      Then { NavOptionChecksum.tag == NavTag::CHECKSUM }
+    end
+
+    describe "data fields" do
+      Then { csum.tag == NavOptionChecksum.tag }
+      Then { csum.size == raw_data.size }
+      Then { csum.chks == 0x12345678 }
+      Then { csum.checksum == 0x12345678 }
+    end
+  end
+
+end

data/spec/argus/nav_option_demo_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+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" +
+      "AAAAZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" +
+      "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0AAADWP3i/6kNxPniCg72IpXO+64R4" +
+      "v+kAAD2hLGG9u7U6PatYfz8AAAAAAAAAAAAAdcMQAEgBAAAAAAAAAAAAAAAA" +
+      "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" +
+      "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" +
+      "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" +
+      "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" +
+      "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" +
+      "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" +
+      "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//8I" +
+      "ANQdAAA="
+    }
+    Given(:raw_data) { Base64.decode64(base64_data) }
+    Given(:nav_data) { NavData.new(raw_data) }
+
+    When(:demo) { nav_data.options.first }
+
+    Then { ! demo.nil? }
+    Then { demo.tag == Argus::NavTag::DEMO }
+    Then { demo.size == 148 }
+
+    Then { demo.ctrl_state == 0x20000 }
+    Then { demo.control_state_name == :default }
+    Then { demo.vbat_flying_percentage == 60 }
+    Then { demo.battery_level == 60 }
+    Then { demo.theta == 3151.0 }
+    Then { demo.phi == 2616.0 }
+    Then { demo.psi == -166213.0 }
+    Then { demo.pitch == 3.151 }
+    Then { demo.roll == 2.616 }
+    Then { demo.yaw == -166.213 }
+    Then { demo.altitude == 0 }
+    Then { demo.vx == about(0).delta(0.00000001) }
+    Then { demo.vy == about(0).delta(0.00000001) }
+    Then { demo.vz == about(0).delta(0.00000001) }
+    Then { demo.detection_camera_rot }
+    Then { demo.detection_camera_trans }
+    Then { demo.detection_tag_index == 0 }
+    Then { demo.detection_camera_type == 13 }
+    Then { demo.drone_camera_rot }
+    Then { demo.drone_camera_trans }
+  end
+
+end

data/spec/argus/nav_option_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+module Argus
+  describe NavOption do
+    let(:raw_checksum)      { [ NavTag::CHECKSUM, 8, 0x5555aaaa].pack("vvV") }
+    let(:raw_demo)          { [ NavTag::DEMO, 148 ].pack("vv") + "\0" * 148 }
+    let(:raw_vision_detect) { [ NavTag::VISION_DETECT, 328 ].pack("vv") + "\0" * 328 }
+    let(:raw_unknown_tag)   { [ 12345, 8 ].pack("vv") + "    " }
+
+    When(:result) { NavOption.parse(raw_data) }
+
+    describe "parsing checksum options" do
+      Given(:raw_data) { raw_checksum }
+      Then { result.is_a?(NavOptionChecksum) }
+    end
+
+    describe "parsing demo option" do
+      Given(:raw_data) { raw_demo }
+      Then { result.is_a?(NavOptionDemo) }
+    end
+
+    describe "parsing vision detect option" do
+      Given(:raw_data) { raw_vision_detect }
+      Then { result.is_a?(NavOptionVisionDetect) }
+    end
+
+    describe "parsing bad tag" do
+      Given(:raw_data) { raw_unknown_tag }
+      Then { result.is_a?(NavOptionUnknown) }
+    end
+  end
+end

data/spec/argus/nav_option_unknown_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+module Argus
+
+  describe NavOptionUnknown do
+    Given(:raw_data) { [0x5231, 8, 0x12345678].pack("vvV") }
+    Given(:opt) { NavOptionUnknown.new(raw_data) }
+
+    describe ".tag" do
+      Then { NavOptionUnknown.tag == 0xfffe }
+    end
+
+    describe "data fields" do
+      Then { opt.tag == 0x5231 }
+      Then { opt.size == raw_data.size }
+    end
+  end
+
+end

data/spec/argus/nav_option_vision_detect_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+module Argus
+
+  describe NavOptionVisionDetect do
+    def f(float)
+      FloatEncoding.encode_float(float)
+    end
+
+    Given(:raw_data) {
+      [
+        NavTag::VISION_DETECT, 328,
+        2,
+        1, 2, 3, 4,
+        10, 11, 12, 13,
+        20, 21, 22, 23,
+        30, 31, 32, 33,
+        40, 41, 42, 43,
+        50, 51, 52, 53,
+        f(60.0), f(61.0), f(62.0), f(63.0),
+        0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,
+        0,0,0, 0,0,0, 0,0,0, 0,0,0,
+        70, 71, 72, 73
+      ].flatten.pack("vv V V4 V4 V4 V4 V4 V4 V4 V36 V12 V4")
+    }
+
+    When(:detect) { NavOptionVisionDetect.new(raw_data) }
+
+    Then { NavOptionVisionDetect.tag == NavTag::VISION_DETECT }
+    Then { detect.tag == Argus::NavTag::VISION_DETECT }
+    Then { detect.size == 328 }
+
+    describe "C fields" do
+      Then { detect.nb_detected == 2 }
+      Then { detect.type == [1, 2, 3, 4] }
+      Then { detect.type_name == [:vertical, :vision, :none, :cocarde] }
+      Then { detect.xc == [10, 11, 12, 13] }
+      Then { detect.yc == [20, 21, 22, 23] }
+      Then { detect.width == [30, 31, 32, 33] }
+      Then { detect.height == [40, 41, 42, 43] }
+      Then { detect.dist == [50, 51, 52, 53] }
+      Then { detect.distance == [50, 51, 52, 53] }
+      Then { detect.orientation_angle == [60.0, 61.0, 62.0, 63.0] }
+      Then { detect.rotation.size == 9 * 4 }
+      Then { detect.translation.size == 3 * 4 }
+      Then { detect.camera_source == [70, 71, 72, 73] }
+    end
+
+    describe "detection info" do
+      Then { detect.detections.size == 2 }
+
+      let(:d0) { detect.detections[0] }
+      Then { d0.type == 1 }
+      Then { d0.type_name == :vertical }
+      Then { d0.x == 10 }
+      Then { d0.y == 20 }
+      Then { d0.width == 30 }
+      Then { d0.height == 40 }
+      Then { d0.orientation_angle == 60.0 }
+      Then { d0.camera_source == 70 }
+    end
+
+  end
+
+end

data/spec/argus/nav_streamer_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+module Argus
+  describe NavStreamer do
+    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, UDPSocket: flexmock(new: socket)) }
+
+    context "after starting" do
+      Given { streamer.start }
+
+      context "when receiving good data" do
+        Given(:bytes) { Bytes.make_nav_data(Bytes.make_header(0x1234, 0, 0)) }
+        Given { socket.should_receive(recvfrom: bytes) }
+        When(:nav_data) { streamer.receive_data }
+        Then { nav_data.state_mask == 0x1234}
+      end
+
+      context "when receiving bad data" do
+        Given(:bytes) { [0x89, 0x77, 0x66, 0x55, 0x34, 0x12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0].pack("C*") }
+        Given { socket.should_receive(:recvfrom => bytes) }
+        When(:nav_data) { streamer.receive_data }
+        Then { nav_data.nil? }
+      end
+    end
+
+    describe "State Transitions" do
+      Given {
+        flexmock(streamer, reconnect: nil, request_nav_data: nil)
+      }
+
+      def goto_wait
+        streamer.start
+      end
+
+      def goto_run
+        streamer.start
+        streamer.received_data
+      end
+
+      context "when init & start" do
+        Given { streamer.start }
+        Then { streamer.should have_received(:reconnect).once }
+        Then { streamer.state == :wait }
+      end
+
+      context "when init & short_timeout" do
+        Given { streamer.short_timeout }
+        Then { streamer.should have_received(:reconnect).never }
+        Then { streamer.should have_received(:request_nav_data).never }
+        Then { streamer.state == :init }
+      end
+
+      context "when init & long_timeout" do
+        Given { streamer.long_timeout }
+        Then { streamer.should have_received(:reconnect).never }
+        Then { streamer.should have_received(:request_nav_data).never }
+        Then { streamer.state == :init }
+      end
+
+      context "when wait & received_data" do
+        Given { goto_wait }
+        Given { streamer.received_data }
+        Then { streamer.should have_received(:reconnect).once }
+        Then { streamer.should have_received(:request_nav_data).never }
+        Then { streamer.state == :run }
+      end
+
+      context "when wait & short_timeout" do
+        Given { goto_wait }
+        Given { streamer.short_timeout }
+        Then { streamer.should have_received(:reconnect).once }
+        Then { streamer.should have_received(:request_nav_data).once }
+        Then { streamer.state == :wait }
+      end
+
+      context "when wait & long_timeout" do
+        Given { goto_wait }
+        Given { streamer.long_timeout }
+        Then { streamer.should have_received(:reconnect).twice }
+        Then { streamer.should have_received(:request_nav_data).never }
+        Then { streamer.state == :wait }
+      end
+
+      context "when run & received_data" do
+        Given { goto_run }
+        Given { streamer.received_data }
+        Then { streamer.should have_received(:reconnect).once }
+        Then { streamer.should have_received(:request_nav_data).never }
+        Then { streamer.state == :run }
+      end
+
+      context "when run & short_timeout" do
+        Given { goto_run }
+        Given { streamer.short_timeout }
+        Then { streamer.should have_received(:reconnect).once }
+        Then { streamer.should have_received(:request_nav_data).never }
+        Then { streamer.state == :run }
+      end
+
+      context "when run & long_timeout" do
+        Given { goto_run }
+        Given { streamer.long_timeout }
+        Then { streamer.should have_received(:reconnect).twice }
+        Then { streamer.should have_received(:request_nav_data).never }
+        Then { streamer.state == :wait }
+      end
+    end
+  end
+end