Une question qu'il faut se poser: As-tu déjà pratiqué l'aéromodélisme? Si non, alors en premier lieu il faut aller voir un club près de chez toi pour prendre des renseignements de vive voix, et surtout se rendre compte de ce qu'est cette discipline et de ce qu'elle implique niveau sécurité (voir blessures en cas de non respect de sécurité élémentaire).
Si oui et que tu as déjà conscience de tout cela (lieux de vols, fréquences, puissances d'émissions, protection des personnes des biens et des animaux, heures de vols, nuisances sonores, licence d'aéromodélisme affiliée à un club, assurance en cas de crash, risques divers, etc...), alors tu peux te lancer 
La question qui reste (si oui à la première), faire le pas de programmer un contrôleur de vol soit même (carte arduino uno par exemple), ou acheter du tout fait?
Si tu décides de programmer toi même, alors il faut vraiment commencer par d'une part se documenter (documentation arduino, mais aussi documentation sur le vol d'un aéronef type hélico/quadri, des principes du gyroscope, etc...), pour cela il y a les livres, les moustachus (aéromodélistes et pilotes grandeur), internet, et autodidacte pourquoi pas (?), ensuite effectuer des tests basiques, à savoir commencer par faire bouger un servo-moteur avec un gyroscope.
Une première approche consiste à récupérer la valeur d'un axe (accélération x y ou z) d'un gyroscope en degrés par seconde (si on suis une logique), de modifier l'échelle de cette valeur pour la passer en micro-secondes, c'est à dire la largeur d'impulsion (signal pwm) qu'il faut envoyer au servo-moteur.
Imagine un gyroscope comme le mpu6050 (très utilisé encore aujourd'hui) dont on récupère l'axe d'accélération x, une fonction mathématique permettant de faire des courbes (en l'occurence dans l'exemple c'est juste un changement d'échelle), et un servo-moteur lambda (acceptant des ordres de 1000 à 2000 micro-seconde à la fréquence de 50Hz), la ligne correspondrait dans l'idéal à ça:
tonServo.us (courbe (-2000, tonGyroscope.x, 2000, 1000, 2000);
tonGyroscope.x c'est la valeur en degrés par seconde renvoyé par le gyro (le mini/maxi possible avec le mpu6050)
tonServo.us est une fonction pour envoyer le pwm en micro-seconde au servo-moteur
et courbe sert à faire en sorte que l'intervalle -2000 à 2000 degrés par seconde renvoyé par le gyro se retrouve dans un intervalle 1000 à 2000 micro-secondes (valeur acceptées par le servo).
Si tu veux un détail de la fonction courbe (on sait jamais):
float courbe (const float POSITION_START, const float POSITION_CURRENT, const float POSITION_END, const float INTERPOLATION_START, const float INTERPOLATION_END)
{
float value = 0;
if ((POSITION_START < POSITION_END && POSITION_CURRENT <= POSITION_START) || (POSITION_START > POSITION_END && POSITION_CURRENT >= POSITION_START))
{
value = INTERPOLATION_START;
}
else if ((POSITION_START < POSITION_END && POSITION_CURRENT >= POSITION_END) || (POSITION_START > POSITION_END && POSITION_CURRENT <= POSITION_END))
{
value = INTERPOLATION_END;
}
else
{
if (INTERPOLATION_END > INTERPOLATION_START)
{
value = INTERPOLATION_START + ((INTERPOLATION_END - INTERPOLATION_START) * ((POSITION_CURRENT - POSITION_START) / (POSITION_END - POSITION_START)));
}
else
{
value = INTERPOLATION_START - ((INTERPOLATION_START - INTERPOLATION_END) * ((POSITION_CURRENT - POSITION_START) / (POSITION_END - POSITION_START)));
}
}
return value;
}
Maintenant que cette logique est comprise, que ton servo bouge au max quand le gyroscope détecte une accélération de 2000 degrés par seconde et au min quand il détecte -2000 degrés par seconde, il faut comprendre ce que sont les gains dans un tel système asservi.
Un exemple très simple consiste à modifier les valeurs min max (butées) de 2000 et - 2000 degrés par seconde:
tonServo.us (courbe (-1000, tonGyroscope.x, 1000, 1000, 2000);
Ici, j'ai passé -2000°/s à -1000°/s, et 2000°/s à 1000°/s, j'ai donc rajouté 50% de gains.
Ce qui à pour conséquence de rendre le système 50% plus sensible (50% plus réactif à une accélération), à ceci il faut comprendre que dès que le gyro détecte 1000°/s en positif ou en négatif, le servo se déplace au min ou max. Ou en prévision de ton développement de drone, cela signifie que l'hélicoptère est plus verrouillé sur son axe x (généralement l'axe de tangage).
On peut donc déjà inclure les gains sur l'axe x:
const float GAIN_X = 50;
float gainX = 0;
gainX = courbe (0, GAIN_X, 100, 2000, 0);
tonServo.us (courbe (-gainX, tonGyroscope.x, gainX, 1000, 2000);
Ici GAIN_X est le paramètre de réglage du gain allant de 0% à 100%, gainX est un changement d'échelle respectivement de 2000°/s pour un gain de 0% à 0°/s pour un gain de 100%.
Une fois que tu as bien compris ce principe, il faut ajouter la consigne du pilote sur cet axe x (on a dit tangage).
Tu peux utiliser du matos perso pour le pilotage mais j'imagine que tu vas utiliser une radiocommande et récepteur rc standards pour piloter, donc la fonction qui va récupérer le signal pwm de l'axe de tangage vennant de ton récepteur de modélisme standard renverra des valeurs en largeur d'impulsion donc en micro-seconde (si on respecte la logique).
Je pense que comme la majorité des radiocommandes du commerce, l'intervalle sera comme celle d'un servo-moteur standard à savoir 1000 à 2000 micro-seconde.
Le but du jeu est d'utiliser cet ordre (valeur lue de 1000us à 2000us) et de modifier cet intervalle pour le passer en degrés par seconde afin d'induire un décalage (offset) dans la consigne par rapport aux valeurs retournées par le gyroscope. Ce qui signifie qu'au lieu que le gyroscope suive une valeur neutre de 0°/s, et stabilise l'ensemble à cette valeur, il devra stabiliser l'hélicoptère à une autre valeur (si l'ordre du pilote indique de faire pivoter l'hélicoptère sur l'axe de tangage à 25°/s, le système fera tout pour stabiliser la machine à 25°/s au lieu de 0°/s).
L'exemple devient alors ceci:
const float GAIN_X = 50;
float gainX = 0;
float offsetX = 0;
gainX = courbe (0, GAIN_X, 100, 2000, 0);
offsetX = courbe (1000, pilotageTangage.us, 2000, -45, 45);
tonServo.us (courbe (-gainX, tonGyroscope.x + offsetX, gainX, 1000, 2000);
Le nouveau venu est pilotageTangage.us, la valeur pwm en micro-secondes renvoyée par le récepteur de modélisme standard. Cette valeur est changée en -45°/s à 45°/s, puis injectée comme offset à la valeur renvoyée du gyroscope.
-45°/s à 45°/s sont les débattements min max, cela signifie que ton servo-moteur ou à posteriori ton drone (quadrihélicoptère) pivotera sur lui même à 45°/s quand tu penchera ton manche de tangage au max (si bien entendu les gains sont bien réglés).
Une fois que tu es arrivé à cette étape on pourra voir la suite si tu veux, à savoir qu'un servo-moteur seul ce n'est pas 4 moteurs (il faut dispatcher les ordres à des couples de moteurs), ensuite pour qu'un hélico soit bien verrouillé sur ses axe il doit disposer pour effectuer ses corrections du maximum de débattements disponibles (gaz au ralenti jusqu'à pleins gaz), quel que soit si ton manche de gaz à la radiocommande (le collectif) soit à gaz mini ou gaz maxi.
Cela implique donc de gérer les corrections aux moteurs de façon dissymétrique lorsque le manche de gaz n'est pas parfaitement au neutre (comprendre à cela que quand les moteurs sont déjà au gaz ralenti, on ne peut pas leur demander de ralentir encore plus, et inversement quand on est déjà à plein gaz).
Ensuite il faudra induire des gains variables en fonction de la position du manche de gaz (le gain diminue un peu plus on va vers plein gaz du fait du rendement des hélices qui augmente).
Et chose que j'ai rajouté sur le mien mais qui n'est pas nécessaire en prise de vue aérienne (c'est surtout en voltige au final mais je préfère te l'indiquer ça fait une info de plus), c'est le gain qui augmente en fonction d'un ordre au cyclique, et qui persiste un peu (quelques 10ènes de millisecondes tout au plus) ce qui verrouille plus l'hélico durant les ordres vifs au cyclique.
Il faudra rajouter aussi pour ton projet la gestion d'un horizon artificiel, très pratique pour de la prise de vue aérienne stabilisée. Un internaute m'avait demandé cet horizon (j'en avais pas le besoin personnel), j'avais donc développé et testé en ce sens une nouvelle version de mon algorithme avec horizon, parfaitement fonctionnelle et validée. Quand tu sera rendu à cette étape je pourrais t'expliquer si tu le souhaites.
