jeudi 15 septembre 2016

Orientation d'un panneau photovoltaïque (PV)

Suite à l'article sur le PV résidentiel, cet article concerne l'orientation des panneaux et le calcul de la position du soleil par rapport au point d'observation / d'installation du PV.

Le soleil parcourt durant 24 h un cercle par rapport au sol. L'inclinaison de ce cercle par rapport à l'horizon dépend de la latitude du lieu. Le centre de ce cercle se décale verticalement en dessous et au dessus du point d'observation en fonction du jour de l'année.

Je vous invite à vous faire une idée précise et visuelle du parcours du soleil en installant sur votre smartphone l'application Sun Surveyor Lite.
En changeant le jour à l'aide du slider du bas, en mode année, on voit bien que le cercle du soleil passe devant et derrière l'utilisateur.

Les journées en été sont plus longues et le soleil se lève au Nord Est pour se coucher au Nord Ouest



Les journées en hiver sont plus courtes et le soleil se lève au Sud Est pour se coucher au Sud Ouest


A l'équinoxe d'automne, le jour et la nuit sont égaux en durée. le soleil se lève à l'Est pour se coucher à l'Ouest

L'extraction de puissance est maximale quand le PV est perpendiculaire aux rayons du soleil. L'idéal est donc d'avoir un système de tracking qui permet de suivre la course du soleil le long de la journée et de l'année.

J'ai depuis longtemps développé des algorithmes de calcul de la position du soleil et on peut coupler cela à une RTC (real time clock) + Arduino ou dspic afin d'avoir la position exacte du soleil.
Techniquement, c'est tout à fait faisable avec une motorisation sur 2 axes et une régulation de position.

Cependant, d'un point de vue énergétique, ce n'est pas du tout intéressant. En effet, le système de suivi consommerait toute la puissance produite par le PV pour le tracking, surtout qu'il doit tenir la position, particulièrement en cas de vent.

Des compromis doivent donc être trouvés.
On peut par exemple choisir de n'orienter le PV qu'en 3 positions horizontalement (azimut, donc par rapport à un axe de rotation vertical). La tenue en couple se ferait par un système de verrouillage mécanique.
Quand à l'orientation verticale (hauteur), elle serait soit fixe, soit manuellement modifiable tous les 1 à 3 mois de manière à tenir compte du parcours du soleil tout au long de l'année.
On peut aussi choisir de maintenir l'azimut fixe, on choisit alors d'orienter le PV plein sud.
Si la hauteur est également fixe, on favorisera plutôt un angle inférieur à la latitude du lieu de manière à mieux capter le soleil en hiver.

Une étude rigoureuse doit être menée mais les aspects technico-économiques et de rendement global doivent y être présents.

Voici mes programmes Matlab qui permettent d'afficher la hauteur et l'azimut du soleil tout au long de l'année.
Bonne continuation pour leur exploitation dans vos propres études, vous pouvez citer (BibTex) mes 2 blogs comme :

@online{baghli_orientation_2016,
title = {Orientation d'un panneau photovoltaïque ({PV})},
url = {http://baghli.blogspot.com/2016/09/orientation-dun-panneau-photovoltaique.html},
titleaddon = {activités baghli},
type = {blog},
author = {Baghli, Lotfi},
urldate = {2016-09-15},
date = {2016-09-15}
}

@online{baghli_photovoltaique_2016,
title = {Le photovoltaïque ({PV}) résidentiel},
url = {http://baghli.blogspot.com/2016/09/le-photovoltaique-pv-residentiel.html},
titleaddon = {activités baghli},
type = {Blog},
author = {Baghli, Lotfi},
urldate = {2016-09-15},
date = {2016-09-15}
}


Voici le programme Matlab et les 2 fonctions qui permettent de faire le calcul de la position du soleil dans le ciel de l'observateur et de calculer l'incidence par rapport au PV.

La fonction calchaz, calcule la hauteur et l'azimut du soleil (par rapport au sud) :
function [hauteur,azcorrige] = calchaz(latitudeinput, longitudeinput, Timezoneinput, DSTinput, heurelocaleinput, jour, mois, annee)
% calchaz(34.88,-1.31, 1, 0, 14, 8,6,2016 )
% 2 Algérie          Tlemcen          34.88       -1.31       1        0   1 
Mn2PI =2*pi;
pin2 =pi/2;
deg2rd = 0.017453292519943295769236907684886;
rd2deg = 57.295779513082320876798154814105;
SolarSiderealCorrection = 1.002738;

latitude = deg2rd*latitudeinput;
longitude = deg2rd*longitudeinput;
% CountryName = CountryNameinput;
% TownName = VilleSelect;

TimeZone = Timezoneinput;
DST = DSTinput;
heurelocale = heurelocaleinput;


Soleil.az = 0;  % coord. horizontal
Soleil.h = 0;
Soleil.delta = 0;  % coord equatorial
Soleil.tau = 0;
Soleil.RA = 0;  % ascension droite
Soleil.L = 0;   %longitude r�ele

% jour/mois/ann�e/heure.xxx
date.j = jour;
date.m = mois;
date.a = annee;
date.h = 0; %sera écrasé

% % milisec, secondes/, minutes, heures
% heure.ms = 0;
% heure.s = 0;
% heure.m = 0;
% heure.h = 0;

%struct TownData { char CountryName[Namelenght], TownName[Namelenght];
%  double longitude, latitude;
%  int TimeZoneTown, Convention, DST;
% };

% datenanNow;
% ActualDate; %format JS
% Njours=new Array(12);
%
% JD, T,  % Jour Julien, Julien Century : T,
% theta0, theta,  % theta0 : temps sideral � Greenwich
% longitude, latitude;
% TimeZone, TimeZoneTown, NTowns, TownSelected, Verbose, Convention;
% DST, DSTApplies;

Mounths=char('Janvier', 'Février', 'Mars', 'Avril', 'Mai', 'Juin', 'Juillet', 'Août', 'Septembre', 'Octobre', 'Novembre', 'Décembre');
MounthsAbrev=char('jan', 'févr', 'mars', 'avr', 'mai', 'juin', 'juil','août', 'sept', 'oct', 'nov', 'déc');
Days=char('Lundi', 'Mardi', 'Mercredi', 'Jeudi', 'Vendredi', 'Samedi', 'Dimanche');


%%--------------------------------------------------------------------------
% Julian day: 86400 s, Julian year: 365.25 d, Julian Century: 36525 d
% Julian Day (valid from 1900/3/1 to 2100/2/28)
%function JulianDay (ndate, nmonth, nyear, nUT)
%{
% if (nmonth<=2) {nmonth=nmonth+12; nyear=nyear-1;}
% return floor(365.25*nyear) + (int)(30.6001*(nmonth+1)) - 15 + 1720996.5 + ndate + nUT/24.0;
%}
%%-------------------------------------------------------------------------
function  [JC] = JulianCentury (ndate, nmonth, nyear, nUT)
% Julian century depuis 01/01/2000 � 12h UT
    if (nmonth<=2) 
    nmonth = nmonth+12;
    nyear = nyear-1;
    end
  JC = (floor(365.25*nyear) + floor(30.6001*(nmonth+1)) - 15 + 1720996.5 + ndate + nUT/24.0 - 2451545.0)/36525.0;
end 
%%-------------------------------------------------------------------------
%Solar Coordinates (according to: Jean Meeus: Astronomical Algorithms), accuracy of 0.01 degree 
function result = SoleilLongitude( nT)   % L
 nM = 357.52910 + 35999.05030*nT - 0.0001559*nT*nT - 0.00000048*nT*nT*nT; % mean anomaly, degree
 nL0 = 280.46645 + 36000.76983*nT + 0.0003032*nT*nT; % mean longitude, degree 
 nDL = (1.914600 - 0.004817*nT - 0.000014*nT*nT)*sin(deg2rd*nM) + (0.019993 - 0.000101*nT)*sin(deg2rd*2*nM) + 0.000290*sin(deg2rd*3*nM); 
 nL=nL0 + nDL; % true longitude, deg sans modulo
 nLm=nL-360*floor(nL/360);
 if (nLm==0)
        nLm = nLm+360;
    end
 result= nLm*deg2rd; % true , rd 
end 
%%-------------------------------------------------------------------------
% convert ecliptic longitude L (rd) to right ascension RA and declination delta
function [RA, delta] = eclipticL2RAndelta( nT, nSol)
% convert ecliptic longitude L (rd) to right ascension RA and declination delta
% old approxim  neps = deg2rd*23.43999; % obliquity of ecliptic
 neps = deg2rd*(23.4393 -0.013*nT); % obliquity of ecliptic
 nX = cos(nSol.L); nY = cos(neps)*sin(nSol.L); nZ = sin(neps)*sin(nSol.L); nR = sqrt(1.0-nZ*nZ); 
 delta = atan2(nZ, nR); % in rd 
 RA = 2*atan2(nY, nX+nR); %  in rd 
end 

%%-------------------------------------------------------------------------
function theta0 = TempsSideral( nT)   % theta0
%compute sidereal time at Greenwich (according to: Jean Meeus: Astronomical Algorithms ) 
% T siecle julien depuis 2000
 ntheta0=280.46061837 + 360.98564736629*nT*36525 + 0.000387933*nT*nT - nT*nT*nT/38710000.0;
 ntheta0m=ntheta0-360*floor(ntheta0/360);
 if (ntheta0m<0)
        ntheta0m = ntheta0m+360;
    end
 theta0 = ntheta0m*deg2rd;    % TempsSideralen rd
end 
%%-------------------------------------------------------------------------
function [h, az] = equatorial2horizontal( nbeta, nSol)
%convert tau, delta to horizon coordinates of the observer (altitude h, azimuth az) , needs latitude : beta
 h=asin( sin(nbeta)*sin(nSol.delta) + cos(nbeta)*cos(nSol.delta)*cos(nSol.tau)); % h en rd
 az =atan2( -sin(nSol.tau), cos(nbeta)*tan(nSol.delta) - sin(nbeta)*cos(nSol.tau))-pi; % az en rd du SUD
 if (az<0)
        az = az+2*pi;
    end
end 
%%-------------------------------------------------------------------------
function Calchaz_in()
 date.h=heurelocale-TimeZone; % heure GMT
 if (date.h<0) 
        date.h = date.h + 24;
        date.j = date.j-1;
    end
 T=JulianCentury (date.j, date.m, date.a, date.h);
 Soleil.L=SoleilLongitude(T);
 [Soleil.RA, Soleil.delta] = eclipticL2RAndelta( T, Soleil);
 theta0=TempsSideral( T);
 theta=theta0+longitude;
 Soleil.tau=theta-Soleil.RA;
 [Soleil.h, Soleil.az] =equatorial2horizontal( latitude, Soleil);
% equatorial2horizontal( latitude, Soleil.tau, Soleil.delta, Soleil.h, Soleil.az);
end
%%-------------------------------------------------------------------------
%function CalculeNjdumois( m, annee)
%{
%Nonbissextile = floor(annee-4*floor(annee/4)+2)/3;  % 1 pour une ann�e commune et  0 pour une bissextile)
% if (m==1 || m==3 || m==5 || m==7
%  || m==8 || m==10 || m==12)  return 31;
%   else {
%      if (m==2) {if (Nonbissextile) return 28;
%               else    return 29;
%           }
%        else  return 30;
%    }
%}

 Calchaz_in();
 azcorrige=Soleil.az;
 if (azcorrige<-pi)
        azcorrige = azcorrige + Mn2PI;
    end
 if (azcorrige> pi)
        azcorrige = azcorrige - Mn2PI;
    end
 hauteur = Soleil.h;
%% en degrés    
    hauteur = hauteur*rd2deg;
    azcorrige = azcorrige*rd2deg;
    %Days(i,:)
end


La fonction incline permet de calculer l'angle que fait le soleil avec la surface du PV :
function inc = incline(azs, inclineMax)
% calcule l'inclinaison pour un angle d'azimut donné 
 inc = asin( sin(inclineMax) *cos(azs)); % h en rd
end


Le programme principal uilise les 2 fonctions précédentes pour afficher la hauteur du soleil et son azimut le long de la journée et de l'année et de calculer l'angle d'incidence sur le PV :
% course du soleil durant l'année à Tlemcen
%[h, az] = calchaz(34.88,-1.31, 1, 0, 14, 8,6,2016 )
close all; clear all;
deg2rd = 0.017453292519943295769236907684886;
rd2deg = 57.295779513082320876798154814105;
inclinaisonPV = 34;
heure = [5:10./60:22];
for mm = 1:12
    for hh = 1:length(heure)
        [h, az] = calchaz(34.88,-1.31, 1, 0, heure(hh), 1,mm,2016 );
        Hauteur(mm,hh)=h;
        Azimut(mm,hh)=az;
        inclinaison(mm,hh)= h + rd2deg*incline(az*deg2rd, inclinaisonPV*deg2rd);
    end
end
cc=hsv(12);
% Hauteur
figure (1);
hold on;
for mm = 1:12
    plot(heure, Hauteur(mm,:),'color',cc(mm,:));
end
% Azimut
figure (2);
hold on;
for mm = 1:12
    plot(heure, Azimut(mm,:),'color',cc(mm,:));
end

% inclinaison absolue
figure (3);
hold on;
for mm = 1:12
    plot(heure, inclinaison(mm,:),'color',cc(mm,:));
end

figure (4);
plot(heure, Hauteur(6,:),'b', heure, inclinaison(6,:),'r' );
legend('hauteur horizon', 'inclinaison soleil - PV juin');


Hauteur (en °) du soleil en fonction de l'heure de la journée
Un angle négatif signifie que le soleil est en dessous de l'horizon


Azimut (en °) du soleil en fonction de l'heure de la journée
Un angle négatif signifie que le soleil se trouve à l'est, nul au sud, positif à l'ouest


Inclinaison (en °) ou incidence du soleil par rapport au PV en fonction de l'heure de la journée, l'inclinaison du PV est de 34°

Comparaison entre la hauteur du soleil et de l'incidence des rayons sur le PV, en fonction de l'heure de la journée, pour le mois de juin
L'inclinaison du PV est de 34°



Le photovoltaïque (PV) résidentiel

Préambule

Cet article donne des informations sur le choix, l'installation et l'utilisation d'un système de génération d'énergie électrique à base de panneaux photovoltaïques installés chez le particulier.
Il s'appuie sur une situation vécue et personnelle. Un calcul du coût d’amortissement de l'installation est donné, par rapport aux prix pratiqués en Algérie.

Introduction

A l'heure où tout le monde parle d'énergie renouvelable; solaire et éolienne, il me parait intéressant, en tant qu'enseignant-chercheur, de me faire ma propre idée sur l'utilisation, au quotidien, d'un système PV de génération d'énergie.
Il existe des solutions actuellement en test par l'opérateur national SONELGAZ sur des centrales au sud et quelques expérimentations au CDER et dans quelques universités mais pas chez le particulier.

Choix technologique

Le choix du PV par rapport à l'éolien pour une installation résidentielle est d'abord fondé sur la simplicité de l'installation mais aussi par rapport à la disponibilité de la ressource d'énergie; le vent étant rarement disponible dans ma région.
Le soleil par contre est disponible en abondance sur tout le territoire.

Il existe plusieurs type de panneaux photovoltaïques, du monocristalin, polycrystalin et mêmes de nouvelles technologies très prometteuses comme les perovskite qui ont connu ces derniers mois des progrès considérables en terme de rendement et de procédé de fabrication.
La disponibilité des PV localement a restreint notre choix entre le mono et le polycristalin. Le nombre de cellules par panneau, la dimension et donc la tension de sortie l'ont finalement fixé. C'est du 60 cellules en poly, que fabrique ALPV dans la Z.I. de Tlemcen.
Le PV sort environ 37 V 8A pour une puissance maximale de 230 W. Ceci nous amène au mode d'utilisation de cette énergie électrique.
Elle va être continue (donc pas alternative), de faible tension, intermittente et disponible environ 10h par jour, au plus.

Si on n'était pas raccordé au réseau électrique ou si la fiabilité du réseau était déplorable, il serait judicieux de penser à un système de stockage d'énergie sous forme continue (dans une batterie) et de l'utiliser avec un onduleur autonome (non assisté) pour générer une tension alternative et alimenter une partie de la puissance installée à la maison.

Il existe un autre mode pour le résidentiel qui utilise un onduleur assisté (par le réseau). Son nom est le GTI (Grid Tie Inverter). Cet onduleur se synchronise sur le réseau pour adapter la fréquence et la tension et venir puiser l'énergie du PV par un algorithme MPPT (Maximum Power Point Tracking) et la renvoyer sur le réseau.
Cela permet de diminuer la puissance totale absorbée par la maison du réseau, puisque une partie est fournie par le système PV-Onduleur GTI et ainsi réduire la consommation et la facture d'électricité.
On peut même fournir de la puissance nette au réseau si la puissance générée devient supérieure à la puissance consommée par la maison.
Nous avons choisi le mode assisté et donc un GTI.

Dimensionnement

Quel est alors la puissance à installer ?
Pour prendre cette décision, on peut déjà commencer à regarder quels sont les besoins en électricité en pointe et en moyenne sur 24h tout au long de l'année.
Nous utilisons, depuis plusieurs années, sans modification de l'installation électrique, un système de mesure et d'information de la puissance instantanée consommée par la maison et de l'énergie consommée par 24h (environ 10 kWh).
La puissance instantanée fluctue grandement en fonction du temps. La nuit, elle peut descendre même en dessous de 100 W. Seuls restent alimentés les réfrigérateur et congélateur et les quelques circuits de veille des TV, démos et chargeurs de téléphone.

Je précise que le domicile est à 95% en lampe éco et que le renouvellement des lampes se fait depuis quelques mois en lampes LED (10 W à 450 DA/unité). Je conseille d'ailleurs à tout ceux qui sont encore équipés en lampes à incandescence de passer directement aux lampes LED qui supplantent en avantages les lampes éco (allumage instantané avec le maximum d'éclairement, durée de vie supérieure et absence de mercure).

Pendant la journée, des utilisations temporaires d'appareils gros consommateur d'énergie électrique, font grimper la puissance maximale demandée. Par exemple, le micro ondes requiert 900 W mais ne les consomme que pendant sa courte utilisation (1 min), le grille pain 1000 W, la résistance de la machine à laver 2000 W de même que le sèche cheveux...

Faut-il alors dimensionner l'onduleur et les PV par rapport au pic maximal de consommation ou par rapport à la puissance moyenne sur 24h.
En fait, le choix d'un GTI nous permet de faire ce qu'on veut. En effet, contrairement au système PV autonome qui doit assurer tout seul toute la consommation de l'énergie, à tout moment, le système GTI quand à lui n'est là que pour réduire les besoins du réseau.

On peut ainsi annuler complètement sa consommation sur 24h, si on produit les 10 kWh journalier. Avec 10h de soleil, il faudrait donc 1 kW installé et cela en supposant que le PV donnerait le maximum de puissance durant toute la journée.

J'ai choisis pour ma part de m'équiper de 2 panneaux PV, chacun de 230 W. Cela donne 460 W de puissance au maximum.



Afin de maximiser l'extraction de puissance, il faut disposer d'une connexion indépendante pour chacun des PV et pilotée par un algorithme de MPPT.
Notre choix s'est porté sur le micro onduleur YC-500 d'AP Systems.

Il supporte jusqu'à 500 W nominal avec 2 entrées de PV. La sortie doit être branchée sur le réseau domestique 230V AC.
La connectique DC est la nouvelle norme MC4 qu'il convient de faire correspondre avec celle des PV. Ces derniers sont aussi protégés avec une diode contre les retours de courant dans le cas de branchement en parallèle de PV, ce qui n'est pas notre cas.
La connectique AC de l'onduleur est propriétaire et il faut acheter le connecteur. Ce système de micro onduleur est fait pour qu'ils se branchent en parallèles l'un derrière l'autre, sur une ligne au sol, dans le cas d'une installation multiple, jusqu'à 16 PV mais toujours en nombre pair, donc jusqu'à 8 micro onduleurs YC-500.
Le système sera monitoré par une boîte (box) qui, relié à internet et au réseau 230V domestique, récupère les informations par courant porteur (CPL) des micro onduleurs et donc des PV. Elle permet un suivi de la production de sa mini station solaire :-)


Notre installation minimaliste comporte, un micro onduleur YC-500 et sa connectique (chez AlmaSolar France à 250 €).

Les 2 PV 230W 60 cellules (18 kDA/unité), leurs 2 supports inclinables, un disjoncteur magnétothermique bipolaire (qui permet de complètement isoler le micro onduleur de mon réseau, sauf la terre qui est en permanence connecté à l'ensemble), ont coûté 50 kDA.

Installation

L'installation se fait obligatoirement sur le toit de manière à éviter l'ombre portée par les murs voisins. Sur les conseils du vendeur des chevilles métalliques sont utilisées pour fixer les supports des PV directement dans la dalle de la terrasse. J'espère que l'on n'aura pas d’infiltration d'eau cet hiver via ces interstices même si du FlintCoat a été mis à posteriori.


Il vaut mieux aligner les PV de manière à ce qu'ils ne fassent pas d'ombre l'un sur l'autre quand ils sont inclinés et que le soleil n''est pas très haut dans le ciel.
Pour ma part, je n'ai pas pu suivre cette configuration afin d'éviter les poutres horizontales de la structure porteuse de la dalle.


Mesures

Le système de mesure basique comporte une pince à effet hall ou transformateur de courant qui transmet, par liaison RF 433 MHz, la mesure de courant AC vers un afficheur déporté. Ce dernier calcule la puissance qui passe donc par ce câble et l'affiche. Il fait aussi le calcul de l'énergie cumulée sur 24h et permet aussi de calculer des coûts moyens.


J'ai disposé 2 mesures, l'une à la sortie de l'onduleur GTI (YC-500) et l'autre sur l'entrée du disjoncteur différentiel de la maison.
Cela me permet de connaitre la production d'énergie électrique AC du système PV+Onduleur et aussi la puissance consommée par la maison.


A droite, la puissance générée en plein soleil
A gauche, la puissance nette consommée par la maison


L'ennui de ce système c'est qu'il n'informe pas si la puissance est générée ou consommée car il ne mesure pas la tension (qu'il suppose de 230 V) et surtout son déphasage par rapport à celle du courant.
Des appareils plus appropriés peuvent être utilisés pour ce faire. Exemple : Fluke 43B
qui permet de mesurer la puissance active, réactive et les harmoniques.
On peut aussi construire un système de mesure et de log. Un futur projet ;-)

A vide (pas de soleil), l'onduleur consomme entre 32 et 48 W. Je ne sais pas si c'est de l'actif ou du réactif vu que je n'ai pas encore appareillé par le système adéquat, mais dans le doute, j'ai placé un programmateur d'allumage rotatif qui raccorde l'onduleur au réseau uniquement entre 7 h et 19 h. Comme à ces heures là la puissance produite est celle de la consommation de l'onduleur, je n'ai pas de problème de pouvoir de coupure sur le programmateur journalier.
Le maximum de puissance que j'ai pu avoir au zénith, quand les panneaux sont super propres et inclinés de 15° (une explication sur l'inclinaison avec programme Matlab est prévue sur un prochain post) est de 400 W AC.

En moyenne, par jour j'ai 2.6 kWh. On est donc loin du calcul rapide 400 W*10h.

Sur le moniteur de droite, le système PV+onduleur produit 370 W à 12h22 et une moyenne journalière de 2.65 kWh
La maison consomme 579 W dont seulement 209 W (moniteur de gauche) du réseau SONELGAZ

Si on regarde l’ensoleillement prévu en moyenne sur notre région (2600 heures par an, suivant le MEM), cela fait 400 W *2600 h = 1040 kWh par an.
Dans la réalité, je calculerai plutôt 2.6 kWh*300 jours d'ensoleillement annuel = 780 kWh par an.
Seule une étude rigoureuse sur plusieurs années, nous permettrai de juger, mais on a déjà une idée sur la production de ce système.
Alors, si on veut calculer l’amortissement de l'installation, on est vite refroidit.
En effet, avec le prix actuel du kWh en Algérie : 
Voir site du MEM, de la CREG et de la presse donnant les prix des différentes tranches :
4.179 DA/kWh pour une consommation entre 125 et 250 kWh/trimestre
4.812 DA/kWh pour une consommation entre 250 et 1000 kWh/trimestre
5.480 DA/kWh pour une consommation >1000 kWh/trimestre

Donc même dans le cas le plus défavorable, pour amortir les 50 kDA+250*180 DA = 95 kDA de l'installation, il faudrait 95000 / 5.48 = 17336 kWh de produit par le système.
Ce qui correspond, si le système ne vieillit pas, à 17336 / 780 = 22 ans. Les PV seront surement H.S. avant !

Conclusion

Il est clair qu'au prix du kWh de l'électricité résidentiel en Algérie, il n'est pas du tout intéressant pour le particulier d'installer un système PV du type GTI.

Il peut être intéressant pour l'industriel producteur d'énergie de le faire car il vendrait à SONELGAZ pour un prix bien plus supérieur à 5 DA; entre 11 et 22 DA/kWh fixé par la CREG.

L'intérêt pour le particulier de disposer d'un système PV est l'indépendance énergétique. Ce qui n'a pas de prix, mais il faudrait qu'il investisse en un système d'onduleur autonome avec la possibilité de se raccorder ou non au réseau.

Le dernier intérêt d'installer un PV GTI est dans le but de l'étudier, la curiosité scientifique n'a évidement pas de prix.

samedi 9 juillet 2016

circuits.io

Comment apprendre l'électronique avec un simple navigateur web

Je suis tombé sur un site extraordinaire d'Autodesk.
On peut y programmer des Arduino, les connecter sur des composants, faire marcher, debugger, afficher les sorties du moniteur (liaison série).

On peut aussi faire de l'électronique analogique, numérique, des possibilités infinies.

Un exemple rapidement pour vous montrer les possibilités :
Un capteur Ultrason one pin, on envoie un pulse et il répond par un pulse plus ou moins long, donnant la distance.
Egalement, un buzzer qui joue une petite mélodie au début du programme.
Comme on ne peut pas inclure plusieurs fichiers ou bibliotèques personnelle, j'ai inclus les notes du .h dans le fichier de l'Arduino, donc descendez en bas du programme pour visualiser les routines setup() et loop().

Pour exécuter, il suffit de lancer la simulation. Pour visualiser les sorties du moniteur de la liaison série. Il faut afficher le code et cliquer à droite. On interagit avec l'ultrason en le sélectionnant et en déplaçant le point obstacle sur le cone de détection, voir ci-dessous une image capture d'écran :

On peut aussi partager son code avec les autres et c'est justement le but de ce genre de site web.
Voici comment est visualisé le partage et comment vous pouvez interagir directement sur mon blog sans même ouvrir un compte Autodesk.

More to read: https://circuits.io/blog/building-the-most-versatile-electronics-simulator-in-the-world

il y a 20 vidéos de tutorial.

Clonez puis développez !


vendredi 8 juillet 2016

RTC, SalatTime et Arduino


Real Time Clock, heures de prière et Arduino

Code pour Arduino


Le code suivant (trois fichiers) permet d'implanter une horloge à l'aide d'une  RTC afin de prendre directement l'heure et la date de l'horloge, de calculer les horaires de prière et de détecter l'heure de l'Athan.

Il faut d'abord effectuer les connexions suivantes :

Il suffit de relier le module RTC à l'Arduino via la liaison I2C (SDA, SCL). Attention les pins A4, A5 sont les pins SDA, SCL obligatoirement sur la carte Arduino.
On relie aussi le 5V et le GND du module RTC à ceux de l'Arduino. Ce dernier sera alimenté par le port USB ou bien par une alim séparée sur Vin ou sur +5V.

Voici le pinout de l'Arduino Nano V3. Je choisi cette carte car c'est la moins chère sur le marché (moins de 3 USD sur ebay ou banggood).

Le programme contient une librairie (mainroutines) comportant les fonctions nécessaires au calcul mais aussi les coordonnées de la ville :
[code] const double latitude = 34.88*deg2rd; const double longitude = -1.31*deg2rd; const int TimeZoneTown = 1; const int Convention = 1; const int DST = 0; [/code]
La convention est à choisir en fonction du pays :  0 : UOIF, 1 : Algérie... (voir librairie).

Il comporte aussi les fonctions
[code] void GetDate() { DateTime now = rtc.now(); date.a = now.year(); date.m = now.month(); date.j = now.day(); #ifdef Verbose Serial << date.j <<F ("/") << date.m << F("/") << date.a <<endl; #endif } //--------------------------------------------------------------------------- void GetHeure() { DateTime now = rtc.now(); heure.h = now.hour(); heure.m = now.minute(); heure.s = now.second(); heure.ms=0; // heure.h=12; heure.m=00; heure.s=00; #ifdef Verbose Serial << heure.h << F(":") << heure.m << F(":") << heure.s <<endl; #endif } [/code]
qui permettent de lire la date et l'heure du calcul à partir de la RTC.

Ce qui donne le fonctionnement suivant :
lat=34.8800010681 long=-1.3099999427
latitude=34°52'48.0038450000" longitude=-1°-18'-35.9997940000"
Conv 1

8/7/2016 16:56:51
8/7/2016
T=0.1651745414  JC à 12h GMT
T=0.1651747226  JC à 12h9'55.0160980000"
meridien/Zuhr=13.1643514633 ie : 13h9'51.6652680000"
Fajr    =4:14
Chourouk=6:0
Zuhr    =13:10
Asr     =16:57
Maghrib =20:25
Isha    =21:59
8/7/2016 16:56:52
SalatT.m[4] =59
SalatT.m[3] =25
SalatT.m[2] =57
Recherche de 16:57
8/7/2016 16:56:53
8/7/2016 16:56:54
8/7/2016 16:56:55
8/7/2016 16:56:56
8/7/2016 16:56:57
8/7/2016 16:56:58
8/7/2016 16:56:59
8/7/2016 16:57:0
Athan 2            2 : Asr, 3 : Maghrib...
SalatT.m[4] =59
SalatT.m[3] =25
SalatT.m[2] =57
Recherche de 16:57
8/7/2016 16:57:1
8/7/2016 16:57:2
8/7/2016 16:57:3
...
8/7/2016 16:57:57
8/7/2016 16:57:58
8/7/2016 16:57:59
8/7/2016 16:58:0
SalatT.m[4] =59
SalatT.m[3] =25
Recherche de 20:25
8/7/2016 16:58:1
8/7/2016 16:58:2
8/7/2016 16:58:3
...

Vous pouvez télécharger le code sur :
https://codebender.cc/sketch:341753


Applications :
Horloge de calcul des horaires de prières
Athan
Calendriers

Ceci est un doua3ware, c'est-à-dire que, si vous êtes musulman, merci de prier pour mon salut.

jeudi 7 juillet 2016

Position du Soleil et SalatTime pour Arduino



Position du Soleil et heures de prière pour Arduino

Calcul de la position du soleil

Le code suivant (trois fichiers) permet de faire le calcul de la position du soleil à n'importe quelle heure de la journée, de l'année, du lieu.
Il contient une librairie (mainroutines) comportant les fonctions nécessaires au calcul mais aussi les coordonnées de la ville :
[code] const double latitude = 34.88*deg2rd; const double longitude = -1.31*deg2rd; const int TimeZoneTown = 1; const int Convention = 1; const int DST = 0; [/code]

Il comporte aussi les fonctions
GetDate()
et
GetHeure()
qui permettent de spécifier la date et l'heure d'observation.
Ils peuvent être modifiées comme on le verra dans un prochain blog pour utiliser une RTC afin de prendre directement l'heure et la date de l'horloge.

Le calcul de la position du soleil se fait par l'appel de la fonction
Calc_hazClick();

le code ne compile pas sur codebender mais marche très bien avec l'IDE de l'Arduino.

Le résultat pour le 6 juillet à 10h est le suivant :
lat=34.8800010681 long=-1.3099999427
latitude=34°52'48.0038450000" longitude=-1°-18'-35.9997940000"
Conv 1
6/7/2016
6/7/2016
10:0:0
Date=6/7/2016Heure=9.00DST does not apply1
az=273.42° (orgine Sud) ie : azimut 273°25'0.1831054700"
------az=93.42° (orgine Nord) ie -180 : azimut 93°25'0.1281738300"
h=46.98°  ie altitude 46°58'35.1855470000"


A comparer avec la version PC qui donne des résultats à peine plus précis (calcul en double précision : double 64 bits au lieu de float 32 bits de l'Arduino).
Cela suffit amplement pour connaître correctement la position du soleil.
_____________________________________________________________
__ Lieu : Algérie, Tlemcen latitude= 34°52'48"   longitude= -1°-18'-36" Convention 1
latitude=34.88°  longitude=-1.31°
__ Date : Jeudi 6/7/2016 à 9.00833333333333 h UT    *DST does not apply*  TZ (include DST)=1
T=0.165116368164879 JC
Soleil Longitude L=104.731736033691°  ie 06h58'56"
theta0=59.9020313587971°  ie 03h59'36"
theta=58.5920313587971°  ie heure sidérale 03h54'22"
RA=105.991297501229°  ie 07h03'58"
delta=22.6231272290966°  ie DE  22°37'23"
tau=-47.3992661424321°  ie angle horaire -3h-9'-36"
az=273.515069036948° (orgine Sud) ie : azimut273°30'54"
------az=93.5150690369481° (orgine Nord) ie -180 : azimut 93°30'54"
h=47.0992260396189°  ie altitude  47°05'57"

Applications :
Station météo connectée
Orientation des panneaux photovoltaïques (PV)
Automatisation de l'ouverture et de la fermeture des stores

Calcul des horaires de prière

Afin de calculer les horaires de prière, il suffit d'appeler la routine 
ComputeSalatTime();
comme suit
[code] // SalatTime without RTC #include "mainroutines.h" void setup() { Serial.begin(115200); // Init SalatTime STinit(); ComputeSalatTime(); } //---------------------------------------------------------------------------- void loop() { } [/code]

samedi 19 mars 2016

TWordApplication sur XE5 ou XE8 C++ Builder

Suite à beaucoup de temps perdu à comprendre pourquoi les composants apparaissent sous Delphi et pas sous C++ Builder, dans un environnement de développement XE5 ou XE8 Studio, je tiens à partager ma solution.

Vous ne pouvez pas avoir les composants Office 2000 (2k) ou Office XP, de Delphi ou de C++ en même temps :
https://community.embarcadero.com/answers/packages-unchecked

Il suffit de cocher qu'un seul à la fois.
https://www.youtube.com/watch?v=AP3if58B2Ks

Il existe aussi
c:\Program Files (x86)\Embarcadero\Studio\16.0\bin\dcloffice2010220.bpl
qu'on pourrait ajouter si l'on souhaite avoir certaines fonctionnalités d'office 2010 inexistantes dans les version 2013 ou plus mais ces composants n'existent pas pour C++.

En C++ Builder il faut charger Serveurs Office 2000 ou XP du 2ème groupe de composants :


au lieu du premier groupe :

Voilà.
Cependant, y a des incompatibilités dues au passage à UnicodeString 
voici comment contourner les problèmes

Vous pouvez à nouveau compiler vos anciens programmes de C++ Builder.

Exemple :
http://ideone.com/yLnBZo


void __fastcall TForm2::Button1Click(TObject *Sender)
{
OleVariant Template = EmptyParam();
OleVariant  NewTemplate = False;
OleVariant  ItemIndex = 1;
UnicodeString wstr = L"Calendrier";
 try {
  WordApplication1->Connect();
 } catch (...) {
  Application->MessageBox(L"Word non installé", L"Erreur", MB_OK|MB_ICONSTOP);
 }
 
 WordApplication1->Visible=true;
 WordApplication1->Documents->Add( Template, NewTemplate);      // utilise le template
 
 WordApplication1->Selection->ParagraphFormat->Alignment = WdParagraphAlignment::wdAlignParagraphCenter;
 WordApplication1->Selection->Font->Name=StringToOleStr(UnicodeString("Verdana"));
 WordApplication1->Selection->Font->Size=10;
 
 WordApplication1->Selection->TypeText(StringToOleStr(UnicodeString("Calendrier")));
 WordApplication1->Disconnect();
 }
//---------------------------------------------------------------------------