crubyflie 0.1.0

data/spec/radio_ack_spec.rb

@@ -0,0 +1,43 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2013 Hector Sanjuan
+
+# This file is part of Crubyflie.
+
+# Crubyflie is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# Crubyflie is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with Crubyflie.  If not, see <http://www.gnu.org/licenses/>
+
+require 'crazyradio/radio_ack'
+
+describe RadioAck do
+    describe "#initialize" do
+        it "should initialize a RadioAck" do
+            rack = RadioAck.new(true, 1, 5, [1,2,3])
+            rack.ack.should == true
+            rack.powerDet.should == 1
+            rack.retry_count.should == 5
+            rack.data.should == [1,2,3]
+        end
+    end
+    describe "#from_raw" do
+        it "should create a radio ack from raw USB data" do
+            header = 0b11110101 # ack = 1, powerDet = 0, retry_c = 1111
+            data = [0xFF] * 31
+            packet = [header].concat(data)
+            rack = RadioAck.from_raw(packet.pack('C*'))
+            rack.ack.should == true
+            rack.powerDet.should == false
+            rack.retry_count.should == 15
+            rack.data == data
+        end
+    end
+end

data/spec/radio_driver_spec.rb

@@ -0,0 +1,227 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2013 Hector Sanjuan
+
+# This file is part of Crubyflie.
+
+# Crubyflie is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# Crubyflie is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with Crubyflie.  If not, see <http://www.gnu.org/licenses/>
+
+require 'driver/radio_driver'
+
+describe RadioDriver do
+    before :each do
+        @radiodriver = RadioDriver.new()
+        @link_error_cb = Proc.new {|m| m}
+        @link_quality_cb = Proc.new {|m| m}
+        @connect_params = ['radio://0/2/1M',{
+                               :link_quality_cb => @link_quality_cb,
+                               :link_error_cb   => @link_error_cb
+                           }]
+        @crazyradio = double("Crazyradio")
+        allow(@crazyradio).to receive(:close)
+        @ack = RadioAck.new(true, true, 3, [1,2,3])
+        allow(@crazyradio).to receive(:send_packet).and_return(@ack)
+        allow(Crazyradio).to receive(:new).and_return(@crazyradio)
+        allow(Crazyradio).to receive(:factory).and_return(@crazyradio)
+
+    end
+
+    describe "#initialize" do
+        it "should intialize the radio driver" do
+            rd = RadioDriver.new()
+            rd.should be_an_instance_of RadioDriver
+            rd.uri.should be_nil
+        end
+    end
+
+    describe "#connect" do
+        it "should connect" do
+            expect(@radiodriver).to receive(:start_radio_thread)
+
+            @radiodriver.connect(*@connect_params)
+
+            expected_retries = RadioDriver::RETRIES_BEFORE_DISCONNECT
+            expected_queue_size = RadioDriver::OUT_QUEUE_MAX_SIZE
+            @radiodriver.retries_before_disconnect.should == expected_retries
+            @radiodriver.out_queue_max_size.should == expected_queue_size
+            @radiodriver.disconnect()
+        end
+
+
+        it "should raise an exception if the link is active" do
+            @radiodriver.connect(*@connect_params)
+            mesg = "Active link to radio://0/2/1M. Disconnect first"
+            expect {
+                @radiodriver.connect('radio://1/2/2M')
+            }.to raise_exception(OpenLink, mesg)
+            @radiodriver.disconnect()
+        end
+
+        it "should raise an exception a callback is missing" do
+            expect {
+                @radiodriver.connect('radio://1/2/2M', {
+                                         :link_quality_cb => Proc.new {}
+                                     })
+            }.to raise_exception(CallbackMissing,
+                                 "Callback link_error_cb mandatory")
+        end
+    end
+
+    describe "#disconnect" do
+        it "should disconnect if it is not connected" do
+            expect(@crazyradio).not_to receive(:close)
+            @radiodriver.disconnect()
+        end
+
+        it "should disconnect if it is connected" do
+            expect(@crazyradio).to receive(:close)
+            @radiodriver.connect(*@connect_params)
+            @radiodriver.disconnect()
+        end
+
+        it "should kill the thread if disconnect is called with true" do
+            expect_any_instance_of(Thread).to receive(:kill)
+            @radiodriver.connect(*@connect_params)
+            @radiodriver.disconnect(true)
+        end
+    end
+
+    describe "#send_packet" do
+        it "should do nothing when not connected" do
+            #expect_any_instance_of(Queue).not_to receive(:push)
+            @radiodriver.send_packet([1,2,3])
+        end
+
+        it "should push a packet to the queue and send it" do
+            #expect_any_instance_of(Queue).to receive(:push)
+            expect(@crazyradio).to receive(:send_packet)
+            @radiodriver.connect(*@connect_params)
+            @radiodriver.send_packet(CRTPPacket.unpack([1,2,3]))
+            @radiodriver.disconnect()
+        end
+
+        it "should call the link error callback if max size is reached" do
+            # prevent consuming packages
+            expect(@radiodriver).to receive(:start_radio_thread)
+            @radiodriver.connect(*@connect_params)
+            max = @radiodriver.out_queue_max_size
+            m = "Reached #{max} elements in outgoing queue"
+            # When it reaches 50 it disconnects and not send anymore
+            expect(@link_error_cb).to receive(:call).with(m).once
+            (1..52).each do
+                @radiodriver.send_packet([4,5,6])
+            end
+            @radiodriver.disconnect()
+        end
+    end
+
+    describe "#receive_packet" do
+        # note that thread sends control packages all the time
+        it "should receive nil if queue is empty" do
+            @radiodriver.connect(*@connect_params)
+            @radiodriver.disconnect() #empty queues
+            @radiodriver.receive_packet(true).should be_nil
+        end
+
+        it "should raise error if Crazyradio complains" do
+            e = USBDongleException
+            expect(@crazyradio).to receive(:send_packet).and_raise(e, "aa")
+            m = "Error talking to Crazyradio: aa"
+            expect(@link_error_cb).to receive(:call).with(m)
+            @radiodriver.connect(*@connect_params)
+            sleep 0.1
+            @radiodriver.disconnect()
+        end
+
+        it "should raise error if nil is returned as response" do
+            allow(@crazyradio).to receive(:send_packet).and_return(nil)
+            m = "Dongle communication error (ack is nil)"
+            expect(@link_error_cb).to receive(:call).with(m)
+            @radiodriver.connect(*@connect_params)
+            sleep 0.1
+            @radiodriver.disconnect()
+        end
+
+        it "should suicide if too many packets are lost" do
+            allow(@ack).to receive(:ack).and_return(false)
+            m = "Too many packets lost"
+            expect(@link_error_cb).to receive(:call).with(m).once
+            @radiodriver.connect(*@connect_params)
+            sleep 0.1
+            @radiodriver.disconnect()
+        end
+
+        it "should receive a packet" do
+            expect(@link_quality_cb).to receive(:call).with(70).at_least(:once)
+            @radiodriver.connect(*@connect_params)
+            @radiodriver.send_packet(CRTPPacket.unpack([1,2,3]))
+            packet = @radiodriver.receive_packet(false)
+            # send package returns an ack with [1,2,3] as data
+            expect(packet).to be_an_instance_of CRTPPacket
+            packet.size.should == 2
+            packet.header.should == 1
+            packet.data.should == [2,3]
+            @radiodriver.disconnect()
+        end
+    end
+
+    describe "#scan_interface" do
+        it "should complain if link is open" do
+            @radiodriver.connect(*@connect_params)
+            expect {
+                @radiodriver.scan_interface()
+            }.to raise_exception(OpenLink, "Cannot scan when link is open")
+            @radiodriver.disconnect()
+        end
+
+        it "should return the found some uris" do
+            allow(@crazyradio).to receive(:scan_channels).and_return([1,2,3],
+                                                                     [7,8,9],
+                                                                     [21,22,4])
+            expect(@crazyradio).to receive(:[]=).with(:arc, 1)
+            expect(@crazyradio).to receive(:[]=).with(:data_rate,
+                                                      Crazyradio::DR_250KPS)
+            expect(@crazyradio).to receive(:[]=).with(:data_rate,
+                                                      Crazyradio::DR_1MPS)
+            expect(@crazyradio).to receive(:[]=).with(:data_rate,
+                                                      Crazyradio::DR_2MPS)
+            expect(@crazyradio).to receive(:close)
+            @radiodriver.scan_interface().should == [
+                                                     'radio://0/1/250K',
+                                                     'radio://0/2/250K',
+                                                     'radio://0/3/250K',
+                                                     'radio://0/7/1M',
+                                                     'radio://0/8/1M',
+                                                     'radio://0/9/1M',
+                                                     'radio://0/21/2M',
+                                                     'radio://0/22/2M',
+                                                     'radio://0/4/2M']
+        end
+
+        it "should raise a usb dongle exception it it happens" do
+            e = USBDongleException
+            allow(@crazyradio).to receive(:scan_channels).and_raise(e)
+            allow(@crazyradio).to receive(:[]=)
+            expect {
+                @radiodriver.scan_interface()
+            }.to raise_exception(e)
+        end
+    end
+
+    describe "#get_status" do
+        it "should get status" do
+            allow(Crazyradio).to receive(:status).and_return("hola")
+            @radiodriver.get_status.should == "hola"
+        end
+    end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2013 Hector Sanjuan
+
+# This file is part of Crubyflie.
+
+# Crubyflie is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# Crubyflie is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with Crubyflie.  If not, see <http://www.gnu.org/licenses/>
+
+require 'simplecov'
+SimpleCov.at_exit do
+    SimpleCov.minimum_coverage 95
+    SimpleCov.result.format!
+end
+SimpleCov.start do
+    add_group "Libraries", "lib"
+    add_group "Specs", "spec"
+end
+
+
+$: << File.join(File.dirname(__FILE__), "lib")
+$: << File.join(File.dirname(__FILE__))
+
+require 'crubyflie'
+include Crubyflie
+include CRTPConstants
+
+require 'radio_ack_spec'
+require 'crtp_packet_spec'
+require 'crazyradio_spec'
+require 'radio_driver_spec'
+require 'radio_ack_spec'
+require 'toc_cache_spec'
+require 'toc_spec'
+require 'crazyflie_spec'
+require 'log_spec'
+require 'param_spec'
+require 'console_spec'
+require 'commander_spec'
+require 'joystick_input_reader_spec'
+require 'input_reader_spec'
+require 'crubyflie_logger_spec'

data/spec/toc_cache_spec.rb

@@ -0,0 +1,87 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2013 Hector Sanjuan
+
+# This file is part of Crubyflie.
+
+# Crubyflie is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# Crubyflie is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with Crubyflie.  If not, see <http://www.gnu.org/licenses/>
+
+require 'crazyflie/toc_cache'
+
+describe TOCCache do
+
+    before :each do
+        allow_any_instance_of(TOCCache).to receive(:warn)
+
+
+        allow(File).to receive(:exist?).with('baa').and_return(true)
+        allow(File).to receive(:directory?).with('baa').and_return(true)
+        expect(FileUtils).to receive(:touch)
+        expect(FileUtils).to receive(:rm)
+        @cache = TOCCache.new('baa')
+    end
+
+    describe "#initialize" do
+        it "shoud not create a folder where it does not have permissions" do
+            allow(File).to receive(:exist?).with('baa').and_return(false)
+            do_this = receive(:mkdir_p).with('baa').and_raise(Errno::EACCES)
+            expect(FileUtils).to do_this
+            m = "Deactivating cache. Cannot create folder"
+            expect_any_instance_of(TOCCache).to receive(:warn).with(m)
+            cache = TOCCache.new('baa')
+        end
+
+        it "should veryfy the cache folder is a directory" do
+            allow(File).to receive(:exist?).with('baa').and_return(true)
+            allow(File).to receive(:directory?).with('baa').and_return(false)
+            m = "Deactivating cache. Folder is not a directory"
+            expect_any_instance_of(TOCCache).to receive(:warn).with(m)
+            cache = TOCCache.new('baa')
+        end
+
+        it "should test if the cache folder is writable" do
+            allow(File).to receive(:exist?).with('baa').and_return(true)
+            allow(File).to receive(:directory?).with('baa').and_return(true)
+            allow(FileUtils).to receive(:touch).and_raise(Errno::EACCES)
+            expect(FileUtils).not_to receive(:rm)
+            m = "Deactivating cache. Cannot write to folder"
+            expect_any_instance_of(TOCCache).to receive(:warn).with(m)
+            cache = TOCCache.new('baa')
+        end
+
+        it "initialize correctly otherwise" do
+            allow(File).to receive(:exist?).with('baa').and_return(true)
+            allow(File).to receive(:directory?).with('baa').and_return(true)
+            expect(FileUtils).not_to receive(:mkdir_p)
+            expect(FileUtils).to receive(:touch)
+            expect(FileUtils).to receive(:rm)
+            cache = TOCCache.new('baa')
+        end
+    end
+
+    describe "#fetch" do
+        it "should return nil if file does not exist" do
+            allow(File).to receive(:open).and_raise(Errno::ENOENT)
+            expect(Marshal).not_to receive(:load)
+            @cache.fetch("123").should be_nil
+        end
+    end
+
+    describe "#insert" do
+        it "should do nothing if an error happens" do
+            allow(File).to receive(:open).and_raise(Errno::EACCES)
+            expect(Marshal).not_to receive(:dump)
+            @cache.insert("123",{})
+        end
+    end
+end

data/spec/toc_spec.rb

@@ -0,0 +1,187 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2013 Hector Sanjuan
+
+# This file is part of Crubyflie.
+
+# Crubyflie is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# Crubyflie is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with Crubyflie.  If not, see <http://www.gnu.org/licenses/>
+
+require 'crazyflie/toc'
+
+describe TOCElement do
+    describe "#initialize" do
+        it "should assign the variables correctly" do
+            te = TOCElement.new({
+                                    :ident => 1,
+                                    :group => 2,
+                                    :name => 3,
+                                    :ctype => 4,
+                                    :directive => 'C*',
+                                    :access => 6
+                                })
+            te.ident.should == 1
+            te.group.should == 2
+            te.name.should == 3
+            te.ctype.should == 4
+            te.directive.should == 'C*'
+            te.access.should == 6
+        end
+    end
+end
+
+describe TOC do
+    before :each do
+        @cache = double("TOCCache")
+        allow(TOCCache).to receive(:new).and_return(@cache)
+        @toc = TOC.new()
+        @element = TOCElement.new({
+                                    :ident => 1,
+                                    :group => "mygroup",
+                                    :name => "myname",
+                                    :ctype => 4,
+                                    :rtype => 5,
+                                    :access => 6
+                                  })
+        @logger = @toc.logger
+    end
+
+    describe "#initialize" do
+        it "should setup the cache" do
+            expect(TOCCache).to receive(:new).with('abc')
+            toc = TOC.new('abc')
+        end
+    end
+
+    describe "#[]" do
+        it "should find an element by name only" do
+            @toc.insert(@element)
+            @toc["myname",:by_name].should == @element
+            @toc["mygroup.myname",:by_name].should == @element
+            @toc[1,:by_name].should be_nil
+        end
+
+        it "should find an element by id only" do
+            @toc.insert(@element)
+            @toc["myname",:by_id].should be_nil
+            @toc[1,:by_id].should == @element
+        end
+
+        it "should find an element by both name and id" do
+            @toc.insert(@element)
+            @toc["myname"].should == @element
+            @toc[1].should == @element
+        end
+
+        it "should return nil when the element is not found" do
+            @toc.insert(@element)
+            @toc["baa"].should be_nil
+        end
+    end
+
+    describe "#insert" do
+        it "should insert correctly an element" do
+            @toc[1].should be_nil
+            @toc.insert(@element)
+            @toc[1].should == @element
+        end
+    end
+
+    describe "#import/#export" do
+        it "should import and export" do
+            expect(@cache).to receive(:insert).with('abc', @toc.toc)
+            expect(@cache).to receive(:fetch).with('abc').and_return({:a => 3})
+
+            @toc.insert(@element)
+            @toc.export_to_cache('abc')
+            @toc.import_from_cache('abc')
+            @toc.toc.should == {:a => 3}
+        end
+    end
+
+    describe "#fetch_from_crazyflie" do
+        it "should import from cache when the TOC is in it" do
+            cf = double("Crazyflie")
+            queue = Queue.new
+            resp = CRTPPacket.new()
+            resp.modify_header(nil, 0, TOC_CHANNEL)
+            resp.data = [0, 5, 0x01, 0x00, 0x00, 0x00, 0x00]
+            bad_resp = CRTPPacket.new()
+            bad_resp.modify_header(nil, 0, 33)
+
+            allow(@cache).to receive(:fetch).and_return({:abc => "def"}).once
+
+            expect(queue).to receive(:pop).and_return(bad_resp, resp).twice
+            expect(queue).to receive(:<<).with(bad_resp)
+            expect(cf).to receive(:send_packet).with(anything, true).once
+            m = "Got a non-TOC packet. Requeueing..."
+            m2 = "TOC crc #{1}, 5 items"
+            m3 = "TOC found in cache"
+            expect(@logger).to receive(:debug).with(m)
+            expect(@logger).to receive(:debug).with(m2)
+            expect(@logger).to receive(:debug).with(m3)
+
+            @toc.fetch_from_crazyflie(cf, 0, queue)
+        end
+
+        it "should request the elements in the TOC when it is not in cache" do
+            cf = double("Crazyflie")
+            queue = Queue.new
+            resp = CRTPPacket.new()
+            resp.modify_header(nil, 0, TOC_CHANNEL)
+            resp.data = [0, 5, 0x01, 0x00, 0x00, 0x00, 0x00]
+
+            resp_elem = CRTPPacket.new()
+            resp_elem.modify_header(nil, 0, TOC_CHANNEL)
+            resp_elem.data = [0, 0, 0xFF, 0xFF]
+
+            allow(@cache).to receive(:fetch).and_return(nil).once
+
+            do_this = receive(:pop).and_return(resp,
+                                               resp_elem).exactly(6).times
+            expect(queue).to do_this
+            expect(cf).to receive(:send_packet).with(anything,
+                                                     true).exactly(6).times
+
+            mw = "Not in cache"
+            m = "TOC crc 1, 5 items"
+            m0 = "Added 0 to TOC"
+            m1 = "Added 1 to TOC"
+            m2 = "Added 2 to TOC"
+            m3 = "Added 3 to TOC"
+            m4 = "Added 4 to TOC"
+
+            expect(@logger).to receive(:debug).with(mw)
+            expect(@logger).to receive(:debug).with(m)
+            expect(@logger).to receive(:debug).with(m0)
+            expect(@logger).to receive(:debug).with(m1)
+            expect(@logger).to receive(:debug).with(m2)
+            expect(@logger).to receive(:debug).with(m3)
+            expect(@logger).to receive(:debug).with(m4)
+
+            one = { :ident => 0 }
+            two = { :ident => 1 }
+            three = { :ident => 2 }
+            four = { :ident => 3 }
+            five = { :ident => 4 }
+            allow(TOCElement).to receive(:new).and_return(
+                                                          TOCElement.new(one),
+                                                          TOCElement.new(two),
+                                                          TOCElement.new(three),
+                                                          TOCElement.new(four),
+                                                          TOCElement.new(five))
+
+            expect(@cache).to receive(:insert).with("1", anything)
+            @toc.fetch_from_crazyflie(cf, 0, queue)
+        end
+    end
+end

data/tools/sdl-joystick-axis.rb

@@ -0,0 +1,69 @@
+#!/usr/bin/env ruby
+# Copyright (C) 2013 Hector Sanjuan
+
+# This file is part of Crubyflie.
+
+# Crubyflie is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# Crubyflie is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with Crubyflie.  If not, see <http://www.gnu.org/licenses/>
+
+# A simple script to list SDL axis/button numbering and read values
+
+require 'sdl'
+require 'pp'
+
+warn "Welcome to Crubyflie joystick utility. Ctrl-C to exit."
+warn "--"
+Signal.trap("SIGINT") do
+    warn "\n\n"
+    warn "Bye bye!"
+    SDL.quit
+    exit 0
+end
+
+SDL.init(SDL::INIT_JOYSTICK)
+n_joy = SDL::Joystick.num
+if n_joy == 0
+    warn "No joysticks found"
+    exit 1
+end
+
+
+warn "Total number of Joysticks: #{n_joy}"
+n_joy.times do |i|
+    warn "#{i}: #{SDL::Joystick.index_name(i)}"
+end
+warn "--"
+print "Which one should we use (0-#{n_joy-1}): "
+joy_id = gets.to_i
+joy = SDL::Joystick.open(joy_id)
+warn "Opened Joystick #{joy_id}"
+warn "Name: SDL::Joystick.index_name(#{joy_id})"
+warn "Number of Axes: #{joy.num_axes}"
+warn "Number of buttons: #{joy.num_buttons}"
+warn "Here is the reading for axis and buttons:"
+loop {
+    SDL::Joystick.update_all
+    joy.num_axes.times do |i|
+        print "A##{i}: #{joy.axis(i)} | "
+    end
+
+    print " || "
+
+    button_read = []
+    joy.num_buttons.times do |i|
+        print "B##{i}: #{joy.button(i) ? 1 : 0} | "
+    end
+    print "\r"
+    $stdout.flush
+    sleep 0.05
+}