IMA5 2018/2019 P36

Présentation générale

Description

Dans le cadre de ce projet, le drone Parrot Bebop 2 est mis à disposition à des fins expérimentaux. Nous ferons initialement des essais de vols de drones de manière à le maitriser à l’aide de la manette de pilotage ou de l'application smartphone FreeFlight Pro. Nous avons décidé de nous focaliser sur l’aspect suivant : Le maintien en équilibre en hauteur du drone, avec rejet de perturbations, en le pilotant de manière autonome (sans l’utilisation des manettes ou d'une application smartphone).

Le développement des applications pourra se faire sous Linux en passant par ROS, Robot Operating System, grâce à Matlab Simulink ou une application sous le langage Python. Une démarche de prospection et recherche bibliographique est nécessairement entreprise afin de se renseigner le plus possible sur les outils utilisables.

Objectifs

L'objectif est de pouvoir rendre autonome un drone afin qu'il puisse se maintenir en hauteur et se stabiliser automatiquement lors de perturbations. Nous devons pour cela prendre en main le drone au niveau de tous les aspects afin de pouvoir implémenter le programme que l'on souhaite.

L'application qui sera mise en place se fera en principe sous Linux grâce à ROS et Simulink ou par une application Python.

Des réunions hebdomadaires se tiendront avec les encadrants afin de s’échanger sur les avancées du projet.

Préparation du projet

Cahier des charges

- Découvrir, prendre en main et piloter le drone

- Réaliser un schéma bloc pour desceller les différents organes et voir les différentes interactions

- Aspect stabilisation en hauteur et compensation des perturbations

- Utilisation possible de la caméra frontale afin de dicter une commande (facultatif)

- Prises en mains des outils utilisables et faire un choix sur lequel utiliser

- Rendre exploitable le travail final afin que les personnes souhaitant travailler sur ce projet puissent rajouter et mettre en avant leurs connaissances et compétences

Choix techniques : matériel et logiciel

- Drone Parrot Bebop 2

- Environnement Linux

- ROS : Robot Operating System

- Matlab Simulink avec Toolbox Robotic system

Calendrier prévisionnel

Réalisation du Projet

Semaine 1

Lors de la première semaine, nous avons convenu un rendez-vous avec nos encadrants, Mme Lecocq et Mr Nakrachi, afin de discuter et de fixer les attentes concernant ce projet. Nous avons évoqué les sujets suivants :

- L'organisation des rencontres étudiants-encadrants

- Ce que l'on attend du projet

- Ce qu'ils attendent du projet

- Les informations actuellement à leurs dispositions pour la réalisation du projet

- La gestion du projet

Nous avons par la même occasion fixé donc les objectifs de ce projet.

De ce fait afin de se lancer, nous avons tout d'abord effectuer des recherches sur l'appareil que nous utilisons pour connaitre plus en détail son fonctionnement mais également user de toutes ces capacités.

Ce drone est composé des éléments suivants :

- Caractéristiques techniques :

   Poids : 500 g
   Autonomie : 25 min
   Nombre de moteurs : 4
   Capacité de la batterie : 2700 mAh
   Altitude maximale de vol : 150 m
   Vitesse max : 60 km/h

- Une caméra verticale : Elle permet le maintien d’un point fixe. Une fréquence de comparaison d'une image du sol à la précédente de 62,5Hz soit 16ms.

- Un capteur à ultrason : Ce capteur permet de calculer l’altitude de vol jusqu’à 5 mètres.

- Un baromètre (capteur de pression) : Il permet de mesurer la pression et de calculer l'altitude de vol lorsque celle-ci dépasse les 5 mètres.

- Un gyroscope 3 axes : Il permet de calculer l’angle d’inclinaison de l’appareil.

- Un accéléromètre : Il permet de mesurer l’orientation du drone sur 3 axes et sa vitesse linéaire.

- Un magnétomètre 3 axes : Il donne la possibilité de définir la position du drone, à l’image d’une boussole.

- Une puce GNSS (GPS + GLONASS): Cette puce permet la géolocalisation du drone avec précision et aide à mesurer la vitesse au sol de façon très fine pour optimiser la tenue du point fixe en vol stationnaire.

Suites aux recherches effectuées sur le drone, nous nous sommes tournés sur les boites à outils essentielles à Matlab pour mener à bien les objectifs. La principale toolbox que nous allons utiliser est Robotic System. Cette Toolbox fournit des algorithmes de robotique communs et inclut une interface entre MATLAB et Simulink et le Robot Operating System (ROS). Avec cette boîte à outils, on peut explorer des données du robot en mode interactif, le design(la conception, tester des algorithmes avec un simulateur et un robot physique, générer du code en C ++ et analyser des données du journal du robot.

Grâce aux recherches effectuées, nous avons remarqué que nous devions contrôler le drône en wifi et qu'il était préférable de gerer la communication avec le drône avec ROS (Robotics Operating System). ROS est un ensemble d'outils informatiques open source permettant de développer des logiciels ou programmes pour la robotique. Nous allons donc dans ce projet, creer un programme Matlab-Simulink, l'envoyer sur ROS grâce a la Toolbox Robotic System puis gerer la connexion jusqu'au drône via ROS.

Semaine 2

Lors de cette semaine, une réunion avec les encadrants a été mise en place le 26/09 afin de communiquer ce qui a été fait jusqu'ici. Une demande auprès des encadrants concernant la référence et la datasheet des composants du drone Parrot Bebop 2 a été sollicité. Un travail approfondi sur les différents commandes ROS, la toolbox Robotic System et les différents moyens de communication avec le Bebop 2.

Concernant ROS, afin de le faire fonctionner, nous devons installer un environnement de travail adéquat. Cet environnement de travail est Catkin. Catkin va nous permettre ici d'utiliser ROS mais aussi de compiler les divers programmes.

Pour pouvoir installer sur Linux, notre environnement de travail, nous utilisons les commandes ci-après.

   $ mkdir -p ~/catkin_ws_<votre_nom>/src 
   $ cd ~/catkin_ws_<votre_nom>/src 
   $ catkin_init_workspace

Ici, la ligne de commande catkin_init_workspace permet la création d’un lien CMakeLists.txt vers /opt/ros/kinetic/share/catkin/cmake/toplevel.cmake

Suite à ça, nous devons construire notre espace de travail. Pour ceci nous allons utiliser la commande catkin_make qui est un outil qui facilite le travail avec les catkin workspaces. Cette commande va également créer des repertoires "devel" et "build". Le repertoire est l’emplacement par défaut de l’espace de développement « devel space », qui est l’endroit où nos exécutables et les bibliothèques de nos packages vont être installés. Le repertoire "build", quant à lui, est l’emplacement par défaut de l’espace de construction « build space » et c’est dans ce répertoire que « cmake » et « make » sont appelés à configurer et construire nos packages.

Afin de contruire notre espace de travail, nous avons donc utilisé les commandes :

   $ mkdir -p ~/catkin_ws/src
   $ cd ~/catkin_ws_<votre_nom>/ 
   $ catkin_make

Après avoir crée les 2 répertoires, nous avons sourcé le fichier setup présent dans le "devel" puis nous avons commencé à installer les packages de ROS

   $ source devel/setup.bash

Caractéristiques clefs de la toolbox : ( A FINIR )

Semaine 3

Nous avons eu accès au dossier du projet de Cristal qui porte également sur le Bebop2. Leur projet consiste principalement à récupérer des données de vols mais également de pouvoir le contrôler et d'intégrer des programmes. Suite à quelques recherches, nous sommes arrivées aux conclusions suivantes pour accéder aux entrées sorties du drone. :

- Par défaut, le Bebop2 est pilotable via le SDK de Parrot

- Possible d'utiliser d'autres outils comme ROS ou Robompap3

Le SDK permet de connecter, de piloter, recevoir un directe de la caméra, sauvegarder et télécharger des médias (photo ou vidéo), envoyer des plans de vol, de piloter automatiquement et de mettre à jour le drone. FreeFlight3 utilise le SDK. Peu d'informations issues des capteurs et des actionneurs sont accessibles avec le SDK et il n'est pas possible de piloter directement les moteurs. Néanmoins, Parrot met à dispositions des commandes permettant de réaliser des figures ou des tâches complexes tel que des flips ou le trajet d'un point A à un point B. ( Lien d'utilisation SDK : https://developer.parrot.com/docs/SDK3/#general-information )

Liste des entrées accessibles avec le SDK :

- latitude (double): Position en latitude au dixième de degrés

- longitude (double): Position en longitude au dixième de degrés

- altitude (double): Altitude en mètres

- speedX (float): Vitesse relative au Nord en m/s (Quand le drone se deplace vers le Nord, vitesse > 0)

- speedY (float): Vitesse relative à l'EST en m/s (Quand le drone se deplace vers l'Est, une vitesse > 0)

- speedZ (float): Vitesse sur l'axe Z (Quand le drone passe d'une position haute à une position basse, vitesse > 0) (in m/s)

- roll (float): Valeur du mouvement en roulade (en radian)

- pitch (float): Valeur de tangage (en radian)

- yaw (float): Valeur de lacet (en radian)

- longitude_accuracy (i8): Erreur de localisation en longitude (en mètre)

- latitude_accuracy (i8): Erreur de localisation en latitude (en mètre)

- altitude_accuracy (i8): Erreur de localisation pour l'altitude (en mètre)

- picture grâce à la caméra avant

- Vidéo, accès en directe de la caméra si un écran est connecté

- État de la batterie : Pourcentage de batterie

Liste des commandes offertes par le SDK : ( Lien sur les différentes commandes et comment les implémenter https://developer.parrot.com/docs/reference/bebop_2/index.html#bebop-2-commands )

- flip: Drône effectue un flip

- horizontal_panorama: Rotation horizontale du drone

- dronie: Vol du drône sur une distance donnée avec un angle calculé

- horizontal_reveal: Inclinaison du drône vers le bas, puis avance en stablisant la caméra vers l'avant.

- vertical_reveal: Inclinaison du drône vers le bas, puis monte en hauteur en stablisant la caméra vers l'avant.

- parabola: Le drone esquive une cible en effectuant un mouvement en parabole.

- candle: Le drone vole horizontalement en direction de la cible puis s'envole.

- take off : Décollage

- land : Atterrissage

Nous savons qu'à travers SDK , nous pouvons effectuer ces tâches avec le drône, le travail est donc de pouvoir lié ces tâches avec ROS afin de pouvoir récupérer les données mais également pouvoir implémenter des tâches effectuées automatiquement .

Semaine 4

Apres ce début de recherche sur ROS et le SDK de Parro, nous avons donc commencé a installer, dans un premier temps le SDK afin de pouvoir nous connecter au drone et lancer l'une des commandes de base. Afin d'installer le SDK, nous avons donc tout d'abord décidé de l'installer sur le sous-système Ubuntu present sur Windows 10 afin de pouvoir utiliser matlab en meme temps et donc de récuperer les fichiers Simulink que l'on créera. Ce sous-système va nous permettre d'avoir un Shell sur Windows et donc de pouvoir installer SDK et ROS avec de simples lignes de commande (ce qui n'est pas possible avec l'invite de commande Windows). Nous avons fait ce choix car pour le moment, nous ne possèdons pas Matlab sur Linux. Les lignes de commande pour installer le SDK sont donc identiques.

Afin d'installer le SDK, nous procédons de la façon suivante :

• Installation du SDK

• Compilation de l'éxecutable

• Utilisation de l'exemple

Pour l'étape d'installation nous devons aller chercher le fichier d'installation sur Git. Pour réaliser ceci nous utilisons la commande repo qui va définir exactement où trouver les repositories, quelles branches récupérer, où créer les dossiers, etc. La commande est la suivante

     repo init -u https://github.com/Parrot-Developers/arsdk_manifests.git -m release.xml

Une fois le fichier télechargé, on synchronise ensuite tous les repositories :

     repo sync

Maintenant que les repositories sont bien synchronisés, nous pouvons compiler l'exécutable crée lors du téléchargement du fichier. Pour ce faire, nous faisons :

     ./build.sh -p arsdk-native -t build-sdk -j

Nous avons donc crée des fichiers présents dans /out/Unix-base/staging/usr

Nous avons rencontrés quelques soucis lors de ces commandes car pour pouvoir les réaliser, nus avons du telecharger un système d'exploitation (ici Debian 9). Mais, une fois ce dernier mi, nous devions installer manuellement tous les packages nécéssaires (comme man, python3, c++...) ce qui a donné lieu a de nombreuses erreurs.

ROS est un outil ouvert mais assez généraliste quant à son utilisation dans certains programmes. SDK quant à lui est un outil fermé où seules des instructions pré-faites de Parrot peuvent être utilisées.

Le prochaine objectif est de connecter le drone avec ROS et de pouvoir juger de l'utilité de matlab sur le drone bebop2.