Rapport de projet de 3ème année (MSC) Aile volante

1. Présentation 2. Cahier des charges : explication des choix 3. Réalisations 4. Conclusion 5. Annexes 6. Bibliographie

1. Présentation

Une aile volante est un appareil où tous les éléments nécessaires au pilotage sont situées sur elle-même. Le pilotage s’effectue par l’intermédiaire d’une console équipée généralement de joysticks, l’un pour contrôler la poussée, le second pour la direction. Une aile volante est constituée de plusieurs éléments tels qu’un moteur brushless, des servomoteurs, une centrale inertielle, une caméra, un GPS, une batterie, une carte électronique…

L’objectif de notre projet était de concevoir, réaliser et tester une aile volante du type Parrot Disco:

Pour atteindre cet objectif, nous avons travaillé sur les différents blocs de la chaîne de commande de l’aile.

Dès le début du projet, nous avions à disposition un moteur brushless avec son contrôleur ESC, des servomoteurs et nos cartes STM32.

Le moteur brushless va permettre de faire avancer l’aile (poussée). Les moteurs brushless sont un type de moteur synchrone où le champ magnétique généré par le stator et le rotor tournent à la même fréquence. On peut les commander en utilisant 2 types de commande: la commande séquentielle et la commande vectorielle.

Pour contrôler la direction de l’aile volante, on doit jouer sur les servomoteurs qui sont liés aux ailerons. En effet, on envoie des signaux PWM qui vont nous permettre de mettre les ailerons dans une certaine position et ainsi faire tourner l’aile en roulis ou en tangage.

2. Cahier des charges et explication des choix Nous avons commandé 3 équipements pour notre projet. Nous avons décidé de

commander une aile déjà faite sans électronique. Nous avons décidé cela car la conception de l’aile par nous-même nous prendrait trop de temps.

Nous avons aussi commandé une télécommande avec récepteur radio afin de

pouvoir piloter l’aile à distance et donc utiliser nos STM32 pour traiter l'information nous venant de la télécommande.

Et enfin, nous avons commandé un convertisseur BOOST pour élever la tension des

signaux PWM sortant de la STM32(3.3V) qui contrôlent servomoteurs et moteur brushless (5V).

Malgré toutes ces commandes, nous n’avons rien reçu à temps. Nous avions commandé l’aile et la télécommande dès la première séance. Hélas, nous n’avons rien reçu. Ceci ne nous a pas empêchés de travailler sur la commande des différents moteurs et sur l’exploitation des données venant du gyromètre de la STM32 puis de l'accéléromètre.

Architecture désirée:

Ces différents éléments seront liés de la manière suivante:

3. Réalisations

a. Commande des servomoteurs

Un servomoteur est un moteur capable d’atteindre et de maintenir une position angulaire précise, comprise dans un arc de 180 degrés. Cette position dépend du signal de commande qui lui est transmis.

Ce signal de commande est un signal PWM particulier. Ses paramètres sont normalisés :

● Période : 20 ms (donc une fréquence de 50 Hz) ; ● Temps haut : entre 1 et 2 ms. L’intégralité des 180° est couverte par cette plage de

rapports cycliques. (donc pour un temps haut de 1.5 ms, le servomoteur est à une position de 90°)

Pour commander ces servomoteurs, nous tirons profit des sorties PWM de la

STM32. Nous avons pris celles situées sur les broches PD14 et PE9.

On a donc besoin de deux sorties PWM, une pour chaque servomoteur commandant chacun un aileron. Le code relatif à ces sorties se présente comme suivant :

où les variables time_ms_PWM_right et time_ms_PWM_left correspondent aux temps hauts des deux PWM, calculés à chaque mesure de position angulaire.

b. Mesure de position angulaire - acquisition et traitement des données du gyromètre

Pour obtenir une mesure de position angulaire, une première idée a été d’utiliser le gyromètre l3GD20 inclus dans la STM32 discovery. Celui-ci fournissant une donnée de vitesse angulaire, il faut traiter celle-ci afin d’obtenir la position angulaire de notre aile.

Premièrement, il faut acquérir les données du gyromètre. Cela se fait simplement sur mbed, comme suivant :

Puis, dans la boucle infinie :

Les variables xSpeed, ySpeed et zSpeed contiennent alors les vitesse angulaires de l’aile selon les 3 axes.

Pour obtenir la position angulaire, l’idée est de considérer qu’entre deux mesures suffisamment proches dans le temps, la vitesse évolue selon une droite (méthode des trapèzes). On peut donc facilement l’intégrer, en s’aidant d’une position angulaire initiale nulle.

On aurait donc sur chaque axe la relation suivante :

(t) x(t Δt) Δt x = − + 2(v(t) + v(t−Δt))

Dans le code, cela se traduit (ici, sur l’axe X) comme suivant :

Notons qu’il est nécessaire d’éliminer toute mesure parasite de variation de vitesse.

On applique pour cela un seuil, et seulement au delà de celui-ci, on prend en compte la vitesse mesurée comme une variation de position. Cela ne serait pas nécessaire si on avait pu utiliser un accéléromètre (cf les pistes d’amélioration du projet).

Pour connaître l’intervalle de temps entre deux mesures de vitesse, on utilise un

timer, qui mesure le temps d'exécution du programme. La fonction t.read() donne le temps mesuré par le timer (qu’on a appelé t), en secondes. On y ajoute le temps d’attente entre chaque itération de la boucle while(1), qui est dans notre programme de 10 ms (mis à la fin de cette boucle par la ligne wait(0.01)). Cette valeur de temps d’attente à été choisie pour avoir un compromis entre rapidité de mesure (plus ce temps est petit, plus la mesure de position est bonne) et une vitesse de rafraîchissement de l’écran LCD acceptable.

Enfin, il faut convertir la valeur de cette information en position en degrés, à l’aide

d’un coefficient mesuré empiriquement lié à la sensibilité du capteur.

En appliquant ce processus suivant les axes X et Y, on obtient toutes les informations dont on a besoin pour contrôler et piloter l’aile volante.

c. Asservissement en position angulaire

Afin de garantir la stabilité de l’aile quand celle-ci est en vol, il faut assurer que sa position angulaire suive la consigne indiquée par l’utilisateur au travers de la télécommande.

Pour cela, on compare la position mesurée avec celle désirée. Si la différence entre les deux excède un certain seuil, on modifie la valeur d’un incrément qui va progressivement modifier la commande des servomoteurs, et donc la position des ailerons, pour ramener l’aile sur cette position. Cet incrément ne cesse de se modifier que lorsque l’on revient à la position désirée, ou qu’il a atteint sa valeur maximale (limitée par la position angulaire maximale des servomoteurs).

L’asservissement est effectué suivant les axes X et Y. La commande des servomoteurs doit donc être affectée par l’écart de position sur les deux axes, mais d’une façon différente suivant l’axe considéré :

● Dans notre cas, l’axe Y détermine si l’on souhaite tourner à gauche ou à droite. Or, pour tourner ainsi, les servomoteurs se comportent de façon opposée : l’un abaisse un aileron tandis que l’autre remonte l’autre aileron.

● L’axe X détermine alors si l’on souhaite plonger ou s’élever. Pour cette commande-ci, les ailerons s’inclinent dans la même direction (les deux s’abaissent ou remontent).

La valeur de nos incréments traduit le rapport cyclique que l’on va transmettre à nos

servomoteurs. Donc : ● Si l’on souhaite tourner (à gauche ou à droite, selon l’axe Y), l’un des incréments va

augmenter, l’autre diminuer. ● Si l’on souhaite plonger ou prendre de l’altitude (selon l’axe X), les deux incréments

vont soit augmenter tous les deux, soit diminuer.

Pour rappel, le rapport cyclique de nos servomoteurs est fixé par la valeur du temps pendant lequel le signal transmis est à l’état haut. Cette valeur est comprise entre 1 et 2 ms, impliquant une position neutre pour un temps haut de 1.5 ms.

Pour que l’asservissement en position soit effectué à la fois sur l’axe X et Y, nous avons donc limité la variation maximale des incréments, de sorte qu’ils augmentent ou diminuent la durée de temps haut de maximum 0.25 ms. Ainsi, on conserve bien un temps haut entre 1ms (si les deux incréments diminuent le temps haut de 0.25 ms) et 2 ms (si les deux incréments augmentent le temps haut de 0.25 ms).

Le code, identique pour les axes X et Y et réalisant ceci s’organise comme suivant : ● Premièrement, on calcul l’écart de position par rapport à la valeur de commande

indiquée par l’utilisateur (venant théoriquement du récepteur qui reçoit la consigne de l’utilisateur).

deltaX mesure cet écart pour l’axe X. xPosDegres est la position angulaire de l’aide suivant l’axe X en degrés, et xCommande est la valeur de commande désirée.

● Si l’on se trouve dans l’intervalle de position souhaitée, on diminue fortement l’incrément (pour le ramener le plus vite possible à 0, car on souhaite rester dans cette position)

xIncr est la valeur de l’incrément suivant l’axe X.

Si la valeur de l’incrément est proche de 0, on la met directement à 0 :

● Sinon, on modifie la valeur de l’incrément, pour faire en sorte que les ailerons ramènent l’aile dans la position souhaitée :

xIncr, et son équivalent sur l’axe Y, yIncr, ont une valeur absolue maximale de 50. Ainsi, lorsque l’on somme les deux, on obtiendra une valeur entre -100 et 100, facile à manipuler.

● Il faut ensuite convertir ces incréments en une durée de temps haut pour les signaux

PWM des servomoteurs :

La valeur absolue de la somme de yIncr et xIncr est de 100, et correspond à une durée de 0.5 ms, d’où le coefficient 0.005 (= 0.5 ms / 100). On retrouve bien le comportement différent sur les variations de commande des servomoteurs selon l’axe : lorsque yIncr augmente, le temps haut d’un servomoteur augmente tandis que celui de l’autre diminue ; tandis que lorsque xIncr augmente, les temps hauts des deux servomoteurs augmentent.

● Enfin, on convertit cette valeur de temps haut en rapport cyclique à l’aide de la valeur de la période, qu’on envoie aux sorties PWM :

(code déjà apparu précedemment, dans la présentation de la construction des signaux PWM)

d. Affichage sur l’écran LCD

Afin de tester notre programme, et parce que nous ne pouvions utiliser printf avec mbed, nous avons tiré profit de l’écran LCD de la STM32 discovery pour afficher les valeurs de différentes variables.

Pour réaliser cela, plusieurs étapes sont nécessaires : ● initialisation de l’écran

● Création d’un buffer pour accueillir la variable convertie en char :

● Conversion de la donnée en char :

● Effacement de l’intégralité de l’écran, pour que les données se mettent correctement à jour, sans être parasitées par les affichages précédents :

● Affichage sur une ligne du nom de la donnée à gauche, ainsi que sa valeur à droite :

e. Gestion de la télécommande

La signal envoyé par la télécommande est reçu par son récepteur, branché sur une entrée analogique de la STM32. Sachant que nous devons recevoir de la télécommande trois données (poussée, direction suivant les axes X et Y), il faut donc initialiser 3 entrées analogiques, pour lesquelles on a choisi les broches PF3-5 de la STM32 :

Le signal reçu est un signal PWM, de même format que ceux que l’on doit sortir aux servomoteurs. Cependant, sachant que l’on passe par la STM32, il faut récupérer la donnée de commande de joystick, comprise dans le rapport cyclique de ce signal PWM. (Cette dernière étape de traitement n’est pas fonctionnelle et figure parmi les pistes de poursuite des travaux sur le projet. En effet, elle dépend en partie de l’utilisation d’un accéléromètre et non du gyromètre de la STM32.)

f. Modélisation 3D sur Catia

Nous avons commencé à voir comment modéliser l’aile sur Catiav5. L’idée était d’avoir un aperçu de tout notre système sur Catiav5 pendant qu’on attendait les commandes. Pour modéliser une aile, la méthode rigoureuse est de prendre les coordonnées des points d’un profil qui nous intéresse sur le site http://airfoiltools.com/. Puis on peut utiliser un script python pour intégrer le fichier.dat contenant les coordonnées sur Catiav5 et tracer un profil. Sinon, il faut entrer un à un les points du profil. Après il faut créer différents profils qui seront une homothétie du premier. Pour finaliser l’aile, il faut Nous avons juste commencé la modélisation :

4. Conclusion - pistes d’amélioration et regard critique sur le projet

Pour conclure cette synthèse de projet, nous porterons un regard critique sur le travail fourni, et les décisions prises dans ce projet :

- Choix de l’IDE. Au vu des problèmes rencontrés avec l’utilisation de l’I2C avec l’IDE que nous avons choisi (mbed), il aurait pu être judicieux de changer pour un autre, comme TrueStudio que nous avons utilisé en TP de capteurs. Cela nous aurait permis de très facilement reprendre le travail qui avait été réalisé pour avoir très facilement un accéléromètre fonctionnel, ce qui est particulièrement important étant donné que notre système repose sur ce capteur.

- On aurait pu commencer directement à utiliser l’accéléromètre. Il était tout à fait prévisible qu’un gyromètre ne fournirait pas de mesure précise. Nous avons commencé à travailler sur l'accéléromètre de l’IMU 9DOF relié en I2C sur la STM32. Cependant, nous nous y sommes pris relativement tard et ne sommes pas parvenus à le faire fonctionner.

- Nous avons probablement écarté trop rapidement la conception de l’aile elle-même. Après quelques recherches, nous avons constaté qu’il était tout à fait faisable de modéliser complètement l’aile sous Catia (cf. la partie dédiée à ce sujet).

Annexe : Code complet (sans affichage LCD)

Bibliographie : Page sur l’aile volante Parrot disco : https://www.parrot.com/fr/drones/parrot-disco-fpv#parrot-disco-fpv-details Datasheet du gyromètre de la STM32 : https://stm32f4-discovery.net/2014/08/library-28-l3gd20-3-axis-gyroscope/ Datasheet de l’accéléromètre : https://www.invensense.com/wp-content/uploads/2015/02/PS-MPU-9250A-01-v1.1.pdf Datasheet du contrôleur ESC : https://www.multiplex-rc.de/Downloads/Multiplex/Bedienungsanleitungen/318975-bedienungsanleitung-roxxy-bl-control-755-s-bec--de-en-fr.pdf Datasheet du récepteur de la télécommande empruntée pour les tests : https://www.graupner.de/media/pdf/9b/25/62/S1037_S1012_GR_12_L_FR_201710155a311bc4258ba.pdf