Satelliten, Sonne und Mond
Satelliten, Sonne und Mond
Es gibt vielfältige Gründe dafür, dass sich auf einer Satelliten-Homepage auch Programmroutinen für die Mondberechnung finden.
Zunächst ist der Mond auch ein Satellit - wenn auch ein natürlicher -und somit für die Berechnung nicht ohne Reiz. Weiterhin haben viele Funkamateure, die sich dem Satellitenhobby verschrieben haben, auch Interesse an allgemeinen astrophysikalischen Vorgängen oder nutzen sogar den Mond als Reflektor für EME-Verbindungen.
Ein weiterer Grund ist auch, dass man die Einflüsse des Mondes auf Erdsatelliten nur dann rechnerisch in den Griff bekommt, wenn man die Stellung des Mondes auf seiner Bahn selbst berechnen kann. Dazu sollen u.a. die nachfolgenden Erläuterungen dienen. Das Programm am Ende des Artikels berechnet den Mond mit einer Genauigkeit von ca. ± einer Winkelminute, die Sonne sogar mit einer Genauigkeit von ca. ± 1 Winkelsekunde und ist damit für unsere - und für EME-Zwecke voll ausreichend.
Das Programm ermittelt neben der Richtung, Elevation, Entfernung auch die geographischen Koordinaten des Sublunarpunktes ( Submondpunkt ) analog zum Subsatellitenpunkt und zusätzlich die Länge auf der Ekliptik um diese mit der Stellung der Sonne vergleichen zu können (für Phasenberechnung, Anziehungskräfte etc.). Auch die Deklination wird bestimmt, wobei diese im verwendeten geozentrischen astronomischen Koordinatensystem in etwa der geographischen Breite des Sublunarpunktes entspricht.
Rektaszension, Stundenwinkel sowie die Entfernung Erde - Mond werden ebenfalls berechnet. Die Ergebnisse können mit den Angaben in den einschlägigen Himmelsjahrbüchern verglichen - und somit nachgeprüft werden. Die Differenzen zu den in den Almanachen veröffentlichten, mit aufwändigen Methoden berechneten Mondephemeriden sind gering, das Programm ist also recht genau. Da man bei der Mondberechnung sowieso die Daten der Sonne berechnen muss, werden auch dazu umfangreiche Routinen angeboten.
1. Die Mondbahn
Die Berechnung der Mondbahn ist ein schwieriges Kapitel, denn die störenden Einflüsse durch Erde, Sonne und Planeten sind sehr groß. Für genaue Berechnungen muss man einige hundert Bahnstörungen berücksichtigen. Es gibt daher kein geschlossenes mathematisches Modell oder einen umfassenden Algorithmus für die Mondberechnung. Man kommt aber mit verschiedenen Näherungsverfahren und der Berücksichtigung einer Vielzahl von empirisch ermittelten Konstanten zu guten Ergebnissen.
Die Bahnebene des Mondes ist gegenüber der Ekliptik um 5.15° geneigt und hat eine Exzentrizität von 0.0549; diese schwankt mit einer Periode von 31.8 Tagen. Durch die Anziehungskraft der Sonne entsteht eine konkave Krümmung der Bahn in Richtung Sonne, die sich je nach Stellung der Sonne in der Ausprägung ändert, auch die Anziehungskräfte der Planeten wirken auf die Bahn so ein dass sie z.T. erheblich von der keplerschen Ellipsenform abweicht.
Die Apsidenlinie des Mondes auf der Ekliptik, dem Argument des Perigäums eines Satelliten in der Äquatorebene entsprechend, vollführt einen Umlauf von 360° in 8.85 Jahren. Die Knotenlinie in der Ebene der Ekliptik dreht sich in 18.6 Jahren um 360°. Da die Erde selbst eine Bahnneigung von ca. 23.4406° besitzt, schwankt dadurch die Inklination der Mondbahn in Bezug auf die Äquatorebene der Erde ebenfalls mit einer Periode von 18.6 Jahren. Das erklärt, warum in manchen Jahren der Vollmond immer tief am Himmel steht und einige Jahr später wesentlich höher.
Infolge der Apsidendrehung ist die anomalistische Umlaufzeit, d.h. die Umlaufzeit von Perigäum zu Perigäum, um 5-6 Stunden länger als die siderische. Wobei auch die siderische Umlaufzeit aufgrund der Schwankungen der Exzentrizität, der sog " Evektion", erhebliche Unterschiede aufweisen kann.
Die Bahnstörungen sind also teilweise säkular d.h. fortschreitend, einige sind kurzperiodisch, andere haben eine Periode von mehreren hundert Jahren, können also aus der gegenwärtigen Sicht ebenfalls als säkular betrachtet werden. Die Grafik zeigt die Mondbahn auf die Ebene der Ekliptik bezogen.
2. Das Programm SUN_MOON.PAS
SUN_MOON ist ein Kombiprogramm, das Sonnen- und Monddaten gleichzeitig berechnet und in zwei Bildschirmspalten ausgibt. Es kann die Daten in Echtzeit darstellen oder die Daten für ein bestimmtes Datum ermitteln.
Das Programm wurde unter Turbo-Pascal 7.0 entwickelt und besteht aus dem Hauptprogramm SUN_MOON.PAS , den Units MONDUNIT und SONNUNIT sowie der Unit ASTRO. Für die mathematischen Routinen wird auf eine mathematische UNIT, die VARUNIT zurückgegriffen. Alle Programmteile sind ausdokumentiert, so dass nur wenige Anmerkungen unter Bezug auf die Zeilennummern notwendig sind. Um die interne Genauigkeit zu erhöhen, werden alle Floatingpoint-Variablen vom TYP REAL mit 19-stelliger Genauigkeit berechnet. Dazu werden sowohl in den Units als auch im Hauptprogramm der Compilerschalter {$E+,N+} gesetzt und alle REAL Variablen als Extended Typen deklariert.
2.1 Die zentrale Unit ASTRO.PAS
Die Unit berechnet mit speziellen Algorithmen u.a. die Exzentrizität der Erde, den Radiusvektor Erde-Sonne, die Länge der Sonne auf der Ekliptik sowie weitere, in der Astronomie wichtige Parameter wie Sternzeit und Julianisches Datum. Zusätzlich gibt es darin noch Prozeduren und Funktionen zur Berechnung von Rektaszension, Deklination, der Subpunkte, sowie von Richtung und Entfernung. Die folgenden Erklärungen mit Zeilennummern beziehen sich zunächst nur auf die Unit Astro, Hinweise auf Formeln beziehen sich auf meine Publikation[1].
Die Funktion "Sternzeit" ,(Zle 171-178) berechnet die Sternzeit sehr genau, der Algorithmus dazu stammt von der Internationalen Astronomischen Union(IAU) , ist also sozusagen offiziell.
Die Prozedur Sonnenparameter (ab Zle 135), berechnet die Länge der Sonne auf der Ekliptik, die aktuelle Exzentrizität der Erdbahn, die mittlere - und wahre Anomalie, den Radiusvektor Erde-Sonne sowie den aktuellen Wert der Schiefe der Ekliptik . Diese Parameter dienen später u.a. als Grundlage für weitere Berechnungen. Auch diese Routine ist sehr genau, die Algorithmen haben für Jahrhunderte bestand und müssen daher nicht geändert werden. Auf Einzelheiten gehe ich im nächsten Kapitel noch ein. Weitere Details können den Kommentaren entnommen werden.
Die Funktion Jultage (111) ermittelt aus einem übergebenen Kalenderdatum das Julianische Datum und die Funktion Quadrant (122), bringt einen mit der ARCTAN-Funktion berechneten Wert in den richtigen Quadranten.
Rekt (52) berechnet aus ekliptikalen Koordinaten die Rektaszension, die Funktion Dekl (62) aus den gleichen Angaben die Deklination. Siehe dazu auch die Formeln in [1].
Sublaenge (68) und Subbreite (76) ermitteln die geographischen Koordinaten der Subpunkte auf der Erdoberfläche und die bereits aus [1] bekannten Funktionen Azimut (88) und Zentriwinkel (83) berechnen die Richtung von einer Bodenstation zum Subpkt, bzw. über die Funktion Entf (98) auch die Distanz in km. Die Elevation eines Gestirns wird mit der Funktion Elev (105) ermittelt.
{ 1} UNIT Astro;
{ 3} {Lehr- und Lernprogramm zur MOND- und Sonnenberechnung, M.Maday }
{ 4} {DC9ZP, (C) 2001-2006}
{ 5} { Echtzeitberechnung für die Routinen MOND und SONNE mit simul- }
{ 6} { taner Darstellung der Ergebnisse }
{ 9} { Formeln nach DC9ZP }
{ 10} { Die UNIT stellt Routinen für die Berechnung von Sternzeit }
{ 11} { Rektaszension, Deklination, Solar/Mondsubpunkte und Länge }
{ 12} { der Sonne auf der Ekliptik für die Routinen MOND- und }
{ 13} {Sonnenberechnung bereit. }
{ 14} {$E+,N+} { Coprozessor einschalten oder Emulation }
{ 15} { der Genauigkeit von 1E-19 Stellen }
{ 16} INTERFACE
{ 17} USES CRT,VARUNIT;
{ 18} TYPE REAL = EXTENDED; {mit 19 stelliger Genauigkeit rechnen }
{ 19} CONST PI_2 = 2*PI;
{ 20} ekl = 23.43929111; {Schiefe der Ekliptik }
{ 21} { Globale Variablen }
{ 22} VAR sonnlaenge, rv_sonne, ex_erde,ekliptik,
{ 23} nutation :REAL;
{ 24}
{ 25} VAR tag, monat, jahr, stunde, minute, sekunde,
{ 26} richtung, entfernung,ekl_laenge,slp_laenge,
{ 27} slp_breite, elevation, juldate, sz, phase,
{ 28} rektaszension, stdwinkel,r_vec,deklination,
{ 29} tagteil,epoche, startime, ssp_laenge,
{ 30} ssp_breite, eigenbreite, eigenlaenge : REAL;
{ 31} datum : STRING[10];
{ 32} { Öffentliche Funktionen und Prozeduren }
{ 33} FUNCTION Quadrant(y,x : REAL) : REAL;
{ 34} PROCEDURE sonnenparameter(jultag : REAL);
{ 35} FUNCTION sternzeit (jultage,tagteil : REAL):REAL;
{ 36} FUNCTION Jultage (tag,monat,jahr : REAL):REAL;
{ 37} FUNCTION Rekt(l,b,dekl,ekl:REAL) : REAL;
{ 38} FUNCTION Dekl(l,b,ekl:REAL) : REAL;
{ 39} FUNCTION elev(l1,b1,l2,b2,rv:REAL) : REAL;
{ 40} FUNCTION sublaenge(sz,rekt:REAL) : REAL;
{ 41} FUNCTION subbreite(dekl:REAL) : REAL;
{ 42} FUNCTION azimut(l1,b1,l2,b2:REAL) : REAL;
{ 43} FUNCTION entf(l1,b1,l2,b2:REAL) : REAL;
{ 44} PROCEDURE Ausgabe_mond;
{ 45} PROCEDURE Ausgabe_sonne;
{ 46} IMPLEMENTATION
{ 47} { Berechnet die Rektaszension eines beliebigen Gestirns aus den }
{ 48} { ekliptikalen Koordinaten und der Deklination. Beim Aufruf sind }
{ 49} { übergeben l = ekliptikale Länge, b = ekliptikale Breite, dekl }
{ 50} { Deklination, ekl = Schiefe der Ekliptik }
{ 51} { der Sonne wird als Breite = 0 übergeben }
{ 52} FUNCTION Rekt(l,b,dekl,ekl:REAL):REAL;
{ 53} VAR a1,a2:REAL;
{ 54} BEGIN
{ 55} a2:= cosinus(b) * cosinus(l)/cosinus(dekl);
{ 56} a1:=(cosinus(b)* sinus(l)*cosinus(ekl)-sinus(b)*sinus(ekl))/
{ 57} cosinus(dekl);
{ 58} rekt := quadrant(a1,a2);
{ 59} END;
{ 60} {Berechnet Deklination, übergeben l =ekliptikale Länge, }
{ 61} {ekliptikale Breite, ekl = Schiefe der Ekliptik }
{ 62} FUNCTION Dekl(l,b,ekl:REAL):REAL;
{ 63} BEGIN
{ 64} dekl:= asn(cosinus(b)*sinus(l)*sinus(ekl)+sinus(b)*cosinus(ekl));
{ 65} END;
{ 66} {Berechnet Subpktlaenge in nautischer Form, sz =Sternzeit }
{ 67} {rekt =Rektaszension }
{ 68} FUNCTION sublaenge(sz,rekt:REAL):REAL;
{ 69} VAR sw,l :REAL;
{ 70} BEGIN
{ 71} sw := degr(sz-rekt);
{ 72} IF sw < 180 THEN l:= -sw ELSE l := 360-sw;
{ 73} sublaenge:= l;
{ 74} END;
{ 75} {Berechnet genaue geogr Breite Subpkt aus Deklination, Formel 78 }
{ 76} FUNCTION Subbreite(dekl:REAL):REAL;
{ 77} BEGIN
{ 78} subbreite:= atn(tan(dekl)/0.993305525);
{ 79} END;
{ 80} {Berechnet aus Koordinatenunterschieden den Zentriwkl im }
{ 81} {Erdmittelpunkt. Übergeben Länge /Breite QTH =l1,b1,Länge }
{ 82} {Breite des 2. QTH l2/b2 oder des Subpunktes }
{ 83} FUNCTION Zentriwinkel(l1,b1,l2,b2:REAL):REAL; { Formel 21 }
{ 84} BEGIN
{ 85} zentriwinkel:= degr(acs(cosinus(b1)*cosinus(l1-l2)*cosinus(b2)
{ 86} +sinus(b1)*sinus(b2)));
{ 87} END;
{ 88} {Berechnet Azimut von Norden aus, übergeben geogr Koordinaten }
{ 89} {nautischerForm wie Funktion Zentriwinkel }
{ 90} FUNCTION azimut(l1,b1,l2,b2:REAL):REAL; { Formel 22 }
{ 91} VAR az,zw :REAL;
{ 92} BEGIN
{ 93} zw := zentriwinkel(l1,b1,l2,b2);
{ 94} az := acs((sinus(b2)-sinus(b1)*cosinus(zw))/(cosinus(b1)*
{ 95} sinus(zw)));
{ 96} IF sinus(l1-l2) < 0 THEN azimut:=az ELSE azimut :=360-az;
{ 97} END;
{ 98} FUNCTION entf(l1,b1,l2,b2:REAL):REAL { Formel 21.1 }
{ 99} BEGIN
{100} entf:=zentriwinkel(l1,b1,l2,b2)*111.2;
{101} END;
{102} {Berechnet Elevation eines Gestirns aus den geogr Koordinaten }
{103} {der Bodenstation l1,b1 und der Subpkte des Gestirns über }
{104} {Zentriwinkel, dazu muss noch der Radiusvektor übergeben werden }
{105} FUNCTION elev(l1,b1,l2,b2,rv:REAL):REAL; { Formel 23 }
{106} VAR zw :REAL;
{107} BEGIN
{108} zw := zentriwinkel(l1,b1,l2,b2);
{109} elev := atn((cosinus(zw)-(6378.14/rv))/sinus(zw));
{110} END;
{111} { Berechnet das Julianische Datum aus einem Kalender-Datum }
{112} FUNCTION Jultage(tag,monat,jahr:REAL):REAL;
{113} VAR a,b:REAL;
{114} BEGIN
{115} IF monat <= 2 THEN
{116} BEGIN jahr := jahr - 1; monat:= monat +12; END;
{117} a := INT(jahr/100);
{118} b := 2-a+INT(a/4);
{119} jultage := INT(365.25*(jahr+4716))+INT(30.60001*(monat+1))+
{120} tag + b-1524.5;
{121} END;
{122} { Bringt ARCTAN in den richtigen Quadranten}
{123} FUNCTION Quadrant(y,x:REAL):REAL;
{124} VAR wert:REAL;
{125} BEGIN
{126} IF x=0 THEN wert:=PI/2 *sgn(y) ELSE wert := ARCTAN(y/x);
{127} IF x < 0 THEN wert := wert+PI;
{128} IF wert < 0 THEN wert := wert+PI_2;
{129} Quadrant := wert*k0;
{130} END;
{131} { Berechnet die Ekliptikale Länge der Sonne, die wahre Anomalie, }
{132} { den Radiusvektor Erde-Sonne die aktuelle Exzentrizität der }
{133} { Erdbahn sowie den aktuellen Wert der Schiefe der Ekliptik }
{134} { Die Formeln sind sehr genau und haben für Jahrhunderte Bestand }
{135} PROCEDURE Sonnenparameter(jultag:REAL);
{136} CONST ae = 1.4959965E8; { Die astromische Einheit }
{137} VAR t,ml0,m,c,v,lmond,o,deltaekl,abberation:REAL;
{138} BEGIN
{139} t := (jultag-2451545.0)/36525; { Juldatum in Jahrhunderten }
{140} ml0:= 280.46645 + 36000.76983 * t+0.0003032*t*t; { Mittl Länge }
{141} { m = Mittlere Anomalie der Sonne }
{142} m := 357.529010+ 35999.05030 * t-0.0001559*t*t-0.00000048*t*t*t;
{143} { c = Korrekturwert für M und Ml }
{144} c := (1.914600-0.004817*t-0.000014*t*t)*sinus(m) +
{145} (0.019993-0.000101*t)*sinus(2*m)+ 0.000290*sinus(3*m);
{146} { Exzentrizät der Erde für die nächsten Jahrhunderte }
{147} ex_erde := 0.016708617-0.000042037*t-0.0000001236*t*t;
{148} v := degr(m+c); { Die wahre Anomalie der Sonne }
{149} { Radiusvektor Erde-Sonne in Kmangegeben }
{150} rv_sonne := (1.000001018*(1-ex_erde*ex_erde))/
{151} (1+ex_erde*cosinus(v))*ae;
{152} { Mittlere Schiefe der Ekliptik für die nächsten Jahrhunderte }
{153} lmond := degr(218.3164591+481267.88134236*t-
{154} 0.00136268*t*t+t*t*t/538841); { Überschlägige Länge des Mondes }
{155} O:= degr(125.04452-1934.136261*t+0.0020708*t*t+t*t*t/450000);
{156} {O= Aufsteigender Mondknoten,jetzt Nutation der Erdachse berechnen }
{157} nutation := (-17.2*sinus(o)-1.32*sinus(2*ml0)-0.23*
{158} sinus(2*lmond)+0.21*sinus(2*o))/3600;
{159} { Korrekturwert für Schiefe der Ekliptik }
{160} deltaekl := (+9.2*cosinus(o)+0.57*cosinus(2*ml0)+
{161} 0.1*cosinus(2*lmond)-0.09*cosinus(2*o))/3600;
{162} ekliptik := ekl-46.815/3600*t-0.00059/3600*t*t+0.0001813/
{163} 3600*t*t*t+deltaekl; { Jährliche Abberation }
{164} abberation:= -(20.4898/3600)/(Rv_sonne/ae);
{165} sonnlaenge := degr(ml0+c) + nutation + abberation;
{166} {korrigierte Länge auf der Ekliptik }
{167} END;
{168}
{169} { Sternzeit unter Berücksichtigung der Präzession genau }
{170} {Die Formel stammt von der "Internationalen Astronomischen Union" }
{171} FUNCTION Sternzeit(jultage,tagteil:REAL):REAL;
{172} VAR t,x,t1:REAL;
{173} BEGIN
{174} t := (jultage-2451545.0)/36525.0; { Juldatum in Jahrhunderten }
{175} t1 := 360.98564736629*tagteil; { Tägliche Änderung der Sz }
{176} sternzeit := degr(100.460618375+36000.77005360833*t+
{177} 0.0003879333*t*t - (t*t*t)/38710000+t1);
{178} END;
{179 { Ausgabe der Monddaten auf den Bildschirm in Spalte links }
{180} PROCEDURE Ausgabe_mond;
{181} BEGIN
{182} WR(3,1,'Bahnberechnung für Mond und Sonne am '+f(tag,2,0)
{183} +'.'+f(monat,2,0)+'.'+f(jahr,4,0)+' Uhrzeit '
{184} +grad(tagteil*24)+' UTC');
{185} WR(3,3, 'Monddaten für QTH : '+qth );
{186} WR(3,5, 'Richtung zum Mond...: '+f(richtung,3,2)+g);
{187} WR(3,6, 'Elevation...........: '+f(elevation,3,2)+g);
{188} WR(3,7, 'Geogr Länge des SLP.: '+grad(slp_laenge)+g);
{189} WR(3,8, 'Geogr Breite des SLP: '+grad(slp_breite)+g);
{190} WR(3,9, 'Entfernung zum SLP..: '+f(entfernung,5,2));
{191} WR(3,10,'Länge Mond Ekliptik.: '+f(ekl_laenge,3,2)+g);
{192} WR(3,11,'Rektaszension.......: '+grad(rektaszension/15));
{193} WR(3,12,'Deklination ........: '+f(deklination,3,2)+g);
{194} WR(3,13,'Stundenwinkel.......: '+f(stdwinkel,3,2)+g);
{195} WR(3,14,'Mondphase in %......: '+f(phase,2,2)+'%');
{196} WR(3,15,'Radiusvektor........: '+f(r_vec,6,2)+' km');
{197} END;
{198} {Ausgabe der Ergebnisse für die Sonnenberechnung, rechte Spalte }
{199} PROCEDURE Ausgabe_sonne;
{200} BEGIN
{201} WR(40,3, 'Sonnendaten für QTH : '+qth);
{202} WR(40,5, 'Richtung zur Sonne..: '+f(richtung,3,2)+g);
{203} WR(40,6, 'Elevation der Sonne.: '+f(elevation,3,2)+g);
{204} WR(40,7, 'Geogr. Länge SSP....: '+grad(ssp_laenge)+g);
{205} WR(40,8, 'Geogr. Breite SSP...: '+grad(ssp_breite)+g);
{206} WR(40,9,'Entfernung zum SSP..: '+f(entfernung,5,2)+'Km');
{207} WR(40,10, 'Rektaszension.......: '+grad(rektaszension/15)+g);
{208} WR(40,11, 'Deklination in Grad.: '+f(deklination,3,4)+g);
{209} WR(40,12, 'Länge auf Ekliptik.: '+f(sonnlaenge,3,4)+g);
{210} WR(40,13, 'Radiusvektor Sonne..: '+f(rv_sonne,8,0)+' Km');
{211} WR(40,14, 'Sternzeit...........: '+grad(sz/15));
{212} wr(40,15, 'Julianischer Tag....: '+f(juldate,7,1));
{213} END;
{214} BEGIN
{215} END.
2.2 Die MONDUNIT
Zentrale Prozedur der Mondunit ist "Rechneeme" . Sie beginnt ab Zeile 53 mit der Berechnung der geogr. Koordinaten aus dem in Zeile 52 deklarierten QTH-Kenner, ermittelt durch Aufruf der Funktion Jultage das Julianische Datum, die Zeitdifferenz seit der Epoche und zählt dazu den Tagesteil der aus den eingegeben Std., Min, Sek berechnet wird, und ruft dann die Funktion Sternzeit auf.
Danach folgt die Berechnung einiger Bahnkonstanten (ab Zle 61) bezogen auf das Berechnungsdatum und daraus(Zle 67-72) die Länge des Mondes auf der Ekliptik. Die ekliptikale Länge ist wichtig für die Phasenberechnung des Mondes da diese von der Differenz ekliptikale Länge der Sonne - ekliptikalen Länge des Mondes abhängig ist. Durch Aufruf der Prozedur Sonnenparameter (Unit Astro) wird die Länge der Sonne ermittelt ( Zle 58) und mit der ekliptikalen Länge des Mondes verglichen. Daraus folgt(Zle 75) als Ergebnis die Mondphase in Prozent, wobei 100 % Vollmond, 50% erstes- oder letztes Viertel (im Volksmund Halbmond) und 0% Neumond bedeuten. Bei Vollmond ist die Längendifferenz also 0°, beim ersten Viertel 90°, bei Neumond 180 ° und beim letzten Viertel 270°.
In Zeile 81 wird die Deklination des Mondes im astronomischen Koordinatensystem ermittelt, dazu wird die Funktion Dekl in der Unit ASTRO aufgerufen. Der genaue Wert der geographischen Breite des Sublunarpunktes (SLP_Breite) wird aus der Deklination berechnet (87). Es folgen die Rektaszension in Grad (83) und der Stundenwinkel (84).
Die geographische Länge des Sublunarpunktes wird in 86 berechnet, wobei die Längenangabe wieder in nautischer Form erfolgt. Die westliche Länge erhält ein negatives Vorzeichen(0° bis -180°) und die ostwärtige Länge(0° bis 180°) bleibt ohne Vorzeichen. Diese Schreibweise ist seit 1982 durch die IAU standardisiert. In den folgenden Zeilen werden die Entfernung Bodenstation zum Sublunarpunkt (90), die Richtung vom QTH zum Mond (88) sowie die Elevation des Mondes über dem Horizont, vom QTH aus gesehen berechnet (91). Die Entfernung Erde - Mond, die dem Radiusvektor vom Mittelpunkt der Erde zu Mond entspricht, wird über die Funktion Rv_mond (Zle 26 ff) ermittelt. Wie aus der Größe der Funktion ersichtlich, ist dies wesentlich schwieriger als bei künstlichen Satelliten. Grund sind wieder die immensen Bahnstörungen deren Einflüsse in Form von Termen zu berücksichtigen sind. Aus dem Radiusvektor kann im übrigen bei Bedarf die Freiraumdämpfung der Strecke Erde - Mond leicht berechnet werden.
{ 1} UNIT MONDUNIT;
{ 3} {Lehr- und Lernprogramm zur MOND und Sonnenberechnung, M.Maday }
{ 4} {DC9ZP, (C) 2001}
{ 5} { Echtzeitberechnung für die Routinen MOND und SONNE mit simul- }
{ 6} { taner Darstellung der Ergebnisse }
{ 7} { Die UNIT enthält alle Mondberechnungsroutinen }
{ 8} { Formeln nach DC9ZP }
{ 9} {$E+,N+} { Coprozessor einschalten oder Emulation }
{ 10} INTERFACE
{ 11} USES CRT,
{ 12} ASTRO,
{ 13} VARUNIT;
{ 14} TYPE REAL = EXTENDED; {mit 19 stelliger Genauigkeit rechnen }
{ 15} { Globale Variablen mit Ergebnissen }
{ 16} PROCEDURE Rechneeme;
{ 17} IMPLEMENTATION
{ 18} PROCEDURE Rechneeme;
{ 19}
{ 20} VAR konst1,konst2,konst3,konst4,konst5,konst6,a2,
{ 21} a1, rekt0, zw, az, eigenbreite, eigenlaenge,
{ 22} epochtage, tagesdifferenz, ml, ml1, ml2,
{ 23} ekl_breite, ml0 : REAL;
{ 24} {Funktion berechnet den aktuellen Radiusvector Erde-Mond in km }
{ 25} { Die Genauigkeit beträgt ca +-50 km }
{ 26} FUNCTION Rv_mond(jultage:REAL): REAL;
{ 27} VAR t,d,ms,m,f,rv: REAL;
{ 28} BEGIN
{ 29} t := (jultage-2451545.0)/36525.0;
{ 30} d := degr(297.8502042+445267.1115168*t-0.0016300*t*t+t*t*t/
{ 31} 545868-t*t*t*t/113065000);
{ 32} ms:= degr(357.5291092+35999.0502909*t-0.0001536*t*t + t*t*t/
{ 33} 24490000);
{ 34} m := degr(134.9634114+477198.8676313*t+0.0089970*t*t + t*t*t/
{ 35} 69699 - t*t*t*t/14712000);
{ 36} f:=degr(93.2720993+483202.0175273*t-0.0034029*t*t-t*t*t/3526000
{ 37} + t*t*t*t/863310000);
{ 38} { es folgen Termen zur Einberechnung der Bahnstörungen }
{ 39} rv:= -20905355 * cosinus(m) - 3699111*cosinus(2*d-m)-2955968*
{ 40} cosinus(2*d) - 569925 * cosinus(2*m)+48888*cosinus(ms)-3149*
{ 41} cosinus(2*f)+246158*cosinus(2*d-2*m)-152138*cosinus(2*d-m-ms)-
{ 42} 170733*cosinus(2*d+m)-204586*cosinus(2*d-ms)-129620*
{ 43} cosinus(ms-m)+108743*cosinus(d)+104755*cosinus(m+ms)+
{ 44} 10321*cosinus(2*d-2*f)+79661*cosinus(m-2*f)-34782*cosinus(4*d-m)
{ 45} -23210*cosinus(3*m)-21636*cosinus(4*d-2*m)+24208*
{ 46} cosinus(2*d+ms-m)+30824*cosinus(2*d+ms)-8397*cosinus(d-m)-
{ 47} 16675*cosinus(d+ms)-12831*cosinus(2*d-ms+m)-10445*
{ 48} cosinus(2*d+2*m)-11650*cosinus(4*d)+14403*cosinus(2*d-3*m);
{ 49} rv_mond:= 385000.56 + rv/1000.0; { Funktionsergebnis }
{ 50} END;
{ 51} BEGIN
{ 52 } qth:='JO30VL; {Hier eigenen QTH-LOC einsetzen }
{ 53} rechneqth(qth,eigenlaenge,eigenbreite); {QTH in geogr Koordinaten }
{ 54} juldate := jultage(tag,monat,jahr); { Juldatum errechnen }
{ 55} epochtage := juldate-2415020; { Tage seit Epoche }
{ 56} tagteil := (stunde+minute/60+sekunde/3600)/24; {Tagteil }
{ 57} tagesdifferenz := epochtage+tagteil;
{ 58} sonnenparameter(juldate+tagteil); {Aufruf Prozedur Sonne }
{ 59} sz := sternzeit(juldate,tagteil); { Sternzeit ermitteln }
{ 60} { Und hier die Mondkonstanten auf die Epoche bringen}
{ 61} konst1 := FRAC((0.751213+ 0.036601102 * tagesdifferenz)) * 360.0;
{ 62} konst2 := FRAC((0.822513+ 0.0362916457 * tagesdifferenz)) * 360.0;
{ 63} konst3 := FRAC((0.995766+ 0.00273777852* tagesdifferenz)) * 360.0;
{ 64} konst4 := FRAC((0.974271+ 0.0338631922 * tagesdifferenz)) * 360.0;
{ 65} konst5 := FRAC((0.0312525+0.0367481957 * tagesdifferenz)) * 360.0;
{ 66} { Mondlänge auf der Ekliptik berechnen }
{ 67} ml0 := konst1 + 0.658 * sinus(2.0*konst4) + 6.289 * sinus(konst2);
{ 68} ml1 := ml0-1.274 * sinus(konst2-2.0*konst4) - 0.186*sinus(konst3);
{ 69} ml2 := ml1+0.214 * sinus(2.0*konst2) - 0.114 * sinus(2*konst5);
{ 70} ml := ml2-0.059 * sinus(2*konst2-2*konst4)-0.057*
{ 71} sinus(konst2+konst3-2*konst4);
{ 72} ekl_laenge := ml+nutation;
{ 73} {ekl_laenge ist Länge des Mondes auf der Ekliptik }
{ 74} { Hier ist die Phasenberechnung in % ,Vergleich mit Länge Sonne}
{ 75} phase := ROUND(sqr(sinus(degr(ekl_laenge-sonnlaenge)/2))*100);
{ 76} { Mondephemeriden berechnen }
{ 77} konst6:=konst5+0.6593*sinus(2*konst4)+6.2303*
{ 78} sinus(konst2)-1.272*sinus(konst2-2*konst4);
{ 79} { Monddeklination berechnen }
{ 80} ekl_breite := 5.144*sinus(konst6)-0.146*sinus(konst5-2*konst4);
{ 81} deklination:= dekl(ekl_laenge,ekl_breite,ekliptik);
{ 82} { Rektaszension berechnen }
{ 83} rektaszension := rekt(ekl_laenge,ekl_breite,deklination,ekliptik);
{ 84} stdwinkel := degr(sz-rektaszension); { Ortsstundenwinkel }
{ 85} { Submondpunkte ermitteln SLP-Breite =Monddeklination }
{ 86} slp_laenge := sublaenge(sz,rektaszension);
{ 87} slp_breite := subbreite(deklination);
{ 88} richtung := azimut(eigenlaenge,eigenbreite,slp_laenge,slp_breite);
{ 89} r_vec := rv_mond(juldate); { Radiusvektor Erde-Mond }
{ 90} entfernung := entf(eigenlaenge,eigenbreite,slp_laenge,slp_breite);
{ 91} elevation := elev(eigenlaenge,eigenbreite,slp_laenge,slp_breite, r_vec);
{ 93} END;
{ 94} BEGIN
{ 95} END.
Um das Programm an die jeweiligen Bedürfnisse anzupassen, darf nicht vergessen werden, den eigenen QTH-Kenner in der richtigen Schreibweise, also sechsstellig mit Großbuchstaben, in die Zeile 52 der Mondunit sowie in Zeile 20 der Sonnunit einzusetzen.
Einzelheiten zum Hauptprogramm sind im folgenden Kapitel enthalten.
3.1 Einführung
Das Kombiprogramm SUN_MOON rechnet in Bezug auf die Sonne, mit anerkannten astronomischen Algorithmen, die Genauigkeit beträgt ca +- 1 bis 2 Winkelsekunden. Die Routinen sind zeitfest, d.h. die verwendeten Konstanten können für die nächsten "Jahrhunderte" benutzt werden. Auch die Sonnenroutinen greifen auf die Unit ASTRO zurück, die im vorigen Kapitel bei der Mondberechnung bereits beschrieben wurde.
Die Sonnunit ist kurz gehalten, daraus erkennt man schon, dass die Berechnung der Sonne wesentlich einfacher ist, als die des Mondes.
3.2 Die Sonnenbahn
Bei der Berechnung der Sonne tut man so, als würde sie sich um die Erde drehen und sich auf einer scheinbaren Bahn mit einer Inklination von 23.44° bewegen. Diese "Schiefe der Ekliptik" ist in Wahrheit der Winkel der Erdachse zur Ebene der Ekliptik, er beträgt zur Zeit ca 23.44 °, unterliegt aber periodischen und säkularen Änderungen, die mit zu berücksichtigen sind, wenn man genaue Ergebnisse haben will. Dies wird im Programm in der Unit ASTRO in der Prozedur "Sonnenparameter" geleistet. Die Oszillation der Erdachse (Nutation) wird dabei eingerechnet.
Grundlage zur Sonnenberechnung ist das Astronomische - Äquatoriale Koordinatensystem mit dem Erdmittelpunkt als Ursprung, dem Erdäquator als Bezugsebene in der Horizontalen, dem Nordpol als Z-Achse und der Richtung zum Frühlingspunkt als X-Achse und Ausgangspunkt zur Zählung der astronomischen Längenkoordinaten, der Rektaszension.
Die Y-Achse liegt auf der Äquatorebene und ist von der X- Achse aus um 90° nach Osten verschoben. Die zu diesem kartesischen Koordinatensystem gehörigen Polarkoordinaten sind die Rektaszension, die Deklination und der Radiusvektor Erde-Sonne.
Die Deklination wird wie bereits festgestellt, in Winkelgraden vom Erdäquator nach Norden (ohne Vorzeichen) und nach Süden (- Vorzeichen) in Grad angeben. Die dadurch ermittelte geozentrische Breite ist nahezu identisch mit der geographischen Breite des Subsolarpunktes. Da die scheinbare Inklination der Sonne ca 23.44 ° beträgt, können sich die Subsolarpunkte immer nur im Bereich zwischen 23.44° Nord (Sommer) und -23.44° Süd (Winter) bewegen.
Die Erdbahn ist ellipsenförmig mit einer mittleren Exzentrizität von 0.016708. Die Geschwindigkeit der fiktiven Sonne auf ihrer Bahn kann also nicht gleichförmig sein. Man unterscheidet daher nach mittlerer Länge der Sonne und wahrer Länge. Der Abstand Erde - Sonne schwankt, außerdem unterliegt die Exzentrizität Änderungen die im Programm ebenfalls berücksichtigt werden.
Bei der Bahnberechnung geht man so vor, dass zunächst die ekliptikalen Koordinaten der Sonne in Länge und Breite berechnet werden und diese dann auf das äquatoriale Koordinatensystem umgerechnet werden. Da die Breite der Sonne auf der Ekliptik maximal + - 1 Winkelsekunde beträgt, kann man sie ganz vernachlässigen.
3.3 Erläuterungen zu den Sonnenroutinen
Zunächst einige Hinweise zur Prozedur Sonnenparameter in der Unit Astro (Zle 135-167), da diese im vorigen Kapitel nur kurz behandelt wurde.
Die Prozedur berechnet zunächst (139) aus dem Julianischen Datum die bei Berechnungen in der Astronomie üblichen Julianischen Jahrhunderte, ausgehend von der Epoche des Jahres 2000.0, das ist der Julianische Tag 245145.0. Der so gefundene Wert ist Grundlage für die Berechnung der mittleren Länge (140), der mittleren Anomalie (142) sowie der Mittelpunktsgleichung C (144). Die wahre Länge wird später aus Summe von mittlerer Länge und Mittelpunktsgleichung und weiterer Einflüsse berechnet (165).
Das Ergebnis der wahren Länge steht dann in der globalen Variable Sonnlaenge. Da die Exzentrizität der Erde Schwankungen unterliegt, wird in Zle 147 der aktuelle Wert für das gewünschte Datum berechnet und daraus in Zle 148 die wahre Anomalie der Sonne. Wie bei der Satellitenberechnung in Formel 14 bereits vorgestellt, läßt sich dann der Radiusvektor, d.h. in diesem Fall die Entfernung vom Erdmittelpunkt zur Sonne, mit hoher Genauigkeit bestimmen (Zle 150). Die Schwankungen der Schiefe der Ekliptik werden ab Zle 162 in einen aktuellen Wert für die gewählte Epoche umgesetzt. Auch die Nutation der Erdachse wird berücksichtigt.
Insgesamt führen diese Berechnungen zu der gewünschten Genauigkeit von einigen wenigen Winkelsekunden.
3.4 Die Sonnunit
Die zentrale Prozedur der Sonnunit ist "Rechnesonne" (Zle 18ff). Hier wird zunächst der QTH- Kenner (Zle 20-21) durch Aufruf der entsprechenden Routine wieder in die geographische Länge und Breite umgewandelt und das julianische Datum berechnet (22). Der Aufruf der soeben beschriebenen Prozedur Sonnenparameter erfolgt aus Zle 24, aus der wahren Länge werden dann durch Aufruf der entsprechenden Funktionen der Unit ASTRO, die Rektaszension und Deklination ermittelt (25-26). Mit der Funktion Sternzeit wird die Sternzeit und daraus durch Subtraktion der Rektaszension, der Stundenwinkel der Sonne berechnet (Zle 28). Danach folgt die Berechnung der Subsolarpunkte (29-30).
Die Bestimmung der Richtung vom QTH zur Sonne (Siehe auch Formel 22) und die Berechnung der Elevation der Sonne (Siehe auch Formel 23) folgen in den Zeilen 32-33.
{ 1 } UNIT Sonnunit ;
{ 2} { }
{ 3} {Lehr- und Lernprogramm zur MOND- und Sonnenberechnung, M.Maday }
{ 4} {DC9ZP,(C) 2001 }
{ 5} { Echtzeitberechnung für die Routinen MOND und SONNE mit simul- }
{ 6} { taner Darstellung der Ergebnisse }
{ 8} { Enthält alle Rechenroutinen für die genaue Sonnenberechnung }
{ 9} { Formeln nach DC9ZP }
{ 10} {$E+,N+}
{ 11} INTERFACE
{ 12} USES VARUNIT,ASTRO;
{ 13}
{ 14} TYPE REAL = EXTENDED; { Genauigkeit immer 19 Stellen }
{ 15} { Globale Variablen }
{ 16} PROCEDURE Rechnesonne;
{ 17} IMPLEMENTATION
{ 18} PROCEDURE Rechnesonne;
{ 19} BEGIN
{ 20} qth:='JO30VL'; { Hier eigenen QTH-LOC einsetzen }
{ 21} rechneqth(qth,eigenlaenge,eigenbreite); {QTH-LOC in geogr Koord }
{ 22} epoche := jultage(tag,monat,jahr);
{ 23} tagteil := (stunde+(minute+sekunde/60)/60)/24; {Bruchteil Tag }
{ 24} sonnenparameter(epoche+tagteil); { Aufruf Längenberechnung etc }
{ 25} Deklination := dekl(sonnlaenge,0,ekliptik); { Deklination }
{ 26} Rektaszension := rekt(sonnlaenge,0,deklination,ekliptik); {RA }
{ 27} Startime := sternzeit(epoche,tagteil); {Sternzeit }
{ 28} Stdwinkel := degr(startime-rektaszension); { Stundenwinkel }
{ 29} Ssp_breite := subbreite(deklination); {SubPkt Breite }
{ 30} Ssp_laenge:= sublaenge(startime,rektaszension); {SubpktLänge }
{ 31} Entfernung:= entf(eigenlaenge,eigenbreite,ssp_laenge,ssp_breite); {Entfer }
{ 32} Richtung := azimut(eigenlaenge,eigenbreite, ssp_laenge,ssp_breite);
{ 33} Elevation := elev(eigenlaenge,eigenbreite,ssp_laenge, { Elevation }
{ 34} ssp_breite,rv_sonne);
{ 35} END; { Ende Prozedur }
{ 36} BEGIN
{ 37} END.
3.5 Die VARUNIT
Sie enhält alle wichtigen mathematischen Routinen, wie Winkelfunktionen. Einzelheiten sind im Quelltext kommentiert.
{ 1} UNIT Varunit;
{ 2} {$n+,e+} { Coprozessor ein oder Emulation der doppelten }
{ 3} {Genauigkeit 1E-19 ein }
{ 4} {Diese UNIT enthält mathematische Funktionen und Prozeduren }
{ 5} { für DC9ZP-Programme }
{ 8} INTERFACE
{ 9} USES CRT,DOS;
{ 10} TYPE REAL = EXTENDED;
{ 11} CONST k0 = 180.0/PI; { Umwandlung Bogenmaß in Grad}
{ 12} g ='°';
{ 13} TYPE qthstr = STRING[6];
{ 14} str80 = STRING[80];
{ 15} VAR qth : qthstr;
{ 16} reg : registers;
{ 17} FUNCTION atn(x : REAL):REAL; { Öffentliche Funktionen und}
{ 18} FUNCTION tan(x : REAL):REAL; { Prozeduren}
{ 19} FUNCTION acs(x : REAL):REAL;
{ 20} FUNCTION asn(x : REAL):REAL;
{ 21} FUNCTION cosinus(x : REAL):REAL;
{ 22} FUNCTION sinus(x : REAL):REAL;
{ 23} FUNCTION power(x,y : REAL):REAL;
{ 24} FUNCTION log10(x : REAL):REAL;
{ 25} FUNCTION degr(x : REAL):REAL;
{ 26} FUNCTION sgn (x : REAL):INTEGER;
{ 27} FUNCTION Grad(x : REAL): STRING;
{ 28} FUNCTION f(x:REAL;x1,y1:BYTE):str80;
{ 29} PROCEDURE rechneqth(qth : qthstr; VAR laenge,breite :REAL);
{ 30} PROCEDURE Con;
{ 31} PROCEDURE Coff;
{ 32} PROCEDURE wr(x,y:INTEGER;xstr:str80);
{ 33} IMPLEMENTATION
{ 34} {Berechnung des Tangens in Grad}
{ 35} FUNCTION tan(x : REAL):REAL;
{ 36} BEGIN
{ 37} IF (x = 90.0) OR (x=270.0) THEN
{ 38} tan := 5729578.0 { Verhindern daß Überlauf bei 90.0 Grad }
{ 39} ELSE
{ 40} tan := (SIN(x/k0)/COS(x/k0));
{ 41} END;
{ 42} {Berechnung des ARCUS-Sinus in Grad}
{ 43} FUNCTION asn(x : REAL):REAL;
{ 44} BEGIN
{ 45} IF x>= 1 THEN { Überlauffalle}
{ 46} asn := 90.0
{ 47} ELSE
{ 48} IF x<= -1 THEN
{ 49} asn := -90.0
{ 50} ELSE
{ 51} asn := ARCTAN(x/SQRT(-x*x+1))*k0;
{ 52} END;
{ 53} {Berechnung des ARCUS-Cosinus}
{ 54} FUNCTION acs(x : REAL):REAL;
{ 55} BEGIN
{ 56} IF x>= 1 THEN acs := 0 { Überlauffalle}
{ 57} ELSE
{ 58} IF x<= -1 THEN acs := 180.0
{ 59} ELSE
{ 60} acs := (-ARCTAN(x/SQRT(-x*x+1))*k0+90.000);
{ 61} END;
{ 62} {Cosinus in Grad}
{ 63} FUNCTION cosinus(x : REAL):REAL;
{ 64} BEGIN
{ 65} cosinus := COS(x/k0);
{ 66} END;
{ 67} {Sinus in Grad}
{ 68} FUNCTION sinus(x : REAL):REAL;
{ 69} BEGIN
{ 70} sinus := SIN(x/k0);
{ 71} END;
{ 72} {Arcustangens in Grad}
{ 73} FUNCTION atn(x : REAL):REAL;
{ 74} BEGIN
{ 75} atn := ARCTAN(x)*k0;
{ 76} END;
{ 77} {Funktion x hoch y}
{ 78} FUNCTION power(x,y : REAL):REAL;
{ 79} BEGIN
{ 80} power := EXP(y*LN(x));
{ 81} END;
{ 82} FUNCTION log10(x : REAL):REAL; {Log 10 Funktion}
{ 83} BEGIN
{ 84} log10 := LN(x)/LN(10);
{ 85} END;
{ 86} {Reduzierung eines Winkels auf den Vollkreis 0..360 °}
{ 87} {wird immer aufgerufen, nachdem Winkel aufaddiert wurden }
{ 88} FUNCTION degr(x : REAL):REAL;
{ 89} VAR index : INTEGER;
{ 90} BEGIN
{ 91} IF x < 0 THEN
{ 92} index := 360 ELSE index:=0; {Negative Winkel gibt es nicht}
{ 93} degr := (x-(INT(x/360.0)*360.0))+index;
{ 94} END;
{ 95} { Ermittelt das Vorzeichen, wer kennt dies nicht von BASIC}
{ 96} FUNCTION sgn(x : REAL) : INTEGER;
{ 97} BEGIN
{ 98} sgn := 1;
{ 99} IF x < 0.0 THEN sgn := -1;
{100} END;
{101} { Berechnet aus einem QTH-LOC die geogr Länge und Breite }
{102} { Siehe dazu auch Teil D -QTH Kenner Algorithmen}
{103} PROCEDURE rechneqth (qth : qthstr; VAR laenge,breite :REAL);
{104} CONST asc = 65;
{105} VAR i : INTEGER;
{106} result : REAL;
{107} { Berechnet geogr Laenge -180° West .. 180 °Ost}
{108} FUNCTION laengeqth(x : qthstr):REAL;
{109} VAR x1,x3,x5 : INTEGER;
{110} BEGIN
{111} x1 := ORD(x[1])-asc;
{112} VAL(x[3],x3,i);
{113} x5 := ORD(x[5])-asc;
{114} result := x1*20-180+x3*2+x5/12;
{115} laengeqth := result;
{116} END;
{117} { Berechnet geogr Breite -90 ° Süd .. 90° Nord}
{118} FUNCTION breiteqth(x : qthstr):REAL;
{119} VAR x2,x4,x6 : INTEGER;
{120} BEGIN
{121} x2 := ORD(x[2])-asc;
{122} VAL(x[4],x4,i);
{123} x6 := ORD(x[6])-asc;
{124} result := x2*10-90+x4+x6/24;
{125} breiteqth := result;
{126} END;
{127} BEGIN { Beginn der Prozedur}
{128} FOR i := 1 TO 6 DO { Müssen Großbuchstaben sein !!}
{129} qth[i] := UPCASE(qth[i]); { Zur Vorsicht wird umgewandelt}
{130} laenge := laengeqth(qth);
{131} breite := breiteqth(qth);
{132} END; { Ende QTH-Kenner Berechnung}
{133} { Rechnet einen Winkel von Dezimal in Grad:Min:Sek um}
{134} FUNCTION Grad(x : REAL): STRING;
{135} CONST z =':';
{136} VAR xstr : STRING[8];
{137} FUNCTION Tostr(g : REAL): STRING; { Wandelt Zahlen in String}
{138} BEGIN
{139} STR(TRUNC(ABS(g)) : 0,xstr);
{140} IF LENGTH(xstr) < 2 THEN
{141} xstr :='0'+xstr;
{142} IF g < 0 THEN xstr :='-'+xstr;
{143} tostr := xstr;
{144} END;
{145} BEGIN
{146} x := x+0.5/3600;
{147} grad := tostr(x)+z+tostr(ABS(FRAC(x))*60.0)+z+
{148} tostr(ABS(FRAC(FRAC(x)*60)*60));
{149} END;
{150} {Formatiert / wandelt REAL-Variablen in STRING um}
{151} FUNCTION F(x:REAL;x1,y1:BYTE):str80;
{152} CONST s=' ';
{153} VAR xstr,ystr,astr:str80;
{154} BEGIN
{155} str(TRUNC(x):x1,ystr);str(FRAC(abs(x)):0:y1,xstr);
{156} DELETE(xstr,1,1);IF (TRUNC(x)=0) AND (FRAC(x)<0) THEN
{157} ystr := COPY(s,1,x1-2)+'-0';
{158} f := ystr+xstr;
{159} END;
{160} { Schaltet Cursor wieder ein}
{161} PROCEDURE Con;
{162} BEGIN
{163} reg.cx := 11 SHL 8;
{164} reg.cx := reg.cx OR 13;
{165} reg.ax := 1 SHL 8;
{166} INTR($10,reg);
{167} END;
{168} { Schaltet Cursor ab}
{169} PROCEDURE Coff;
{170} BEGIN
{171} reg.ax := $0100;
{172} reg.cx := $2607;
{173} INTR($10,reg);
{174} END;
{175} { Gibt TEXT an bestimmter Stelle aus}
{176} PROCEDURE wr(x,y:INTEGER;xstr:str80);
{177} BEGIN
{178} GOTOXY(x,y);WRITE(xstr);
{179} END;
{180} BEGIN { Start der UNIT}
{181} END. { Ende der UNIT}
4. Das Hauptprogramm SUN_MOON.PAS
Das Hauptprogramm ist einfach gehalten, es ruft nur noch wechselweise die entsprechenden Routinen zur Sonnen - und Mondberechnung entweder in Echtzeit, zeitsynchron zur Systemuhr des PC, oder für ein bestimmtes Datum auf. Die Ausgabe erfolgt dann nach dem nachstehenden Muster auf dem Bildschirm:
{ 1} PROGRAM SUN_MOON;
{ 3} {Lehr- und Lernprogramm zur MOND und Sonnenberechnung, M.Maday }
{ 4} {DC9ZP, (C) 2001 }
{ 5} { Echtzeitberechnung für die Routinen MOND und SONNE mit simul- }
{ 6} { taner Darstellung der Ergebnisse }
{ 7} {$e+,n+} { Doppelte Genauigkeit einschalten }
{ 8} {oder Emulation ein }
{ 9} USES CRT, { Die folgenden Units müssen eingebunden werden }
{ 10} DOS,
{ 11} ASTRO, { Enthält gemeinsame Routinen für beide Prog-Teile }
{ 12} MONDUNIT, { Mondberechnungsunit - Prozedur Rechneeme }
{ 13} Varunit, { Unit Varunit mit math.Routinen für beide Programme}
{ 14} SONNUNIT; { Sonnenberechnungsunit Prozedur Rechnesonne }
{ 15} TYPE REAL = EXTENDED; {Alle REAL Variablen werden mit 1E-19 }
{ 16} VAR ch : CHAR; { Genauigkeit berechnet }
{ 17} { Holt UTC und Datum von der Systemzeit }
{ 18} { Die Systemuhr muss unbedingt in UTC gestellt sein! }
{ 19} PROCEDURE Holezeit;
{ 20} VAR t,m,j,st,mn,
{ 21} sk,sk100,wt : WORD;
{ 22} BEGIN
{ 23} GETTIME(st,mn,sk,sk100);
{ 24} stunde:=st; minute:=mn; sekunde:=sk;
{ 25} GETDATE(j,m,t,wt);
{ 26} tag:=t; monat:=m; jahr:=j;
{ 27} END;
{ 28} PROCEDURE eingabe_datum;
{ 29} BEGIN
{ 30} CLRSCR;
{ 31} WR(15,3,' Sonnen- und Mondberechnung nach DC9ZP ');
{ 32} WR(10,6, ' Bitte Datum eingeben 1. Tag ');READLN(tag);
{ 33} WR(10,7, ' 2. Monat ');READLN(monat);
{ 34} WR(10,8,' 3. Jahr(JJJJ) ');READLN(Jahr);
{ 35} WR(10,9,' Bitte UTC eingeben 1. Stunde ');READLN(stunde);
{ 36} WR(10,10,' 2. Minute ');READLN(minute);
{ 37} WR(10,11,' 3. Sekunde ');READLN(sekunde);
{ 38} CLRSCR;
{ 39} Rechneeme;
{ 40} Ausgabe_mond;
{ 41} Rechnesonne;
{ 42} Ausgabe_sonne;
{ 43} WR(28,25,'Ende mit RETURN');
{ 44} READLN;
{ 45} CLRSCR;
{ 46} END;
{ 47} PROCEDURE Echtzeit;
{ 48} BEGIN
{ 49} Coff; { Cursor abschalten, er stört bei der Ausgabe }
{ 50} REPEAT
{ 51} Holezeit; { Datum /Uhrzeit in UTC holen }
{ 52} Rechneeme; { Erst Mond berechnen }
{ 53} Ausgabe_mond; { Dann Ergebnisse ausgeben }
{ 54} Rechnesonne; { Dann Sonne berechnen }
{ 55} Ausgabe_sonne; { Und hiermit die Ergebnisse ausgeben }
{ 56} WR(27,25,' Ende mit jederTaste ');
{ 57} UNTIL KEYPRESSED; { Abbruch wenn Taste gedrückt }
{ 58} CON; { Cursor wiederherstellen }
{ 59} END;
{ 60} BEGIN { Hier beginnt das Hauptprogramm }
{ 61} Textattr := 31; { Weiße Schrift auf blauem Grund }
{ 62} CLRSCR;
{ 63} REPEAT
{ 64} WR(6,15,'In Echtzeit (E) oder für ein Datum (D) berechnen ?');
{ 65} ch:=UPCASE(READKEY);
{ 66} UNTIL ch in ['E','D'];
{ 67} CLRSCR;
{ 68} IF ch = 'E' THEN echtzeit ELSE eingabe_datum;
{ 69} CON;
{ 70} CLRSCR;
{ 71} END. { Programmende }
6. Hinweise
Für die Echtzeitberechnung muss die PC-Systemuhr zwingend auf UTC eingestellt werden, die Ortszeit bringt falsche Ergebnisse.
Eine genauere Mondberechnung ( nach der sog. Brownschen Mondtheorie ), mit implementierter Rotorsteuerung- speziell für EME-Freunde - ist seit Olims Zeiten im Satellitendienstprogramm [2] enthalten, wer die Sonne noch genauer als hier vorgestellt berechnen will, dem steht mit dem Sonnendienstprogramm [3] ebenfalls ein gutes Werkzeug zur Verfügung. Damit kommen auch Nichtprogrammierer zu ihrem Recht.
7. Literatur/Anmerkungen
[1] Maday, Manfred, DC9ZP "Grundlagen und Software für die Bahnberechnung von Satelliten", Marburg 1995 (beam-Verlag)
[2] Satellitendienstprogramm DC9ZP AMSAT-DL Warenvertrieb Artikel #103.
[3] Sonnendienstprogramm DC9ZP AMSAT-DL Warenvertrieb.
Bearbeitungstand dieser Seite : 21.03.08
