hybridgroup-argus 0.2.0 → 0.3.0

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 == [nil, nil, nil, nil] }
+      Then { detect.translation == [nil, nil, nil, nil] }
+      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,28 @@
+require 'spec_helper'
+
+module Argus
+  describe NavStreamer do
+    Given(:socket) { flexmock("Socket", send: nil).should_ignore_missing }
+    Given(:streamer) { NavStreamer.new(socket) }
+
+    context "starting the stream" do
+      When { streamer.start }
+      Then { socket.should have_received(:bind).with(String, Object) }
+      Then { socket.should have_received(:send) }
+    end
+
+    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
+end

data/spec/argus/udp_sender_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 require 'socket'
 
 describe Argus::UdpSender do
-  Given(:port) { 5500 }
+  Given(:port) { '5500' }
   Given(:socket) { UDPSocket.new }
   Given(:sender) { Argus::UdpSender.new(socket, 'localhost', port) }
   Given!(:server) {

data/spec/argus/video_data_envelope_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+module Argus
+  describe VideoDataEnvelope do
+    Given(:unpacker) { flexmock("Unpacker", :unpack => values) }
+    Given(:socket) { flexmock("socket", :read => unpacker) }
+    Given(:video_data_envelope) { VideoDataEnvelope.new(socket) }
+
+    describe "version" do
+      When(:values) { flexmock("Values", :first => 3) }
+      Then { video_data_envelope.version == 3 }
+    end
+
+    describe "frame_number" do
+      When(:values) { flexmock("Values", :first => 42) }
+      Then { video_data_envelope.frame_number == 42 }
+    end
+
+    describe "payload_size" do
+      When(:values) { flexmock("Values", :first => 2048) }
+      Then { video_data_envelope.payload_size == 2048 }
+    end
+
+    pending "TODO: handle invalid envelope"
+  end
+end

data/spec/argus/video_data_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+module Argus
+  describe VideoData do
+    Given(:raw_header) { Bytes.make_video_envelope }
+    Given(:raw_video_bytes) { Bytes.make_video_data(raw_header) }
+    Given(:video_data) { VideoData.new(socket) }
+
+    describe "valid envelope" do
+      When(:socket) { StringIO.new(raw_header) }
+      Then {video_data.envelope.signature == "PaVE"}
+    end
+
+    pending "TODO: handle invalid envelope"
+    pending "TODO: handle valid envelope but invalid frame"
+    
+  end
+end

data/spec/argus/video_streamer_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+module Argus
+  describe VideoStreamer do
+    Given(:tcp_socket) { flexmock("TCPSocket", send: nil).should_ignore_missing }
+    Given(:streamer) { VideoStreamer.new(tcp_socket) }
+    Given(:udp_socket) { flexmock("UDPSocket", send: nil).should_ignore_missing }
+
+    describe "starting the stream" do
+      When { streamer.start(udp_socket) }
+      Then { udp_socket.should have_received(:send) }
+      Then { udp_socket.should have_received(:close) }
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -4,7 +4,10 @@ require 'rspec/given'
 require 'flexmock'
 
 require 'argus'
+require 'support/bytes'
 
 RSpec.configure do |config|
   config.mock_with :flexmock
 end
+
+RSpec::Given.use_natural_assertions

data/spec/support/bytes.rb

@@ -0,0 +1,48 @@
+module Bytes
+  module_function
+
+  def int16(n)
+    [n].pack("v").unpack("C*")
+  end
+
+  def int32(n)
+    [n].pack("V").unpack("C*")
+  end
+
+  def make_nav_data(*options)
+    result = options.flatten
+    add_checksum(result)
+    result.pack("C*")
+  end
+
+  def make_header(state_bits, seq_number, vision_flag)
+    Bytes.int32(0x55667788) +
+      Bytes.int32(state_bits) +
+      Bytes.int32(seq_number) +
+      Bytes.int32(vision_flag)
+  end
+
+  def make_demo_data
+    Bytes.int16(0) + Bytes.int16(148) + [0] * 144
+  end
+
+  def add_checksum(bytes)
+    [0xff, 0xff, 0x08, 0x00, 0x61, 0x04, 0x00, 0x00].each do |b| bytes << b end
+    bytes
+  end
+
+  def make_video_envelope
+    val = "PaVE".bytes.to_a +
+      Bytes.int16(0x01) +
+      Bytes.int16(0x02) +
+      Bytes.int32(0x68) +
+      [0] * 60
+    val.pack("C*")
+  end
+
+  def make_video_data(*options)
+    result = options.flatten
+    result << Bytes.make_demo_data
+    result
+  end
+end

metadata

@@ -1,8 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hybridgroup-argus
 version: !ruby/object:Gem::Version
-  version: 0.2.0
-  prerelease: 
+  version: 0.3.0
 platform: ruby
 authors:
 - Jim Weirich
@@ -11,12 +10,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-23 00:00:00.000000000 Z
+date: 2013-05-13 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
@@ -24,7 +22,6 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -44,22 +41,48 @@ files:
 - Rakefile
 - lib/argus.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/float_encoding.rb
+- lib/argus/led_animation.rb
 - lib/argus/nav_data.rb
+- lib/argus/nav_monitor.rb
+- lib/argus/nav_option.rb
+- lib/argus/nav_option_checksum.rb
+- lib/argus/nav_option_demo.rb
+- lib/argus/nav_option_unknown.rb
+- lib/argus/nav_option_vision_detect.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/nav_tag.rb
 - lib/argus/udp_sender.rb
 - lib/argus/version.rb
+- lib/argus/video_data.rb
+- lib/argus/video_data_envelope.rb
+- lib/argus/video_streamer.rb
 - spec/spec_helper.rb
 - spec/argus/at_commander_spec.rb
 - spec/argus/controller_spec.rb
+- spec/argus/drone_spec.rb
+- spec/argus/float_encoding_spec.rb
+- spec/argus/led_animation_spec.rb
+- spec/argus/nav_data_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/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
 - MIT-LICENSE
-homepage: http://github.com/hybridgroup/argus
+homepage: http://github.com/jimweirich/argus
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options:
 - --line-numbers
@@ -71,21 +94,19 @@ rdoc_options:
 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
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Ruby API for a Parrot AD Drone Quadcopter
 test_files: []

data/lib/argus/pave_parser.rb

@@ -1,39 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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