IMA5 2018/2019 P36

De Wiki de Projets IMA
Révision datée du 9 novembre 2018 à 10:18 par Aayoub (discussion | contributions) (Semaine 4)


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.


Composants drone Parrot Bebop 2

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

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érentes commandes ROS, la toolbox Robotic System et les différents moyens de communication avec le Bebop 2 via le SDK.

Nous nous sommes concentrés tout d'abord sur le SDK

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

Build arsdk





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.

Une fois le SDK pret a être utilisé, nous avons donc essayer de lancer un executable d'exemple pour pouvoir manipuler le drone. Cet executable se nomme BebopSample et nous le compilons en utilisant :

     ./build.sh -p arsdk-native -t build-sample-BebopSample -j

Nous retrouvons donc l'executable ci dessous :

executable BebopSample




L'éxécutable a donc été crée a partir d'un fichier .C présent en ~/packages/Samples/Unix/BebopSample

Code BebopSample


Nous pouvons donc, en utilisant la commande vi, voir quelles sont les commandes nécessaires pour contrôler le robot.

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.


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.


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

Nous avons tout d’abord commencé notre porjet avec la version 18.0 de ubuntu. Nous avons réalisé le controle du drone avec SDK avec succés. Nous passons alors à l’installation de ROS. Ayant choisi la version kinetic qui est la plus complète et la plus stable, nous nous sommes rendus compte que celle-ci n’était compatible qu’avec la version 14.0 et 16.0 de ubuntu. Nous nous sommes tournés en premier lieu sur la version melodic qui est la seule compatible avec la version 18.0. Suite à cela, des erreurs de compilation pour des fichiers inexistants et des dependances, nous avons opté de downgrade à ubuntu 16.0 pour pouvoir utiliser ros kinetic. Après le downgrade, nous avons installé à nouveaux les différents outils extern afin de pouvoir compiler le SDK et ROS. Les outils externes pour compiler le SDK sont les suivants :

 git 
 build-essential
 autoconf 
 libtool 
 python 
 python3   
 libavahi-client-dev
 libavcodec-dev
 libavformat-dev
 libswscale-dev
 libncurses5-dev
 mplayer

Semaine 5

Une fois le SDK de Parrot installé et testé, nous avons installé le système d’exploitation Robotique ROS. (Robotic Operating System). Ce dernier est considéré comme un système d’exploitation pour robot pour l’ensemble des services qu’il peut fournir comme par exemple la gestion de bases de données, la gestion de la concurrence, la gestion des processus ou ensemble le paramétrage de robot.

Pourquoi utiliser un OS et pas directement un logiciel adapté ?

Nous avons décidé d’utilisé un OS pour faciliter l’exécution et la gestion des programmes. En effet, dans notre cas précis, nous souhaitons commander en temps réel notre robot et donc recevoir de nombreuses données des capteurs pour pouvoir le commander. Le fait d’utiliser un OS nous permettra d’éviter de perdre du temps sur la gestion de la mémoire, la gestion des processus et d’avoir un accès simple aux différentes données.

Pourquoi ROS et pas un autre OS ?

Nous avons fait le choix d’utiliser ROS pour plusieurs raisons. La première est la comptabilité vaec notre drone. Notre drone est en effet ouvert, ce qui nous permet de pouvoir travailler dessus mais il n’est pas compatible avec tous les OS. Nous nous sommes rendu compte que nous pouvions utiliser ROS ainsi que Microsoft Robotics Developper Studio pour pouvoir le contrôler.

Nous avons décidé de ne pas utiliser Microsoft Robotic Developper Studio pour la simple et bonne raison que les programmes sont créés avec un langage managé et de préférence C#. Or ROS nous permet de faire de la programmation en C++, en Python, en Lisb ainsi qu’en Java ce qui est plus simple pour nous. La seconde raison est que ROS commence à être très utilisés dans de nombreux laboratoires de recherche et que nous pouvons donc trouver beaucoup d’information et d’aides d’utilisation.

Comment est structuré ROS ?

ROS est structuré de la manière suivante :

Structuration ROS

ROS propose une architecture souple permettant la communication entre les processus et entre les machines. Ces processus sont appellés « nodes » ou « nœuds ». Un nœud peut etre par exemple un capteur, un moteur ou encore un algorithme. Chaque node peut être appélle d’une façon ou d’une autre en fonction de l’action qu’il est train de réaliser. En effet, un node qui publie des données est un « publisher ».

A contrario, un node quisouscrit à des données est un « subscriber ». La communication entre chaque node se fait via des topics. Un topic est un système de transport de l’information basé, comme dit précédemment, sur le système de publisher/subscriber. Un topic est standardisé (le type d’informations qui est publié sur le topic est toujours formé de la même manière) et sert entre guillemet de bus d’informations. Cette communication entre 2 nœuds est gérée par un Master.

Un master est une sorte de base de données permettant aux différents nœuds de s’enregistrer et donc de se connaitre entre eux. La communication d’un message se fait comme ceci :

• Le premier nœud avertit le master qu’il a une donnée a publier • Le deuxième nœud avertit le master quil souhaite souscrire a une donnée • La connexion entre les 2 nœuds est créés

Un nœud peut etre à la fois publisher et subscriber.

Le topic est donc un mode de communication asynchrones permettant la communication entre plusieurs nœuds. Il existe néanmoins un autre mode de communication qui est le Service. Le service est un mode de communication qui permet la communication synchrone entre 2 nœuds.

Communication ROS

Quelles sont les différents fichiers utilisables ?

Concernant l’utilisation de fichier ROS, il existe 2 concepts : celui de package et celui de stack.

Le plus courramment utilisé est le package. Un package est un répertoire de nœuds (décrit précédemment). Il possède également les librairies externes, les données…

Quant à lui, le stack est une collection de package permettant des fonctions plus complexe comme la localisation… L’un des interet de ces fichiers c’est que ce sont tous des éxécutables. Cela signifie que le non-fonctionnement de l’un d’entre eux pour une quelconque raison n’entraine pas de problèmes sur les autres vu qu’ils sont tous indépendants les uns des autres.

Installation de ROS

Concernant son installation, l’idéal est d’installer ROS Kinétic pour sa stabilité et ses ressources disponibles. Durant les premières semaines de projet, nous utilisions Ubunto 18 et Debian 9 ce qui nous a contraint d'utiliser ROS Kinetic. Afin de procéder a l’installation (de ROS kinetic), nous avons du crée un workspace Catkin (Déjà fait) et configurer les « repositories » de permettre « non-free » et « contrib » . Pour ceci, nous allons dans le fichier /etc/apt/sources.list et nous ajoutons les 4 lignes suivantes :


    deb http://deb.debian.org/debian-security/ stretch/updates main
    deb-src http://deb.debian.org/debian-security/ stretch/updates main
    deb http://deb.debian.org/debian stretch-updates main
    deb-src http://deb.debian.org/debian stretch-updates main

Concernant l'installation de ROS Kinetic, nous avons également du configurer les "repositories" de permettre « restricted » et « universe » et "multiverse".

Une fois enregistré, nous faisons l’installation comme ceci :

    sudo sh -c 'echo "deb http://packages.ros.org/ros/ubuntu $(lsb_release -sc) main" > /etc/apt/sources.list.d/ros-latest.list'

Puis :

    sudo apt-key adv --keyserver hkp://ha.pool.sks-keyservers.net:80 --recv-key 421C365BD9FF1F717815A3895523BAEEB01FA116

Nous pouvons donc installer ROS :

    sudo apt-get install ros-kinetic-desktop-full

Initialisation de Rosdep

    sudo rosdep init
    rosdep update

Configuration de l’environnement

    echo "source /opt/ros/kinetic/setup.bash" >> ~/.bashrc
    source ~/.bashrc

Dependances pour « build » les packages

    sudo apt-get install python-rosinstall python-rosinstall-generator python-wstool build-essential

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

Documents Rendus