hybridgroup-argus 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 61222b712f9c3d858153e12e2a386aa03e8e06a1
-  data.tar.gz: a0c4785df6cde5776eb45c997382b96f5de4e656
+  metadata.gz: 43c7894a41a1033f29b7da584853f6652165ed9c
+  data.tar.gz: 1d8496bc4cb2f4139d62b1e63ddbde9389f9be46
 SHA512:
-  metadata.gz: 7f306362aafe950603de3dba9d6efefbaa834a23b4fa27c6e655f85d146b702b115543665dc6d7ea1c273ace9cadbc5a4aec7f68fe3280a763ddbf2c3580d29d
-  data.tar.gz: 028aa4c216e1ebec8a6756635b54221ba87f6bfa6c6d34fb9d0f9ebd8226e464911048d2b9c954dbbb7d84cd46f19cbc138f163b76a9fdec3c480e20ea68e8c0
+  metadata.gz: 3ad023f7f146c1dcd8457734fdeb532f3462439bf24fb1da9872732c05c27d505be576bdd88e0204e5ffac9cdc154e237bda84278fadce24db96d8f4f48496a1
+  data.tar.gz: f162db2640775556506541e8ca6485a337b55d354bd2edd3705be92120d899830839a19492be7344c764497c94c54a3a03c35e8076927612f346cdfad5aa95a2

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2012 Jim Weirich
+Copyright (c) 2012, 2013 Jim Weirich
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -9,7 +9,7 @@
 
 ## Example
 
-<pre>
+```ruby
   require 'argus'
 
   drone = Argus::Drone.new
@@ -24,4 +24,30 @@
   drone.hover.land
   sleep 5
   drone.stop
-</pre>
+```
+
+## Using with external socket
+
+You can also use Argus by providing an externally created socket. For example, if you are using Artoo (http://artoo.io), which makes use of celluloid-io (https://github.com/celluloid/celluloid-io). Normally in this use case, you would want to NOT use the automatic navigation callbacks, as they are not guaranteed to be thread safe within Celluloid.
+
+```ruby
+  require 'argus'
+  require 'celluloid/io'
+
+  include Celluloid::IO
+
+  socket = UDPSocket.new
+  drone = Argus::Drone.new(socket: socket)
+  drone.start(false) # do not auto-notify on nav callbacks
+
+  drone.take_off
+  sleep 5
+  drone.turn_right(1.0)
+  sleep 5
+  drone.turn_left(1.0)
+  sleep 5
+  drone.hover.land
+  sleep 5
+  drone.stop
+```
+

data/Rakefile

@@ -7,3 +7,7 @@ task :default => :specs
 task :specs do
   sh "rspec spec"
 end
+
+task :land do
+  ruby "-Ilib examples/land.rb"
+end

data/lib/argus/cfields.rb

@@ -3,8 +3,6 @@ require 'argus/float_encoding'
 module Argus
 
   module CFields
-    include FloatEncoding
-
     def self.included(base)
       base.send :extend, ClassMethods
     end
@@ -44,29 +42,13 @@ module Argus
       def define_scaler_field(name, format, width, transform)
         index = allot(width)
         format_string << (width==1 ? format : "#{format}#{width}")
-        if transform
-          ivar = "@#{name}".to_sym
-          define_method(name) {
-            instance_variable_get(ivar) ||
-              instance_variable_set(ivar, transform.call(@data[index]))
-          }
-        else
-          define_method(name) { @data[index] }
-        end
+        define_method(name) { @data[index] }
       end
 
       def define_array_field(name, size, format, width, transform)
         index = allot(width*size)
         format_string << "#{format}#{width*size}"
-        if transform
-          ivar = "@#{name}".to_sym
-          define_method(name) {
-            instance_variable_get(ivar) ||
-              instance_variable_set(ivar, @data[index, size].map(&transform))
-          }
-        else
-          define_method(name) { @data[index, size] }
-        end
+        define_method(name) { @data[index, width*size] }
       end
 
       def uint32_t(name, size=nil)
@@ -78,7 +60,7 @@ module Argus
       end
 
       def float32_t(name, size=nil)
-        define_field(name, size, "V") { |v| FloatEncoding.decode_float(v) }
+        define_field(name, size, "e")
       end
 
       def int32_t(name, size=nil)
@@ -86,11 +68,11 @@ module Argus
       end
 
       def matrix33_t(name, size=nil)
-        define_field(name, size, "V", 9) { |v| nil }
+        define_field(name, size, "V", 9)
       end
 
       def vector31_t(name, size=nil)
-        define_field(name, size, "V", 3) { |v| nil }
+        define_field(name, size, "V", 3)
       end
     end
   end

data/lib/argus/drone.rb

@@ -6,9 +6,11 @@ module Argus
   class Drone
     attr_reader :controller, :enable_nav_monitor
 
-    def initialize(socket=nil, host='192.168.1.1', port='5556')
-      @socket = socket || UDPSocket.new
-      @sender = Argus::UdpSender.new(@socket, host, port)
+    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)
       
@@ -23,7 +25,7 @@ module Argus
       @enable_nav_monitor = enable_nav_monitor
       
       if enable_nav_monitor
-        @nav = NavMonitor.new(@controller)
+        @nav = NavMonitor.new(@controller, @host)
         @nav.start
       end
 
@@ -52,6 +54,7 @@ module Argus
        turn_left turn_right
        front_camera bottom_camera
        config
+       led
        reset_watchdog
     ).each do |meth|
       define_method(meth) { |*args|

data/lib/argus/nav_monitor.rb

@@ -1,9 +1,11 @@
 module Argus
 
   class NavMonitor
-    def initialize(controller)
+    attr_reader :streamer
+
+    def initialize(controller, remote_host)
       @controller = controller
-      @nav = NavStreamer.new
+      @streamer = NavStreamer.new(remote_host: remote_host)
       @callbacks = []
       @mutex = Mutex.new
       @nav_data = nil
@@ -11,11 +13,11 @@ module Argus
     end
 
     def start
-      @nav.start
+      @streamer.start
       @running = true
       @nav_thread = Thread.new do
         while @running
-          data = @nav.receive_data
+          data = @streamer.receive_data
           update_nav_data(data) if data
         end
       end

data/lib/argus/nav_option_demo.rb

@@ -54,7 +54,7 @@ module Argus
     ]
 
     def control_state_name
-      CONTROL_STATE_NAMES[ctrl_state]
+      CONTROL_STATE_NAMES[ctrl_state & 0x0f]
     end
 
     def pitch

data/lib/argus/nav_streamer.rb

@@ -1,26 +1,111 @@
 require 'socket'
 
 module Argus
+
+  # NavStreamer State Transitions:
+  #
+  # State    Trigger         Next  Action
+  # ------   --------------  ----  -----------------
+  # init     start           wait  reconnect
+  #
+  # wait     short_timeout   wait  request_nav_data
+  # wait     long_timeout    wait  reconnect
+  # wait     received_data   run   --
+  #
+  # run      short_timeout   run   --
+  # run      long_timeout    wait  reconnect
+  # run      received_data   run   --
+
   class NavStreamer
-    def initialize(socket=nil, host='192.168.1.1', port='5554')
-      # TODO: Why is the port a string?
-      @socket = socket || UDPSocket.new
-      @host = host
-      @port = port
-      @socket.bind("0.0.0.0", port)
+    attr_reader :state
+
+    def initialize(opts={})
+      @state = :init
+      @socket = nil
+      @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
     end
 
     def start
-      @socket.send("\x01\x00\x00\x00", 0, @host, @port)
+      @state = :wait
+      reconnect
+    end
+
+    def short_timeout
+      if state == :wait
+        request_nav_data
+      end
+    end
+
+    def long_timeout
+      if @state == :wait || @state == :run
+        @state = :wait
+        reconnect
+      end
     end
 
     def receive_data
-      data, from = @socket.recvfrom(1024)
+     data, from = @socket.recvfrom(1024)
       if data.unpack("V").first == 0x55667788
-        NavData.new(data)
+        received_data
+        nav_data = NavData.new(data)
       else
         nil
       end
     end
+
+    def received_data
+      if state == :wait || state == :run
+        @state = :run
+        @long_flag = false
+        @short_flag = false
+      end
+    end
+
+    private
+
+    def request_nav_data
+      @socket.send("\x01\x00\x00\x00", 0, @remote_host, @port)
+    end
+
+    def reconnect
+      disconnect if @socket
+      @socket = new_socket
+      @socket.bind(@local_host, @port) rescue nil
+      request_nav_data
+    end
+
+    def disconnect
+      @socket.close
+      @socket = nil
+    end
+
+    def new_socket
+      @socket_class.new
+    end
+
+    def tick
+      short_timeout if @short_flag
+      @short_flag = true
+      if @n == 0
+        long_timeout if @long_flag
+        @long_flag = true
+      end
+      @n += 1
+      @n = 0 if @n == 10
+    end
+
+    def start_timer
+      @n = 0
+      @thread = Thread.new do
+        loop do
+          tick
+          sleep 1.0
+        end
+      end
+    end
   end
 end

data/lib/argus/time_queue.rb

@@ -0,0 +1,62 @@
+class TimeQueue
+  Item = Struct.new(:time, :value) do
+    def <=>(other)
+      time <=> other.time
+    end
+
+    def key
+      object_id
+    end
+
+    def to_s(basetime=nil)
+      if basetime
+        "#{value.inspect}@+#{time-basetime}"
+      else
+        "#{value.inspect}@#{time.strftime('%H:%M:%S.%L')}"
+      end
+    end
+  end
+
+  def initialize
+    @items = []
+  end
+
+  def add(time, value)
+    item = Item.new(time, value)
+    @items << item
+    @items.sort!
+    item.key
+  end
+
+  def remove(key)
+    @items.delete_if { |item| item.key == key }
+  end
+
+  def any_ready?(time)
+    ! @items.empty? && @items.first.time <= time
+  end
+
+  def all_ready(time)
+    result = []
+    each_ready(time) do |value| result << value end
+    result
+  end
+
+  def each_ready(time)
+    while any_ready?(time)
+      item = @items.shift
+      yield item.value
+    end
+  end
+
+  def to_s
+    base_time = nil
+    strings = @items[0,3].map { |item|
+      string = item.to_s(base_time)
+      base_time ||= item.time
+      string
+    }
+    strings << "..." if @items.size > 3
+    "[#{strings.join(', ')}]"
+  end
+end

data/lib/argus/udp_sender.rb

@@ -1,9 +1,9 @@
 module Argus
   class UdpSender
-    def initialize(udp_socket, host=nil, port=nil)
-      @udp_socket = udp_socket
-      @host = host || '192.168.1.1'
-      @port = port || 5556
+    def initialize(opts={})
+      @udp_socket = opts.fetch(:socket)
+      @host = opts.fetch(:remote_host)
+      @port = opts.fetch(:port, 5556)
     end
 
     def send_packet(data)

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_streamer.rb

@@ -4,10 +4,10 @@ module Argus
   class VideoStreamer
     attr_reader :tcp_socket, :host, :port
     
-    def initialize(tcp_socket=nil, host='192.168.1.1', port=5555)
-      @tcp_socket = tcp_socket || TCPSocket.new(host, port)
-      @host = host
-      @port = 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)

data/spec/argus/drone_spec.rb

@@ -4,7 +4,7 @@ module Argus
   describe Drone do
 
     Given(:socket) { flexmock("Socket", send: nil).should_ignore_missing }
-    Given(:drone) { Drone.new(socket) }
+    Given(:drone) { Drone.new(socket: socket) }
 
     describe "default navigation monitor enabled" do
       Then { drone.enable_nav_monitor == false }

data/spec/argus/nav_option_demo_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require 'base64'
 
 module Argus
   describe NavOptionDemo do
@@ -6,39 +7,49 @@ module Argus
       FloatEncoding.encode_float(float)
     end
 
-    Given(:raw_data) { [
-        NavTag::DEMO, 148,
-        3, 0xcacacaca,
-        f(5.0), f(6.0), f(7.0),
-        -100000,
-        f(-5.0), f(-6.0), f(-7.0),
-        33,
-        [0]*9, [0]*3,
-        12, 34,
-        [0]*9, [0]*3,
-      ].flatten.pack("vv VV V3 l< V3 V V9 V3 VV V9 v3") }
+    # 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) { NavOptionDemo.new(raw_data) }
+    When(:demo) { nav_data.options.first }
 
     Then { ! demo.nil? }
+    Then { demo.tag == 0 }
 
-    Then { demo.ctrl_state == 3 }
-    Then { demo.control_state_name == :flying }
-    Then { demo.vbat_flying_percentage == 0xcacacaca }
-    Then { demo.battery_level == 0xcacacaca }
-    Then { demo.theta == 5.0 }
-    Then { demo.phi == 6.0 }
-    Then { demo.psi == 7.0 }
-    Then { demo.altitude == -100000 }
-    Then { demo.vx == -5.0 }
-    Then { demo.vy == -6.0 }
-    Then { demo.vz == -7.0 }
-    Then { demo.detection_camera_rot.nil? }
-    Then { demo.detection_camera_trans.nil? }
-    Then { demo.detection_tag_index == 12 }
-    Then { demo.detection_camera_type == 34 }
-    Then { demo.drone_camera_rot.nil? }
-    Then { demo.drone_camera_trans.nil? }
+    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_vision_detect_spec.rb

@@ -41,8 +41,8 @@ module Argus
       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.rotation.size == 9 * 4 }
+      Then { detect.translation.size == 3 * 4 }
       Then { detect.camera_source == [70, 71, 72, 73] }
     end
 

data/spec/argus/nav_streamer_spec.rb

@@ -2,27 +2,110 @@ 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(socket) }
+    Given(:streamer) { NavStreamer.new(remote_host: remote_host, socket: flexmock(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 "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 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}
+      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
 
-    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? }
+    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

data/spec/argus/time_queue_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+require 'time'
+
+describe TimeQueue do
+  Given(:time) { Time.now }
+  Given(:tq) { TimeQueue.new }
+
+  context "with an empty queue" do
+    Then { ! tq.any_ready?(time+100) }
+  end
+
+  context "with several items" do
+    Given {
+      tq.add(time, :zero)
+      tq.add(time+2, :two)
+      tq.add(time+1, :one)
+    }
+    Then { ! tq.any_ready?(time-1) }
+    Then { tq.any_ready?(time) }
+
+    Then { tq.all_ready(time-1) == [] }
+    Then { tq.all_ready(time  ) == [:zero] }
+    Then { tq.all_ready(time+1) == [:zero, :one] }
+    Then { tq.all_ready(time+2) == [:zero, :one, :two] }
+  end
+
+  describe "#to_s" do
+    Given(:time) { Time.parse("12:00:00") }
+    Given(:items) { [ ] }
+    Given {
+      items.each.with_index do |item, i| tq.add(time+i, item) end
+    }
+
+    context "with no items" do
+      Then { tq.to_s == "[]" }
+    end
+
+    context "with one item" do
+      Given(:items) { [ :zero ] }
+      Then { tq.to_s == "[:zero@12:00:00.000]" }
+    end
+
+    context "with four items" do
+      Given(:items) { [ :zero, :one, :two, :three ] }
+      Then { tq.to_s == "[:zero@12:00:00.000, :one@+1.0, :two@+2.0, ...]" }
+    end
+  end
+
+  describe "removing items" do
+    Given {
+      tq.add(time, :zero)
+      tq.add(time+2, :two)
+    }
+    Given!(:onekey) { tq.add(time+1, :one) }
+
+    When { tq.remove(onekey) }
+    let(:result) { tq.all_ready(time+100) }
+
+    Then { result == [:zero, :two] }
+  end
+end

data/spec/argus/udp_sender_spec.rb

@@ -4,7 +4,7 @@ require 'socket'
 describe Argus::UdpSender do
   Given(:port) { '5500' }
   Given(:socket) { UDPSocket.new }
-  Given(:sender) { Argus::UdpSender.new(socket, 'localhost', port) }
+  Given(:sender) { Argus::UdpSender.new(socket: socket, remote_host: 'localhost', port: port) }
   Given!(:server) {
     server = UDPSocket.new
     server.bind(nil, port)

data/spec/argus/video_streamer_spec.rb

@@ -3,7 +3,7 @@ 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(:streamer) { VideoStreamer.new(socket: tcp_socket) }
     Given(:udp_socket) { flexmock("UDPSocket", send: nil).should_ignore_missing }
 
     describe "starting the stream" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hybridgroup-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-05-13 00:00:00.000000000 Z
+date: 2013-08-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec-given
@@ -56,6 +56,7 @@ files:
 - lib/argus/nav_option_vision_detect.rb
 - lib/argus/nav_streamer.rb
 - lib/argus/nav_tag.rb
+- lib/argus/time_queue.rb
 - lib/argus/udp_sender.rb
 - lib/argus/version.rb
 - lib/argus/video_data.rb
@@ -74,6 +75,7 @@ files:
 - spec/argus/nav_option_unknown_spec.rb
 - spec/argus/nav_option_vision_detect_spec.rb
 - spec/argus/nav_streamer_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