Пример #1
0
    async def test_armmodestatus(self):
        """Test getting of the arming status and mode from heartbeat"""
        self.veh = Vehicle(self.loop, "VehA", self.source_system, self.source_component,
                           self.target_system, self.target_component, self.dialect, self.mavversion)

        assert self.veh.isArmed is None
        assert self.veh.flightMode is None

        pkt = self.mod.MAVLink_heartbeat_message(
            self.mod.MAV_TYPE_QUADROTOR, self.mod.MAV_AUTOPILOT_ARDUPILOTMEGA, self.mod.MAV_MODE_AUTO_DISARMED, 0, 0, int(self.mavversion))
        self.veh.newPacketCallback(pkt)

        assert self.veh.isArmed is False
        assert self.veh.flightMode == "0"

        pkt = self.mod.MAVLink_heartbeat_message(
            self.mod.MAV_TYPE_QUADROTOR, self.mod.MAV_AUTOPILOT_ARDUPILOTMEGA, self.mod.MAV_MODE_MANUAL_ARMED, 1, 0, int(self.mavversion))
        self.veh.newPacketCallback(pkt)

        assert self.veh.isArmed is True
        assert self.veh.flightMode == "1"

        pkt = self.mod.MAVLink_heartbeat_message(
            self.mod.MAV_TYPE_QUADROTOR, self.mod.MAV_AUTOPILOT_ARDUPILOTMEGA, self.mod.MAV_MODE_MANUAL_DISARMED, 15, 0, int(self.mavversion))
        self.veh.newPacketCallback(pkt)

        assert self.veh.isArmed is False
        assert self.veh.flightMode == '15'
Пример #2
0
    async def test_params_before(self):
        """Test getting of the parameters before downloaded"""
        self.veh = Vehicle(self.loop, "VehA", self.source_system, self.source_component,
                           self.target_system, self.target_component, self.dialect, self.mavversion)

        assert self.veh.getParams('RC8_MAX') is None
        assert self.veh.getParams() is None
Пример #3
0
    async def test_set_param_no_params(self):
        """Test setting of params if params not downloaded yet"""
        self.veh = Vehicle(self.loop, "VehA", self.source_system, self.source_component,
                           self.target_system, self.target_component, self.dialect, self.mavversion)
        self.veh.txcallback = self.paramcallback

        assert await self.veh.setParam('RC8_MAX', 1800) is False
Пример #4
0
    def setUp(self):
        """Set up some data that is reused in many tests"""

        self.manager = None

        # The PaGS settings dir (just in source dir)
        self.settingsdir = os.path.join(os.getcwd(), ".PaGS")
        if not os.path.exists(self.settingsdir):
            os.makedirs(self.settingsdir)

        self.dialect = 'ardupilotmega'
        self.version = 2.0
        self.mod = getpymavlinkpackage(self.dialect, self.version)
        self.mavUAS = self.mod.MAVLink(
            self, srcSystem=4, srcComponent=0, use_native=False)

        self.VehA = Vehicle(self.loop, "VehA", 255, 0, 4,
                            0, self.dialect, self.version)
        self.VehA.hasInitial = True
        self.VehB = Vehicle(self.loop, "VehB", 255, 0, 5,
                            0, self.dialect, self.version)
        self.VehB.hasInitial = True
        self.VehC = Vehicle(self.loop, "VehC", 255, 0, 10,
                            0, self.dialect, self.version)
        self.VehC.hasInitial = False

        self.txPackets = {}
Пример #5
0
    def setUp(self):
        """Set up some data that is reused in many tests"""

        self.manager = None

        self.dialect = 'ardupilotmega'
        self.version = 2.0
        self.mod = getpymavlinkpackage(self.dialect, self.version)
        self.mavUAS = self.mod.MAVLink(self,
                                       srcSystem=4,
                                       srcComponent=0,
                                       use_native=False)
        self.VehA = Vehicle(self.loop, "VehA", 255, 0, 4, 0, self.dialect,
                            self.version)
        self.VehA.onPacketTxAttach(self.vehSendFunc)
        self.VehA.hasInitial = True

        # The PaGS settings dir (just in source dir)
        self.settingsdir = os.path.join(os.getcwd(), ".PaGS")
        if not os.path.exists(self.settingsdir):
            os.makedirs(self.settingsdir)

        self.manager = moduleManager.moduleManager(self.loop, self.settingsdir,
                                                   False)
        self.manager.onVehListAttach(self.getVehListCallback)
        self.manager.onVehGetAttach(self.getVehicleCallback)
        self.manager.onPktTxAttach(self.txcallback)

        self.manager.addModule("internalPrinterModule")
Пример #6
0
    def setUp(self):
        """Set up some data that is reused in many tests"""

        self.manager = None

        self.dialect = 'ardupilotmega'
        self.version = 2.0
        self.mod = getpymavlinkpackage(self.dialect, self.version)
        self.mavUAS = self.mod.MAVLink(self,
                                       srcSystem=4,
                                       srcComponent=0,
                                       use_native=False)
        self.VehA = Vehicle(self.loop, "VehA", 255, 0, 4, 0, self.dialect,
                            self.version)
        self.VehA.onPacketTxAttach(self.vehSendFunc)

        self.txPackets = {}
        self.txVehPackets = {}

        self.manager = moduleManager.moduleManager(self.loop, self.dialect,
                                                   self.version, False)
        self.manager.onVehListAttach(self.getVehListCallback)
        self.manager.onVehGetAttach(self.getVehicleCallback)
        self.manager.onPktTxAttach(self.txcallback)

        self.manager.addModule("PaGS.modules.internalPrinterModule")
Пример #7
0
    async def test_params_noresponse(self):
        """Test getting of the parameters, no response from vehicle"""
        self.veh = Vehicle(self.loop, "VehA", self.source_system, self.source_component,
                           self.target_system, self.target_component, self.dialect, self.mavversion)
        await self.veh.downloadParams(timeout=0.1)

        assert self.veh.getParams('RC8_MAX') is None
        assert self.veh.getParams() is None
Пример #8
0
    async def test_get_params(self):
        """Test getting of the parameters, got all. Plus typo"""
        self.veh = Vehicle(self.loop, "VehA", self.source_system, self.source_component,
                           self.target_system, self.target_component, self.dialect, self.mavversion)
        self.veh.txcallback = self.paramcallback
        await self.veh.downloadParams(timeout=0.25)

        assert self.veh.getParams('RC8_MAX') == 1900
        assert self.veh.getParams('RC8_MAXXX') is None
Пример #9
0
    async def test_get_params_retry(self):
        """Test getting of the parameters, need to retry some"""
        self.veh = Vehicle(self.loop, "VehA", self.source_system, self.source_component,
                           self.target_system, self.target_component, self.dialect, self.mavversion)
        self.veh.txcallback = self.paramcallbackpartial
        await self.veh.downloadParams(timeout=0.25)

        assert self.veh.getParams('RC8_MAX') == 1900
        assert self.veh.getParams('RC8_TRIM') == 1500
Пример #10
0
    async def test_set_param(self):
        """Test setting of param"""
        self.veh = Vehicle(self.loop, "VehA", self.source_system, self.source_component,
                           self.target_system, self.target_component, self.dialect, self.mavversion)
        self.veh.txcallback = self.paramcallback
        await self.veh.downloadParams(timeout=0.25)

        assert await self.veh.setParam('RC8_MAX', 1730) is True
        assert self.veh.getParams('RC8_MAX') == 1730
Пример #11
0
    async def test_norxheartbeat(self):
        """Test no rx hb task ever"""
        self.veh = Vehicle(self.loop, "VehA", self.source_system, self.source_component,
                           self.target_system, self.target_component, self.dialect, self.mavversion)

        await self.veh.setTimeout(0)
        await asyncio.sleep(0.01)

        assert self.veh.isConnected is False
Пример #12
0
    async def test_noheartbeat(self):
        """Test no hb task ever"""
        self.veh = Vehicle(self.loop, "VehA", self.source_system, self.source_component,
                           self.target_system, self.target_component, self.dialect, self.mavversion)
        self.veh.txcallback = self.newpacketcallback

        await self.veh.setHearbeatRate(0)
        await asyncio.sleep(0.01)

        assert len(self.txpackets) == 0
Пример #13
0
    async def test_vehtypename(self):
        """Test correct veh type and gf name from vehicle"""
        self.veh = Vehicle(self.loop, "VehA", self.source_system, self.source_component,
                           self.target_system, self.target_component, self.dialect, self.mavversion)
        self.veh.txcallback = self.newpacketcallback

        pkt = self.mod.MAVLink_heartbeat_message(
            self.mod.MAV_TYPE_QUADROTOR, self.mod.MAV_AUTOPILOT_ARDUPILOTMEGA, 0, 0, 0, int(self.mavversion))
        self.veh.newPacketCallback(pkt)

        assert self.veh.fcName == "MAV_AUTOPILOT_ARDUPILOTMEGA"
        assert self.veh.vehType == "MAV_TYPE_QUADROTOR"
Пример #14
0
    async def test_getPacket(self):
        """Test getting a packet"""
        self.veh = Vehicle(self.loop, "VehA", self.source_system, self.source_component,
                           self.target_system, self.target_component, self.dialect, self.mavversion)
        pkt = self.mod.MAVLink_heartbeat_message(
            self.mod.MAV_TYPE_QUADROTOR, self.mod.MAV_AUTOPILOT_ARDUPILOTMEGA, 0, 0, 0, int(self.mavversion))
        self.veh.newPacketCallback(pkt)

        await asyncio.sleep(0.01)

        assert len(self.veh.latestPacketDict) == 1
        assert self.veh.getPacket(self.mod.MAVLINK_MSG_ID_HEARTBEAT) == pkt
        assert self.veh.getPacket(
            self.mod.MAVLINK_MSG_ID_ESC_TELEMETRY_9_TO_12) is None
Пример #15
0
    def test_sendPacket(self):
        """Assembling a packet"""
        self.veh = Vehicle(self.loop, "VehA", self.source_system, self.source_component,
                           self.target_system, self.target_component, self.dialect, self.mavversion)
        self.veh.txcallback = self.newpacketcallback

        self.veh.sendPacket(self.mod.MAVLINK_MSG_ID_HEARTBEAT,
                            type=self.mod.MAV_TYPE_GCS,
                            autopilot=self.mod.MAV_AUTOPILOT_INVALID,
                            base_mode=0,
                            custom_mode=0,
                            system_status=0,
                            mavlink_version=int(self.mavversion))

        assert len(self.txpackets) == 1
Пример #16
0
    async def add_vehicle(self, name: str, source_system: int,
                          source_component: int, target_system: int,
                          target_component: int, dialect: str,
                          mavversion: float, strconnection: str):
        """ Add a new vehicle"""
        if name in self.veh_list:
            raise ValueError('Already a vehicle with that name')
        else:
            self.veh_list[name] = Vehicle(self.loop, name, source_system,
                                          source_component, target_system,
                                          target_component, dialect,
                                          mavversion)

            # Connect packet RX from vehicle to moduleManager
            # self.veh_list[name].onPacketRxAttach(self.incoming_packet_callback)

            # Connect packet TX from vehicle to connectionManager
            self.veh_list[name].onPacketTxAttach(self.outgoingPacketBuffer)

            # tell the modulemanager
            if self.add_vehicle_callback:
                self.add_vehicle_callback(name)
            # matrix.addVehicleLink(self.VehA.name, self.VehA.target_system, self.linkC)
            if self.add_link:
                # self.add_link(name, target_system, strconnection)
                asyncio.ensure_future(
                    self.add_link(name, target_system, strconnection))
Пример #17
0
    async def test_rxheartbeat(self):
        """Test correct rx of hb from vehicle - time of last packet"""
        self.veh = Vehicle(self.loop, "VehA", self.source_system, self.source_component,
                           self.target_system, self.target_component, self.dialect, self.mavversion)
        self.veh.txcallback = self.newpacketcallback
        await self.veh.setTimeout(0.05)

        pkt = self.mod.MAVLink_heartbeat_message(
            self.mod.MAV_TYPE_QUADROTOR, self.mod.MAV_AUTOPILOT_ARDUPILOTMEGA, 0, 0, 0, int(self.mavversion))
        self.veh.newPacketCallback(pkt)

        await asyncio.sleep(0.02)
        assert self.veh.isConnected is True

        await asyncio.sleep(0.10)
        assert self.veh.isConnected is False
Пример #18
0
    async def test_heartbeat(self):
        """Test heatbeat rate and stopping hb task"""
        self.veh = Vehicle(self.loop, "VehA", self.source_system, self.source_component,
                           self.target_system, self.target_component, self.dialect, self.mavversion)
        self.veh.txcallback = self.newpacketcallback

        await self.veh.setHearbeatRate(0.001)
        await asyncio.sleep(0.15)

        # stop for a while - no extra hb emitted
        await self.veh.setHearbeatRate(0)
        await asyncio.sleep(0.01)

        # due to timer jitter, can only test for approx rate
        # Expecting between 4 and 120 hb packets
        assert len(self.txpackets) > 4
        assert len(self.txpackets) < 120
Пример #19
0
    def setUp(self):
        """Set up some data that is reused in many tests"""

        self.manager = None

        self.dialect = 'ardupilotmega'
        self.version = 2.0
        self.mod = getpymavlinkpackage(self.dialect, self.version)
        self.mavUAS = self.mod.MAVLink(
            self, srcSystem=4, srcComponent=0, use_native=False)
        self.VehA = Vehicle(self.loop, "VehA", 255, 0, 4,
                            0, self.dialect, self.version)

        self.txPackets = {}
Пример #20
0
    def setUp(self):
        """Set up some data that is reused in many tests"""
        self.dialect = 'ardupilotmega'
        self.version = 2.0
        self.ip = "127.0.0.1"

        # The links
        self.linkA = 'tcpclient:127.0.0.1:15001'
        self.linkB = 'tcpserver:127.0.0.1:15020'
        self.linkC = 'udpclient:127.0.0.1:15002'
        self.linkD = 'udpserver:127.0.0.1:15021'

        # The vehicles. Note the vehicles A and C have the same sysid
        # Source s/c then target s/c
        self.VehA = Vehicle(self.loop, "VehA", 255, 0, 4,
                            0, self.dialect, self.version)
        self.VehB = Vehicle(self.loop, "VehB", 254, 0, 3,
                            0, self.dialect, self.version)
        self.VehC = Vehicle(self.loop, "VehC", 255, 0, 4,
                            0, self.dialect, self.version)

        # Dict of data rx'd by each link
        self.rxdata = {}

        # Dict of data rx'd by each vehicle
        self.vehpkts = {}

        self.mod = getpymavlinkpackage(self.dialect, self.version)
        # From the vehicle
        self.mavUAS = self.mod.MAVLink(
            self, srcSystem=4, srcComponent=0, use_native=False)
        self.mavoneUAS = self.mod.MAVLink(
            self, srcSystem=3, srcComponent=0, use_native=False)
        self.mavGCS = self.mod.MAVLink(
            self, srcSystem=255, srcComponent=0, use_native=False)
        self.mavoneGCS = self.mod.MAVLink(
            self, srcSystem=254, srcComponent=0, use_native=False)
Пример #21
0
class ModuleManagerTest(asynctest.TestCase):
    """
    Class to test templateModule
    """
    def setUp(self):
        """Set up some data that is reused in many tests"""

        self.manager = None

        self.dialect = 'ardupilotmega'
        self.version = 2.0
        self.mod = getpymavlinkpackage(self.dialect, self.version)
        self.mavUAS = self.mod.MAVLink(self,
                                       srcSystem=4,
                                       srcComponent=0,
                                       use_native=False)
        self.VehA = Vehicle(self.loop, "VehA", 255, 0, 4, 0, self.dialect,
                            self.version)
        self.VehA.onPacketTxAttach(self.vehSendFunc)

        self.txPackets = {}
        self.txVehPackets = {}

        self.manager = moduleManager.moduleManager(self.loop, self.dialect,
                                                   self.version, False)
        self.manager.onVehListAttach(self.getVehListCallback)
        self.manager.onVehGetAttach(self.getVehicleCallback)
        self.manager.onPktTxAttach(self.txcallback)

        self.manager.addModule("PaGS.modules.internalPrinterModule")

    async def tearDown(self):
        """Close down the test"""
        await self.VehA.stopheartbeat()
        await self.VehA.stoprxtimeout()

    def vehSendFunc(self, buf, name):
        """Event for when vehicle send buffer"""
        self.txVehPackets[name] = buf

    def txcallback(self, name, pkt, **kwargs):
        """Event callback to sending a packet on to vehiclemanager"""
        self.txPackets[name] = pkt

    def getVehListCallback(self):
        """Get list of vehicles"""
        return ["VehA"]

    def getVehicleCallback(self, vehname):
        """Get a particular vehicle"""
        if vehname == "VehA":
            return self.VehA
        else:
            raise ValueError('No vehicle with that name')

    def test_loadModule(self):
        """Test adding and removal of module"""
        self.manager.addModule("PaGS.modules.paramModule")

        # is the module loaded?
        # (noting that internalPrinter is already loaded)
        assert len(self.manager.multiModules) == 2
        assert "param" in self.manager.commands
        assert len(self.manager.commands["param"]) == 6

        self.manager.removeModule("PaGS.modules.paramModule")

        # is the module unloaded?
        assert len(self.manager.multiModules) == 1
        assert "param" not in self.manager.commands

    async def test_cmd_download(self):
        """Test the "download" command"""
        self.manager.addModule("PaGS.modules.paramModule")

        # execute a command
        self.manager.onModuleCommandCallback("VehA", "param download")

        # assert
        await asyncio.sleep(0.001)
        assert self.txVehPackets['VehA'] is not None

    async def test_cmd_status(self):
        """Test the "status" command"""
        self.manager.addModule("PaGS.modules.paramModule")

        # execute a command
        self.manager.onModuleCommandCallback("VehA", "param status")

        # assert printed
        assert self.getOutText("VehA", 1) == "Params not downloaded"

        # now we have some params downloaded
        self.VehA.paramstatus = [15, 20, [1, 2, 4, 6, 13]]

        # execute a command
        self.manager.onModuleCommandCallback("VehA", "param status")

        # assert
        assert self.getOutText("VehA", 3) == "Downloaded 5 of 20 params"

        # now all params downloaded
        self.VehA.paramstatus = True

        # execute a command
        self.manager.onModuleCommandCallback("VehA", "param status")

        # assert
        assert self.getOutText("VehA", 5) == "Got all (0) params"

    async def test_cmd_show(self):
        """Test the "show" command"""
        self.manager.addModule("PaGS.modules.paramModule")

        # test with no params
        self.manager.onModuleCommandCallback("VehA", "param show *")

        # assert
        assert self.getOutText("VehA", 1) == "Params not downloaded"

        # now all params downloaded
        self.VehA.paramstatus = True
        self.VehA.params = {"RC1_MIN": 1000, "RC2_MAX": 2000}

        # get one param
        self.manager.onModuleCommandCallback("VehA", "param show RC1_MIN")
        assert self.getOutText("VehA", 3) == "RC1_MIN          1000"

        # get several params
        self.manager.onModuleCommandCallback("VehA", "param show RC*")
        allstr = self.getOutText("VehA", 5) + ", " + self.getOutText("VehA", 6)
        assert "RC1_MIN          1000" in allstr
        assert "RC2_MAX          2000" in allstr

        # get not existing param
        self.manager.onModuleCommandCallback("VehA", "param show RC5_MAX")
        assert self.getOutText("VehA", 8) == "No param RC5_MAX"

        # get no param
        self.manager.onModuleCommandCallback("VehA", "param show")
        assert "Traceback" in self.getOutText("VehA", 10)

    async def test_cmd_set(self):
        """Test the "set" command"""
        self.manager.addModule("PaGS.modules.paramModule")

        # test with no params
        self.manager.onModuleCommandCallback("VehA", "param set RC1_MIN 1102")

        # assert
        assert self.getOutText("VehA", 1) == "Params not downloaded"

        # now all params downloaded
        self.VehA.paramstatus = True
        self.VehA.params = {"RC1_MIN": 1000, "RC2_MAX": 2000}
        self.VehA.params_type = {
            "RC1_MIN": self.mod.MAV_PARAM_TYPE_UINT16,
            "RC2_MAX": self.mod.MAV_PARAM_TYPE_UINT16
        }

        # test with single param
        self.manager.onModuleCommandCallback("VehA", "param set RC1_MIN 1102")
        # assert
        await asyncio.sleep(0.1)
        assert self.txVehPackets['VehA'] is not None

        # test with not existing param
        self.manager.onModuleCommandCallback("VehA", "param set RC1_MAX 1102")
        # assert
        assert self.getOutText("VehA", 4) == "No param with that name"

        # test with invalid val
        self.manager.onModuleCommandCallback("VehA", "param set RC1_MIN fgda")
        # assert
        assert self.getOutText("VehA", 6) == "Invalid param value"

        # test with no val
        self.manager.onModuleCommandCallback("VehA", "param set RC1_MIN")
        # assert
        assert "Traceback" in self.getOutText("VehA", 8)

    def test_cmd_save(self):
        """Test the save param command"""
        self.manager.addModule("PaGS.modules.paramModule")

        # test with no params
        self.manager.onModuleCommandCallback("VehA", "param save temp.parm")

        # assert
        assert self.getOutText("VehA", 1) == "Params not downloaded"

        # now all params downloaded
        self.VehA.paramstatus = True
        self.VehA.params = {"RC1_MIN": 1000, "RC2_MAX": 2000}
        self.VehA.params_type = {
            "RC1_MIN": self.mod.MAV_PARAM_TYPE_UINT16,
            "RC2_MAX": self.mod.MAV_PARAM_TYPE_UINT16
        }

        # test with params
        self.manager.onModuleCommandCallback("VehA", "param save temp.parm")
        # assert
        assert self.getOutText("VehA", 3) == "2 params saved to temp.parm"
        assert os.path.isfile("temp.parm")
        with open('temp.parm', 'r') as myfile:
            data = myfile.read()
        assert "RC1_MIN          1000\n" in data
        assert "RC2_MAX          2000\n" in data

        # test with space in filename
        self.manager.onModuleCommandCallback("VehA",
                                             "param save \"temp 1.parm\"")
        # assert
        assert self.getOutText("VehA", 5) == "2 params saved to temp 1.parm"
        assert os.path.isfile("temp 1.parm")
        with open('temp 1.parm', 'r') as myfile:
            data = myfile.read()
        assert "RC1_MIN          1000\n" in data
        assert "RC2_MAX          2000\n" in data

        # and clean up files
        os.remove("temp.parm")
        os.remove("temp 1.parm")

    async def test_cmd_load(self):
        """Test the load param command"""
        self.manager.addModule("PaGS.modules.paramModule")

        # create the param files - good, param name bad, param value bad,
        # corrupt
        with open('tempload.parm', 'w') as myfile:
            myfile.write("RC1_MIN          1100\nRC2_MAX          2100\n")
        with open('temploadbad1.parm', 'w') as myfile:
            myfile.write("RC1_MID          1100\nRC2_MAX          2100\n")
        with open('temploadbad2.parm', 'w') as myfile:
            myfile.write("RC1_MIN          1100\nRC2_MAX          dsf\n")
        with open('temploadbad3.parm', 'w') as myfile:
            myfile.write("w309836nb32n98n72\nw983n5c032 948")

        # test with no params
        self.manager.onModuleCommandCallback("VehA",
                                             "param load tempload.parm")

        # assert
        assert self.getOutText("VehA", 1) == "Params not downloaded"

        # now all params downloaded
        self.VehA.paramstatus = True
        self.VehA.params = {"RC1_MIN": 1000, "RC2_MAX": 2000}
        self.VehA.params_type = {
            "RC1_MIN": self.mod.MAV_PARAM_TYPE_UINT16,
            "RC2_MAX": self.mod.MAV_PARAM_TYPE_UINT16
        }

        # test the normal good file
        self.manager.onModuleCommandCallback("VehA",
                                             "param load tempload.parm")

        # and assert
        assert self.getOutText("VehA",
                               3) == "2 params loaded from tempload.parm"
        await asyncio.sleep(0.01)
        assert self.txVehPackets['VehA'] is not None

        # bad file 1 - wrong param name
        self.manager.onModuleCommandCallback("VehA",
                                             "param load temploadbad1.parm")

        # and assert
        assert self.getOutText("VehA", 5) == "Invalid param: RC1_MID"
        assert self.getOutText("VehA",
                               6) == "1 params loaded from temploadbad1.parm"

        # bad file 2 - wrong param value
        self.manager.onModuleCommandCallback("VehA",
                                             "param load temploadbad2.parm")

        # and assert
        assert self.getOutText("VehA", 8) == "Invalid param value: dsf"
        assert self.getOutText("VehA",
                               9) == "1 params loaded from temploadbad2.parm"

        # bad file 3 - just plain corrupt
        self.manager.onModuleCommandCallback("VehA",
                                             "param load temploadbad3.parm")

        # and assert
        assert self.getOutText("VehA",
                               11) == "Param line not valid: w309836nb32n98n72"
        assert self.getOutText("VehA", 12) == "Invalid param: w983n5c032"
        assert self.getOutText("VehA",
                               13) == "0 params loaded from temploadbad3.parm"

        # and clean up files
        os.remove("tempload.parm")
        os.remove("temploadbad1.parm")
        os.remove("temploadbad2.parm")
        os.remove("temploadbad3.parm")

    def test_guiStart(self):
        """Simple test of the GUI startup"""

        # need to reset for handling gui
        self.manager = moduleManager.moduleManager(self.loop, self.dialect,
                                                   self.version, True)
        self.manager.onVehListAttach(self.getVehListCallback)
        self.manager.onVehGetAttach(self.getVehicleCallback)
        self.manager.onPktTxAttach(self.txcallback)

        self.manager.addModule("PaGS.modules.internalPrinterModule")

        self.manager.addModule("PaGS.modules.paramModule")

        # TODO: some GUI tests?

    def getOutText(self, Veh: str, line: int):
        """Helper function for getting output text from internalPrinterModule"""
        return self.manager.multiModules[
            'PaGS.modules.internalPrinterModule'].printedout[Veh][line]

    def test_incoming(self):
        """Test incoming packets"""
        pass
Пример #22
0
class StatusModuleTest(asynctest.TestCase):
    """
    Class to test statusModule
    """
    def setUp(self):
        """Set up some data that is reused in many tests"""

        self.manager = None

        self.dialect = 'ardupilotmega'
        self.version = 2.0
        self.mod = getpymavlinkpackage(self.dialect, self.version)
        self.mavUAS = self.mod.MAVLink(self,
                                       srcSystem=4,
                                       srcComponent=0,
                                       use_native=False)
        self.VehA = Vehicle(self.loop, "VehA", 255, 0, 4, 0, self.dialect,
                            self.version)
        self.VehA.onPacketTxAttach(self.vehSendFunc)
        self.VehA.hasInitial = True

        # The PaGS settings dir (just in source dir)
        self.settingsdir = os.path.join(os.getcwd(), ".PaGS")
        if not os.path.exists(self.settingsdir):
            os.makedirs(self.settingsdir)

        self.manager = moduleManager.moduleManager(self.loop, self.settingsdir,
                                                   False)
        self.manager.onVehListAttach(self.getVehListCallback)
        self.manager.onVehGetAttach(self.getVehicleCallback)
        self.manager.onPktTxAttach(self.txcallback)

        self.manager.addModule("internalPrinterModule")

    async def tearDown(self):
        """Close down the test"""
        await self.VehA.stopheartbeat()
        await self.VehA.stoprxtimeout()
        if "PaGS.modules.statusModule" in self.manager.multiModules:
            await self.manager.removeModule("PaGS.modules.statusModule")
        if os.path.exists(self.settingsdir):
            shutil.rmtree(self.settingsdir)

    def vehSendFunc(self, buf, name):
        """Event for when vehicle send buffer"""
        pass

    def txcallback(self, name, pkt, **kwargs):
        """Event callback to sending a packet on to vehiclemanager"""
        pass

    def getVehListCallback(self):
        """Get list of vehicles"""
        return ["VehA"]

    def getVehicleCallback(self, vehname):
        """Get a particular vehicle"""
        if vehname == "VehA":
            return self.VehA
        else:
            raise ValueError('No vehicle with that name')

    async def test_loadModule(self):
        """Test adding and removal of module"""
        self.manager.addModule("PaGS.modules.statusModule")

        # is the module loaded?
        # (noting that internalPrinter is already loaded)
        assert len(self.manager.multiModules) == 2
        assert "status" in self.manager.commands
        assert len(self.manager.commands["status"]) == 1

        await self.manager.removeModule("PaGS.modules.statusModule")

        # is the module unloaded?
        assert len(self.manager.multiModules) == 1
        assert "status" not in self.manager.commands

    async def test_cmd_status(self):
        """Test the "show" command"""
        self.manager.addModule("PaGS.modules.statusModule")

        # test with no params
        self.manager.onModuleCommandCallback("VehA", "status status")

        # assert
        assert self.getOutText("VehA", 1) == "No status packets recieved yet"

        # now there's a status packet at vehicle
        self.VehA.latestPacketDict[
            "SYS_STATUS"] = self.mod.MAVLink_sys_status_message(
                52485167, 35684399, 52461871, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)

        # test with no params
        self.manager.onModuleCommandCallback("VehA", "status status")

        # assert
        assert self.getOutText("VehA", 3) == "3D_GYRO: Healthy"
        assert self.getOutText("VehA", 4) == "3D_ACCEL: Healthy"
        assert self.getOutText("VehA", 5) == "3D_MAG: Healthy"

    async def test_guiStart(self):
        """Simple test of the GUI startup"""

        # need to reset for handling gui
        self.manager = moduleManager.moduleManager(self.loop, self.settingsdir,
                                                   True)
        self.manager.onVehListAttach(self.getVehListCallback)
        self.manager.onVehGetAttach(self.getVehicleCallback)
        self.manager.onPktTxAttach(self.txcallback)

        self.manager.addModule("internalPrinterModule")

        self.manager.addModule("PaGS.modules.statusModule")

        # Wait for param gui to load
        await asyncio.sleep(0.2)

        # Update the GUI with some status
        pkt = self.mod.MAVLink_sys_status_message(52485167, 35684399, 52461871,
                                                  0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
        self.manager.multiModules["PaGS.modules.statusModule"].incomingPacket(
            "VehA", pkt)

        # TODO: some GUI tests?

    def getOutText(self, Veh: str, line: int):
        """Helper function for getting output text from internalPrinterModule"""
        return self.manager.multiModules['internalPrinterModule'].printedout[
            Veh][line]
Пример #23
0
class VehicleTest(asynctest.TestCase):

    """
    Class to test Vehicle
    """

    def setUp(self):
        """Set up some data that is reused in many tests"""
        self.dialect = 'ardupilotmega'
        self.mavversion = 2.0
        self.source_system = 255
        self.source_component = 0
        self.target_system = 1
        self.target_component = 0

        # This is the "vehicle" to respond to messages
        self.mod = getpymavlinkpackage(self.dialect, self.mavversion)
        self.mavVehicle = self.mod.MAVLink(self, srcSystem=self.target_system,
                                           srcComponent=self.target_component,
                                           use_native=False)
        self.mavVehicle.robust_parsing = True

        self.veh = None

        self.txpackets = []

        self.onNewPackets = []

    def onNewEvent(self, vehName, pkt):
        """Callback for new packet"""
        self.onNewPackets.append(pkt)

    async def tearDown(self):
        """Close down the test"""
        if self.veh:
            await self.veh.stopheartbeat()
            await self.veh.stoprxtimeout()

    def newpacketcallback(self, buf: bytes, vehname: str):
        """Callback when a vehicle sends a packet"""
        self.txpackets.append(buf)

    def paramcallback(self, buf: bytes, vehname: str):
        """Callback when a vehicle sends a packet - for param testing"""
        # if param request, start sending some params
        pkt = self.mavVehicle.parse_char(buf)
        if isinstance(pkt, self.mod.MAVLink_param_request_list_message):
            # send all params (3 of them)
            pkt = self.mod.MAVLink_param_value_message(
                'RC8_MIN', 1100, self.mod.MAV_PARAM_TYPE_REAL32, 3, 0)
            self.veh.newPacketCallback(pkt)
            pkt = self.mod.MAVLink_param_value_message(
                'RC8_TRIM', 1500, self.mod.MAV_PARAM_TYPE_REAL32, 3, 1)
            self.veh.newPacketCallback(pkt)
            pkt = self.mod.MAVLink_param_value_message(
                'RC8_MAX', 1900, self.mod.MAV_PARAM_TYPE_REAL32, 3, 2)
            self.veh.newPacketCallback(pkt)
        # callback for setting a param
        elif isinstance(pkt, self.mod.MAVLink_param_set_message):
            # send back confirmation
            pkt = self.mod.MAVLink_param_value_message(
                pkt.param_id, pkt.param_value, pkt.param_type, 1, 1)
            self.veh.newPacketCallback(pkt)

    def paramcallbackpartial(self, buf: bytes, vehname: str):
        """Callback when a vehicle sends a packet - for param testing"""
        # if param request, start sending some params
        pkt = self.mavVehicle.parse_char(buf)
        if isinstance(pkt, self.mod.MAVLink_param_request_list_message):
            # send all params (3 of them)
            pkt = self.mod.MAVLink_param_value_message(
                'RC8_MIN', 1100, self.mod.MAV_PARAM_TYPE_REAL32, 3, 0)
            self.veh.newPacketCallback(pkt)
            pkt = self.mod.MAVLink_param_value_message(
                'RC8_MAX', 1900, self.mod.MAV_PARAM_TYPE_REAL32, 3, 2)
            self.veh.newPacketCallback(pkt)
        if isinstance(pkt, self.mod.MAVLink_param_request_read_message):
            # get the missing param
            if pkt.param_index == 1:
                pkt = self.mod.MAVLink_param_value_message(
                    'RC8_TRIM', 1500, self.mod.MAV_PARAM_TYPE_REAL32, 3, 1)
                self.veh.newPacketCallback(pkt)

    async def test_vehicle(self):
        """Test vehicle initialises OK"""
        self.veh = Vehicle(self.loop, "VehA", self.source_system, self.source_component,
                           self.target_system, self.target_component, self.dialect, self.mavversion)

        assert self.veh is not None

    # async def test_onPacketCallback(self):
    #    """Test the onPacketCallback works"""
    #    self.veh = Vehicle(self.loop, "VehA", self.source_system, self.source_component,
    #                       self.target_system, self.target_component, self.dialect, self.mavversion)
    #    self.veh.onPacketRxAttach(self.onNewEvent)
    #
    #    pkt = self.mod.MAVLink_heartbeat_message(
    #        self.mod.MAV_TYPE_QUADROTOR, self.mod.MAV_AUTOPILOT_ARDUPILOTMEGA, 0, 0, 0, int(self.mavversion))
    #    self.veh.newPacketCallback(pkt)
    #
    #    await asyncio.sleep(0.01)
    #
    #    assert len(self.onNewPackets) == 1
    #    assert self.onNewPackets[0] == pkt

    async def test_getPacket(self):
        """Test getting a packet"""
        self.veh = Vehicle(self.loop, "VehA", self.source_system, self.source_component,
                           self.target_system, self.target_component, self.dialect, self.mavversion)
        pkt = self.mod.MAVLink_heartbeat_message(
            self.mod.MAV_TYPE_QUADROTOR, self.mod.MAV_AUTOPILOT_ARDUPILOTMEGA, 0, 0, 0, int(self.mavversion))
        self.veh.newPacketCallback(pkt)

        await asyncio.sleep(0.01)

        assert len(self.veh.latestPacketDict) == 1
        assert self.veh.getPacket(self.mod.MAVLINK_MSG_ID_HEARTBEAT) == pkt
        assert self.veh.getPacket(
            self.mod.MAVLINK_MSG_ID_ESC_TELEMETRY_9_TO_12) is None

    async def test_heartbeat(self):
        """Test heatbeat rate and stopping hb task"""
        self.veh = Vehicle(self.loop, "VehA", self.source_system, self.source_component,
                           self.target_system, self.target_component, self.dialect, self.mavversion)
        self.veh.txcallback = self.newpacketcallback

        await self.veh.setHearbeatRate(0.001)
        await asyncio.sleep(0.15)

        # stop for a while - no extra hb emitted
        await self.veh.setHearbeatRate(0)
        await asyncio.sleep(0.01)

        # due to timer jitter, can only test for approx rate
        # Expecting between 4 and 120 hb packets
        assert len(self.txpackets) > 4
        assert len(self.txpackets) < 120

    async def test_noheartbeat(self):
        """Test no hb task ever"""
        self.veh = Vehicle(self.loop, "VehA", self.source_system, self.source_component,
                           self.target_system, self.target_component, self.dialect, self.mavversion)
        self.veh.txcallback = self.newpacketcallback

        await self.veh.setHearbeatRate(0)
        await asyncio.sleep(0.01)

        assert len(self.txpackets) == 0

    async def test_rxheartbeat(self):
        """Test correct rx of hb from vehicle - time of last packet"""
        self.veh = Vehicle(self.loop, "VehA", self.source_system, self.source_component,
                           self.target_system, self.target_component, self.dialect, self.mavversion)
        self.veh.txcallback = self.newpacketcallback
        await self.veh.setTimeout(0.05)

        pkt = self.mod.MAVLink_heartbeat_message(
            self.mod.MAV_TYPE_QUADROTOR, self.mod.MAV_AUTOPILOT_ARDUPILOTMEGA, 0, 0, 0, int(self.mavversion))
        self.veh.newPacketCallback(pkt)

        await asyncio.sleep(0.02)
        assert self.veh.isConnected is True

        await asyncio.sleep(0.10)
        assert self.veh.isConnected is False

    async def test_norxheartbeat(self):
        """Test no rx hb task ever"""
        self.veh = Vehicle(self.loop, "VehA", self.source_system, self.source_component,
                           self.target_system, self.target_component, self.dialect, self.mavversion)

        await self.veh.setTimeout(0)
        await asyncio.sleep(0.01)

        assert self.veh.isConnected is False

    async def test_vehtypename(self):
        """Test correct veh type and gf name from vehicle"""
        self.veh = Vehicle(self.loop, "VehA", self.source_system, self.source_component,
                           self.target_system, self.target_component, self.dialect, self.mavversion)
        self.veh.txcallback = self.newpacketcallback

        pkt = self.mod.MAVLink_heartbeat_message(
            self.mod.MAV_TYPE_QUADROTOR, self.mod.MAV_AUTOPILOT_ARDUPILOTMEGA, 0, 0, 0, int(self.mavversion))
        self.veh.newPacketCallback(pkt)

        assert self.veh.fcName == "MAV_AUTOPILOT_ARDUPILOTMEGA"
        assert self.veh.vehType == "MAV_TYPE_QUADROTOR"

    async def test_armmodestatus(self):
        """Test getting of the arming status and mode from heartbeat"""
        self.veh = Vehicle(self.loop, "VehA", self.source_system, self.source_component,
                           self.target_system, self.target_component, self.dialect, self.mavversion)

        assert self.veh.isArmed is None
        assert self.veh.flightMode is None

        pkt = self.mod.MAVLink_heartbeat_message(
            self.mod.MAV_TYPE_QUADROTOR, self.mod.MAV_AUTOPILOT_ARDUPILOTMEGA, self.mod.MAV_MODE_AUTO_DISARMED, 0, 0, int(self.mavversion))
        self.veh.newPacketCallback(pkt)

        assert self.veh.isArmed is False
        assert self.veh.flightMode == "0"

        pkt = self.mod.MAVLink_heartbeat_message(
            self.mod.MAV_TYPE_QUADROTOR, self.mod.MAV_AUTOPILOT_ARDUPILOTMEGA, self.mod.MAV_MODE_MANUAL_ARMED, 1, 0, int(self.mavversion))
        self.veh.newPacketCallback(pkt)

        assert self.veh.isArmed is True
        assert self.veh.flightMode == "1"

        pkt = self.mod.MAVLink_heartbeat_message(
            self.mod.MAV_TYPE_QUADROTOR, self.mod.MAV_AUTOPILOT_ARDUPILOTMEGA, self.mod.MAV_MODE_MANUAL_DISARMED, 15, 0, int(self.mavversion))
        self.veh.newPacketCallback(pkt)

        assert self.veh.isArmed is False
        assert self.veh.flightMode == '15'

    async def test_params_before(self):
        """Test getting of the parameters before downloaded"""
        self.veh = Vehicle(self.loop, "VehA", self.source_system, self.source_component,
                           self.target_system, self.target_component, self.dialect, self.mavversion)

        assert self.veh.getParams('RC8_MAX') is None
        assert self.veh.getParams() is None

    async def test_params_noresponse(self):
        """Test getting of the parameters, no response from vehicle"""
        self.veh = Vehicle(self.loop, "VehA", self.source_system, self.source_component,
                           self.target_system, self.target_component, self.dialect, self.mavversion)
        await self.veh.downloadParams(timeout=0.1)

        assert self.veh.getParams('RC8_MAX') is None
        assert self.veh.getParams() is None

    async def test_get_params(self):
        """Test getting of the parameters, got all. Plus typo"""
        self.veh = Vehicle(self.loop, "VehA", self.source_system, self.source_component,
                           self.target_system, self.target_component, self.dialect, self.mavversion)
        self.veh.txcallback = self.paramcallback
        await self.veh.downloadParams(timeout=0.25)

        assert self.veh.getParams('RC8_MAX') == 1900
        assert self.veh.getParams('RC8_MAXXX') is None

    async def test_get_params_retry(self):
        """Test getting of the parameters, need to retry some"""
        self.veh = Vehicle(self.loop, "VehA", self.source_system, self.source_component,
                           self.target_system, self.target_component, self.dialect, self.mavversion)
        self.veh.txcallback = self.paramcallbackpartial
        await self.veh.downloadParams(timeout=0.25)

        assert self.veh.getParams('RC8_MAX') == 1900
        assert self.veh.getParams('RC8_TRIM') == 1500

    async def test_set_param_no_params(self):
        """Test setting of params if params not downloaded yet"""
        self.veh = Vehicle(self.loop, "VehA", self.source_system, self.source_component,
                           self.target_system, self.target_component, self.dialect, self.mavversion)
        self.veh.txcallback = self.paramcallback

        assert await self.veh.setParam('RC8_MAX', 1800) is False

    async def test_set_param(self):
        """Test setting of param"""
        self.veh = Vehicle(self.loop, "VehA", self.source_system, self.source_component,
                           self.target_system, self.target_component, self.dialect, self.mavversion)
        self.veh.txcallback = self.paramcallback
        await self.veh.downloadParams(timeout=0.25)

        assert await self.veh.setParam('RC8_MAX', 1730) is True
        assert self.veh.getParams('RC8_MAX') == 1730

    def test_sendPacket(self):
        """Assembling a packet"""
        self.veh = Vehicle(self.loop, "VehA", self.source_system, self.source_component,
                           self.target_system, self.target_component, self.dialect, self.mavversion)
        self.veh.txcallback = self.newpacketcallback

        self.veh.sendPacket(self.mod.MAVLINK_MSG_ID_HEARTBEAT,
                            type=self.mod.MAV_TYPE_GCS,
                            autopilot=self.mod.MAV_AUTOPILOT_INVALID,
                            base_mode=0,
                            custom_mode=0,
                            system_status=0,
                            mavlink_version=int(self.mavversion))

        assert len(self.txpackets) == 1
Пример #24
0
class ModeModuleTest(asynctest.TestCase):
    """
    Class to test Mode module
    """
    def setUp(self):
        """Set up some data that is reused in many tests"""

        self.manager = None

        # The PaGS settings dir (just in source dir)
        self.settingsdir = os.path.join(os.getcwd(), ".PaGS")
        if not os.path.exists(self.settingsdir):
            os.makedirs(self.settingsdir)

        self.dialect = 'ardupilotmega'
        self.version = 2.0
        self.mod = getpymavlinkpackage(self.dialect, self.version)
        self.mavUAS = self.mod.MAVLink(self,
                                       srcSystem=4,
                                       srcComponent=0,
                                       use_native=False)
        self.VehA = Vehicle(self.loop, "VehA", 255, 0, 4, 0, self.dialect,
                            self.version)
        self.VehA.onPacketTxAttach(self.vehSendFunc)
        self.VehA.vehType = 1
        self.VehA.fcName = 3
        self.VehA.hasInitial = True

        self.txPackets = {}
        self.txVehPackets = {}
        self.txPackets["VehA"] = []

        self.manager = moduleManager.moduleManager(self.loop, self.settingsdir,
                                                   False)
        self.manager.onVehListAttach(self.getVehListCallback)
        self.manager.onVehGetAttach(self.getVehicleCallback)
        self.manager.onPktTxAttach(self.txcallback)

        self.manager.addModule("internalPrinterModule")

    async def tearDown(self):
        """Close down the test"""
        await self.VehA.stopheartbeat()
        await self.VehA.stoprxtimeout()
        if os.path.exists(self.settingsdir):
            shutil.rmtree(self.settingsdir)

    def vehSendFunc(self, buf, name):
        """Event for when vehicle send buffer"""
        self.txVehPackets[name] = buf

    def txcallback(self, name, pkt, **kwargs):
        """Event callback to sending a packet on to vehiclemanager"""
        self.txPackets[name].append(pkt)

    def getVehListCallback(self):
        """Get list of vehicles"""
        return ["VehA"]

    def getVehicleCallback(self, vehname):
        """Get a particular vehicle"""
        if vehname == "VehA":
            return self.VehA
        else:
            raise ValueError('No vehicle with that name')

    def getOutText(self, Veh: str, line: int):
        """Helper function for getting output text from internalPrinterModule"""
        return self.manager.multiModules['internalPrinterModule'].printedout[
            Veh][line]

    async def test_loadModule(self):
        """Test adding and removal of module"""
        self.manager.addModule("PaGS.modules.modeModule")

        # is the module loaded?
        assert len(self.manager.multiModules) == 2
        assert "mode" in self.manager.commands
        assert len(self.manager.commands["mode"]) == 5

        await self.manager.removeModule("PaGS.modules.modeModule")

        # is the module unloaded?
        assert len(self.manager.multiModules) == 1
        assert "mode" not in self.manager.commands

    def test_cmd_listmodes(self):
        """Test the listModes() command"""
        self.manager.addModule("PaGS.modules.modeModule")

        # execute a command
        self.manager.onModuleCommandCallback("VehA", "mode list")

        # and assert
        assert self.getOutText("VehA", 1)[0:18] == "Valid modes are: ["
        assert self.getOutText("VehA", 1)[-1] == "]"

    def test_cmd_doMode(self):
        """Test the doMode command"""
        self.manager.addModule("PaGS.modules.modeModule")

        # execute a bad mode
        self.manager.onModuleCommandCallback("VehA", "mode do BADMODE")

        # assert
        assert len(self.txPackets["VehA"]) == 0
        assert self.getOutText("VehA", 1) == "No mode: BADMODE"

        # execute a mode change
        self.manager.onModuleCommandCallback("VehA", "mode do AUTO")

        # assert
        assert len(self.txPackets["VehA"]) == 1
        assert len(self.txPackets) == 1

    async def test_cmd_armDisarm(self):
        """Test the arm and disarm commands"""
        self.manager.addModule("PaGS.modules.modeModule")

        # execute an arm
        self.manager.onModuleCommandCallback("VehA", "mode arm")

        # assert
        assert len(self.txPackets["VehA"]) == 1

        # execute a disarm
        self.manager.onModuleCommandCallback("VehA", "mode disarm")

        # assert
        assert len(self.txPackets["VehA"]) == 2
        assert len(self.txPackets) == 1

    async def test_cmd_reboot(self):
        """Test the reboot command"""
        self.manager.addModule("PaGS.modules.modeModule")

        # execute an arm
        self.manager.onModuleCommandCallback("VehA", "mode reboot")

        # assert
        assert len(self.txPackets["VehA"]) == 1

    def test_incoming(self):
        """Test incoming packets"""
        self.manager.addModule("PaGS.modules.modeModule")

        # change mode
        pkt = self.mod.MAVLink_heartbeat_message(
            self.mod.MAV_TYPE_QUADROTOR, self.mod.MAV_AUTOPILOT_ARDUPILOTMEGA,
            0, 0, 4, int(self.version))
        self.manager.incomingPacket("VehA", pkt, "Constr")

        # assert
        assert self.getOutText("VehA", 0) == "Mode changed to: STABILIZE"

        # Don't change mode
        self.manager.incomingPacket("VehA", pkt, "Constr")

        # assert no extra text
        assert len(self.manager.multiModules['internalPrinterModule'].
                   printedout["VehA"]) == 1
Пример #25
0
class ConnectionMatrixTest(asynctest.TestCase):

    """
    Class to test The connection matrix
    """

    def setUp(self):
        """Set up some data that is reused in many tests"""
        self.dialect = 'ardupilotmega'
        self.version = 2.0
        self.ip = "127.0.0.1"

        # The links
        self.linkA = 'tcpclient:127.0.0.1:15001'
        self.linkB = 'tcpserver:127.0.0.1:15020'
        self.linkC = 'udpclient:127.0.0.1:15002'
        self.linkD = 'udpserver:127.0.0.1:15021'

        # The vehicles. Note the vehicles A and C have the same sysid
        # Source s/c then target s/c
        self.VehA = Vehicle(self.loop, "VehA", 255, 0, 4,
                            0, self.dialect, self.version)
        self.VehB = Vehicle(self.loop, "VehB", 254, 0, 3,
                            0, self.dialect, self.version)
        self.VehC = Vehicle(self.loop, "VehC", 255, 0, 4,
                            0, self.dialect, self.version)

        # Dict of data rx'd by each link
        self.rxdata = {}

        # Dict of data rx'd by each vehicle
        self.vehpkts = {}

        self.mod = getpymavlinkpackage(self.dialect, self.version)
        # From the vehicle
        self.mavUAS = self.mod.MAVLink(
            self, srcSystem=4, srcComponent=0, use_native=False)
        self.mavoneUAS = self.mod.MAVLink(
            self, srcSystem=3, srcComponent=0, use_native=False)
        self.mavGCS = self.mod.MAVLink(
            self, srcSystem=255, srcComponent=0, use_native=False)
        self.mavoneGCS = self.mod.MAVLink(
            self, srcSystem=254, srcComponent=0, use_native=False)

    async def tearDown(self):
        """Called at the end of each test"""
        await self.VehA.stopheartbeat()
        await self.VehB.stopheartbeat()
        await self.VehC.stopheartbeat()
        await self.VehA.stoprxtimeout()
        await self.VehB.stoprxtimeout()
        await self.VehC.stoprxtimeout()

    def newpacketcallbackVeh(self, vehname, pkt, strconnection):
        """Callback when a vehicle has a new packet"""
        try:
            self.vehpkts[vehname].append(pkt)
        except KeyError:
            self.vehpkts[vehname] = [pkt]

    def newpacketcallbackLnk(self, pkt, strconnection):
        """Callback when a test link has a new packet"""
        try:
            self.rxdata[strconnection].append(pkt)
        except KeyError:
            self.rxdata[strconnection] = [pkt]

    async def test_matrixstartup(self):
        """Test a simple startup of the matrix"""
        matrix = ConnectionManager(self.loop, self.dialect, self.version, 0, 0)

        await matrix.stoploop()

        assert matrix is not None

    async def test_matrixaddremove(self):
        """Test adding and removing vehicles from the matrix"""
        matrix = ConnectionManager(self.loop, self.dialect, self.version, 0, 0)
        matrix.onPacketAttach(self.newpacketcallbackVeh)

        await matrix.addVehicleLink(self.VehA.name, self.VehA.target_system, self.linkB)
        await matrix.addVehicleLink(self.VehB.name, self.VehB.target_system, self.linkB)
        await matrix.addVehicleLink(self.VehC.name, self.VehC.target_system, self.linkD)

        # now wait for a bit - 0.02 sec
        await asyncio.sleep(0.02)

        assert len(matrix.getAllVeh()) == 3
        assert len(matrix.linkdict) == 2

        # remove a link - it will remove the associated veh C too
        await matrix.removeLink(self.linkD)

        # now wait for a bit - 0.02 sec
        await asyncio.sleep(0.02)

        assert len(matrix.getAllVeh()) == 2
        assert len(matrix.linkdict) == 1

        # remove a vehicle
        await matrix.removeVehicle(self.VehA.name)

        # now wait for a bit - 0.02 sec
        await asyncio.sleep(0.02)

        await matrix.stoploop()

        # assert. It should be VehA and linkB left
        assert len(matrix.getAllVeh()) == 1
        assert len(matrix.linkdict) == 1

    async def test_linkretry_tcp(self):
        """For each of the TCP link types, test that they
        keep re-trying to connect, by only adding in the
        other side of the link 0.5 sec after startup"""
        matrix = ConnectionManager(
            self.loop, self.dialect, self.version, 0, 0, 0.05)
        matrix.onPacketAttach(self.newpacketcallbackVeh)

        await matrix.addVehicleLink(self.VehA.name, self.VehA.target_system, self.linkA)
        await matrix.addVehicleLink(self.VehB.name, self.VehB.target_system, self.linkB)

        # now wait for a bit
        await asyncio.sleep(0.10)

        # now connect the other sides
        tcpserver = TCPConnection(rxcallback=self.newpacketcallbackLnk,
                                  dialect=self.dialect, mavversion=self.version,
                                  srcsystem=0, srccomp=0,
                                  server=True, name='tcpserver:127.0.0.1:15001')
        tcpclient = TCPConnection(rxcallback=self.newpacketcallbackLnk,
                                  dialect=self.dialect, mavversion=self.version,
                                  srcsystem=0, srccomp=0,
                                  server=False, name='tcpclient:127.0.0.1:15020')
        await self.loop.create_server(lambda: tcpserver, self.ip, 15001)
        await self.loop.create_connection(lambda: tcpclient, self.ip, 15020)

        # send packets on each link and wait
        await asyncio.sleep(0.20)

        pkt = self.mod.MAVLink_heartbeat_message(
            5, 4, 0, 0, 0, int(self.version))
        pktbytes = pkt.pack(self.mavUAS, force_mavlink1=False)
        pktbytesone = pkt.pack(self.mavoneUAS, force_mavlink1=False)
        tcpserver.send_data(pktbytes)
        tcpclient.send_data(pktbytesone)

        await asyncio.sleep(0.20)

        await matrix.stoploop()

        tcpserver.close()
        tcpclient.close()

        # assert the links are all still there
        assert len(matrix.getAllVeh()) == 2
        assert len(matrix.linkdict) == 2

        # assert packets were recived on both links (vehicles) in the matrix
        assert self.vehpkts[self.VehA.name][0].get_msgbuf() == pktbytes
        assert self.vehpkts[self.VehB.name][0].get_msgbuf() == pktbytesone

    async def test_linkretry_udp(self):
        """For each of the UDP link types, test that they
        keep re-trying to connect, by only adding in the
        other side of the link 0.5 sec after startup"""
        matrix = ConnectionManager(
            self.loop, self.dialect, self.version, 0, 0, 0.05)
        matrix.onPacketAttach(self.newpacketcallbackVeh)

        self.VehA.onPacketTxAttach(matrix.outgoingPacket)
        self.VehB.onPacketTxAttach(matrix.outgoingPacket)

        await matrix.addVehicleLink(self.VehA.name, self.VehA.target_system, self.linkC)
        await matrix.addVehicleLink(self.VehB.name, self.VehB.target_system, self.linkD)

        # now wait for a bit - 0.02 sec
        await asyncio.sleep(0.02)

        # now connect the other sides
        udpserver = UDPConnection(rxcallback=self.newpacketcallbackLnk,
                                  dialect=self.dialect, mavversion=self.version,
                                  srcsystem=0, srccomp=0,
                                  server=True, name='udpserver:127.0.0.1:15002')
        udpclient = UDPConnection(rxcallback=self.newpacketcallbackLnk,
                                  dialect=self.dialect, mavversion=self.version,
                                  srcsystem=0, srccomp=0,
                                  server=False, name='udpclient:127.0.0.1:15021')
        await self.loop.create_datagram_endpoint(lambda: udpserver,
                                                 local_addr=(self.ip, 15002))
        await self.loop.create_datagram_endpoint(lambda: udpclient,
                                                 remote_addr=(self.ip, 15021))

        # send packets on each link and wait 0.02 sec
        await asyncio.sleep(0.02)

        pkt = self.mod.MAVLink_heartbeat_message(
            5, 4, 0, 0, 0, int(self.version))
        pktbytes = pkt.pack(self.mavUAS, force_mavlink1=False)
        pktbytesone = pkt.pack(self.mavoneUAS, force_mavlink1=False)

        # need to send a packet from client to server to init the link
        self.VehA.sendPacket(self.VehA.mod.MAVLINK_MSG_ID_HEARTBEAT,
                             type=self.VehA.mod.MAV_TYPE_GCS,
                             autopilot=self.VehA.mod.MAV_AUTOPILOT_INVALID,
                             base_mode=0,
                             custom_mode=0,
                             system_status=0,
                             mavlink_version=int(self.VehA.mavversion))

        await asyncio.sleep(0.02)

        udpserver.send_data(pktbytes)
        udpclient.send_data(pktbytesone)

        await asyncio.sleep(0.02)

        await matrix.stoploop()

        udpserver.close()
        udpclient.close()

        # assert the links are all still there
        assert len(matrix.getAllVeh()) == 2
        assert len(matrix.linkdict) == 2

        # assert packets were recived on both links (vehicles) in the matrix
        assert len(self.vehpkts) == 2
        assert self.vehpkts[self.VehA.name][0].get_msgbuf() == pktbytes
        assert self.vehpkts[self.VehB.name][0].get_msgbuf() == pktbytesone

    async def test_incomingdistribution(self):
        """Test incoming packets (from vehicle) are distributed
        correctly"""
        # -VehA: LinkA,LinkB, VehB: LinkB, VehC: LinkC
        matrix = ConnectionManager(
            self.loop, self.dialect, self.version, 0, 0, 0.05)
        matrix.onPacketAttach(self.newpacketcallbackVeh)

        await matrix.addVehicleLink(self.VehA.name, self.VehA.target_system, self.linkA)
        await matrix.addVehicleLink(self.VehA.name, self.VehA.target_system, self.linkB)
        await matrix.addVehicleLink(self.VehB.name, self.VehB.target_system, self.linkB)
        await matrix.addVehicleLink(self.VehC.name, self.VehC.target_system, self.linkD)

        # now wait for a bit
        await asyncio.sleep(0.10)

        # now connect the other sides
        tcpserver = TCPConnection(rxcallback=self.newpacketcallbackLnk,
                                  dialect=self.dialect, mavversion=self.version,
                                  srcsystem=0, srccomp=0,
                                  server=True, name='tcpserver:127.0.0.1:15001')
        tcpclient = TCPConnection(rxcallback=self.newpacketcallbackLnk,
                                  dialect=self.dialect, mavversion=self.version,
                                  srcsystem=0, srccomp=0,
                                  server=False, name='tcpclient:127.0.0.1:15020')
        udpclient = UDPConnection(rxcallback=self.newpacketcallbackLnk,
                                  dialect=self.dialect, mavversion=self.version,
                                  srcsystem=0, srccomp=0,
                                  server=False, name='udpclient:127.0.0.1:15021')
        await self.loop.create_server(lambda: tcpserver, self.ip, 15001)
        await self.loop.create_connection(lambda: tcpclient, self.ip, 15020)
        await self.loop.create_datagram_endpoint(lambda: udpclient,
                                                 remote_addr=(self.ip, 15021))

        # send packets on each link and wait
        await asyncio.sleep(0.10)

        pkt = self.mod.MAVLink_heartbeat_message(
            5, 4, 0, 0, 0, int(self.version))
        pktbytes = pkt.pack(self.mavUAS, force_mavlink1=False)
        pktbytesone = pkt.pack(self.mavoneUAS, force_mavlink1=False)

        # send packet to VehA on LinkA
        tcpserver.send_data(pktbytes)
        await asyncio.sleep(0.10)

        # send new (updated) packet to VehA on LinkB
        pktupdate = self.mod.MAVLink_heartbeat_message(
            5, 3, 0, 0, 0, int(self.version))
        pktbytesupdate = pktupdate.pack(self.mavUAS, force_mavlink1=False)
        tcpclient.send_data(pktbytesupdate)

        # need a small sleep here otherwise the linkB gets confused
        await asyncio.sleep(0.10)

        # send packet to VehB on linkB
        tcpclient.send_data(pktbytesone)
        await asyncio.sleep(0.10)

        # send packet to VehC on LinkC
        udpclient.send_data(pktbytes)

        # wait for packets to send
        await asyncio.sleep(0.10)

        # and close everything
        await matrix.stoploop()

        tcpserver.close()
        tcpclient.close()
        udpclient.close()

        # assert the links are all still there
        assert len(matrix.getAllVeh()) == 3
        assert len(matrix.linkdict) == 3

        # assert packets were recived
        assert self.vehpkts[self.VehA.name][0].get_msgbuf() == pktbytes
        assert self.vehpkts[self.VehA.name][1].get_msgbuf() == pktbytesupdate
        assert self.vehpkts[self.VehB.name][0].get_msgbuf() == pktbytesone
        assert self.vehpkts[self.VehC.name][0].get_msgbuf() == pktbytes

    async def test_outgoingdistribution(self):
        """Test outgoing packets (from gcs) are distributed
        correctly"""
        # -VehA: LinkA,LinkB, VehB: LinkB, VehC: LinkC
        await self.VehA.setHearbeatRate(0)
        await self.VehB.setHearbeatRate(0)
        await self.VehC.setHearbeatRate(0)

        matrix = ConnectionManager(
            self.loop, self.dialect, self.version, 0, 0, 0.05)
        matrix.onPacketAttach(self.newpacketcallbackVeh)

        self.VehA.onPacketTxAttach(matrix.outgoingPacket)
        self.VehB.onPacketTxAttach(matrix.outgoingPacket)
        self.VehC.onPacketTxAttach(matrix.outgoingPacket)

        await matrix.addVehicleLink(self.VehA.name, self.VehA.target_system, self.linkA)
        await matrix.addVehicleLink(self.VehA.name, self.VehA.target_system, self.linkB)
        await matrix.addVehicleLink(self.VehB.name, self.VehB.target_system, self.linkB)
        await matrix.addVehicleLink(self.VehC.name, self.VehC.target_system, self.linkC)

        # now wait for a bit
        await asyncio.sleep(0.15)

        # now connect the other sides
        tcpserver = TCPConnection(rxcallback=self.newpacketcallbackLnk,
                                  dialect=self.dialect, mavversion=self.version,
                                  srcsystem=0, srccomp=0,
                                  server=True, name='tcpserver:127.0.0.1:15001')
        tcpclient = TCPConnection(rxcallback=self.newpacketcallbackLnk,
                                  dialect=self.dialect, mavversion=self.version,
                                  srcsystem=0, srccomp=0,
                                  server=False, name='tcpclient:127.0.0.1:15020')
        udpserver = UDPConnection(rxcallback=self.newpacketcallbackLnk,
                                  dialect=self.dialect, mavversion=self.version,
                                  srcsystem=0, srccomp=0,
                                  server=True, name='udpserver:127.0.0.1:15002')
        await self.loop.create_server(lambda: tcpserver, self.ip, 15001)
        await self.loop.create_connection(lambda: tcpclient, self.ip, 15020)
        await self.loop.create_datagram_endpoint(lambda: udpserver,
                                                 local_addr=(self.ip, 15002))

        # send packets on each link and wait
        await asyncio.sleep(0.15)

        # send packet from the GCS of VehA, VehB and VehC
        pktbytesA = self.VehA.sendPacket(self.mod.MAVLINK_MSG_ID_HEARTBEAT,
                                         type=self.mod.MAV_TYPE_GCS,
                                         autopilot=self.mod.MAV_AUTOPILOT_INVALID,
                                         base_mode=0,
                                         custom_mode=0,
                                         system_status=0,
                                         mavlink_version=int(self.VehA.mavversion))
        await asyncio.sleep(0.10)
        pktbytesB = self.VehB.sendPacket(self.mod.MAVLINK_MSG_ID_HEARTBEAT,
                                         type=self.mod.MAV_TYPE_GCS,
                                         autopilot=self.mod.MAV_AUTOPILOT_INVALID,
                                         base_mode=0,
                                         custom_mode=0,
                                         system_status=0,
                                         mavlink_version=int(self.VehB.mavversion))
        await asyncio.sleep(0.10)
        pktbytesC = self.VehC.sendPacket(self.mod.MAVLINK_MSG_ID_HEARTBEAT,
                                         type=self.mod.MAV_TYPE_GCS,
                                         autopilot=self.mod.MAV_AUTOPILOT_INVALID,
                                         base_mode=0,
                                         custom_mode=0,
                                         system_status=0,
                                         mavlink_version=int(self.VehC.mavversion))

        # wait for packets to send
        await asyncio.sleep(0.15)

        # and close everything
        await matrix.stoploop()

        tcpserver.close()
        tcpclient.close()
        udpserver.close()

        # assert the links are all still there
        assert len(matrix.getAllVeh()) == 3
        assert len(matrix.linkdict) == 3

        # assert packets were recived on the endpoints
        assert self.rxdata['tcpserver:127.0.0.1:15001'][0].get_msgbuf(
        ) == pktbytesA
        assert self.rxdata['tcpclient:127.0.0.1:15020'][0].get_msgbuf(
        ) == pktbytesC
        assert self.rxdata['tcpclient:127.0.0.1:15020'][1].get_msgbuf(
        ) == pktbytesB
        assert self.rxdata['udpserver:127.0.0.1:15002'][0].get_msgbuf(
        ) == pktbytesC
Пример #26
0
    async def test_vehicle(self):
        """Test vehicle initialises OK"""
        self.veh = Vehicle(self.loop, "VehA", self.source_system, self.source_component,
                           self.target_system, self.target_component, self.dialect, self.mavversion)

        assert self.veh is not None
Пример #27
0
class ModuleManagerTest(asynctest.TestCase):
    """
    Class to test manager module commands
    """
    def setUp(self):
        """Set up some data that is reused in many tests"""

        self.manager = None

        # The PaGS settings dir (just in source dir)
        self.settingsdir = os.path.join(os.getcwd(), ".PaGS")
        if not os.path.exists(self.settingsdir):
            os.makedirs(self.settingsdir)

        self.dialect = 'ardupilotmega'
        self.version = 2.0
        self.mod = getpymavlinkpackage(self.dialect, self.version)
        self.mavUAS = self.mod.MAVLink(self,
                                       srcSystem=4,
                                       srcComponent=0,
                                       use_native=False)
        self.VehA = Vehicle(self.loop, "VehA", 255, 0, 4, 0, self.dialect,
                            self.version)
        self.VehA.onPacketTxAttach(self.vehSendFunc)
        self.VehA.vehType = 1
        self.VehA.fcName = 3
        self.VehA.hasInitial = True

        self.txPackets = {}
        self.txVehPackets = {}
        self.txPackets["VehA"] = []

        self.manager = moduleManager.moduleManager(self.loop, self.settingsdir,
                                                   False)
        self.manager.onVehListAttach(self.getVehListCallback)
        self.manager.onVehGetAttach(self.getVehicleCallback)
        self.manager.onPktTxAttach(self.txcallback)

        self.manager.addModule("internalPrinterModule")

    async def tearDown(self):
        """Close down the test"""
        await self.VehA.stopheartbeat()
        await self.VehA.stoprxtimeout()
        if os.path.exists(self.settingsdir):
            shutil.rmtree(self.settingsdir)

    def vehSendFunc(self, buf, name):
        """Event for when vehicle send buffer"""
        self.txVehPackets[name] = buf

    def txcallback(self, name, pkt, **kwargs):
        """Event callback to sending a packet on to vehiclemanager"""
        self.txPackets[name].append(pkt)

    def getVehListCallback(self):
        """Get list of vehicles"""
        return ["VehA"]

    def getVehicleCallback(self, vehname):
        """Get a particular vehicle"""
        if vehname == "VehA":
            return self.VehA
        else:
            raise ValueError('No vehicle with that name')

    def getOutText(self, Veh: str, line: int):
        """Helper function for getting output text from internalPrinterModule"""
        return self.manager.multiModules['internalPrinterModule'].printedout[
            Veh][line]

    def test_loadModule(self):
        """Test loading: good, bad and existing"""
        self.manager.onModuleCommandCallback("VehA",
                                             "module load modules.dontexist")

        assert self.getOutText("VehA", 1) == "Cannot find module"
        assert len(self.manager.multiModules) == 1

        self.manager.onModuleCommandCallback("VehA",
                                             "module load modules.modeModule")

        assert self.getOutText("VehA", 3) == "Loaded module modules.modeModule"
        assert len(self.manager.multiModules) == 2

        self.manager.onModuleCommandCallback("VehA",
                                             "module load modules.modeModule")

        assert self.getOutText("VehA", 5) == "Module already loaded"
        assert len(self.manager.multiModules) == 2

    def test_listModule(self):
        """
        Test listing of modules "module list"
        """
        self.manager.onModuleCommandCallback("VehA", "module list")

        assert self.getOutText("VehA", 1) == "Loaded Modules: "
        assert self.getOutText("VehA", 2) == "internalPrinterModule"

        self.manager.onModuleCommandCallback("VehA",
                                             "module load modules.modeModule")
        self.manager.onModuleCommandCallback("VehA", "module list")

        # The loaded module listing order is not important
        assert self.getOutText("VehA", 6) == "Loaded Modules: "
        assert self.getOutText(
            "VehA", 7) == "internalPrinterModule" or "PaGS.modules.modeModule"
        assert self.getOutText(
            "VehA", 8) == "internalPrinterModule" or "PaGS.modules.modeModule"
        assert self.getOutText("VehA", 7) != self.getOutText("VehA", 8)