Professional Documents
Culture Documents
informatique
LENERGIE SOLAIRE
Introduction
Lnergie solaire est une nergie renouvelable, mais malheureusement souvent peu rentable car base sur un grand
nombre de paramtres lis la fois aux conditions temporelles (date, heure) et mtorologiques (temps, humidit,
altitude...) ainsi que gographiques (latitude, longitude, inclinaison, orientation).
De plus, le panneau photovoltaque lui-mme possde un rendement faible (moins de 20% en gnral). Il est donc
difficile dobtenir de bonnes conditions de production dlectricit partir dnergie solaire.
Cependant, des calculs peuvent tre effectus en fonction de ces diffrents paramtres pour obtenir une production
optimale, notamment laide de loutil informatique. Le but de ce projet est justement de concevoir un programme
capable de prvoir partir de diffrents paramtres dentre le rayonnement solaire reu par un panneau. Pour
cela, on se placera dans le cas dun temps ensoleill.
Pour cela, il tait utile de dclarer de nouveaux types (types composs) permettant de stocker les informations plus
facilement
Dabord, un type date compos de 3 entiers (jour, mois et anne) qui permettra de stocker la date entre par
lutilisateur
struct date
{
int j;
int m;
int a;
};
Un type heure compos de 3 entiers (heures, minutes, secondes) qui permettra de stocker lheure lgale entre par
lutilisateur
struct heure
{
int h;
int m;
int s;
};
Un type coordonnee compos de 3 entiers (degrs, minutes, secondes), qui permettra de stocker les valeurs
sexagsimales de latitude EST et de longitude NORD saisies par lutilisateur
struct coordonnee
{
int d;
int m;
int s;
};
Un type situation compos de 2 rels, qui contiendra la latitude et la longitude dcimales une fois converties
struct situation
{
float la;
float lo;
};
Deux groupes de travail se sont chargs de ces fonctions de saisie, cest--dire la fois assurer le respect des
conditions de saisie et parfois modifier la forme des informations reues.
do {
cout << "Saisir un jour sous la forme jj :
";
cin >> j1;
cout << "Saisir un mois sous la forme mm :
";
cin >> m1;
cout << "Saisir une annee sour la forme aaaa : ";
cin >> a1;
On effectuera cette demande ainsi que toutes les vrifications suivantes tant que la saisie est mauvaise. Cest-dire :
Premirement, on vrifie si le mois entr est infrieur ou gal 12 :
if (m1 <= 12)
Dans ce cas, on initalise le boolen erreur false. Il passera true ds que la saisie sera incorrecte :
erreur = false;
On limine tous les cas o la saisie est correcte sauf pour le mois de fvrier
else
{
if (!(m1
j1 <= 31
10 && j1
m1 == 06
30))
==
||
<=
&&
01
m1
31
j1
&&
==
||
<=
j1
07
m1
30
<=
&&
==
||
31
j1
12
m1
||
<=
&&
==
Ensuite, on regarde si lanne nest pas bissextile. Dans ce cas, le jour associ fvrier ne doit pas tre suprieur
28. (Pour savoir si lanne est bissextile, on utilise une fonction cre par le groupe 3 que lon dtaillera ensuite)
{
if (!(est_bissextile(a1)))
{
if (j1 > 28)
{
erreur = true;
cout << "Date entree incorrecte"
<< endl<< endl;
}
}
Dans le cas contraire (lanne est bissextile), le jour ne doit pas tre suprieur 29.
else
{
if (j1 > 29
{
erreur = true;
cout << "Date entree incorrecte" << endl << endl;
}
}
}
}
}
Enfin, on prcise que lorsque la condition de dpart (mois infrieur 12) nest pas vrifie, le boolen passe
videmment true.
else
{
erreur = true;
cout << "Date entree incorrecte" << endl << endl;
}
On effectuera donc toutes les saisies et vrifications tant que les 3 donnes entres par lutilisateur seront
incorrectes :
} while (erreur == true);
Nb : il ny a pas de contrainte de saisie pour lanne (peut tre positive, ngative ou nulle)
Enfin, on affecte les diffrentes saisies la variable de type date que lon retourne ensuite.
dateprojet.j = j1;
dateprojet.m = m1;
dateprojet.a = a1;
return dateprojet;
}
En rouge : les valeurs fausses (pour les 2 dernires saisies, le 29/2/2015 nexiste pas car 2015 nest pas une anne
bissextile, et le 29/2/2016 existe car 2016 est une anne bissextile).
On utilise une boucle while qui va afficher un message derreur et saisir une nouvelle valeur sous la forme heure
minutes secondes tant que les conditions ne seront pas respectes.
On utilise le type compos heure pour pouvoir retourner les trois saisies heures, minutes et secondes dans la mme
fonction.
On vrifie que les degrs sont bien compris entre -90 et +90, les minutes et secondes entre 0 et 59. Enfin, du fait de
la forme sexagsimale, lorsquon entre -90 ou +90, il faut que les champs minutes et secondes soient nuls, sinon on
dpasse -90 ou 90 degrs.
Le type compos coordonnee permet de retourner les trois informations sexagsimales relatives la latitude
(degrs, minutes, secondes) en une seule fonction.
R : Demande lutilisateur de saisir une longitude Est en degrs sexagsimaux valide (dans le cas contraire, le
programme doit redemander la longitude jusqu ce quelle soit valide)
E : vide
S : 1 coordonne (type compos des degrs, des minutes et des secondes (3 entiers))
Les tests effectus pour la fonction sont semblables ceux de celle de la latitude, lexception prs que la longitude
est, elle, comprise entre -180 et 180 degrs.
while (lng.d < -180 || lng.d > 180 || lng.m < 0 || lng.m > 59 || lng.s < 0 || lng.s >
59 || ((lng.d==180 || lng.d==-180) && (lng.m!=0 || lng.s!=0)) )
{
cout << " La valeur que vous avez entre pour les degres, les minutes ou les
secondes n'est pas valide. Veuillez les entrer a nouveau : " << endl;
cin >> lng.d;
cin >> lng.m;
cin >> lng.s;
}
return lng;
Le type compos coordonnee permet encore une fois de stocker des donnes sexagsimales et de les retourner en
une seule fonction (ici, pour les donnes de longitude).
R : Demande lutilisateur de saisir une inclinaison en degrs dcimaux du panneau valide (dans le cas contraire, le
programme doit redemander linclinaison jusqu ce quelle soit valide)
E : vide
S : 1 rel (linclinaison du panneau en degrs)
Linclinaison du panneau doit tre comprise entre 0 et 90 degrs, do le test effectu prcdemment dans la boucle
while.
10
11
case 2: coeff=0.05;
break;
case 3: coeff=0.1;
break;
case 4: coeff=0.2;
break;
}
12
13
return situ;
5me fonction : dtermination des heures de lever et de coucher du soleil, et vrification par rapport
lheure solaire considre
Lever_coucher : la fonction (la : 1 rel, dec : 1 rel, h : 1 rel) 1 boolen
R : Calcule partir de la latitude Nord et de la dclinaison les heures de lever et de coucher de soleil, renvoie VRAI si
lheure saisie par lutilisateur est dans cet intervalle et FAUX sinon
E : 3 rels (la latitude et la dclinaison en degrs dcimaux et lheure en heures dcimales)
S : 1 boolen
Pour effectuer les calculs de cette fonction, il fallait incorporer math.h dans le .cpp. En effet, nous
devions avoir accs aux fonctions tangentes et arccosinus pour calculer les heures de lever et de coucher du
soleil. Cela constituait le seul vrai problme de la fonction. Le reste ne consistait quen lutilisation de Si et de
variable boolenne. On retourne finalement la variable res correspondant ltat de lheure solaire vraie
entre par lutilisateur : Soit lintrieur de lintervalle, soit lextrieur. Du fait que les fonctions
trigonomtriques travaillent en radians dans le module math.h , il fallait prendre en compte le fait que la
fonction tangente prend des radians en entre et arcosinus donne des radians en sortie, do lutilit des
deux fonctions Deg2Rad et Rad2Deg. La dclinaison est une quantit dont la mthode de calcul sera dtaille
dans la partie calcul .
14
15
Aprs avoir trait lanne, le calcul de lentier renvoyer est diffrent selon le mois. On utilise donc la
fonction SELON.
Si le mois est gal 1, janvier, alors lentier correspond au nombre de jours, car janvier et le premier mois
de lanne.
Si le mois est gal 2, fvrier, alors lentier correspond au nombre de jours, plus le nombre de jours que
contient janvier. (soit 31+j)
switch(d.m)
{
case 1: jour=d.j;
break;
case 2: jour=31+d.j;
break;
case 3: jour=31+28+d.j;
break;
case 4: jour=31+28+31+d.j;
break;
case 5: jour=31+28+31+30+d.j;
break;
case 6: jour=31+28+31+30+31+d.j;
break;
case 7: jour=31+28+31+30+31+30+d.j;
break;
case 8: jour=31+28+31+30+31+30+31+d.j;
break;
case 9: jour=31+28+31+30+31+30+31+31+d.j;
break;
case 10: jour=31+28+31+30+31+30+31+31+30+d.j;
break;
case 11: jour=31+28+31+30+31+30+31+31+30+31+d.j;
break;
case 12: jour=31+28+31+30+31+30+31+31+30+31+30+d.j;
break;
default: cout<<"Erreur de saisie"<<endl;
}
Le boolen intervient partir du mois 3 (mars), car il change le nombre de jours que contient fvrier. On
ajoutera alors 28 ou 29. Le systme est le mme pour tous les mois suivants, on prend le nombre de jours pass en
paramtre (dans le type compos de la date), et on y ajoute le nombre de jours que contiennent les mois
prcdents.
if(res==true)
{
if(d.m>=3)
{
jour=jour+1;
16
}
}
17
Le principal problme rencontr a t de redcouper la fonction heure_solaire_vraie en dautres sous fonctions plus
simple.
Pour Saisie_fuseau, il fallait tester si le fuseau entr tait correct. Pour cela on utilise une boucle FAIRE TANT QUE,
avec un boolen error que lon fait passer true lorsque la saisie est mauvaise et false lorsque la valeur est juste en
utilisant un SI
do
{
cout << "Saisissez le fuseau horaire correspondant l'heure saisie (Ex.: 1 ou -1) : ";
cin >> fuseau;
if (fuseau < -12 || fuseau > 12)
{
error = true;
cout << "la valeur saisie est incorrecte !" << endl << endl;
}
else
{
error = false;
}
} while (error);
Pour Dernier_dimanche, on utilise une quation permettant de dterminer quel est le dernier jour du mois (0 pour
le dimanche, 1 pour le lundi ) puis on soustrait cette valeur au nombre de jour dans le mois (31 pour mars et
octobre). Lquation demande cependant de calculer un modulo dun rel ce qui est impossible en C, on affecte donc
la valeur dans une variable entire intermdiaire.
intermed = ceil(31 + d.a + (d.a / 4.0) - (d.a / 100.0) + (d.a / 400.0) + 31 * (d.m / 12.0));
j = 31 - (intermed % 7);
Pour Corr_tpsUniversel, On effectue diffrents tests sur le mois pour dterminer si cest un mois bascule (mars ou
octobre), un mois dt ou un mois dhiver. Si cest un mois bascule, on vrifie si le jour se situe avant ou aprs le
dernier dimanche du mois puis on affecte la valeur retourner en fonction de la priode.
if (today.m > 3 && today.m < 10) {
corr_periode = 1;
} else if (today.m == 3) {
if (today.j < dernier_dimanche(today)) {
corr_periode = 0;
} else {
18
corr_periode = 1;
}
} else if (today.m == 10) {
if (today.j >= dernier_dimanche(today)) {
corr_periode = 0;
} else {
corr_periode = 1;
}
} else {
corr_periode = 0;
}
Pour Corr_longitude, on applique simplement lquation t = -4* qui donne le dcalage en minutes puis on le
convertit en heures en divisant par 60.
En effet, la longitude EST est compte ngativement dans ce calcul, contrairement la faon habituelle de signer la
longitude (o elle est positive et la longitude OUEST ngative)
delta=-4*lon;
t=delta/60.0;
Pour Corr_eqTemps, on commence par convertir la date en nombre de jours grce la fonction Nb_jours puis on
appelle les deux fonctions Oblicite et Ellipticite retournant chacune une composante de lquation de
Temps dont on fait la somme, puis que lon divise par 60 pour lavoir en heures.
Ellipticite
const float A = 0.98560028;
const float B = 357.5261;
//algo local
C = (1.9148*sin(Deg2rad(B + A + j)) + 0.02*sin(Deg2rad(2 * (B + A*j))) + 0.0003*sin(Deg2rad(3 * (B
+ A*j)))) * 4;
Oblicite
const float T = 0.98564736;
const float R = 280.4665;
float O;
//algo local
O = (-2.468*sin(Deg2rad(2 * (R + T*j))) + 0.053*sin(Deg2rad(4 * (R + T*j))) - 0.0014*sin(Deg2rad(6
* (R + T*j)))) * 4;
Corr_eqTemps
j = Nb_jours(date_in);
c = Ellipticite(j);
o = Oblicite(j);
Eq = (c + o)/60;
19
La dclinaison
Langle horaire
La hauteur solaire
Lazimut
Le coefficient dincidence
Lnergie solaire
La masse dair optique relative
Lpaisseur optique de Rayleigh
Le coefficient de trouble de Linke
Le rayonnement solaire direct
Le rayonnement solaire diffus
On peut distinguer deux parties dans le raisonnement bien quelles soient lies :
La premire concerne des calculs plutt angulaires. En effet, la dclinaison, langle horaire, la hauteur solaire et
lazimut constituent des angles lis la position du soleil en fonction de lheure de la journe et de la situation
gographique. Le coefficient dincidence est li aux angles dinclinaison et dorientation du panneau solaire.
Tout dabord, la dclinaison se calcule par rapport au jour de lanne.
On calcule langle horaire en fonction de lheure solaire vraie associe au cas donn.
Grce ces deux quantits ainsi qu la latitude du lieu considr, on en dduit la hauteur solaire correspondante.
Enfin, partir de ces trois valeurs calcules (dclinaison, angle horaire et hauteur solaire), on en dduit lazimut du
soleil.
Le coefficient dincidence du panneau est ensuite calcul laide de ce mme azimut ainsi que de la hauteur solaire.
Entrent galement en considration linclinaison et lorientation du panneau photovoltaque.
Cela a constitu lensemble du travail du 5me groupe.
On a ensuite une deuxime partie de calculs lis plutt des conditions climatiques et mtorologiques mais qui
utilisent aussi les calculs prcdents pour arriver au rsultat final du rayonnement solaire global.
On calcule dabord lnergie solaire partir du jour de lanne considre.
Ensuite, partir de laltitude du lieu considr, on calcule la masse dair optique relative puis directement partir de
celle-ci on dtermine lpaisseur optique de Rayleigh.
Paralllement, on utilise, la temprature, le coefficient de trouble atmosphrique ainsi que le taux dhumidit
relative saisis par lutilisateur pour calculer le facteur de trouble de Linke.
A partir de cette mme quantit ainsi que de la masse dair optique relative, lpaisseur optique de Rayleigh,
lnergie solaire et le coefficient dincidence, on peut ensuite calculer le rayonnement solaire direct.
On utilise aussi linclinaison ainsi que la hauteur solaire pour dterminer le rayonnement solaire diffus, puis la
somme de ces deux rsultats constitue le rayonnement solaire global reu par le panneau.
Cela a constitu lensemble du travail du 6me groupe.
Ce raisonnement est rsum via le schma en annexe.
Ces calculs utilisent les fonctions trigonomtriques de la librairie math.h . On doit donc encore une fois utiliser les
fonctions Deg2Rad (pour les fonctions travaillant avec des paramtres en radians comme cos, sin, tan) et Rad2Deg
(pour les fonctions renvoyant un rsultat en radians comme arcos, arcsin, arctan).
Par la suite, les variables avec le suffixe rad seront des valeurs en radians (pralablement converties de degrs vers
radians grce la fonction Deg2Rad) et les valeurs avec le suffixe deg seront en degrs. Cest un choix des deux
groupes de travail pour bien distinguer valeurs en degrs et valeurs en radians.
20
Alix Jeannerot
Paul Bouchillou
Sbastien Cizeron
21
hauteurdeg=Rad2deg(hauteurrad) ;
return hauteurdeg;
22
Les valeurs attendues ont t soit calcules par ce groupe de travail avec excel, soit prises dans le fascicule. Excel
fonctionne aussi en radians, il devait donc y avoir le mme raisonnement que lors de la programmation (conversions
degrs / radians pour cosinus, sinus et radians / degrs pour arcsinus)
Grgoire Bouland
Charles Royer
Geoffrey Dumon
Nour Hassoun
23
24
25
26
27
decl;
a_horaire;
h_solaire;
az;
c_incidence;
ener_sol;
m_air;
e_optique;
t_linke;
s_direct;
s_global;
Arrive lalgorithme principal. On commence par effectuer les diffrentes saisies aprs avoir prsent le programme :
Presentation();
d_comp=Saisie_date();
h_comp=Saisie_heure();
lat_comp=Saisie_latitude();
lon_comp=Saisie_longitude();
inclinaison=Saisie_inclinaison();
orientation=Saisie_orientation();
altitude=saisie_alt();
temperature=Saisie_temperature();
coef_trouble=saisie_milieu();
humidite=Saisie_hum();
Ensuite, on effectue dabord les calculs utiles pour reconnatre directement si le rayonnement correspondant la
saisie sera nul (on connat par les conversions le paramtre lheure solaire vraie, il reste calculer la dclinaison pour
pouvoir faire fonctionner lever_coucher) :
decl=Declinaison(nombre_j);
rayon_nul=lever_coucher(s_geo.la, decl, hs_vraie);
Si le boolen retourn a pour valeur false, cela signifie que lheure saisie est durant la nuit donc on indique
directement lutilisateur que le rayonnement sera nul :
if (rayon_nul==false)
{
cout<<"L'heure que vous avez saisie correspond a une heure d'ensoleillement
nul. Vous n'aurez aucun rayonnement sur votre panneau."<<endl;
}
Sinon, on poursuit les calculs jusquau rayonnement solaire global puis on affiche le rsultat :
else
{
a_horaire=Angle_horaire(hs_vraie);
h_solaire=Hauteur_solaire(s_geo.la, decl, a_horaire);
az = Azimut(decl, a_horaire, h_solaire);
c_incidence=Coef_incidence(inclinaison, orientation, az, h_solaire);
ener_sol=Energie_solaire(nombre_j);
28
m_air=Masse_air(altitude, h_solaire);
e_optique=Epaisseur_optique(m_air);
t_linke=trouble_linke(temperature, coef_trouble, humidite);
s_direct=solaire_direct(ener_sol, e_optique, m_air, t_linke, c_incidence);
s_global=Solaire_global(s_direct, h_solaire, inclinaison);
Affiche_res(s_global, d_comp, h_comp, lat_comp, lon_comp, inclinaison,
orientation, altitude, temperature, coef_trouble, humidite);
}
On peut ensuite tester le programme avec les valeurs du fascicule (ville de Mulhouse). Pour cela, il faut convertir les
10h heure solaire vraie utilises en heure lgale (car dans le fascicule les calculs ont t faits directement partir
dune heure solaire vraie). On obtient grce cet algorithme disponible sur le site :
http://michel.lalos.free.fr/cadrans_solaires/outils/Tables-hs-hl.php
Le calcul du nombre de jours associ au 1er juillet a t fait dans le cas dune anne non bissextile (il est compt 28
jours fvrier) donc 2013 a t saisi pour respecter cette condition.
Nb : il y a une erreur dans le fascicule au niveau du nombre de jours correspondant au 1er juillet (il est de 181 dans
celui-ci au lieu de 182 en ralit, car 30 jours ont t compts janvier)
Le rsultat avec lensemble des valeurs donne le rsultat suivant :
En faisant en sorte davoir 181 jours (comme dans le fascicule), le rsultat obtenu est 871.288 W/m pour 871.66
dans le fascicule.
On obtient donc un rsultat dune prcision convenable.
29
Une fonction regroupant tous les appels des fonctions de calculs situes prcdemment dans la fonction
main a t cre pour pouvoir facilement insrer une boucle pour calculer lensoleillement pour plusieurs
valeurs conscutive de manire rapide.
double Ensoleillement(date d_comp, heure h_comp, coordonnee lat_comp, coordonnee
lon_comp, float inclinaison, float orientation, float altitude, float temperature,
float coef_trouble, float humidite, int fuseau)
Une autre fonction a t cre, contenant un menu pour demander lutilisateur sil dsire gnrer un
rapport.
bool menu_rapport()
Conception
La fonction Ensoleillement reprend donc les appels conscutifs de toutes les fonctions de calcul et de traitement. Les
paramtres sont toutes les valeurs saisies par lutilisateur pour dcrire les conditions dinstallation de son panneau
solaire.
La petite particularit est le rayon nul. Durant la nuit, lensoleillement dun panneau solaire est trs faible. Dans ce
cas, on ne calcule pas lensoleillement en retournant simplement un 0.
bool rayon_nul; //Boolen renvoyant TRUE si rayonnement non nul et FALSE sinon
if (rayon_nul == false)
{
s_global = 0;
}
La fonction menu_rapport est une simple fonction de saisie en menu. Deux choix soffrent lutilisateur et elle
renvoie un boolen signifiant oui ou non en fonction du choix de lutilisateur pour rpondre la question.
do{
cout << endl << "Voulez vous generer un tableau d'ensoleillement au format csv ?" <<
endl
<< "1 : oui" << endl
<< "0 : non" << endl
<< "Votre choix (0 ou 1):";
30
La fonction build_rapport est plus complique. En effet, elle crit des donnes dans un fichier. On utilise donc une
bibliothque spciale : #include<fstream>
On commence par ouvrir le fichier, puis on vrifie si il a bien t ouvert (si par exemple le fichier est dj ouvert, le
programme ne peut pas louvrir en criture). Sinon on affiche un message derreur et on propose lutilisateur de
ressayer ou dabandonner car parfois la raison est plus complexe.
do
{
ofstream myFile("Ensoleillement.csv");
if (myFile)
{
//Gnration du fichier
}
else
{
cout << "ERREUR: Impossible d'ouvrir le fichier." << endl
<< "Verifiez qu'il ne soit pas ouvert par un autre programme" << endl <<
endl;
do
{
cout << "Voulez vous reessayer de l'ouvrir ? [o/n] ";
cin >> retry_in;
switch (retry_in)
{
case 'o':
retry = true;
break;
case 'n':
retry = false;
cout << "Abandon de l'ecriture du rapport..." << endl;
}
} while ((retry_in != 'o') && (retry_in != 'n'));
}
} while (retry);
Ensuite, il existe un format de fichier nomm CSV (comma separated value) qui permet de reprsenter des tables de
donnes et qui peut tre ouvert par Excel. Il sagt en fait dun fichier texte basique contenant des valeurs spares
par un caractre dfinit dans les paramtres de rgions de lordinateur (pour sparer les colonnes) sur plusieurs
lignes (pour sparer les lignes du tableau). Ils sont donc faciles gnrer.
31
De plus, lcriture dans un fichier fonctionne de la mme manire que la fonction cout. La gnration dun fichier
CSV est donc trs facile. Il suffit juste dappliquer une boucle sur la fonction de calcul Ensoleillement() puis
denregistrer les valeurs dans le fichier ouvert. On cre une constante SEPARATOR de type caractre afin de stocker
le sparateur de colonnes.
Nous avons cr plusieurs boucles afin de pouvoir tracer plusieurs graphiques intressants en fonction de diffrents
paramtres laide dun tableur.
Pour les tableaux en fonctions de lhumidit, de la temprature, de lorientation et de linclinaison, les boucles sont
quasiment identiques part la plage parcourue par la boucle. On utilise une boucle for car elle permet facilement de
dclarer une variable indice, de tester une condition et dincrmenter lindice. On appel juste Ensoleillement avec la
valeur de lindice pour obtenir lensoleillement global avant de lcrire dans le fichier aprs lindice.
//Tableau orientation
myFile << "orientation" << SEPARATOR << "ensoleillement" << SEPARATOR <<
"Energie convertie"; //criture des enttes de colonnes
for (int ori = -170; ori <= 180; ori = ori + 10)
{
ens_loop = Ensoleillement(d_comp, h_comp, lat_comp, lon_comp,
inclinaison, ori, altitude, temperature, coef_trouble, humidite, fuseau);
if (ens_loop != 0)
{
myFile << endl << ori << SEPARATOR << ens_loop << SEPARATOR <<
ens_loop * 0.2 * 0.97;
}
}
Pour le tableau en fonction du mois, le principe est le mme que prcdemment. On intgre juste lindice de la
boucle dans un type complexe date avant de lenvoyer Ensoleillement.
d_loop.a = d_comp.a;
d_loop.j = d_comp.j;
for (int m = 1; m <= 12; m++)
{
d_loop.m = m;
Pour le jour, on reste dans le mme fonctionnement que le mois. Mais le nombre de jours tant diffrents dans
chaque mois, il est ncessaire de dterminer la borne maximale avant la boucle.
if (d_comp.m == 1 || d_comp.m == 3 || d_comp.m == 5 || d_comp.m == 7 ||
d_comp.m == 8 || d_comp.m == 10 || d_comp.m == 12){
d_max = 31;
}else{
if (d_comp.m == 4 || d_comp.m == 6 || d_comp.m == 9 || d_comp.m == 11){
d_max = 30;
}else{
if (est_bissextile(d_comp.a)){
d_max = 29;
}else{
d_max = 28;
}
}
}
d_loop.a = d_comp.a;
d_loop.m = d_comp.m;
for (int j = 1; j <= d_max; j++)
{
d_loop.j = j;
Pour lheure, afin dobtenir un nombre suffisant de valeurs, il est ncessaire de calculer un ensoleillement tous les
quarts dheures. On utilise deux boucles for embotes pour gnrer indice de lheure et lindice du quart dheure.
On multiplie lindice du quart dheure par 15 pour obtenir le nombre de minutes affecter au type compos pass
en paramtre la fonction Ensoleillement.
32
h_loop.s = 0;
for (int h = 0; h < 24; h++){
h_loop.h = h;
for (int m = 0; m < 4; m++){
h_loop.m = m * 15;
ens_loop = Ensoleillement(d_comp, h_loop, lat_comp, lon_comp,
inclinaison, orientation, altitude, temperature, coef_trouble, humidite, fuseau);
if (ens_loop != 0){
myFile << endl << h_loop.h << ":" << h_loop.m << SEPARATOR
<< ens_loop << SEPARATOR << ens_loop * 0.2 * 0.97;
}
}
}
Conclusion du projet
Tout dabord, le bilan de ralisation du projet est plutt positif : en effet, nous sommes arrivs au but principal, celui
dexprimer le rayonnement solaire global mais nous avons galement pu approfondir la problmatique.
Nous avons ensuite pu utiliser le programme dans le but de gnrer un fichier Excel (.csv) afin dcrire des donnes
dans un tableur. Cela a permis dexprimer le rayonnement solaire global pour un lieu donn en fonction de lun de
ses paramtres, notamment le jour de lanne considr, lheure dans la journe ou encore lorientation du panneau
photovoltaque. Le programme possde donc une relle utilit par rapport la problmatique de base : prvoir un
fonctionnement optimal pour un panneau solaire.
De plus, ce projet nous a permis de matriser la plupart des concepts algorithmiques de base :
-
Enfin, nous avons pu approfondir les possibilits offertes par le langage C en gnrant un fichier Excel avec les
donnes du programme, ainsi quen utilisant une librairie complmentaire math.h contenant les principales
fonctions usuelles de mathmatiques pour les calculs.
33
Annexe
34