Calcul de la position du soleil (déclinaison, angle horaire, altitude et azimut) : altaz solaire

Soyez le premier à donner votre avis sur cette source.

Snippet vu 84 560 fois - Téléchargée 3 086 fois

Contenu du snippet

Salut,

il s'agit d'un code qui peut vous aider si vous aimez l'astronomie et plus particulièrement le soleil.
Il permet de connaître à la seconde près la position du soleil.
Je vous laisse essayer.
Il a été fait sous Borland C++builder6.

A+!

Source / Exemple :


//-----------------------------bibliothèques------------------------------------
//------------------------------------------------------------------------------

#include <iostream.h>
#include <conio.h>
#include <math.h>
#include <iomanip>
#include <windows.h>

//-----------------------------déclaration--------------------------------------
//------------------------------------------------------------------------------

const HANDLE MaConsoleEcran=GetStdHandle(STD_OUTPUT_HANDLE);

//-----------------------------fonction d'attente-------------------------------
//------------------------------------------------------------------------------

void wait(long sec)
{
    long start, courante;
    time(&start) ;
    time(&courante) ;

    while((courante-start)<sec)
    {
        time(&courante) ;
    }
}

//-----------------------------calcul du jour julien----------------------------
//------------------------------------------------------------------------------

long double calcul_jour_julien(long double jour, long double mois, long double annee, long double heure, long double minute, long double seconde)
{
        long double month, year, day, a, b, jour_julien;

        day=jour+heure/24.0+minute/1440.0+seconde/86400.0;
        year=annee;
        month=mois;

        if(month==1 || month==2)
        {
                year=year-1.0;
                month=month+12.0;
        }

        a=int(year/100.0);
        b=2-a+int(a/4.0);

        jour_julien=int(365.25*(year+4716.0))+int(30.6001*(month+1.0))+day+b-1524.5;
        return jour_julien;
}

int texte;
int fond;

void CouleurTexte( int CouleurTexte )
{
	texte = CouleurTexte;
	SetConsoleTextAttribute (MaConsoleEcran, texte | fond);
}

void CouleurFond(int CouleurFond)
{

	fond = CouleurFond << 4 ;

	SetConsoleTextAttribute (MaConsoleEcran, texte | fond);
}

void AfficherCurseur(int mode)
{
 	CONSOLE_CURSOR_INFO curseur;

	GetConsoleCursorInfo(MaConsoleEcran, &curseur);

		if (mode == TRUE)
		curseur.bVisible = TRUE;
		else
		curseur.bVisible = FALSE;

	SetConsoleCursorInfo(MaConsoleEcran, &curseur);
}

void EffaceEcran()
{
	CONSOLE_SCREEN_BUFFER_INFO MesInfosEcran;

	if (GetConsoleScreenBufferInfo (MaConsoleEcran, &MesInfosEcran))

	{
		COORD origine = { 0, 0 };

		DWORD nbCaractEcrit;

		DWORD taille = MesInfosEcran.dwSize.X * MesInfosEcran.dwSize.Y;

		FillConsoleOutputCharacter (MaConsoleEcran, ' ', taille, origine, &nbCaractEcrit);

		FillConsoleOutputAttribute (MaConsoleEcran, MesInfosEcran.wAttributes, taille, origine, &nbCaractEcrit);

		SetConsoleCursorPosition    (MaConsoleEcran, origine);
          }
}

//-----------------------------programme principal------------------------------
//------------------------------------------------------------------------------

main()
{
SYSTEMTIME    si;
long double sd, jour2, mois2, heure2, minute2, annee2, seconde2, correction_heure;
long double jour_nouveau, g, q, l, e, ascension_droite, declinaison, heure_siderale1, heure_siderale2, nb_siecle;
long double latitude, longitude, angle, angleT, angleH, angle_horaire, altitude, azimut, sinazimut;

CouleurFond(FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_INTENSITY);
EffaceEcran();
AfficherCurseur(0);

//-----------------------------en-tête de la fenêtre----------------------------
//------------------------------------------------------------------------------

COORD         dwTaille = {80, 25};
HANDLE        hConsole = GetStdHandle(STD_OUTPUT_HANDLE);

SetConsoleScreenBufferSize(hConsole, dwTaille);
SetConsoleTitle("AltAz Solaire - version 2                                                                            ------ --------");

//-----------------------------avertissement------------------------------------
//------------------------------------------------------------------------------

CouleurTexte(FOREGROUND_RED | FOREGROUND_INTENSITY);
cout<<" Attention! Vous ne pourrez plus me contacter pour avoir des infos sur les calculs."<<endl;
cout<<" Merci d'avoir choisi AltAz Solaire !"<<endl;
cout<<"----------------------------------------------------------------------------------------------------------------------------------------------------------------"<<endl;

//-----------------------------coordonnées du lieu d'observation----------------
//------------------------------------------------------------------------------

CouleurTexte(FOREGROUND_RED |FOREGROUND_BLUE);
cout<<"                                                                               "<<endl;
cout<<"Entrez la latitude du lieu d'observation (positive vers le Nord):      ";
cin>>latitude; //42.93627 ° N pour la LJR
cout<<"Entrez sa longitude (positive vers l'Est)                       :       ";
cin>>longitude; //0.14291 ° E pour la LJR

//-----------------------------heure d'hiver ou d'été---------------------------
//------------------------------------------------------------------------------

correction_heure=0;
while(correction_heure!=1 && correction_heure!=2)
{
        CouleurTexte(FOREGROUND_GREEN);
        cout<<"                                                                               "<<endl;
        cout<<"Tapez 1 si vous etes a l'heure d'hiver, et 2 si vous etes a l'heure d'ete :   ";
        cin>>correction_heure;
}

//-----------------------------boucle de calculs--------------------------------
//------------------------------------------------------------------------------

while(1)
{

 GetLocalTime(&si);
  jour2 = si.wDay;
  mois2 = si.wMonth;
  annee2 = si.wYear;
  heure2 = si.wHour;
  minute2 = si.wMinute;
  seconde2 = si.wSecond;

//-----------------------------affichages date et heure-------------------------
//------------------------------------------------------------------------------

CouleurFond(FOREGROUND_BLUE);
EffaceEcran();
AfficherCurseur(0);
CouleurTexte(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY);
cout<<"Date                                     : "<<int(jour2)<<" "<<int(mois2)<<" "<<int(annee2)<<endl;
cout<<"Heure                                    : "<<int(heure2)<<":";
if(minute2<10) cout<<"0";
cout<<int(minute2)<<":";
if(seconde2<10) cout<<"0";
cout<<int(seconde2)<<endl<<endl<<endl;

//-----------------------------affichages jour julien et jour julien nouveau----
//------------------------------------------------------------------------------

CouleurTexte(FOREGROUND_GREEN | FOREGROUND_INTENSITY);
cout<<"Jour julien                              : "<<setiosflags(std::ios::fixed)<<calcul_jour_julien(jour2, mois2, annee2, heure2, minute2, seconde2)-correction_heure/24.0<<endl;
jour_nouveau=calcul_jour_julien(jour2, mois2, annee2, heure2, minute2, seconde2)-correction_heure/24.0-2451545.0;
cout<<"Jour julien nouveau                      : "<<jour_nouveau<<endl<<endl<<endl;

//-------------calculs et affichages ascension droite et délinaison-------------
//------------------------------------------------------------------------------

g=357.529+0.98560028*jour_nouveau;
q=280.459+0.98564736*jour_nouveau;
l=q+1.915*sin(g*M_PI/180.0)+0.020*sin(2*g*M_PI/180.0);
e=23.439-0.00000036*jour_nouveau;

ascension_droite=atan(cos(e*M_PI/180.0)*sin(l*M_PI/180.0)/cos(l*M_PI/180.0))*(180.0/M_PI)/15.0;
if(cos(l*M_PI/180.0)<0)
{
        ascension_droite=12.0+ascension_droite;
}
if(cos(l*M_PI/180.0)>0 && sin(l*M_PI/180.0)<0)
{
        ascension_droite=ascension_droite+24.0;
}

CouleurTexte(FOREGROUND_RED | FOREGROUND_INTENSITY);
cout<<"Ascension droite                         : "<<ascension_droite<<" h"<<endl;
cout<<"                                        ou "<<int(ascension_droite)<<" h "<<int((ascension_droite-int(ascension_droite))*60)<<" min "<<((ascension_droite-int(ascension_droite))*60-int((ascension_droite-int(ascension_droite))*60))*60<<" s"<<endl<<endl;

declinaison=asin(sin(e*M_PI/180.0)*sin(l*M_PI/180.0))*180.0/M_PI;
cout<<"Declinaison                              : "<<declinaison<<" deg"<<endl;
cout<<"                                        ou "<<int(declinaison)<<" deg "<<int((declinaison-int(declinaison))*60)<<" min "<<((declinaison-int(declinaison))*60-int((declinaison-int(declinaison))*60))*60<<" s"<<endl<<endl<<endl;

//-----------------------------calculs heure sidérale et angle horaire----------
//------------------------------------------------------------------------------

nb_siecle=jour_nouveau/36525.0;
heure_siderale1=(24110.54841+(8640184.812866*nb_siecle)+(0.093104*(nb_siecle*nb_siecle))-(0.0000062*(nb_siecle*nb_siecle*nb_siecle)))/3600.0;
heure_siderale2=((heure_siderale1/24.0)-int(heure_siderale1/24.0))*24.0;

angleH=360.0*heure_siderale2/23.9344;
angleT=(heure2-correction_heure-12.0+minute2/60.0+seconde2/3600.0)*360.0/23.9344;
angle=angleT+angleH;

angle_horaire=angle-ascension_droite*15.0+longitude;

//-------------calculs et affichages altitude et azimut-------------------------
//------------------------------------------------------------------------------

altitude=asin(sin(declinaison*M_PI/180.0)*sin(latitude*M_PI/180.0)-cos(declinaison*M_PI/180.0)*cos(latitude*M_PI/180.0)*cos(angle_horaire*M_PI/180.0))*180.0/M_PI;

CouleurTexte(FOREGROUND_BLUE | FOREGROUND_GREEN  | FOREGROUND_RED | FOREGROUND_INTENSITY);
cout<<"Altitude                                 : "<<altitude<<" deg"<<endl;
cout<<"                                        ou "<<int(altitude)<<" deg "<<int((altitude-int(altitude))*60)<<" min "<<int(((altitude-int(altitude))*60-int((altitude-int(altitude))*60))*60)<<" s"<<endl<<endl;

azimut=acos((sin(declinaison*M_PI/180.0)-sin(latitude*M_PI/180.0)*sin(altitude*M_PI/180.0))/(cos(latitude*M_PI/180.0)*cos(altitude*M_PI/180.0)))*180.0/M_PI;
sinazimut=(cos(declinaison*M_PI/180.0)*sin(angle_horaire*M_PI/180.0))/cos(altitude*M_PI/180.0);
if(sinazimut<0)
        {
        azimut=360-azimut;
        }

cout<<"Azimut                                   : "<<azimut<<" deg"<<endl;
cout<<"                                        ou "<<int(azimut)<<" deg "<<int((azimut-int(azimut))*60)<<" min "<<int(((azimut-int(azimut))*60-int((azimut-int(azimut))*60))*60)<<" s"<<endl<<endl;

wait(1);

}

}

A voir également

Ajouter un commentaire

Commentaires

Fantastique, conversion en langage Monkey C pour portage sur montre Garmin réussie.
Messages postés
3
Date d'inscription
mercredi 26 août 2009
Statut
Membre
Dernière intervention
18 octobre 2012

Bonjour,
Ce développement est génial, mais pourriez-vous me dire où je pourrais trouver son équivalent en VBA.
J'essaie depuis un moment et je bloque quant à la compréhension de certaines manip.
En regardant votre code je ne sais pas si cela est possible de le transcrire en VBA.

Merci d'avance.
Messages postés
1
Date d'inscription
jeudi 24 décembre 2009
Statut
Membre
Dernière intervention
8 février 2011

Très bon code, on retrouve les formules sur http://emilie.bodin.free.fr/logiciel/logiciel.html#formules
Messages postés
1
Date d'inscription
jeudi 22 juillet 2010
Statut
Membre
Dernière intervention
6 octobre 2010

Bonjour,
Je sais que c'est peux être un peu loin maintenant mais est-ce que tu pourrais citer tes sources par hasard ? Notamment pour le calcul précis de calcul de la position du soleil ... Merci !
Messages postés
4
Date d'inscription
vendredi 22 mai 2009
Statut
Membre
Dernière intervention
3 mars 2010

J'ai fait une petite amélioration au programme:

Actuellement le programme demande si on est en heure d'été ou d'hiver.

Mon module supplémentaire prend la date du jour, calcul la date des changements d'horaire automatiquement et compare les dates de changements avec la date du jour.

En code sa donne:

//---------------------Recuperation date du jour-------------------------------
//-----------------------------------------------------------------------------

struct tm Today;
time_t now;

time(&now);

Today = *localtime(&now);
printf("%4.4d/%2.2d/%2.2d\n",Today.tm_year + 1900, Today.tm_mon + 1, Today.tm_mday);

//---------------Calculer date heure d'été ou heure d'hiver--------------------
//-----------------------------------------------------------------------------

int a = Today.tm_year + 1900;
int y1; //Jour entre 0 et 6 du 31 mars
int z1; //date dernier dimanche de mars
int y2; //Jour entre 0 et 6 du 31 octobre
int z2; //date dernier dimanche de octobre

y1 = (5+ a+ int(a/4)- int(a/100)+ int(a/400))%7;
y2 = (2+ a+ int(a/4)- int(a/100)+ int(a/400))%7;

z1 = 31-y1;
z2 = 31-y2;

//Deux lignes permettant de verifier si la date calculé correspond bien a la réalité
//cout << "Date de l'heure d'été: " << z1 << " mars " << a << "\n";
//cout << "Date de l'heure d'hiver: "<< z2 <<" octobre " << a <<"\n";

struct tm Hiver; //Enregistrement des dates calculés dans structure pour les comparés

Hiver.tm_year = a;
Hiver.tm_mon = 10;
Hiver.tm_mday = z2;

struct tm Ete;

Ete.tm_year = a;
Ete.tm_mon = 3;
Ete.tm_mday = z1;

//-----------------------------heure d'hiver ou d'été---------------------------
//------------------------------------------------------------------------------

correction_heure=0;
while(correction_heure!=1 && correction_heure!=2)
{
CouleurTexte(FOREGROUND_GREEN);
if ((Today.tm_mon<=3 && Today.tm_mday<=Ete.tm_mday)||(11<=Today.tm_mon && Hiver.tm_mday<=Today.tm_mday))
{
cout << "vous etes a l'heure d'hiver\n";
correction_heure = 1;
}
else if ((3<=Today.tm_mon && Ete.tm_mday<=Today.tm_mday)||(Today.tm_mon<=11 && Today.tm_mday<=Hiver.tm_mday))
{
cout << "Vous etes a l'heure d'été\n";
correction_heure = 2;
Today.
}
else
{
cout << "Vous avez un probleme";
}

char continuer;

cout << "Appuyer sur une Y pour continuer";
cin >> continuer;
}
Afficher les 16 commentaires

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.