15P – Auto-pilote V2.0 - Projets d'élèves

1. Introduction

Ce projet a pour but d'ajouter une nouvelle dimension au système d’autopilote inachevé qui résulte du premier projet, réalisé par mes soins. Le problème posé ici est comment faire pour que notre avion, entièrement livré au savoir-faire de notre système, soit capable de garder un cap précis. En effet, l'autopilote doit être non seulement capable de mesurer le cap sur lequel il se trouve mais aussi de transmettre des ordres pour rétablir le cap. En sachant qu'il est déjà théoriquement capable de maintenir une altitude, un deuxième point doit être pris en compte. Le phénomène résultant des deux corrections doit être étudié afin d'apporter des modifications dans le cas ou des limites serait découvert. Le but final de ce projet étant de réussir a créé un système efficace dans sa simplicité et dans son accessibilité. Il doit être capable de réagir rapidement et d'avoir la capacité d'alerté le pilote lorsqu'il y a un problème.
Cet autopilote devrait être capable de maintenir un avion à un cap donné ainsi qu'à une altitude donnée. Pour ce faire il sera capable d'analyser le comportement de l'avion, autrement dit l'attitude de l'avion, avant sa mise en mode marche pour ensuite pouvoir garder l'aéronef dans le prolongement de sa direction initiale. Pour faire plus claire, le pilote qui souhaitera activé l'autopilote devra préalablement carder un cap et une altitude précise un certain temps avant d'activé ce dernier.
L'homme assit derrière les commandes se déchargera alors de sa tâche de pilote et pourra vaquer à d'autres occupations.

2. Matériel et méthodes

2.1 Matériel

Liste de matériel :

2x Arduino Uno
1x SparkFun GPS shield
1x potentiomètres
1x LED RBG
1x Buzzer*
2x Servomoteurs*
2x Relais*
1xBouton-poussoir*
2x Transistor*
Résistances!!*
Programme "Link2fs Multi FSX Beta 5h"
Flight Simulator X
Manette de PS3

* Matériel expliqué dans le billet du projet « H ».

2.1.1 Arduino

L'Arduino est une plateforme libre d'accès, qui est majoritairement utilisé dans le cadre de petits projets pour programmer toute de sorte de choses, comme par exemple des capteurs ou de petits robots. L'Arduino Uno est un circuit imprimé qui permet d'accéder plus facilement à un microcontrôleur ATmega328, de cette manière ce dernier peut être facilement programmé pour analyser et produire des signaux électriques afin de remplir différentes tâches. L'Arduino Uno possède aussi une connexion USB, une connexion pour une alimentation par batterie ainsi qu'un bouton de réinitialisation (bouton "reset").
Source

2.1.2 GPS

Dans l'optique de pouvoir connaître le cap dans lequel l'avion se trouve, l'utilisation d'un GPS fut indispensable. Le GPS choisi est le module GPS EM-506 qui est inclus au kit SparkFun. Le point fort de ce kit étant le shiel GPS permettant de planter directement ce dernier dans les pins de la carte arduino, simplifiant ainsi considérablement son utilisation.

Voici le GPS utilisé dans ce projet : Sur cette image, il est possible de distinguer le module GPS "EM-506" qui se trouve en dessous de la pièce rouge. Cette dernière étant le shield GPS proposé par SparkFun et les pièces noir sont les connecteurs qui sont à souder, comme le module GPS, sur ce shield avant l'utilisation de ce kit GPS.
Source

2.1.3 Potentiomètre

Dans ce projet, qui est pour l'heure à l'étape de prototype, j'utilise deux potentiomètres pour simuler les différentes informations que mon dispositif devra traiter et qui vont être, dans une version future, remplacée par des valeurs provenant de vrais capteurs. Les deux données que l’Arduino Uno doit recevoir sont l’altitude et l’attitude, qui est donnée par la position des gaz, de l’avion.

Voici le modèle de potentiomètre utilisé dans ce prototype : Le potentiomètre est, sur cette photo, l'objet bleu au centre.
Source

2.1.4 LED tricolore

La LED tricolore est utilisée dans ce projet pour données différentes information concernant les états de votre dispositif. Voici la LED tricolore utilisée dans ce prototype : La LED tricolore qui est présente sur cette vidéo a 4 pâtes distinctes. En prenant les pâtes de gauche à droite nous avons le rouge, la masse, le vert et le bleu. Pour toutes autres informations, veuillez consulter la source de ce produit. Source

2.1.5 Link2fs Multi FSX Beta 5h

Ce programme permet de communiquer des informations du simulateur de vol "Flight Simulator X" à une, ou plusieurs, carte Arduino. Dans ce projet, ce programme est indispensable, car sans lui il serait impossible de tester, de manière virtuelle, le comportement d'un avion sous le contrôle de notre dispositif. Toutes les informations concernant l'utilisation de ce logiciel se trouvent sur le site officiel de ce dernier.

2.1.6 Flight Simulator

Flight Simulator est un logiciel très puissant en ce qui concerne la simulation de vol. En effet, il permet de pouvoir tester différents avions dans différentes conditions et avec les caractéristiques précises de ces derniers. Dans notre cas, il présente un réel intérêt car il va permettre de mettre notre dispositif dans des conditions quasiment réelles. Tous les renseignements sur ce logiciel se trouvent sur le site officiel de ce dernière.

2.1.7 Manette de PS3

Dans le cadre de la confection de ce projet, nous avons besoin d'un moyen de renvoi d'information au logiciel de simulation qui se rapproche au plus près des commandes d'un vrai avion. Il s'agit bien de créer un Auto-pilote qui actionne les commandes d'un avion pour le guider. De plus, pour pouvoir connecter la manette à l'ordinateur, il faut avoir en sa possession un programme prévu à cet effet. Le programme en question se nomme "MotioninJoy Gamepad tool" et est disponible sur un grand nombre de site tel que 01.net mais vous trouverez ici le site officiel.

2.2 Méthodes

2.2.1 Explication schématique du programme

Le diagramme ci-dessus reprend exactement la même base que celui du projet « H » car le programme créé dans ce deuxième projet est une version améliorée de l’ancien programme. Sur ce diagramme nous pouvons donc distinguer les trois étant de base. Le mode Stand-by qui est mise en évidence par la couleur bleu, le mode actif ou mode ON en vert et le mode de détresse en rouge. Ces trois modes gardent intégralement leurs objectifs. En effet, le mode Stand-by reste un mode dans lequel notre programme calcule des moyennes mobiles. Le mode actif reste le mode qui induit la mise en marche du système complet d’autopilote. Et pour finir le mode détresse a toujours pour objectif d’alerter le pilote d’un éventuel problème.

Cependant, un certain nombre de fonctions ont été ajoutées aux différents modes. Dans l’objectif de pouvoir connaitre la direction que le pilote maintient avant d’activer le dispositif, le mode stand-by calcule aussi une moyenne mobile pour la direction. Et c’est cette valeur moyenne que le dispositif va retenir lors de son activation. Avant d’approfondir le fonctionnement et le traitement des valeurs de la direction dans le mode actif, il faut préciser que différents moyens ont été testés pour obtenir des valeurs de direction. En effet, dans un premier temps, l’objectif était d’arriver à obtenir une direction grâce à un GPS physique qui était connecté à une deuxième carte Arduino. Cette méthode est représentées par le numéro « 2 » sur le diagramme. Une deuxième méthode, visant cette fois à non seulement donnée une valeur de direction mais également des valeurs d’un gyroscope, a été testée. Cette dernière méthode utilise un programme de simulation (ici « Flight Simulator X ») et un programme faisant le lien entre la carte Arduino et le simulateur. Sur ce diagramme, le numéro « 3 » représente les informations transmises du simulateur au programme de lien et le numéro « 1 » représente les informations transmises à la carte Arduino.

Dans la mesure où la deuxième méthode contient plus de valeurs calculées que la première, l’explication du traitement de ces données pour la deuxième méthode devrait s’avérer suffisant. Donc lorsque le dispositif est en mode actif, il a une et une seule valeur de référence de direction ce qui va permettre de faire la différence entre cette valeur et la valeur en temps réel de la direction. Mais dans le cas de la direction il ne suffit pas de faire correspondre cette différence avec une correction a opéré, il est impératif de passer par les valeurs du gyroscope pour pouvoir stabilisé l’avion dans une attitude précise. Et c’est cette attitude qui va influencer l’avion pour qu’il retourne sur le bon cap. L’explication précise de la parcelle de code effectuant cette correction se trouve sous la rubrique « 2.2.3 La méthode de correction de direction ». L’intégralité du code de ce projet se trouve ici.

2.2.2 Schéma électrique

Voici le schéma électrique du montage final du projet :

On retrouve dans ce schéma électrique toutes les connexions nécessaires au bon fonctionnement de notre système.

2.2.2 Montage du dispositif de motorisation de la manette PS3

En ce qui concerne la méthode utilisée pour renvoyer des informations, ou plus précisément des commandes, à notre avion dans notre simulateur, j'ai choisi de passer par la motorisation d'une manette. Pourquoi avoir choisi cette méthode et bien tout simplement pour pouvoir garder et gérer les servomoteurs. Ainsi mon projet se rapprochait d'autant plus d'une version adaptable à un vrai avion de test.

L'objectif principal de cette motorisation est de réussir à convertir le mouvement des servomoteurs, en mouvement des joysticks. Pour ce faire, il est possible de procéder de la manière suivante. Il suffit d'installer une planche en contreplaqué pour créer une plateforme et de chercher un moyen de fixé les deux servomoteurs. Voici un exemple de dispositif simple mais très efficace : Avec cette disposition, les servomoteurs sont fixés de manière à pouvoir les ajuster au besoin grâce à quatre vis avec écrous. En ce qui concerne la transmission du mouvement, il est possible d'utiliser, comme dans ce cas, de fines barres en métal rigides fixées, à la fois, sur le joystick et sur le servomoteur. Voici un zoom de la fixation sur le joystick : Pour réussir à fixer la barre en métal au joystick, il est possible d'utiliser des petites vis pouvant être visées au centre du joystick de manière à pouvoir actionner ce dernier. La tige de métal et la petite vis sont reliées pas de la gaine thermorétractable pour garder une souplesse suffisante au mouvement. De plus, dans ce projet, le boulon ainsi que la LED tricolore ont été incrustés dans le bois pour plus de facilité d'utilisation. Lorsque le système physique est prêt à l’emploi, il est possible de passer à la partie programmation.

2.2.3 Communication avec LINK2FS

En ce qui concerne la programmation de la communication entre l’Arduino Uno et le programme LINK2FS, elle est relativement simple mais doit être très précise. Tout d’abord le système doit être attentif au moniteur série et pour ce faire nous avons dans la fonction Loop() la possibilité d’écrire ce petit bout de code :

if (Serial.available()){
    CodeIn = getChar();
    if (CodeIn == '<') {FS();}
   }

Ce code permet d’appeler une fonction dans le cas où le moniteur série reçoit un ou plusieurs caractères. Et une fois qu'il sait qu'il y a des caractères dans la liste d'attente du moniteur (buffer), le programme prend le premier caractère, il le met dans une variable "Codeln" pour pouvoir ensuite appeler la fonction correspondante au premier caractère. Dans ce cas-là, nous avons que des messages qui sont envoyés avec un "<" comme premier caractère ce qui a pour conséquence d'appeler une seule et même fonction, la fonction "FS()" . Une petite précision s'impose dans la manière de prendre un caractère. En effet, ici le programme fait appel à la fonction "getChar()" qui renvoi au code :

char getChar()// Prendre un caractère du moniteur série
{
  while(Serial.available() == 0);// wait for data
  return((char)Serial.read());// Thanks Doug
}

Cette fonction fait simplement un "Serial.read" dans le cas ou il y a une valeur. Maintenant que le premier caractère est lu, il faut aller chercher le deuxième caractère. C'est par la fonction "FS()" que ce caractère va entraîner une authentification de la valeur envoyée. En effet il faut distinguer s’il s’agit de l'altitude, de la direction ou encore du roll de l'avion. Et donc grâce à la lettre qui se trouve juste après le "<", le programme va pouvoir mettre le reste de la valeur dans une variable correspondante.

void FS(){    //fonction qui relève les messages commencent par "<"
  CodeIn = getChar();
  switch(CodeIn){
    case 'D':
      delay(11);
          
        altit =  "";
        altit +=  {getChar()};
        altit +=  {getChar()};
        altit +=  {getChar()};
        altit +=  {getChar()};
        altit +=  {getChar()};
        
        if (altit != altitold){  
          //Serial.print(altit);
    
        VALEURAL = altit.toFloat();
        altit = altitold;
      }
      break;
    case 'J':
      delay(11);
          
        altit =  "";
        altit +=  {getChar()};
        altit +=  {getChar()};
        altit +=  {getChar()};
        
        if (altit != altitold){  
          //Serial.print(altit);
    
        VALEURDI = altit.toFloat();
        altit = altitold;
      }
      break;
     case 'R':
      delay(11);
          
        altit =  "";
        altit +=  {getChar()};
        altit +=  {getChar()};
        altit +=  {getChar()};
        altit +=  {getChar()};
        altit +=  {getChar()};
        altit +=  {getChar()};
        
        if (altit != altitold){  
          //Serial.print(altit);
    
        ROLL = altit.toFloat();
        altit = altitold;
      }
      break;
 }
}

De cette manière les différentes valeurs du simulateur sont organisées par le programme link2fs et envoyé par le moniteur série de la carte Arduino. Cette méthode est efficace mais il faut à tout prix lire le bon nombre de caractère pour les différentes valeurs sinon le programme ne vas pas réussir à distinguer les différentes valeurs envoyées.
Les différentes valeurs sont stockée dans des variables "VALEURAL", "VALEURDI", "ROLL". Ces deux premières variables sont par la suite destinées à alimenter deux moyennes mobiles, ces deux moyennes mobiles sont identiques à celle que celle du Projet « H ». Avant de voir comment traiter ces valeurs de direction pour obliger l’avion à garder un cap précis, nous allons regarder dans les grandes lignes comment faire pour alimenter la variable de la direction avec un vrais GPS.

2.2.4 Le GPS

Le GPS utilisé dans ce projet est un GPS relativement bon marché mais qui offre une précision très bonne. De plus le kit contenant le GPS offre un shield pratique à utiliser et simple à assembler. Dans ce projet, il n’est malheureusement pas possible ou trop compliquer de tout mettre sur une seul Arduino Uno, En effet, les servomoteurs et le GPS semble utiliser une manière commune de fonctionner ce qui provoque des interférences qui dérègles le servomoteur. La solution simple et efficace qui a été choisie est de mettre le shield GPS sur une deuxième Arduino Uno et de faire communiquer ces deux derniers par une connexion "I2C". Cette connexion que l’on peut voir ci-dessus permet d’envoyer les données de direction du GPS à l’Arduino Uno qui gère tout le reste. Avec la librairie "Wire.h", il est possible de communiquer avec cette connexion I2C. Pour commencer, il faut savoir qu'il y a une notion de maître et d'esclave dans cette communication. Dans mon projet, l'arduino avec le GPS est le maître et l'autre arduino est l’esclave. Dans cette ordre la, l'arduino qui gère tous les calculs reçois juste les valeurs de la direction.

Le code qui sert à interroger le GPS est relativement simple par le fait qu'il suffit de l'initialiser et de demander les valeurs que l'on veut pour ensuite pouvoir les mettre dans une variable. En voici un exemple :

Serial.print(gps.satellites.value());

Dans la fonction "loop()", l'arduino a juste besoin de demander, dans cette exemple, de demander "gps.satellites.value" pour que le gps imprime dans le moniteur série la valeur du nombre de satellites. Le code complet de l'Arduino Uno avec les GPS ce trouve ici

2.2.5 Correction à opérer

Avec les commandes d'un avion, il est plus dur de faire des mouvements linéaires. En effet, lorsque l'on tourne le volant s'une voiture d'un angle précis et qu'on maintient cette angle, la voiture va tourner toujours autour d'un cercle précis. Alors qu'en ce qui concerne l'avion, si l'on tourne la commande des ailerons d'un certain angle, l'avion va tourner sur lui-même en roulis et il ne va absolument pas changer de cap en toute tranquillité. Pour réussir à faire tourner mon aéronef dans un plan, il a fallu faire une étape de plus que de juste faire correspondre la différence de direction avec une correction à opérer sur le manche. L'étape de plus est présente pour faire correspondre une différence de direction avec une différence de roulis. C’est-à-dire de mettre l'avion dans une attitude penchée pour qu'il se déplace gentiment dans la direction du bon cap. Et pour mettre l'avion dans une telle attitude, il suffit de faire correspondre la différence de roulis entre 0 et le roulis réel avec une correction au manche de l'avion. Cette manipulation ce traduit en langage Arduino par:

 DiffDir = VALEURDI-DirectionReferenceFinale;    
     if ( DiffDir > 180 ){ DiffDirCorr = DiffDir-360; }
     if ( DiffDir < -180 ){ DiffDirCorr = DiffDir+360; }
     else { DiffDirCorr = DiffDir;}
     
     GYROINT = ROLL-map(DiffDirCorr, -90,90,-20,20);
     
     
     if (GYROINT < -20){GYRO = -20;}
     if ( GYROINT > 20){GYRO = 20;}
     else { GYRO=GYROINT;}
     
     CorrFinaleDir = map(GYRO, -20,20,10,170); //*voir si besoin d'une fonction de correction 
     
     if (CorrFinaleDir < 88.00){CorrFinaleDir2 = CorrFinaleDir-20; }
     if (CorrFinaleDir > 92.00){CorrFinaleDir2 = CorrFinaleDir+10; }
     else { CorrFinaleDir2 = CorrFinaleDir; }
     
     ServoAileron.write(CorrFinaleDir2);

3. Résultats

3.1 Vidéo

En ce qui concerne les résultats des différents tests fait sur le simulateur "Flight Simulator X", on arrive à avoir une certaine précision dans les manœuvres. De plus notre dispositif force bien l'aéronef à rester dans une direction. Et lorsqu'un fort vent emporte l'avion sur un autre cap, le dispositif fait revenir l'avion pile sur son cap fixé lors de la mise en marche du système. Afin de mieux comprendre comment le système fonctionne et qu'est-ce qu'il fait réellement, je vous invite à aller voir la vidéo de démonstration. La vidéo montre un exemple en condition idéal mais le dispositif a également été testé dans plusieurs autres conditions (pluie, vent fort, orage). Dans tous les cas le dispositif remplissait son rôle de manière plus ou moins rapide.

4. Discussion

En ce qui concerne l'analyse des résultats, plusieurs éléments peuvent être mis en perspective. Tout d'abord, il est important de relever la réussite de ce projet. En effet, l'avion se stabilise très bien dans une direction donnée. De plus malgré de fort vent ou d'autres intempéries, le dispositif fini toujours par retrouver le bon cap. Bien évidement la précision des données reçues par l'Aduino venant du simulateur aide considérablement notre système à éviter des problèmes tels que la perte de signale. Dans la vidéo de démonstration, on peut voir que la compensation pour retourner au cap fixé est relativement lente mais il faut savoir qu'il suffit de demander au dispositif de mettre plus d'angle d'attaque en fonction de la différence de direction. Un autre défaut qui a été réglé mais qui pose encore quelque problème, c'est le jeu qu'il y a dans les joysticks de la manette de PS3. En effet dans les angles qui se situent entre 85 et 90 degrés sur le servomoteur, il n’y a pas de réaction sur le simulateur. Ce problème est très simple à régler et il faut garder à l’esprit que sur tout appareil, un certain nombre de réglage sont à effectuer.
En ce qui concerne l’étude de la compatibilité des deux projets, on peut dire qu’il n’y a pas de problème à proprement parler. Cependant, il faudrait quand même adapter l’avancé technique de la direction à l’altitude car pour le moment l’altitude est seulement gérée par les gaz. Et ce détail n’est pas anodin lorsque l’on commence à beaucoup pencher avec notre avion lors de gros coup de compensation de la direction. En effet, dans ce cas précis, l’autopilote a besoin d’une compensation de l’altitude plus rapide et plus précise que ce que peut offrir l’accélération du moteur. Une application du deuxième projet pour gérer l’altitude par la gouverne de profondeur devrait être une très bonne solution. Ce projet m’a permis d’apprendre beaucoup sur le comportement d’un avion et sur les différents paramètres qui rentre en ligne de compte lors d’un vol. Un autopilote est quelque chose de fantastique, il demande beaucoup de précision et de patience mais une fois qu’il fait ce que vous voulez, il devient votre meilleur ami !

5. Conclusion

Un tel projet présent de nombreuses possibilités d’amélioration. En effet, cette autopilote n’est pas encore prêt à l’emploi, pour commencer un gyroscope d’une relativement grande précision devrait y être ajouté. Ce gyroscope pourrait être par exemple le MPU-9250 du site Play-zone. Une fois tous les capteurs installés et calibré et une application de ce projet à l’ancien, l’Auto-pilote V3.0 pourra voir le jour et peut-être être testé sur un vrai avion de test.

6. Ressources

_Source_
http://www.arduino.cc/en/reference/Wire http://www.arduino.cc/ https://www.sparkfun.com/ https://www.sparkfun.com/products/13199 http://www.jimspage.co.nz/Link2fs_Multi.htm http://ds3-tool.softonic.fr/ http://www.motioninjoy.com/ Programme : Fritzing (http://fritzing.org/home/) http://www.jimspage.co.nz/Link2fs_Multi.htm
Image : Arduino uno: http://www.conrad.fr/medias/global/ce/1000_1999/1900/1910/1917/191789_LB_01_FB.EPS_1000.jpg https://www.sparkfun.com/products/13199 https://www.sparkfun.com/products/9806 https://www.sparkfun.com/products/105

Livre : SIK GUIDE de SparkFun (site : https://www.sparkfun.com/)
Site :
https://oci.gyp.ch/blog/?post/2014/01/08/Aide-au-d%C3%A9marrage2 http://fr.wikipedia.org/wiki/Loi_d%27Ohm http://fr.wikipedia.org/wiki/Buffer_circulaire http://fr.wikipedia.org/wiki/Moyenne_glissante http://arduino.cc/ http://arduino.cc/en/Reference/HomePage http://arduino.cc/en/Reference/AttachInterrupt http://fr.wikipedia.org/wiki/Servomoteur

Projets d'élèves

À retenir

Recherche

Volées