Programme conversion coordonnées astronomiques

[Tenkaichi]

Bonjour,
Je suis en train d'écrire un petit programme afin de convertir les coordonnées équatoriales d'un objet céleste en coordonnées Alt-azimutales avec un Arduino Mega 2560. Pour cela je me suis grandement inspiré de ce si http://www.stargazing.net/kepler/altaz.html.

Dans un premier temps j'ai calculé l'heure sidérale locale en fonction de ma position sur le globe, puis l'angle horaire afin de pouvoir déterminer par la suite la hauteur et l'azimut de l'objet observé en fonction du temps.

Cependant en comparant mes résultats avec ceux proposés par Stellarium je trouve une différence de plusieurs degrés.. J'ai l'impression d'avoir corrigé toutes les erreurs de monde code, mais n'ayant plus de recule je recherche de l'aide ..


Donc dans un premier temps, le nombre de jours passé depuis la date 1er Janvier 2000 à 12h est calculé, en fraction de jours.

//Calcul du numéro du jour entre 0 et 365
int numeroJour(int annee, int mois, int jours)
{
  int dayNumber = 0;
  int dayMonth[12] = {31,28,31,30,31,30,31,31,30,31,30,31};
  
  if(annee%4 == 0 && annee%100 != 0 || annee%400 == 0)
  {
    dayMonth[1] = 29;
  }
  for(int i=1; i<mois; i++)
  {
    dayNumber += dayMonth[(i-1)];
  }
  dayNumber += jours;
  return dayNumber;
}

Ensuite l'heure sidérale locale (LST) puis l'angle horaire sont calculés. Le calcul de l'heure sidérale locale est très proche, si ce n'est égale, à l'heure sidérale locale fourni par ce site web http://www.jgiesen.de/astro/astroJS/siderealClock/

//Calcul de l'angle horaire pour la conversion des coordonnées
double angleHoraireFunction(double heure, double minute, double seconde, double annee, double anneeSiderale, double jourSiderale, int nombreJours, double longitude, double ascencionDroite)
{
  double fractionJour = heure/24 + minute/(24.0*60.0) + seconde/(24.0*60.0*60.0) + 0.5;
  double daySiderale = (annee - 2000) * anneeSiderale + nombreJours * jourSiderale + fractionJour;
  //Temps UTC
  double universalTime;
  if (heure == 0)
  {
     universalTime = 23 + minute/60 + seconde/3600; 

  }
  else
  {
      universalTime = heure - 1 + minute/60 + seconde/3600; 

  }
  double LST = 100.46 + 0.985647 * daySiderale + longitude + 15 * universalTime;
  while (LST > 360)
  {
    LST = LST - 360;
  }
  while (LST < 0)
  {
    LST = LST + 360;
  }
  double angleHoraire = LST - ascencionDroite;
  if(angleHoraire < 0)
  {
    angleHoraire = angleHoraire + 360;
  }
  return angleHoraire;
}

Et enfin les hauteur et azimuts

//Calcul de l'angle d'altitude
double angleAltitudeFunction(double latitude, double declinaison, double angleHoraire, double pi)
{
  angleAlt = 180/pi*asin(sin(latitude) * sin(declinaison) + cos(latitude) * cos(declinaison) * cos(pi/180*angleHoraire));
  return angleAlt; 
}

//Calcul de l'angle azimutal
double angleAzimutalFunction(double declinaison, double angleAlt, double latitude, double angleHoraire, double pi)
{
  //calcul angle azimut
  angleAzi = 180/pi*acos((sin(declinaison) - sin(pi/180*angleAlt)*sin(latitude))/(cos(pi/180*angleAlt)*cos(latitude)));
  //calcul signe azimut
  if (sin(pi/180*angleHoraire)>0)
  {
    angleAzi = 360 - angleAzi;
  }
  return angleAzi;
}

D'avance merci !
-----

[PA5CAL]

Bonjour

Par défaut, la chaîne de compilation Arduino pour l'ATmega 2560 (avr-gcc) ne fait pas de calcul en double précision. En d'autres termes, le type double est équivalent au type float, qui correspond à une précision relative de seulement 7 chiffres décimaux environ.

Pour faire des calculs plus précis, il faut utiliser une bibliothèque mathématique spécifique ou bien réécrire les fonctions de calcul avec une précision suffisante au regard des résultats attendus.

[Tenkaichi]

Auriez-vous des exemples de librairies permettant des calculs plus précis?
Sinon comment fait-on pour réecrire les fonctions trigo?

[PA5CAL]

Auriez-vous des exemples de librairies permettant des calculs plus précis?

Comme je n'en ai pas eu l'usage (vu que je développe généralement mon propre code), sur le coup je ne saurai donner d'exemple précis.

Toutefois pour avoir fait quelques recherches à une époque, je sais que les bibliothèques mathématiques pour micro-contrôleurs écrites en C « open source » et libres de droit ne manquent pas. Mais elles réclament au minimum une adaptation, et elles ne sont pas optimisées pour n'importe quelle plateforme. On peut aussi en trouver d'autres, optimisées pour les micro-contrôleurs ATmega, mais payantes et soumises à licence.

Mais le point important dans le choix de la solution reste quoi qu'il en soit le cahier des charges, c'est-à-dire le besoin et les contraintes du projet, comme notamment la précision recherchée, les ressources disponibles et les performances attendues.

En effet, il pourrait être dommageable de mettre en œuvre des calculs sur 64 bits si 40 bits suffisent, et peu pertinent de prévoir des fonctions mathématiques dont on n'a pas l'usage. Par ailleurs, il pourrait être intéressant d'effectuer certains calculs en virgule fixe plutôt qu'en virgule flottante.

Sinon comment fait-on pour réecrire les fonctions trigo?

C'est une question purement mathématique. Il suffit d'écrire des algorithmes correspondant aux fonctions à réaliser.

Il existe plusieurs méthodes de calcul, plus ou moins adaptées en fonction des opérations de base mises à disposition par le calculateur.

En l'occurrence, les ATmega ne disposent matériellement que des opérations de test, de décalage, de multiplication, d'addition et de soustraction entières ; les autres opérations simples comme la division ou l'extraction de racine entières, de même que les fonctions plus complexes, doivent être réalisées par logiciel à partir de ces seules opérations de base.

S'agissant de fonctions trigonométriques, on trouve notamment les algorithmes CORDIC qui permettent de réaliser les calculs à l'aide de tests, décalages, additions et soustractions (i.e. sans multiplication ni division). Les développements limités (de Taylor, éventuellement modifiés pour une meilleure convergence) sont plus intéressants dès lors que la multiplication câblée est disponible.

J'allais te citer un exemple, mais je vois qu'il t'a déjà été donné dans la discussion que tu as commencée sur le site d'Arduino.

[A voir en vidéo sur Futura]

[Tenkaichi]

Je ne pense pas qu'une précision au delà de 7 chiffres après la virgule soir réellement nécessaire, la seconde d'Arc étant bien au dessus (2.7x10^-4 dégrée contre 10^-7, on est deux à trois ordres de grandeur au delà de la précision du calcul).

Du coup je n'arrive pas à voir pourquoi je ne trouve pas les mêmes valeurs que Stellarium . . .

[PA5CAL]

Il suffit de comparer le résultat des calculs menés en float et en double sur un PC pour constater que pour certaines valeurs la différence peut dépasser largement la seconde d'arc.

Par exemple :
- latitude = 0 rad
- déclinaison = 0,2618 rad (15 °)
- angle horaire = 0 rad
- angle altitude = 75 °
- différence de calcul sur angle altitude = 7,6294.10^-6 °
- différence de calcul sur angle azimutal = 0,05712 ° (0° 3' 25,6")

Après, si l'on constate des différences entre les angles calculés par le programme et ceux provenant d'une autre source, il faudrait préciser pour quelles valeurs ils sont obtenus.

[Tenkaichi]

J'ai réalisé les calculs pour la galaxie M31 (andromède).
Je me rend compte aussi que j'ai un décalage entre l'heure sidérale locale que je calcule et celle donnée par Stellarium (1min27s), d'où la différence observée sur le résultat final..

[Tenkaichi]

J'ai finalement (ENFIN!) réussi à calculer le temps sidéral local et à obtenir la même valeur que Stellarium (à mois d'une seconde près). Cependant je n'arrive toujours pas à obtenir les mêmes valeurs de hauteur et d'azimut, j'ai une différence de mois d'un degré sur chaque valeur..

Je calcul bien comme précisé sur le site suivant : http://www.stargazing.net/kepler/altaz.html

//Calcul de l'angle d'altitude
double angleAltitudeFunction(double latitude, double declinaison, double angleHoraire, double pi)
{
  double angleAlt = 180/pi*asin(sin(latitude) * sin(declinaison) + cos(latitude) * cos(declinaison) * cos(pi/180*angleHoraire));
  return angleAlt; 
}

//Calcul de l'angle azimutal
double angleAzimutalFunction(double declinaison, double angleAlt, double latitude, double angleHoraire, double pi)
{
  //calcul angle azimut
  double angleAzi = 180/pi*acos((sin(declinaison) - sin(pi/180*angleAlt)*sin(latitude))/(cos(pi/180*angleAlt)*cos(latitude)));
  //calcul signe azimut
  if (sin(pi/180*angleHoraire)>0)
  {
    angleAzi = 360 - angleAzi;
  }
  return angleAzi;
}

Avec mes valeurs dans les sin et cos en degrés...

[Chanur]

Avec mes valeurs dans les sin et cos en degrés...

Comment ça ?
L'argument de sin() et de cos() doit être en radian.

A ta place, je mettrais tous les angles en radians dans le calcul, en faisant la conversion en degré uniquement pour les saisies et affichage :
- l'utilisateur saisit un angle en degrés, tu le convertis immédiatement en radians pour le stocker et t'en servir.
- tu veux afficher un angle, tu le convertis en degrés au moment de l'afficher.
Tes fonctions de calcul seraient plus claires.
(là, pour que ton calcul soit correct, il faut que la fonction angleAltitudeFunction() prenne en argument deux angles en radians et un angle en degrés )

D'autre part, je propose de considérer pi comme constant (constante M_PI dans math.h) ...
Il sera toujours temps d'en faire une variable le jour où tu voudras modifier sa valeur.

[Tenkaichi]

Désolé je me suis trompé.
J'ai mis toute mes valeurs en radians pour faire le calcul des sin et des cos.
La valeur de Pi est défini avec Arduino?? Je n'avais pas trouvé d coup j'ai du définir la valeur..

Finalement mon programme fonctionne, j'avais pris les coordonnées équatoriales à la date J2000, or il me fallait celle d'aujourd'hui..

[Chanur]

La valeur de Pi est défini avec Arduino??

Ah oui, j'avais oublié que c'était un Arduino.
Je ne sais pas. Regarde dans math.h
Mais si ce n'est pas le cas, tu devrais le définir toi-même, comme une constante.

Finalement mon programme fonctionne

Super !