Yasim - Comment ça fonctionne ?

Bonjour à tous,

Suite à ce débat qui tient tant à cœur à helijah et qui prétend détenir la vérité j'ai décidé d'aller moi-même chercher la vérité en analysant scrupuleusement Yasim dans un premier temps puis JSBSim.
Ainsi nous n'aurons plus "une personne" qui dit <<moi je sais parce que je connais et donc ce que je vous dis c'est la vérité>>, mais nous serons alors tous à connaitre tout les tenants et les aboutissants de Yasim et nous pourrons alors cesser d'écouter la sainte parole d'une seule personne qui prétend savoir tout sur tout.

Après cette introduction passons au vif du sujet, à ce qui est incontestable et indiscutable et qui est injustifiable par un "moi je sais et vous vous savez rien", du concret !

Je vais faire cela sous forme de petit article :

1 - TAKEOFF-POWER et TAKEOFF-RPM
2 - PROPPITCH ET ADVANCE

Tout d'abord il y a 2 paramètres Yasim qui sont absent du moteur du DC-3 que sont "takeoff-power" et "takeoff-rpm"
Ces 2 valeurs sont facultatives, mais si elle sont renseigné voilà ce qui se passe :
(en vert ce sont les paramètres qui sont dans le FDM)

Yasim déclenche la fonction "setTakeoff()", cette fonction permet de définir la variable "_matchTakeoff=true" et la variable "_tc0" dont la valeur est définit comme suit :
_tc0 = (torque x gamma) / (0.5 x density x V2 x _f0);
avec :
torque = power0 / omega0;
gamma = _etaC x _beta / _j0;
V2 = _r x omega0 x _r x omega0;
_f0 = 2 x _etaC x power/(rho x v x V2);
density = densité de l'air à l'altitude 0 (la densité de l'air à cette altitude est calculé via un tableau Yasim et un calcul venant de l'algorithme JSBSim)
power0 = takeoff-power x 745.700
omega0 = takeoff-rpm x 0.10471975512
_etaC = 0.85
_beta = 1/(5^-0.25 - 5^-1.25)
_j0 = v/(omega*_lambdaPeak)
_r = radius
power = cruise-power x 745.700
rho = densité de l'air à l'altitude cruise-alt x 0.3048 (la densité de l'air à cette altitude est calculé via un tableau Yasim et un calcul venant de l'algorithme JSBSim)
v = cruise-speed x 0.514444444444
omega = cruise-rpm x 0.10471975512
_lambdaPeak = 5^-0.25

Bon je vous épargne le calcul, allons droit au but, on a donc mis les paramètres "takeoff-power" et "takeoff-rpm" dans notre FDM Yasim ce qui fait qu'on se retrouve avec cette variable "tc0" dont le calcul n'est pas très appétissant. Ce qui est intéressant c'est de savoir ce que Yasim en fait de cette variable. Et bien voilà ce qu'il en fait :
Si "_matchTakeoff" est égale à "true" (ce qui est le cas vue qu'on a mis les 2 paramètre de "takeoff") et que tc est plus grand que tc0 alors tc = tc0
avec :
tc = (1 - lambda) / (1 - _lambdaPeak)
lambda = J/_j0
_lambdaPeak = 5^-0.25
J = v/omega
Si le paramètre "manual-pitch" existe dans la section propeller du FDM
_j0 = _baseJ0 * 2^(2 - 4*_proppitch)
Sinon
_j0 = v/(omega*_lambdaPeak)
v = -(wind[0] x dir[0] + wind[1] x dir[1] + wind[2] x dir[2]) ==> Oh oh ! on est train de faire un calcul qui concerne l'hélice et qu'est-ce qu'on voit là !? le mot "wind"... ça veut pas dire "vent" en Anglais ça ? on est bien tous d'accord que le vent n'a jamais fais tourner l'hélice d'un avion... je crois qu'on a mis le doigt sur un truc mais bon on continue !
_baseJ0 = _j0
_proppitch = control="PROPPITCH" ==> Tiens un nouveau paramètre "PROPPITCH"... qui se traduit par "pas d'hélice"... ben alors pourquoi on utilise "control=ADVANCE" !???
omega = _omega x gear-ratio
_omega = trop compliqué

Bon et bien maintenant qu'on a ce "tc", on va voir ce qu'il en fait notre ami Yasim, alors ensuite il nous dit que :
thrust = 0.5 * density * V2 * _f0 * tc
avec :
V2 = v*v + tipspd*tipspd
tipspd = _r*omega
omega = _omega x gear-ratio
v = -(wind[0] x dir[0] + wind[1] x dir[1] + wind[2] x dir[2]) ==> bon là on se retrouve encore avec ce truc plus que bizarre qu'on déteste tous
_omega = c'est le même que tout à l'heure donc j'en suis au même point : trop compliqué
tc = notre calcul précédent

Donc notre variable "tc0" s'est envolé dans le calcul de "tc" maintenant c'est "tc" qui vient de s'envoler dans le calcul de "thrust" alors bon suivons "thrust"

torque = thrust/gamma
avec :
gamma = (_etaC*_beta/_j0)*(1-l4)
_etaC = 0.85
_beta = 1/(5^-0.25 - 5^-1.25)
_j0 = idem que pour le calcul de "tc"
l4 = lambda^4
lambda = idem que pour le calcul de "tc"

Et bien voilà c'est terminé. Nous avons la valeur de "thrust" qui correspond à la poussée ainsi que la valeur de "torque" qui correspond au couple. Nos 2 paramètres "takeoff-power" et "takeoff-rpm" sont passé à la moulinette pour se retrouver sous forme de poussé et de couple... Chouette hein

Mouai mais bon ça nous mène où tout ça ? Et bien on vient de trouver pourquoi les hélices tournent toute seule sur les avions Yasim quand y'a du vent, et on a aussi mis le doigt sur le paramètre "PROPPITCH" qui est en conflit avec le paramètre "ADVANCE"...

Super ce sujet !! Veux-tu que je le verrouille une fois que tu auras terminé ? Ceci pour éviter les débats et aussi de ne pas avoir des messages correspondants à Yasim séparés par d'autres. Bien sûr, je supprimerais le mien.

Intéressons-nous désormais à PROPPITCH et ADVANCE. Que font-ils ? à quoi servent-ils ?
je rappel qui ce qui est en vert c'est ce que l'on a mis dans notre FDM c'est à dire que si on a ça dans notre FDM :

Code:


<control-input axis="/controls/engines/engine[0]/propeller-pitch" control="ADVANCE"/>


alors on sait que quand on va bouger la manette dans le DC-3 c'est le paramètre ADVANCE qui sera affecté (via la propriété propeller-pitch), donc si la manette est tout en bas dans FG ça veut dire que ADVANCE = 0 et si elle est tout en haut ADVANCE = 1

On commence en analysant la fonction qui lit le notre FDM (dc-3-yasim.xml)

FGFDM.cpp
- fine-stop dont la valeur est renseigné par le paramètre fine-stop du FDM si il existe, sinon Yasim dit que fine-stop = 0.25
- coarse-stop dont la valeur est renseigné par le paramètre coarse-stop du FDM si il existe, sinon Yasim dit que coarse-stop = 4
- on exécute la fonction prop ->setStops(fine-stop, coarse-stop) qui est une fonction qui utilise nos 2 paramètres précédent
- Si on trouve manual-pitch="1" alors on exécute la fonction prop->setManuelPitch()
- le paramètre ADVANCE de notre FDM est envoyé dans la fonction ControlMap::ADVANCE
- le paramètre PROPPITCH de notre FDM est envoyé dans la fonction ControlMap::PROPPITCH
- le paramètre PROP de notre FDM (tiens un petit nouveau !) est envoyé dans la fonction ControlMap::PROP

Voyons donc :
- ce que fait la fonction prop ->setStops(fine-stop, coarse-stop) avec nos 2 paramètres
- ce que fait la fonction prop->setManuelPitch() après avoir vu qu'il y avait écrit manual-pitch="1" dans notre FDM
- Ce que font les fonction ControlMap::" avec nos paramètres ADVANCE, PROPPITCH et PROP

Propeller.cpp
- la fonction [i]prop ->setStops(fine-stop, coarse-stop) permet de dire que la variable _fine_stop = notre paramètre fine-stop, et que la variable _coarse_stop = notre paramètre coarse-stop, en clair on a juste renommé fine-stop en _fine_stop et coarse-stop en _coarse_stop ... génial non ?

- la fonction prop->setManuelPitch() permet de dire que la variable _manuel = TRUE

ControMap.cpp
- la fonction ControlMap::ADVANCE appelle la fonction setAdvance(ADVANCE)
- la fonction ControlMap::PROPPITCH appelle la fonction setPropPitch(PROPPITCH)
- la fonction ControlMap::PROP heeeu et bien... elle n'existe pas tout simplement... merci Yasim hein ^^ bref passons

Nous avons donc avancé dans nos recherches, on a trouvé tout ce qu'on voulait trouvé mais maintenant on se retrouve avec d'autres choses ! On a désormais :
- une variable _fine_stop qui est égale au paramètre fine-stop de notre FDM.
- une variable _coarse_stop qui est égale au paramètre coarse-stop de notre FDM.
- une fonction setAdvance(ADVANCE)
- une fonction setPropPitch(PROPPITCH)

Voyons donc :
- ce que la fonction setAdvance(ADVANCE) va faire de notre paramètre ADVANCE
- ce que la fonction setPropPitch(PROPPITCH) va faire de notre paramètre PROPPITCH
- ce que devient _fine_stop
- ce que devient _coarse_stop

PropEngine.cpp
- la fonction setAdvance(ADVANCE) permet de dire que la variable _advance = notre paramètre ADVANCE
- la fonction setPropPitch(PROPPITCH) appelle la fonction _prop->setPropPitch(PROPPITCH) Mouai... super une fonction qui renvoi vers une fonction du même nom mais autre part... original^^ D'ailleurs allons tout de suite voir ce que fait cette fonction de notre paramètre PROPPITCH

Propeller.cpp
- la fonction _prop->setPropPitch(PROPPITCH) permet de dire que la variable _proppitch = notre paramètre PROPPITCH

Et bien voilà on a trouvé tout ce qu'on voulait trouver, on a donc :
- _proppitch = PROPPITCH
- _advance = ADVANCE
- _fine_stop= fine-stop
- _coarse_stop = coarse-stop
- _manual = TRUE

Tout ça pour ça... mouai je suis bien d'accord avec vous... on aurait pu faire plus simple quand même, mais bon bref on en est là c'est pas mal ! Yasim n'a fait que renommer les paramètres qu'on a écrit dans notre FDM pour l'instant en fait... mais bon^^

Maintenant ce qui est intéressant de voir c'est ce que vont devenir toutes ces variables qui contiennent les paramètres de notre FDM. Allez c'est parti :

- _proppitch n'est utilisé que si _manual = TRUE (ce qui est le cas) et est utilisé comme ceci : _j0 = _baseJ0 x 2^(2 - 4 x _proppitch)
On sait que _proppitch varie de 0 à 1 on peut donc déjà faire une petite partie du calcul si on veut :
2^(2 - 4 x 0) = 4
2^(2 - 4 x 1) = 0.25
Donc _j0 = _baseJ0 x [0.25, 4]
Après ça la variable _proppitch (qui contient notre paramètre PROPPITCH que l'on fait varier avec les manettes blanche dans le DC-3) disparait totalement de la circulation.
- _advance n'est utilisé que si _variable = TRUE ce que l'on ignore actuellement puisque nous découvrons la variable _variable.
- _manual, comme nous l'avons vu, il permet d'inclure _proppitch dans le calcul de _j0 dès lors que manual-pitch="1" se trouve dans le FDM. On pourrait se poser la question <<et si _manual = FALSE alors comment on calcul _j0 ?>> On y reviendra plus tard
- _fine_stop et _coarse_stop, sont utilisé dans la fonction modPitch(mod), dans cette fonction on calcul quoi ? et bien on calcul _j0 et oui encore une fois ! Alors moi je me pose 2 questions là. La première est << Humm et pourquoi on calcul encore une fois _j0 ? >> la deuxième question est << C'est bien gentil de faire des calcul avec nos paramètres _fine_stop et _coarse_stop mais si la fonction n'est jamais exécuté ça sert pas à grand chose. Donc à quelle moment est utilisé cette fonction ?>>

Allons donc chercher :
- le fonctionnement de _variable qui permet de savoir si _advance sera utilisé ou non (_advance étant égal au paramètre ADVANCE de notre FDM)
- à quel moment est appelé la fonction modPitch(mod) ? histoire de savoir quand est-ce que Yasim va se servir de nos paramètres fine-stop et coarse-stop de notre FDM

Revenons dans notre premier fichier, celui qui analyse notre fichier dc-3-yasim.xml

FGFDM.cpp
- Si Monsieur Yasim trouve le paramètre max-rpm alors il appelle la fonction setVariableProp(min-rpm, max-rpm)

PropEngine.cpp
- la fonction setVariableProp(min-rpm, max-rpm) permet de dire que :
1) _minOmega = min-rpm
2) _maxOmega = max-rpm
3) _variable = TRUE ah ah ça y est on sait quand est-ce que _variable passe à TRUE
- la fonction modPitch(mod) est quand a elle appelé dans la "moulinette" de FG c'est à dire qu'elle est constamment appelé

Voyons maintenant :
- à quoi vont servir _maxOmega et _minOmega
- ce que fait la fonction modPitch(mod)

Je commence par _maxOmega et _minOmega :
Si la variable _variable est à false on dit que _omega = 52 sinon si _variable est à true (ce qui est le cas puisqu'il y a le paramètre "max-rpm" dans le FDM) on dit que :
- _omega = _minOmega + _advance x (_maxOmega - _minOmega)
avec :
_minOmega = min-rpm
_maxOmega = max-rpm
_advance = control=ADVANCE ==> Ah tiens on retrouve notre ADVANCE... je vais être honnête : je ne vois pas la différence avec PROPPITCH...
On en profite aussi pour dire que :
_j0 = (v/(omega*_lambdaPeak)) x 1^6
avec
v = cruise-speed x 0.514444444444
omega = cruise-rpm x 0.10471975512
_lambdaPeak = 1^-0.25

La fonction modPitch(mod) fait cela :
- j0 = j0 x mod
- Si _j0 est plus petit que _fine_stop x _j0 alors _j0 = _fine_stop x _j0
- Si _j0 est plus grand que _coarse_stop x _j0 alors _j0 = _coarse_stop x _j0

Il nous faut trouver la valeur de mod, et bien là ça va se compliquer car mod change de valeur plusieurs fois par itération. Ses différentes valeurs sont :
- mod = 1^6
- mod = 1 + (step x 0.005)
- mod = 1 - (step x 0.005)
- mod = 1.04 si propTorque est plus petit que targetTorque, sinon il vaut 1/1.04

Alors trouvons ce que vaut step et propTorque

C'est l'heure de la pause