[C++]à la poursuite du soleil!

[no matter]

Çà ne devrait pas être aussi dur de se servir des rcs... non vraiment pas...

Bref...je suis en train d'essayer d'orienter mon progress afin que les panneaux traquent le soleil et je sèche. Il suffit
pourtant que l'axe y pointe vers le soleil.

J'ai deux idées principales qui n'aboutissent pas:

1- Je récupère la position de soleil dans le repère de progress et je calcule l'inverse du sinus des coordonnées (après
avoir normalisé le vecteur position du soleil) qui me donnera l'angle à respecter sur chaque axe.

2-Je récupère l'orientation globale du soleil et je m'oriente à l'identique avec un angle de 90° pour mettre les
panneaux parallèles et non perpendiculaire (c'est comme "Prograder" autour du soleil...)

On va éviter la seconde idée, le calcule de l'orientation serait chiant à suivre ici.

Pour la première idée, aucun problème pour récupérer la position du soleil:

Code: [Select]

           VECTOR3 sun;
VECTOR3 suninv;
VECTOR3 sunloc;

GetGlobalPos(rsun); // global position, vaisseau par rapport au soleil
rsuninv = _V(-sun.x, -sun.y, -sun.z); // inversion, position relative au vaisseau
Global2Local(suninv,sunloc);               //as Dora says, we did it.

           //**normalisation du vecteur**
            float length = sqrt((sunloc.x*sunloc.x)+(sunloc.y*sunloc.y)+(sunloc.z*sunloc.z));
VECTOR3 normsunloc = { sunloc.x/length, sunloc.y/length, sunloc.z/length};
Tout çà semble fonctionner correctement. J'ai bien les coordonnées.
Maintenant lorsque j'essaie de m'en servir, mon progress virevolte dans tous les sens et ne s'arrête jamais

Prenons le contrôle du pitch par exemple, çà me semble bon même si rien n'est amorti (ce n'est pas le but pour
l'instant):

Code: [Select]

VECTOR3 avel; GetAngularVel(avel);
if (asin(normsunloc.y)*DEG>0)
{
if (avel.x < 2.5*RAD)
SetThrusterGroupLevel(THGROUP_ATT_PITCHUP,0.5);
else
SetThrusterGroupLevel(THGROUP_ATT_PITCHUP,0);
if (GetThrusterGroupLevel(THGROUP_ATT_PITCHDOWN) > 0)
SetThrusterGroupLevel(THGROUP_ATT_PITCHDOWN,0.0);
}
else if (asin(normsunloc.y)*DEG<0)
{
if (avel.x > -2.5*RAD)
SetThrusterGroupLevel(THGROUP_ATT_PITCHDOWN,0.5);
else
SetThrusterGroupLevel(THGROUP_ATT_PITCHDOWN,0);
if (GetThrusterGroupLevel(THGROUP_ATT_PITCHUP) > 0)
SetThrusterGroupLevel(THGROUP_ATT_PITCHUP,0.0);
}
else if (asin(normsunloc.y)*DEG == 0)
{
if (GetThrusterGroupLevel(THGROUP_ATT_PITCHDOWN) > 0)
SetThrusterGroupLevel(THGROUP_ATT_PITCHDOWN,0.0);
if (GetThrusterGroupLevel(THGROUP_ATT_PITCHUP) > 0)
SetThrusterGroupLevel(THGROUP_ATT_PITCHUP,0.0);
SetAngularVel(_V(0,avel.y,avel.z));
}
Même méthode pour les deux autres axes et résultat moisi...

J'ai comme l'impression que je n'ai pas la bonne méthode

La deuxième méthode, me donne le même résultat, aucun soucis pour récupérer les coordonnées solaire, j'ai même
orienté le progress en faisant un coup de SetGlobalOrientation (disgracieux à souhait mais çà oriente bien le progress
convenablement). Par contre dès que j'essaie de me servir de rcs, c'est la catastrophe...
Dans le style:

Code: [Select]

VECTOR3 arot; GetGlobalOrientation(arot);
if (arot.x > alpha)
{
if (avel.x < 2.5*RAD)
SetThrusterGroupLevel(THGROUP_ATT_PITCHUP,0.5);
else
SetThrusterGroupLevel(THGROUP_ATT_PITCHUP,0);
if (GetThrusterGroupLevel(THGROUP_ATT_PITCHDOWN) > 0)
SetThrusterGroupLevel(THGROUP_ATT_PITCHDOWN,0.0);
}
else
{
if (avel.x > -2.5*RAD)
SetThrusterGroupLevel(THGROUP_ATT_PITCHDOWN,0.5);
else
SetThrusterGroupLevel(THGROUP_ATT_PITCHDOWN,0);
if (GetThrusterGroupLevel(THGROUP_ATT_PITCHUP) > 0)
SetThrusterGroupLevel(THGROUP_ATT_PITCHUP,0.0);
}
alpha, beta et gamma sont les coordonnéees du vecteur orientation globale du soleil
Pour chaque axe c'est la même méthode et séparément chaque axe semble fonctionner (plus ou moins) mais les trois
ensemble me donne une dance étrange

Toute aide bienvenue merci



Message modifié ( 25-07-2008 12:00 )

[DanSteph]

Tu peux toujours tricher en manipulant directement les vitesse angulaire sur les trois axes mais c'est... triché.

Sinon c'est une question de retrofeedback, le problème vient de l'inertie, il faut lancer le vessel dans la bonne giration
sur un axe au début puis le freiner AVANT qu'il y arrive pour qu'il puisse s'arretter au bon angle.

*Tout* est dans la gestion de la vitesse angulaire. (Il y a une fonction pour l'avoir GetAngularSpeed ou un truc dans
le genre)

Les RCS eux sont asservi a """l'IA"""" qui demande une certaine vitesse angulaire en fonction de l'angle restant.
Pas assez de vittesse ils poussent, trop ils freinent.

Ch'est clair ?

Ca promet une bonne après midi de prise de tête. Désolé je suis sur FSP et deja envie de morde les murs et avec
deux mois de retard... je peux pas aider plus.

Dan

[no matter]

Ca promet une bonne après midi de prise de tête. Désolé je suis sur FSP et deja envie de morde les murs et
avec deux mois de retard... je peux pas aider plus.

oui, çà va même déborder sur la nuit là je sens... ^^
Bon courage pour FSP!

J'ai bien vu pour la vitesse angulaire:
VECTOR3 avel; GetAngularVel(avel);
Je l'ai limitée à une très petite valeur (2.5*RAD) pour les tests, j'ai pas pris le coups apparemment on dirait que j'ai
merdé sur mes calculs et que l'orientation sur un axe perturbe celle sur les deux autres... une bonne prise de tête en
effet. J'arrête pas de le dire, bouger les rcs ne devrait pas être aussi compliqué.

Je comprend pas qu'on n'ai pas un SetGlobalOrientationByRCS() ou un PointSun() (ok, là j'abuse ^^).
J'ai en tout cas carrément pas le niveau mathématique pour ces trucs, j'ai passé au moins deux heures à capter
comment récupérer les angles ^^ sans parler du googlage pour retrouver comment normaliser un vecteur >_<

Si je résume la situation c'est pourtant simple, je veux simplement prograder autour du soleil tout en restant en
orbite terrestre avec un léger bank de 90° histoire de placer les panneaux correctement.

[JMD]

A lire ton post, ça a l'air effectivement compliqué.

Je ne connait pas C++, Je suis désolé de ne pas pouvoir t'aider, mais je compatis...

[DanSteph]

no matter a écrit:
J'ai en tout cas carrément pas le niveau mathématique pour ces trucs

Alors la je te rassure, j'ai aucun niveau en math, mes algo autopilote c'est juste de la bonne mecanique logique
et ca marche très bien.

1-Tu le bloque sur trois axes, la c'est pas compliqué tu utilise la vitesse angulaire et tu l'applique en retrofeedback:
En bref tu utilise le retour de GetangularVel et tu l'applique simplement au RCS en inverse. Quelques tests te diront
quel coefficient multiplicateur il faut appliquer. Donc plus la vitesse angulaire sera grande, plus le RCS poussera pour
la contrer, c'est ce que j'appelle le retro feedback.

En bref exemple pseudo code:

Code: [Select]

VECTOR3 Vel={0};
GetAngularVel(&vel)
if(vel.x>0)
    SetRCSTrhuster(AXE_XMOINS,vel.x*1.6);   // contre la vitesse angulaire
else
   SetRCSTrhuster(AXE_XPLUS,-vel.x*1.6);   // contre la vitesse angulaire


Tu peux le faire en plusieurs phase ton autopilote (switch case break)

1-Tu annule toutes les vitesses (tu peux aussi lancer un KILLROT et attendre qu'il ce debranche)
2-Tu oriente l'axe X pour que le nez soit a 90°
3-Tu oriente l'axe Z pour qu'il tourne le dos

Enfin bref tu vois le principe quoi, pense grosse mecanique, pas mathemathique. (t'a deja les formule qui te donne la
différence angulaire ? c'est les seuls "gros" math requis) Les autopilotes c'est une des parties que je préfere.
Celui que j'aime le plus c'est le pilote atmo du DGIV: 14 lignes de C++ en tout, une vraie merveille qui marche nickel. (Le pro104 qui tient les 40° lui est assez moche, trop de lignes, mais c'était un des premiers)

Bonne chance

Dan



Message modifié ( 24-07-2008 23:07 )

[no matter]

Enfin bref tu vois le principe quoi, pense grosse mecanique, pas mathemathique.

Voilà une phrase qui me plait Çà devrait aller, mieux. Surtout que je n'avais absolument pas eu l'idée
de me servir de la vitesse angulaire pour régler leur puissance (vel.x*1.6)...
Çà devrait virer les sautillements trop important (pour l'instant c'était très "flottant").

Celui que j'aime le plus c'est le pilote atmo du DGIV: 14 lignes de C++

champion.

Bonne chance

M'ci, je sens venir le bout
En fait, j'avais peur d'avoir fait une bonne grosse erreur dans mes maths mais le tout vérifié avec des
oapiDebugScreen et attitudeMFD pour comparer me prouve le contraire.

[no matter]

YES YES WOOOOHOOOOO

C'est pas encore parfait mais çà en prend le chemin. J'avais fait une erreur, pas dans les calculs mêmes mais dans
mes conditions ensuites, j'avais mis un asin qu lieu d'un atan à un endroit

[vinka]

Va voir à cette adresse,

http://www.mathworks.com/company/newsletters/news_notes/sum99/lunar_module.html

C'est génial, c'est facile, c'est ce que j'utilise pour le contrôle d'attitude de multistage et en plus ça a vraiment servi
sur le LEM ...

[no matter]

Actuellement je n'arrive pas à accéder à la page , même  http://www.mathworks.com/ n'est pas accessible.
Je retenterais plus tard.

Merci

EDIT: Le lien fonctionne maintenant



Message modifié ( 26-07-2008 11:03 )