Güneş Doğma Batma Zaman Hesabı

[SYavuz]

Bir proje için güneş'in, enlem ve boylamlara göre doğma ve batma zamanını hesaplamam gerek, fakat internetten yaptığım kaynak araştırmalarında;

f          :   gözlem yerinin derece biriminde enlemi,
b         :  gözlem yerinin derece biriminde boylamı,
a , d    :  Güneşin ekvatoral koordinatları        
q          :  yerel yıldız zamanı
q0           : Greenwich yıldız zamanı

olmak üzere bir gök cisminin, atmosferik kırılma etkisini de dikkate alınarak , doğma-batma

anındaki saat açısı H0 aşağıdaki formülden hesaplanabilir ;

cos H0 = (( sin( 50' ) - sinj * sind ) / cos j*cos d )
 
böylece hesaplanan H0 değeri, (-180°< H0 <0°) aralığı içinde doğma (0°< H0 <180°)aralığı içinde batmayı temsil edecek şekilde seçilir. Bu her iki saat açısı değeri

q = H0 + a veya    q = q0 + b + a

bağıntısı kullanılarak doğma ve batma anlarındaki Yerel yıldız zamanı elde edilebilir.


bu kadar bilgiye ulaşabildim...bu formülün açılımlarını bilen veya farklı bir hesaplama yöntemini bilen arkadaşlar var ise ve bu bilgilerini bizimle paylaşırlarsa çok sevinirim.

[OG]

http://picproje.org/index.php/topic,11050&highlight=g%FCne%FE

[SYavuz]

Bu link'teki konuyu daha önce inceledim fakat herhangi bir noktaya varamamış daha doğrusu vardıysa bile arkadaşlar sonucu burada yazmamış...Ayrıca benim için ezan veya namaz vakitleri gerekmiyor sadece güneş doğumu ve batımı sürelerinin hesabı gerekiyor...İnternette 'C' kodu ile yazılmış bir "prayer time"-"ibadet zamanı" nı hesaplayan bir source kodu buldum fakat konuyu ayrıştırmak bir hayli zor gözüküyor...İncelemelere devam ediyorum...Ayrıca bilgisini paylaşmak isteyen olursa memnun olurum..Sadece formül işimi görecektir.


'C' Kaynak Dosyası Linki

http://www.hemenpaylas.com/download/1667656/praytimer.c.html

[OG]

İslami günlük prayer times güneşe bağlıdır. güneş doğuş ve batış zamanlarının karşılığı gelen anlamları,

Güneş doğuş saati: Kerahat vakti başlaması
Güneş doğuşunu tamamlama saati: İşrak vakti. Kerahatin bittiğ saat. Mesela bayram namazı saati olarak da kullanılır.
Güneş batış saati:  Akşam ezanı vakti. Aynı zamanda gün değişim zamanı. İslami olarak gün değişimleri akşam vaktinde olur. Yani akşam vakti ile yeni güne girilir. Günün gecesi önce, gündüzü sonra gelir.  

Bu sebeple hesaplanmaktalar. Bundan istifade edebilirsiniz.

[elektroombank]

bende çok araştırdım.Fakat bu bir patenli proje haline getirlimş Alperen (Abdurrahman Özlem) tarafından.Kendisiniden modül olarak bu sistem satın alanılabilir.Bende elimdeki projeyi bitirince öyle bir modül almayı düşünüyorum.

[SYavuz]

elektroombank,

Hiçbiryerden modül almana gerek yok, ben olayı çözdüm sağlam bir algoritma kurmaya çalışıyorum...PIC için C Kodu yazıyorum ve burada yayınlayacağım...yalnız sadece güneşin doğuşunu ve batışını hesaplıyorum...eğer namaz vakitlerini hesaplamak istersen sadece birkaç formül ilave etmen gerekecek.

[elektroombank]

Valla işi gerçekten çözdüysen çok sevinirim.Sadece doğma batma bile yeter.Gerisini çözeriz zaten.

 Aslında yabancı kaynakları buldum ama bizim yarım yamalak inglizce ile algoritma filan çözemiyoruz..

 Heyecanla bekliyorum..

[SYavuz]

Merhaba aşağıda 1-2 dk hassasiyetle çalışan Güneş Doğuş-Batış algoritması mevcuttur. İlgilenen arkadaşların işine yaraması ümidi ile...

struct CTime { //Güneş Doğuş Batış Süreleri Bu değişkenlerde tutulacaktır.
   int sunraise_hour;
   int sunraise_minute;
   int sunset_hour;
   int sunset_minute;
};

struct CTime RTime;
//***************************************************************************************************
bool IsLeapYear(int32 nYear ) {  // Dört yılda bir Şubat Ayı 29 gün olur biliyorsunuz işte burada artık yılı hesaplıyoruz..
   if (((nYear % 4 == 0)  &&  (nYear % 100 != 0)) || (nYear % 400 == 0))
       return (true);
   else
       return (false);
}
//***************************************************************************************************
float RadToDeg(float angleRad) { // Radyanı Dereceye çeviriyoruz
   return (180 * angleRad / 3.1415926535);
}
//***************************************************************************************************
float DegToRad(float angleDeg) { // Dereceyi Radyana çeviriyoruz
   return (3.1415926535 * angleDeg / 180);
}
//***************************************************************************************************
int32 calcDayOfYear(int32 nmn, int32 ndy, bool bLeapYear) { // Yılın hangi günündeyiz bunu hesaplıyoruz

   return ((int16)((275 * nmn) / 9) - (bLeapYear ? 1 : 2) * (int16)((nmn + 9) / 12) + ndy - 30);
}
//***************************************************************************************************
int32 CalcJulianDay(int32 nMonth, int32 nDay, bool bLeapYear) { //Referans olarak aldığımız yıla göre hangi gündeyiz bunu hesaplıyoruz.
                        //Julian Takviminin hesaplama mantığı bilinen bir yıl,ay,gün ve saatinde
                        //güneşin bilinen açısını hesaplıyoruz daha sonra bunu gelecek gün,ay ve yıllara göre ilerletiyoruz.
   int i;
   int32 nJulianDay=0;

   If (bLeapYear) {
       for (i=0;i<(nMonth-1);i++) {
           nJulianDay = nJulianDay + m_monthLeap;
       }
   }
   else {
       for (i=0;i<(nMonth-1);i++) {
           nJulianDay = nJulianDay + m_monthList;
       }
   }

   nJulianDay += nDay;

   return (nJulianDay);
}
//***************************************************************************************************
int dayofweek(int d, int m, int y) { //Haftanın Gününü Hesaplıyoruz.
   static int t[] = { 0, 3, 2, 5, 0, 3, 5, 1, 4, 6, 2, 4 };
   int result;
   y -= m < 3;
   result = ( y + y/4 - y/100 + y/400 + t[m-1] + d) % 7;
   result++;
   return (result);
}
//***************************************************************************************************
//=========================================================================
#define RADEG  180 / PI
#define DEGRAD PI / 180
//=========================================================================

float x_atan2(float ys, float xs){
float theta;
if(xs != 0) {
    theta = atan(ys / xs);
    If(xs < 0){
      theta = theta + PI;
    }
}
else {
  If(ys < 0) {
     theta = 3 * PI / 2; //90
  }  
  else {
     theta = PI / 2; //270
  }
}
  return(theta);
}
//**********************************************************************************************************
float x_sqrt(float x){
//if(x > 0)
  return(sqrt(x));
//else
//  return(0);
}
//**********************************************************************************************************
float x_acos(float x) {
  return (atan(-x / x_sqrt(-x * x + 1)) + 2 * atan(1));
}
//**********************************************************************************************************
float sind(float qqq) {
 return(sin(qqq * DEGRAD));
}
//**********************************************************************************************************
float cosd(float qqq) {
 return(cos((qqq) * DEGRAD));
}
//**********************************************************************************************************
float tand(float qqq){
 return(tan((qqq) * DEGRAD));
}
//**********************************************************************************************************
float atand(float qqq) {
 return(RADEG * atan(qqq));
}
//**********************************************************************************************************
float asind(float qqq) {
 return(RADEG * asin(qqq));
}
//**********************************************************************************************************
float acosd(float qqq) {
 return(RADEG * x_acos(qqq));
}
//**********************************************************************************************************
float atan2d(float qqq, float qqq1) {
 return(RADEG * x_atan2(qqq, qqq1));
}
//**********************************************************************************************************
float rev(float qqq){
float x;
 x = (qqq - (int16)(qqq / 360.0) * 360.0);
 If(x <= 0){ x += 360; }
 return x;
}
//**********************************************************************************************************
void CalcSunTimes(float strYear, float strMonth, float strDay, float longitude, float latitude, float TZ) {
// Örnek Olarak fonksiyonu şu şekilde çağıracaksınız;
// CalcSunTimes(<Yıl>,<Ay>,<Gün>,<İlgili Yerin Boylamı>,<İlgili Yerin Enlemi>,<Yerel Saat Farkı>)
// CalcSunTimes(2008,08,06,29,41,2) Türkiye için İstanbul'un koordinatlarını girdim.Yerel Saat farkı Türkiye için +2 'dir.

float d, n, i, w, m, l, e, e1, a, xv, yv, v, xs, ys, xe, ecl, lonsun, ye, ze, ra, dec, h,r;
float GMST0, UT_Sun_in_south, LHA, hour_rise, hour_set, min_rise, min_set;
int32 nJulianDay=0;

 nJulianDay = CalcJulianDay((int32)strMonth, (int32)strDay, IsLeapYear((int32)strYear));
 dayOfYear = nJulianDay;

 // 1 Ocak 2000 Yılını referans alarak Julian Hesaplamasını Yapıyoruz.
 d = (367 * (strYear) - (int16)((7 * ((strYear) + (((strMonth) + 9) / 12))) / 4) + (int16)((275 * (strMonth)) / 9) + (strDay) - 730530);

 //Güneşin orbital elementlerinin bulunduğu bölgeyi hesaplyoruz.
 //(Orbital-> Elektronların bulunma olasılığının en fazla olduğu hacimsel bölgedir. Güneşten gelen ışık yığınlarının hesabı için burada kullanılmıştır)
 n = 0.0;
 i = 0.0;
 w = 282.9404 + 0.0000470935 * d;

 a = 1.0;
 e = 0.016709 - 0.000000001151 * d;

 m = 356.047 + 0.9856002585 * d;
 m = rev(m);

 ecl = 23.4393 - 0.0000003563 * d;
 l = w + m;
 if((l < 0) || (l > 360)) {
   l = rev(l);
 }

 //Güneşin Pozisyonunu Hesaplıyoruz.
 e1 = m + e * (180 / PI) * sind(m) * (1.0 + e * cosd(m));
 xv = cosd(e1) - e;
 yv = x_sqrt(1.0 - e * e) * sind(e1);
 v = atan2d(yv, xv);
 r = x_sqrt(xv * xv + yv * yv);
 lonsun = v + w;
 If((lonsun < 0) || (lonsun > 360)) {
   lonsun = rev(lonsun);
 }
 xs = r * cosd(lonsun);
 ys = r * sind(lonsun);
 xe = xs;
 ye = ys * cosd(ecl);
 ze = ys * sind(ecl);
 ra = atan2d(ye, xe);
 dec = atan2d(ze, (x_sqrt((xe * xe) + (ye * ye))));
 h = -0.833;

 GMST0 = l + 180;
 if((GMST0 < 0) || (GMST0 > 360)) {
   GMST0 = rev(GMST0);
 }

 UT_Sun_in_south = (ra - GMST0 - longitude) / 15.0;
 If (UT_Sun_in_south < 0) {
   UT_Sun_in_south = UT_Sun_in_south + 24;
 }

 LHA = sind(h) - (sind(latitude) * sind(dec)) / (cosd(latitude) * cosd(dec));
 If ((LHA > -1) && (LHA < 1)) {
   LHA = acosd(LHA) / 15;
 }
 else {
   return;
 }

 hour_rise = (UT_Sun_in_south - LHA);
 hour_set = (UT_Sun_in_south + LHA);
   
 min_rise = (int)((hour_rise - (int)(hour_rise)) * 60);
 min_set = (int)((hour_set - (int)(hour_set)) * 60);

 hour_rise = ((int)(hour_rise) + TZ);
 hour_set = ((int)(hour_set) + TZ);

 RTime.sunraise_hour    = hour_rise;
 RTime.sunraise_minute  = min_rise;
 RTime.sunset_hour      = hour_set;
 RTime.sunset_minute    = min_set;
}