1. Introduction
[à compléter]
2. Thrust Vector Control
La stabilité est un problème majeur lors de la conception de fusées, et cela quelle que soit la taille. En effet, la fusée se propulse sur le même principe qu'un ballon qui se dégonfle, à la différence de celui-ci on essaie d'orienter toute la poussée vers le haut.
Il existe plusieurs méthodes pour stabiliser une fusée. Il y a tout d'abord les méthodes passives qui se basent uniquement sur les caractéristiques aérodynamiques de la fusée (centre de pression sous le centre de gravité pour que le couple dû à l'air crée une boucle de rétroaction négative), en pratique il suffit de mettre des ailerons au bout de la fusée.
Il y a ensuite les méthodes actives, où la fusée est constamment stabilisée par un système et une boucle de contrôle. J'ai utilisé une de ces méthodes appelée Thrust Vector Control (TVC), elle consiste à orienter la poussée du moteur pour corriger les erreurs d'alignement (ici vertical).
Partie Mécanique
Le moteur est orienté grâce à un gimbal et deux servo-moteurs. C'est une des configurations les plus courantes. La conception s'est faite en plusieurs itérations. La CAO a été faites dans Onshape. Le design se base sur deux blocs en pivot l'un par rapport à l'autre, ce qui est équivalent à une rotule. Le système permet ainsi au tube qui maintient le moteur de pivoter sur toute une demi-sphère (voir figure). Toutes les pièces sont imprimées en PLA, pour simplifier et accélérer la conception. Ce choix a un impact direct sur la rigidité du système. Pour de prochaines améliorations, je pourrais utiliser plus de pièces standarisées et en métal.
Les liaisons pivots se font grâce à des petits axes imprimés en PLA. Cette solution n'est vraiment pas optimale pour plusieurs raisons. Les axes sont imprimés dans le sens axial, ce qui entraine une très faible résistance au cisaillement mais assure que la pièce est bien cylindrique et a les bonnes cotes. Après avoir effectué des tests, j'en ai conclu que ce compromis semble acceptable. Je compte sur le fait que les efforts transmis seront faibles à la fois pour la résistance des pièces et pour les frottements. Ce choix a été fait pour aller vite et pour simplifier le système au maximum.
La transmission des efforts du servomoteurs se fait grâce à des biellettes et des axes qui ont aussi été imprimées. La transmission ne se fait pas très bien à cause des frottements et du manque de rigidité.
[à terminer]
3. Flight Computer
L'ordinateur de vol est une partie centrale, il permet de :
- Contrôler les servo pour le TVC Mount
- Gérer les différents états de vol
- Lire les données des capteurs, calculer les caractéristiques de la fusée (attitude, altitude, vitesse, accélération, etc.)
- Logger les données de vol
Détaillons ensuite chaque sous-partie ainsi que leurs choix et difficultés associés.
La conception du PCB pour l'ordinateur de vol a été faite grâce à KiCad, et sa fabrication grâce à JLCPCB.
3.1 Description
Microcontrôleur
Un ESP32 a été choisi comme microcontrôleur car il n'est pas cher, rapide et a un grand nombre de connexions.
Puissance
Pour la puissance, l'alimentation se fait en 9V. Lors des premiers tests celle-ci se faisait grâce à une pile 9V, mais cette solution a été remplacée par une batterie LiPo pour avoir plus de courant ainsi que la possibilité de recharge. Cette tension est ensuite abaissée à 5V grâce à un régulateur linéaire (LM7805). Cette tension 5V alimente presque tous les composants.
Données de vol
Pour obtenir la position dans l'espace de la fusée il me fallait un IMU (Inertial Measurement Unit), j'ai choisi le MPU6050 qui a 6 DoF, trois pour les vitesses angulaires et trois pour les accélérations. Dans de prochaines itérations il faudrait peut-être choisir un composant avec plus de "degrés de liberté", notamment un magnétomètre. Le but étant de fusionner les données des différents capteurs dans un filtre complémentaire, cela permettrait par exemple de bien mieux contrôler la dérive des gyroscopes (cf. Partie Attitude Estimator).
Le capteur barométrique BMP280 permet de connaître la pression atmosphérique, avec laquelle nous pouvons retrouver l'altitude. Cette méthode est assez précise car elle permet de connaître au mètre près la différence d'altitude entre deux endroits, dans mon cas le sol et la fusée.
3.2 Schématique
3.3 Routage
4. Code et Algorithmie
4.1 Acquisition des données
(Contenu à venir)
4.2 State Machine
Le code se décompose en 6 états :
- État 1 : Au Sol, passe à l'état suivant si l'accélération en Z est supérieure à un seuil (20 m/s²) pendant 0,2 s.
- État 2 : Vol Motorisé, passe à l'état suivant si l'accélération totale est inférieure à un seuil (2 m/s²) pendant 0,5 s.
- État 3 : Vol Non Motorisé, passe à l'état suivant si l'altitude décroît, c'est-à-dire zt < zt-1.
- État 4 : Descente en chute libre, passe à l'état suivant si [à terminer]
- État 5 : Descente en chute contrôlée (parachute), passe à l'état suivant si z < 5m pendant 3 s.
- État 6 : Atterri, état final.
4.3 Logging
[à faire]
4.4 Boucle de contrôle
La boucle de contrôle est une des parties qui m'a donné le plus de fil à retordre. J'ai mis beaucoup de temps avant de trouver les gains de la boucle PID. Il y avait plusieurs approches pour régler le correcteur. Les approches plus empiriques et celles plus analytiques. Commençons par les empiriques. La méthode de Ziegler Nichols est assez répendue, voici rapidement en quoi elle consiste : premièrement on désactiver les actions intégrale (I) et dérivée (D), puis on augmente le gain proportionnel Kp jusqu’à ce que le système oscille de manière stable (on note ce gain Ku et la période d’oscillation Tu). Ensuite, selon le type de correcteur souhaité (P, PI ou PID), on calcule Kp, Ti (temps intégral) et Td (temps dérivé) à partir de formules données par Ziegler et Nichols.
Cette méthode a plusieurs inconvénients, notamment elle nécessite beaucoup de tests afin de tuner les paramètres, c'est impossible dans mon cas car pour cela il faudrait que je fasse de nombreux essais statiques. Les moteurs coutent environ 20€ l'unité et durent une dizaine de seconde, le coût serait exorbitant. Une autre approche pourrait être de subtituer la poussée du moteur par une autre poussée, une hélice et un moteur par exemple. Mais il faudrait pour cela trouver un moteur d'une poussée constante de 20N.
Ces problèmes sont communs à toutes les méthodes empiriques que j'ai pu rencontré, c'est pour cela que je me suis tourné vers les méthodes plus théoriques.
J'ai longtemps bloqué sur la modélisation du système et notamment trouver la fonction de transfert, qui m'était nécessaire pour appliquer les connaissance d'automatique que j'avais. Je suis ensuite parti sur une autre approche, qui, il me semble, s'appelle le remplacement de pôles.
J'ai d'abord modélisé les efforts qui s'appliquaient sur la fusée.
Bilan des Moments :
- Moments dus à la force de poussée : \begin{align*} M_f &= l \cdot F_N \\ &= l \cdot F \cdot sin(\alpha) \end{align*}
- Moments dus aux forces aérodynamiques : \begin{align*} M_{aero} &= \vert x_{cg} - x_{cp} \vert \cdot F_{aero}\\ &= \vert x_{cg} - x_{cp} \vert \cdot \frac{1}{2} \rho \, v^2 \, S \, C_x \, sin(\theta) \end{align*}
-
Avec :
- \(l\) : la distance entre le centre de gravité et le moteur
- \(\alpha\) : l'angle du moteur (TVC Gimbal) avec le corps de la fusée
- \(x_{cg}\) : position du centre de gravité
- \(x_{cp}\) : position du centre de pression (déterminé grâce au logiciel OpenRocket)
- \(\rho\) : densité de l'air
- \(v\) : la vitesse
- \(S\) : la surface de coupe
- \(C_x\) : le coefficient de trainée (déterminé grâce au logiciel OpenRocket)
- \(\theta\) : l'angle entre la verticale et le corps de la fusée
Appliquons la 2nde loi de Newton : \begin{align} \sum M_{cg} &= I \ddot \theta \\ M_F - M_{aero} &= I \ddot \theta \end{align}
Notes :
1) On voit ici que pour une bonne stabilisation passive il faut minimiser la distance \(\vert x_{cg}
- x_{cp} \vert\)
et maximiser la la distance entre le centre de gravité et le moteur \(l\)
2) On cherche \(\alpha\) en fonction de \(\theta\)
Pour le correcteur, je vais rester sur un PD pour garder une équation différentielle de degré 2, on
pourra toujours par la suite
rajouter un coef \(K_I = 0,01\) (choisi arbitrairement).
Voici la méthode : je pars de ce que je souhaite, c'est-à-dire que \(\alpha\) soit la commande après
régulation.
\begin{align*}
\alpha &= K_p \, (\theta - consigne) + K_d \, \dot{(\theta - consigne)} \\
&= K_p \, (\theta - 0) + K_d \, \dot{(\theta - 0)}\\
&= K_p \, \theta + K_d \, \dot \theta
\end{align*}
On cherche \(K_p\) et \(K_d\), on injecte \(\alpha\) dans l'équation obtenue avec le PFD :
\begin{align*}
I \, \ddot \theta &= l \, F \, (K_p \, \theta + K_d \, \dot \theta) \\
\Longrightarrow \ddot \theta &= \frac{l \, F \, K_p}{I} \, \theta + \frac{l \, F \, K_d}{I} \, \dot
\theta \\
\end{align*}
\[\Longrightarrow \ddot \theta - \frac{l \, F \, K_p}{I} \, \theta - \frac{l \, F \, K_d}{I} \, \dot
\theta = 0\]
On reconnait l'équation différentielle d'un système du 2nd ordre, avec :
\[ -\frac{l \, F \, K_d}{I} = 2m\omega_0\] \[ -\frac{l \, F \, K_p}{I} = \omega_0^2\]
ce qui donne :
\[ K_d = -\frac{2 \, m \, \omega_0}{l \, F}\] \[ K_p = -\frac{I \, m \, \omega_0^2}{l \, F}\]
On choisit un coefficient d'amortissement \(m = 0,707\) et une fréquence propre \(\omega_0 = 15 \,
rad/s\).
Après calculs, on trouve \( \boldsymbol{K_p = 1,51} \) et \( \boldsymbol{K_d = 0,14} \)
Ainsi nous obtenons :
NB : les effets aérodynamiques ont été ignorés, les résultats avec la version linéarisée des forces aéro sont très semblables.
5. Attitude Estimator
Les données de l'accéléromètre permettent de connaître l'orientation d'un objet en se basant sur une accélération de référence qui est ici la pesanteur. Cependant, lors de la phase ascensionnelle de la fusée, qui est la phase où il est vital de connaître l'orientation, la fusée subit une très grande accélération verticale qui masque la pesanteur. Ce qui rend l'utilisation de ces données impossible. Par conséquent, nous n'utiliserons que les données issues du gyroscope pour l'estimation de l'attitude.
Dans un premier temps, je suis parti sur une estimation "naïve", j'accumulais les vitesses angulaires suivant chaque axe. Cette méthode a très vite trouvé ses limites et ne fonctionnait que pour des petits angles sur une courte durée.
\[ Roll = \int_{0}^{t} \omega_z \,dt \approx \sum_{k=1}^{n} \omega_z(t_k) \Delta t \] \[ Yaw = \int_{0}^{t} \omega_y \,dt \approx \sum_{k=1}^{n} \omega_y(t_k) \Delta t \] \[ Pitch = \int_{0}^{t} \omega_x \,dt \approx \sum_{k=1}^{n} \omega_x(t_k) \Delta t \]Quaternions
Afin d'obtenir une meilleure précision et fiabilité je me suis naturellement tourné vers les quaternions.
Pour faire ce qui suit je me suis grandement aidé de l'article Quaternion kinematics for the error-state Kalman filter de Joan Solà. Tout ce que je vais montrer y est exposé de manière plus détaillée et approfondie. J'adopterai aussi les mêmes conventions que lui.
Pour trouver l'attitute je suis parti d'un vecteur initial (qui sera déterminé lors de
l'initialisation de la fusée,
dans l'état "Au Sol"), que je transforme en quaternion pur, ie avec partie réelle nulle. Je lui
applique ensuite successivement des
opérations de rotations obtenues grâce aux données du gyroscope.
L'objectif est "d'accumuler" les rotations, pour cela j'utiliserai la formule linéarisée de
l'intégration des taux de rotation.
\begin{align*}
\textbf{q}_{n+1} &= \textbf{q}_n \otimes \textbf{q} \, \left\{ \boldsymbol{\omega}_n \, \Delta
t\right\} \\
&= \textbf{q}_n \otimes exp({\frac{\boldsymbol{\omega}_n \, \Delta t}{2}}) \\
&= \textbf{q}_n \otimes \begin{pmatrix} cos(\frac{\lVert \boldsymbol{\omega}_n\rVert \Delta t}{2})
\\ \frac{\lVert
\boldsymbol{\omega}_n\rVert}{\boldsymbol{\omega}_n} sin(\frac{\lVert \boldsymbol{\omega}_n\rVert
\Delta t}{2})
\end{pmatrix}
\end{align*}
Avec :
\( \boldsymbol{\omega}_n\) : les vitesses de rotation instantanée donnée
par le gyroscope.
\( \textbf{q}_n\) : le quaternion d'attitude à la n-ième étape.
On peut ainsi connaitre la quantité de rotation qui a été opérée sur le vecteur initial connu, cela nous permet le connaitre l'attitude en permanence.
Voici mes essais et expérimentations avec les quaternions : Dépôt GitHub
Notes :
5. Système de récupération
[à compléter]