argus 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2f89d5eb3a36569a8fb2d9e6c17a2eebd17e92d8
-  data.tar.gz: ec1b2d028705b04ae55f8eeaa5dfb91c4352347f
+  metadata.gz: a5bfdb6916c2a3d0cd8dc924b5633e2de3bdbdff
+  data.tar.gz: 77c42e8e23f91fa3be7aea5c59b3521ff6e5b9bb
 SHA512:
-  metadata.gz: 80bde0b4804b76b9be1d79d8c3c2537767a1fc35027bf52811d1324fc4a407d645412ab441675049e2dcf9bdaac14382c5f39fb2520f71e9469dbb4dafe533e9
-  data.tar.gz: 330df98c125cfb917f81da99d26dcdc9b25a506e5ffe57ad0c55bc6aad08d035bc2fa6050a377be3f02fe1df58b0d3a1f6e8d587883c5e5753aaba56165244e2
+  metadata.gz: f0a9cefb0fcac10f6295cfc990e9bbaed5c419b19a7ec88c4171bff272628e53753db0af6e456c4bf28b29657d3d38302b04557dc6f14ba65202e34519dd25bb
+  data.tar.gz: fc58f050f88a77cc0a15cc83f77cad71b1e7610b8ac58f9f679ca956399c96cdf7a02fadf089ad02c5f27b6c93018d2f3f373bb245be6072fb8503b38f86b658

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

data/lib/argus/controller.rb

@@ -107,22 +107,24 @@ 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.comwdg
+      self
     end
 
     def ack_control_mode

data/lib/argus/drone.rb

@@ -7,13 +7,15 @@ module Argus
     attr_reader :controller, :nav
 
     def initialize(opts={})
-      @host = opts[:remote_host] || '192.168.1.1'
+      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 = Argus::ATCommander.new(@sender)
-      @controller = Argus::Controller.new(@at)
-      if opts.fetch(:enable_nav_monitor, true)
-        @nav = NavMonitor.new(@controller, @host)
+      @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

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,6 +59,8 @@ module Argus
       $stdout.flush
     end
 
+    private
+
     def update_internal_nav_data(data)
       @nav_data = data
       if @nav_data.bootstrap?

data/lib/argus/nav_streamer.rb

@@ -26,7 +26,7 @@ module Argus
       @local_host   = opts[:local_host]  || '0.0.0.0'
       @port         = opts[:port]        || 5554
       @socket_class = opts[:UDPSocket]   || UDPSocket
-      start_timer
+      start_timer unless opts[:disable_timer]
     end
 
     def start

data/lib/argus/version.rb

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

data/lib/argus/video_data.rb

@@ -0,0 +1,15 @@
+module Argus
+  class VideoData
+    attr_reader :socket, :envelope, :frame
+
+    def initialize(socket)
+      @socket = socket
+      @envelope = VideoDataEnvelope.new(@socket)
+      @frame = parse_frame
+    end
+
+    def parse_frame
+      socket.read(envelope.payload_size) if envelope
+    end
+  end
+end

data/lib/argus/video_data_envelope.rb

@@ -0,0 +1,55 @@
+module Argus
+  class VideoDataEnvelope
+    attr_reader :socket
+
+    def initialize(socket)
+      @socket = socket
+      parse
+    end
+
+    def parse
+      data(:signature, 4, "A*")
+      data(:version, 1, "C")
+      data(:video_codec, 1, "C")
+      data(:header_size, 2, "v")
+      data(:payload_size, 4, "V")
+      data(:encoded_stream_width, 2, "v")
+      data(:encoded_stream_height, 2, "v")
+      data(:display_width, 2, "v")
+      data(:display_height, 2, "v")
+      data(:frame_number, 4, "V")
+      data(:timestamp, 4, "V")
+      data(:total_chunks, 1, "C")
+      data(:chunk_index, 1, "C")
+      data(:frame_type, 1, "C")
+      data(:control, 1, "C")
+      data(:stream_byte_position_lw, 4, "V")
+      data(:stream_byte_position_uw, 4, "V")
+      data(:stream_id, 2, "v")
+      data(:total_slices, 1, "C")
+      data(:slice_index, 1, "C")
+      data(:header1_size, 1, "C")
+      data(:header2_size, 1, "C")
+      data(:reserved_2, 2, "H*")
+      data(:advertised_size, 4, "V")
+      data(:reserved_12, 12, "H*")
+      socket.read(4) # TODO: look at why just throwing this data away
+    end
+
+    def data(name, size, format)
+      define_data(name, get_data(size, format))
+    end
+
+    def get_data(size, format)
+      socket.read(size).unpack(format).first
+    end
+
+    def define_data(name, value)
+      ivar = "@#{name}".to_sym    
+      instance_variable_set(ivar, value)
+      self.class.send(:define_method, name) do
+        instance_variable_get(ivar)
+      end
+    end
+  end
+end

data/lib/argus/video_streamer.rb

@@ -0,0 +1,23 @@
+require 'socket'
+
+module Argus
+  class VideoStreamer
+    attr_reader :tcp_socket, :host, :port
+    
+    def initialize(opts={})
+      @host = opts[:host] || '192.168.1.1'
+      @port = opts[:port] || 5555
+      @tcp_socket = opts[:socket] || TCPSocket.new(@host, @port)
+    end
+
+    def start(udp_socket=nil)
+      @udp_socket = udp_socket || UDPSocket.new
+      @udp_socket.send("\x01\x00\x00\x00", 0, host, port)
+      @udp_socket.close
+    end
+
+    def receive_data
+      VideoData.new(tcp_socket)
+    end
+  end
+end

data/spec/argus/at_commander_spec.rb

@@ -77,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,135 +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)) }
+    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 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 "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
-
-    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) }
-    end
-  end
-
-  describe "ack controll command" do
-    Invariant { result.should == controller }
-    When(:result) { controller.ack_control_mode }
-    Then { at.should have_received(:ctrl).with(5) }
   end
 end

data/spec/argus/drone_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+require 'argus'
+
+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)
+    }
+
+  Then { drone.commander == commander }
+
+  context "when starting the drone" do
+    When { drone.start }
+    Then { commander.should have_received(:start).once }
+    Then { nav_monitor.should have_received(:start).once }
+
+    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 "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
+
+  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/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" +

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, UDPSocket: 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/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
+
+    # TODO: handle invalid envelope
+  end
+end

data/spec/argus/video_data_spec.rb

@@ -0,0 +1,17 @@
+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
+
+    # TODO: handle invalid envelope
+    # TODO: handle valid envelope but invalid frame
+  end
+end

data/spec/argus/video_streamer_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+module Argus
+  describe VideoStreamer do
+    Given(:tcp_socket) { flexmock("TCPSocket", send: nil).should_ignore_missing }
+    Given(:streamer) { VideoStreamer.new(socket: 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
+
+    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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: argus
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Jim Weirich
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-03 00:00:00.000000000 Z
+date: 2013-09-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec-given
@@ -58,17 +58,21 @@ files:
 - lib/argus/nav_streamer.rb
 - lib/argus/nav_tag.rb
 - lib/argus/null_nav_monitor.rb
-- lib/argus/pave_parser.rb
-- lib/argus/tcp_video_streamer.rb
 - lib/argus/time_queue.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/cfields_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_monitor_spec.rb
 - spec/argus/nav_option_checksum_spec.rb
 - spec/argus/nav_option_demo_spec.rb
 - spec/argus/nav_option_spec.rb
@@ -78,9 +82,13 @@ files:
 - 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
 - MIT-LICENSE
 homepage: http://github.com/jimweirich/argus
-licenses: []
+licenses:
+- MIT-LICENSE
 metadata: {}
 post_install_message: 
 rdoc_options:

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(opts={})
-      @host = opts.fetch(:remote_host)
-      @port = opts.fetch(:port, 5555)
-      @tcp_socket = TCPSocket.new(@host, @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