hybridgroup-crubyflie 0.1.4

data/spec/param_spec.rb

@@ -0,0 +1,166 @@
+# -*- 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/param'
+
+
+
+describe LogTOCElement do
+    describe "#initialize" do
+        it "should initialize correctly" do
+            data = [5, 23].pack('C*') + ['hello', 'world'].pack('Z*Z*')
+            lte = ParamTOCElement.new(data)
+            lte.ident.should == 5
+            lte.group.should == 'hello'
+            lte.name.should  == 'world'
+            lte.ctype.should == 'double'
+            lte.directive.should == 'E'
+            lte.access.should == 0x10
+        end
+    end
+end
+
+
+describe Param do
+    before :each do
+        @crazyflie = double("Crazyflie")
+        @queue = Queue.new
+        allow(@crazyflie).to receive(:crtp_queues).and_return({:param =>
+                                                                  @queue})
+        allow(@crazyflie).to receive(:cache_folder).and_return(nil)
+
+        @param = Param.new(@crazyflie)
+        @logger = @param.logger
+    end
+
+    describe "#initialize" do
+        it "should initialize the Param instance" do
+            param = Param.new(@crazyflie)
+            @param.toc.toc.should == {}
+        end
+    end
+
+    describe "#refresh_toc" do
+        it "send the packet and fetch the TOC from the crazyflie" do
+            port = Crazyflie::CRTP_PORTS[:param]
+            channel = Param::TOC_CHANNEL
+            expect(@param.toc).to receive(:fetch_from_crazyflie).with(
+                                                                    @crazyflie,
+                                                                    port,
+                                                                    @queue)
+            @param.refresh_toc()
+        end
+    end
+
+    describe "#set_value" do
+        it "should not do anything if the element is not in the TOC" do
+            expect(@logger).to receive(:error).with("Param abc not in TOC!")
+            expect(@crazyflie).not_to receive(:send_packet)
+            @param.set_value('abc', 45)
+        end
+
+        it "should set the value of a parameter and yield the response" do
+            toc_elem = TOCElement.new({
+                                          :ident => 3,
+                                          :group => "gr",
+                                          :name => "name",
+                                          :ctype => "int32_t",
+                                          :directive => "l<"
+                                      })
+
+            name = 'gr.name'
+            expect(@param.toc).to receive(:[]).with(name).and_return(toc_elem)
+
+            expect(@crazyflie).to receive(:send_packet) { |packet, expect|
+                packet.port.should == CRTP_PORTS[:param]
+                packet.channel == PARAM_WRITE_CHANNEL
+                packet.data.should == [3, 1, 0, 0, 0]
+                expect.should == true
+            }
+
+            res = CRTPPacket.new()
+            expect(@queue).to receive(:pop).and_return(res)
+
+            @param.set_value('gr.name', 1) do |response|
+                response.should == res
+            end
+        end
+
+        it "should set the value of a parameter without a block_given" do
+            toc_elem = TOCElement.new({
+                                          :ident => 3,
+                                          :group => "gr",
+                                          :name => "name",
+                                          :ctype => "int32_t",
+                                          :directive => "l<"
+                                      })
+
+            name = 'gr.name'
+            expect(@param.toc).to receive(:[]).with(name).and_return(toc_elem)
+
+            expect(@crazyflie).to receive(:send_packet) { |packet, expect|
+                packet.port.should == CRTP_PORTS[:param]
+                packet.channel == PARAM_WRITE_CHANNEL
+                packet.data.should == [3, 1, 0, 0, 0]
+                expect.should == true
+            }
+
+            res = CRTPPacket.new()
+            expect(@queue).to receive(:pop).and_return(res)
+
+            m = "Got answer to setting param 'gr.name' with '1'"
+            expect(@logger).to receive(:debug).with(m)
+            @param.set_value('gr.name', 1)
+        end
+    end
+
+    describe "#get_value" do
+        it "should not do anything if the element is not in the TOC" do
+            m = "Cannot update gr.name, not in TOC"
+            expect(@logger).to receive(:error).with(m)
+
+            @param.get_value('gr.name') {}
+        end
+
+        it "should request an element and yield the value" do
+            toc_elem = TOCElement.new({
+                                          :ident => 3,
+                                          :group => "gr",
+                                          :name => "name",
+                                          :ctype => "int32_t",
+                                          :directive => "l<"
+                                      })
+
+            name = 'gr.name'
+            expect(@param.toc).to receive(:[]).with(name).and_return(toc_elem)
+
+            expect(@crazyflie).to receive(:send_packet) do |packet|
+                packet.port.should == CRTP_PORTS[:param]
+                packet.channel.should == PARAM_READ_CHANNEL
+                packet.data.should == [3]
+            end
+
+            res = CRTPPacket.new()
+            res.data = [3, 5, 0, 0, 0]
+            expect(@queue).to receive(:pop).and_return(res)
+            @param.get_value('gr.name') do |value|
+                value.should == 5
+            end
+        end
+    end
+end

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,53 @@
+# -*- 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'
+require 'coveralls'
+SimpleCov.formatter = Coveralls::SimpleCov::Formatter
+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