Astronomie und Satelliten

©   DC9ZP 2001

Inhaltsverzeichnis

Ortszeit und Weltzeit 

Sternzeit

Dynamische Zeit

Programm ZEIT.PAS

Literatur zum Thema Zeit

Satelliten und astronomischer Kalender

Astronomische und geschichtliche Grundlagen

Die Julianische Tageszahl

Der AMSAT Tag

Umkehrfunktionen 

Wochentag berechnen

Tagesdifferenzen

Ostern berechnen

Programmlisting Kalender.pas

Programm AFUKAL.EXE

Literatur zum Thema Kalender

Satellitenbahnberechnung

Satellitensoftware

Satellitenliteratur

Aktuelle Bahndaten AO-40

Funkbetrieb

I  Ortszeit, Weltzeit, Sternzeit und Dynamische Zeit

Dank Einstein wissen wir, dass die Zeit jeweils nur in einem bestimmten Bezugssystem gilt. Ob dies der Grund für die verwirrende Vielfalt der Zeitbegriffe in der Astronomie ist, sei dahingestellt.

Die nachfolgenden Ausführungen  versuchen die verschiedenen Begriffe der Zeit zu ordnen und so zu erklären, dass auch der astronomisch unbedarfte Laie eine Vorstellung von den Zusammenhängen erhält. Dabei kommt es natürlich darauf an, den Kontext zur Satellitenbahnberechnung zu wahren. 

Unser bürgerlicher Zeitbegriff wird bestimmt von der Erddrehung, die mit der Sonne für den Wechsel von Tag und Nacht, Aufstehen und Ruhen, Arbeit und Freizeit sorgt.

Die Erde dreht sich in 24 Stunden einmal um sich selbst, die Länge des Tages ist damit seit alters her vorherbestimmt. Der scheinbare Lauf der Sonne um die Erde und die Erddrehung sind jedoch nicht gleichmäßig, es gibt Schwankungen und Veränderungen des irdischen Uhrtaktes. Die Zeit soll aber nach Möglichkeit über Jahrtausende stabil bleiben; es sind daher einige Kunstgriffe notwendig.

Wenn man an einem bestimmten Ort wohnt, dann geht die Sonne im Prinzip jedes Jahr am gleichen Datum zur gleichen Uhrzeit auf.

Die unterschiedliche Dauer des Tageslichts an einem Ort im Laufe eines Jahres, hat dagegen nichts mit der Erdumdrehung zu tun, sondern mit der Tatsache, dass die Erdachse ca. 23 Grad zur Sonnenbahn geneigt ist. Diese Schiefe der Ekliptik bewirkt, dass im Laufe des Jahres mal die Nord - und mal die Südhalbkugel mit längerem Sonnenschein beaufschlagt wird. Nur bei Frühlings- und Herbstanfang ist die Tageslichtdauer für Orte auf der Süd- und Nordhalbkugel immer gleichlang. Da die Bahnneigung der Erde periodischen Schwankungen, der sog. Nutation , unterliegt gibt es auch hier Unterschiede.

Es ist Mittag an einem Ort, wenn die Sonne ihren Kulminationspunkt erreicht hat. Da man aber zwischen wahrer Sonne und der fiktiven mittleren Sonne unterscheidet, verschiebt sich die Kulmination der Sonne um einen bestimmten Betrag, der durch die sog. Zeitgleichung ausgedrückt wird. Die Kulmination der physischen Sonne findet daher nicht streng immer um 12.00 Uhr Ortszeit auf der geographischen Länge des jeweiligen Mittelmeridians statt. Man bezeichnet als wahren Mittag den Zeitpunkt bei der die wahre Sonne durch den Meridian geht, der mittlere Mittag ist der Durchgang der fiktiven Sonne.

Der Unterschied zwischen wahrer- und mittlerer Sonne liegt u.a. in der Exzentrizität der Erdbahn begründet. Die Erde läuft nicht gleichmäßig um die Sonne herum sondern mit unterschiedlicher Geschwindigkeit, so dass die Tage je nach Stellung auf der Bahn unterschiedlich lang sein können. Um dies zu vermeiden und um besser rechnen zu können, wird als mittlere Sonne die Stellung der Sonne bezeichnet, die bei einem gleichmäßigen Erdumlauf erreicht würde, vergleichbar also mit der Mittleren Anomalie eines Satelliten auf einer elliptischen Bahn. Zeitangaben beziehen sich somit immer auf die mittlere Sonne.

Die Zeitgleichung ist nichts weiter als der Unterschiedsbetrag zwischen der Stellung der physischen (wahren) Sonne und der fiktiven Berechnung, sie ist abhängig von der Jahreszeit und erreicht zur Zeit im Februar einen Minimalwert ( -14.4 min), im Mai ca. +3.8 min, einen erneuten Absturz im Juli auf -6.4 min und den höchsten Wert im November mit +16.4 min. Die Zeitgleichung ist langfristig von der Entwicklung der Exzentrizität der Erdbahn sowie von Bahnstörungen durch Mond und Planeten abhängig, kurzfristige Schwankungen ergeben sich wieder infolge der Oszillation der Erdachse, der Nutation.

Sie berechnet sich aus :

Dabei sind L₀ die mittlere Länge der Sonne, a ist die Rektaszension, Dy die Nutation der Erdachse in der Länge, und e ist der aktuelle Wert der Schiefe der Ekliptik. Ich gehe an dieser Stelle nicht näher auf Sonnenberechnungen ein, da diese in [6] bereits vorgestellt wurden und mit [7] mittlerweile ein Programm beim AMSAT-DL Warenvertrieb abrufbar ist, das alle Berechnungen mit hoher Genauigkeit beinhaltet.

Die Ortszeit ist allein abhängig von der geographischen Länge des Ortes. Jeder Ort mit unterschiedlicher geographischer Länge erlebt die Kulmination der Sonne - gemessen an einer Referenzzeit - zu unterschiedlichen Zeiten oder anders herum ausgedrückt : jeder Ort mit gleicher geographischer Länge erlebt die Kulmination zur gleichen Zeit.

Diese Referenzzeit ist die Zeit der mittleren Sonne des geographischen Längengrades 0 (Greenwich), sie wird als Weltzeit, oder Universal Time (UT) bezeichnet.

Die Uhrzeit, die wir im Alltag - auch als Zeitangabe auf der QSL-Karte - verwenden, leitet sich aus der koordinierten Weltzeit, der UTC ( U niversal T ime C oordinated) ab. Die UTC wird - wie die später behandelte Dynamische Zeit - von Atomuhren abgelesen, aber durch Einlegen von Schaltsekunden bis zu 2 mal im Jahr so mit der UT koordiniert, dass sie nicht mehr als 0.9 Sekunden von ihr abweicht.

                UTC = UT ± 0.9 Sek .

Damit nicht jeder kleine Ort seine eigene Ortszeit definiert, wurde - von der UTC und dem Längengrad 0 ausgehend - die Welt in 24 Zeitzonen mit einer Breite von je 15 Längengraden eingeteilt. Der Grund dafür ist durch einfaches Rechnen nachzuvollziehen:

360 Längengrade der Erde entsprechen 24 Stunden des Tages, also rechnet man

            Zeitzonenbreite = 360 Grad / 24 = 15 Grad .

Eine Zeitstunde entspricht also 15 Längengraden, die Erde dreht sich somit pro Stunde um 15 Grad nach Westen.

Orte, die ostwärts von Greenwich liegen, also bis zum 180. Längengrad Ost, haben den Sonnenaufgang früher als UTC, Orte westlich von Greenwich dem entsprechend später. Die größte Zeitdifferenz zu UTC nach Osten oder Westen kann 12 Stunden nicht überschreiten

Die Zeitzonenrechnung beginnt im Prinzip bei 0 Grad Länge Ost in Richtung Osten und endet wieder bei 0 Grad Länge West im Westen., wobei der 15 Grad Abschnitt jeweils der Mittelmeridian einer Zeitzone ist.

Zur Vereinfachung hat man die Zeitzonen mit Buchstaben versehen, sie also mit A .. Z bezeichnet. Schlaue Leser werden jetzt einwenden, dass das Alphabet 26 Buchstaben hat, die Erde aber nur 24 Zeitzonen. Das ist richtig bemerkt, aber man hat bei der Zeitzonenbezeichnung die Buchstaben I und O wegen der Verwechslungsgefahr mit 1 und 0 ausgelassen, so dass die Rechnung wieder stimmt.

Deutschland liegt demnach in Zeitzone A, hat also ALPHA-Zeit = Mitteleuropäische Zeit (MEZ). Griechenland hat z.B. BRAVO-Zeit und Großbritannien liegt in Zeitzone Z = ZULU-ZEIT. Während der Sommerzeit begibt sich unser Land demnach freiwillig in die B-Zone.

Die Z-Zeit entspricht wieder unserer Weltzeit UTC, früher auch Greenwich-Mean-Time (GMT) genannt. Die Buchstabenbezeichnung der Zeitzonen ist im übrigen eine Erfindung der NATO der 50-er Jahre, sie hat sich aber mittlerweile allgemein etabliert.

In der Praxis wird die Zeitzoneneinteilung nicht strikt eingehalten, es gibt eine ganze Reihe lokaler Lösungen, um z.B. sicher zu stellen, dass Länder, die sich über mehrere Zeitzonen erstrecken, nach Möglichkeit keine, oder nur wenig unterschiedliche Zeiten haben. Wenn man Zeitzonen berechnen - und dieses in einem Algorithmus ausdrücken will - kommt man nicht umhin, diese Sonderlösungen einzeln zu berücksichtigen. So hat zum Beispiel Neufundland eine Ortszeit, die um 30 Minuten von der Zonenzeit abweicht, ähnliche Regelungen gelten für Teile von Australien.

Auch die Sommerzeiten in verschiedenen Ländern - in den USA als Daylight saving time bezeichnet - sind lokale Lösungen, die dazu noch zeitlich begrenzt sind.

Einen generellen Algorithmus ohne Berücksichtigung von Sonderregelungen kann man wie folgt formulieren :

INT ist dabei das ganzahlige (Integer) Ergebnis der Rechnung. Wenn das Ergebnis - die Zeitzone also - negativ ist, dann muss es noch verbessert werden mit

If Zeitzone < 0 then Zeitzone = Zeitzone + 24 und weiter

If Zeitzone = 0 then Zeitzone = 24.

Als Länge setzt man die geographische Länge des Ortes( s. Abb.2) ein, wobei die Koordinatenvorzeichen nach den Regeln der Internationalen Astronomischen Union (IAU) wie folgt festgelegt sind:

Längengrade von 0° - 180° WEST mit negativem Vorzeichen

Längengrade von 0° - 180° OST ohne Vorzeichen

Breitengrade von 0° - 90° NORD ohne Vorzeichen

Breitengrade von 0° - 90° SÜD mit negativem Vorzeichen

 

Das Ergebnis der Formel 1 ist ein ganzzahliger Wert im Bereich von 1 .. 24, den man z.B. in einem Programm über einen Index in den Zonenzeitbuchstaben umwandeln kann:

Im Beispielprogramm wird dies durch die Funktion "Zonenbuchstabe" erledigt. Die Berechnung der Zeitzone erfolgt in der Funktion "Zone".

Um die Ortszeit ( Zonenzeit) eines QTH aus der UTC zu ermitteln rechnet man :

                Ortszeit = UTC + Zeitzone für Orte ostwärts von Greenwich und

                Ortszeit = UTC - (24-Zeitzone) für Orte westlich von Greenwich .

Als Zeitzone setzt man dabei das numerische Ergebnis aus Formel 1 ein.

Dreht man die Formel um, dann berechnet man die UTC aus der Zonenzeit mit

                UTC = Ortszeit - Zeitzone für Orte ostwärts von Greenwich und

                UTC= Ortszeit + (24-Zeitzone) für Orte westlich von Greenwich.

Auch hier wird als Zeitzone das numerische Ergebnis aus Formel 1 eingesetzt. Bei beiden Formeln muss man darauf achten, dass man, wenn die Ergebnisse über 24 Std. liegen, 24 Std. abziehen muss und dass bei negativen Werten 24 Std. addiert werden müssen. Die Berechnungen sind im Programm in den Prozeduren UTC_in_Ortszeit und Ortszeit_in_UTC abgebildet und können dort noch einmal nachvollzogen werden.

Bei der Berechnung der Bahn eines Satelliten werden die bahnbestimmenden Elemente - ausgehend von einem auf UTC bezogenen Keplerdatensatz - für eine bestimmte Weltzeit berechnet. Die Umrechnung auf die Ortszeit des eigenen QTH kann mit den vorgestellten Formeln erfolgen, wobei dann evtl. noch die Sommerzeit zu berücksichtigen ist.

Darüber hinaus ist die Kenntnis der Ortszeit für einen bestimmten Punkt der Erde von Nutzen, denn es kann für das Zustandekommen einer Verbindung mit einer seltenen DX-Station wertvoll sein deren Ortszeit zu wissen. Mitten in deren Nacht wird man sie nicht antreffen. Die laufende oder wahlweise Anzeige der jeweiligen Ortszeit im Bahnberechnungsprogramm ist daher sinnvoll; dabei spielt es keine große Rolle ob die Station dann Sommerzeit hat, oder in einer Gegend mit krummer Zonenzeit zu Hause ist. Als Anhalt ist die Rechnung auf jeden Fall geeignet.

Als Sternzeit bezeichnet man den Winkel des Nullmeridians der Erde - also wieder Greenwich- zum Frühlingspunkt des Himmelsgewölbes. Das Widderzeichen ^ für den Frühlingspunkt stammt aus einer Zeit, als dieser im Sternbild Widder lag, also vor ca. 2000 Jahren. Der Frühlingspunkt ist der Ursprung für die astronomischen Koordinaten Rektaszension und Deklination. Er liegt zur Zeit am Westrand des Sternbildes Fische und ist der Punkt an dem die Sonne zu Frühlingsbeginn den Himmelsäquator nach Norden überschreitet. Die folgenden Abbildungen stellen Einzelheiten des Sterntages heraus und zeigen die Sternzeit in Verbindung mit Greenwich.

Der Sonnentag ist definiert als der Zeitabstand zwischen zwei Meridiandurchgängen der mittleren Sonne. Er beträgt wie eingangs festgestellt, 24 Stunden. Der Sterntag dagegen ist der zeitliche Abstand zwischen zwei Kulminationen des Frühlingspunktes. Wie aus Abb. 4 ersichtlich, ist der Sonnentag ca. 4 Minuten länger, weil sich die Erde im Laufe eines Tages um ca. 1 Grad auf ihrer Bahn weiter bewegt und, um die gleiche Stellung zur Sonne zu erreichen wie vorher, sich noch ein Stückchen weiter drehen muss. Im Vergleich zum unendlich entfernten Frühlingspunkt, wirkt sich die Bewegung der Erde jedoch nicht aus, so dass der Sterntag kürzer ist. Sternzeit und Sonnenzeit müssen daher zwangsläufig unterschiedlich sein, bedingen sich aber gegenseitig, da beide ihren Ursprung in der Erddrehung haben.

Durch die Präzession der Erdachse verschiebt sich der ^ um ca. 50.29 Winkelsekunden pro Jahr in Richtung Westen. Der volle Umlauf beträgt demnach 25850 Jahre - ein sog. Platonisches Jahr - und bewirkt u.a. die Verlagerung des Himmelspols vom derzeitigen Polarstern auf den Stern Wega in der Leier im Jahre 14000. Da sich das Bezugsystem für die Sternzeit allmählich ändert, muss dies für genaue Berechnungen natürlich berücksichtigt werden. Die Präzession steht für die säkulare- also langfristige- Verlagerung der Erdachse, unter Nutation versteht man Auslenkungen der Erdachse mit periodischer Natur, die überwiegend durch den Mond verursacht werden. Der Einfluß der Nutation auf die Sternzeit ist gering, sie muss nur bei sehr genauen Rechnungen berücksichtigt werden.

Der folgende Algorithmus fußt auf Empfehlungen der IAU, er ist also sozusagen offiziell und eignet sich für genaue Berechnungen der Sternzeit für die nächsten 1000 Jahre für jeweils 0.00 UTC jeden beliebigen Tages.

Dabei steht T für die aus der Julianischen Tageszahl (Julian Day = JD) berechneten Julianischen Jahrhunderte :

Im Beispielprogramm ist diese Formel in der Funktion Sternzeit enthalten. Das Ergebnis der Rechnung ist die Sternzeit um 0.00 UT des jeweiligen Julianischen Tages in Grad. Das Resultat muss noch auf den Vollkreis reduziert werden, soweit es über 360 Grad liegt.

Wie man aus einem gegebenen Kalenderdatum die Julianische Tageszahl errechnet, ergibt sich aus dem nachfolgenden Artikel, deshalb gehe ich hier nicht mehr darauf ein. Im Beispielprogram ist die Funktion "Jultage" noch einmal abgebildet. Die Formel kann auch für den AMSAT-Tag (AD) benutzt werden.

Da AD = JD - 2 443 509.5 ist, wird anstelle des JD in Formel 5.1

eingesetzt

Da sich, wie bereits erwähnt, durch die Nutation der Erdachse in der Länge - D y - die Sternzeit periodisch ändert, muss für noch genauere Berechnungen auch dieser Wert berücksichtigt werden. Er liegt im Bereich von maximal 17 Winkelsekunden:

Dabei ist e der aktuelle Wert der Schiefe der Ekliptik, auch diese variiert durch die Nutation mit einer Amplitude von 9 Winkelsekunden. Die Berechnungen sind im übrigen in [7] und [8] enthalten und können dort an praktischen Beispielen nachempfunden werden.

In der Astronomie wird die Formel auch dazu verwendet, die UT zu bestimmen. Denn es ist an einem bestimmten Tag 0.00 UT, wenn die Sternzeit den mit Formel 5 berechneten Wert erreicht. Die Weltzeit ist somit eine Funktion der Sternzeit, sie spiegelt die Drehung der Erde direkt wieder.

In der Satellitenbahnberechnung ist die Sternzeit ein Vehikel zur Koordinatenumwandlung in astronomische Koordinaten und dient u.a. dazu, den Satellitenort im Weltraum auf die Erdoberfläche abzuloten und dann den Sub-Satellitenpunkt der geographischen Länge nach zu bestimmen. Routinen dazu sind in [2] und [3] vorgestellt worden.

Da sich die Erddrehung ändert - und dies leider unregelmäßig - eignen sich die auf ihr basierenden Zeitmessungen nicht für alle astrophysikalischen Zwecke. Hier muss ein Zeitnormal herhalten, dass Berechnungen mit einem gleichmäßigen Zeitmaß über Millionen von Jahren ermöglicht.

Dieses Zeitmaß bezeichnet man als Dynamische Zeit (TD). Eine Sekunde der dynamischen Zeit wird definiert über die Periodenzahl eines bestimmten Übergangs im Cäsium-Atom und wird mit Atomuhren gemessen.

Die dynamische Zeit ersetzt seit 1984 die bis zu diesem Zeit gebräuchliche Ephemeridenzeit (ET), die aus der Stellung der Himmelskörper des Sonnensystems abgeleitet wurde.

Der Grund für die Einführung der TD lag auch in der Erkenntnis der Relativitätstheorie, nach der es keine universelle Zeit gibt und dass damit der Ablauf der Zeit vom Ort und von der Bewegung des jeweiligen Bezugssystems abhängen.

Daher unterscheidet man bei der TD zwischen einer erdbezogenen ( t errestrischen) dynamischen Zeit (TD T ) und einer dynamischen Zeit (TD B ), die sich auf den Schwerpunkt - das B aryzentrum - des Sonnensystems bezieht. Die Differenz beider Zeiten kann aufgrund der relativistischen Effekte bis zu 0.0017 Sekunden betragen.

Die Differenz der TD zur Weltzeit UT - Formelzeichen DT - kann man im Prinzip nicht exakt vorausbestimmen, sondern nur nachträglich feststellen. Sie betrug für 1999 +64 Sekunden und man rechnet mit + 80 Sekunden im Jahre 2010. DT wächst gegenwärtig um ca. 0.5 bis 1.0 Sek pro Jahr, ein sicheres Zeichen dafür, dass sich die Erddrehung verlangsamt. Daraus leitet sich allerdings keine Gesetzmäßigkeit ab; es gab in der Vergangenheit erhebliche Schwankungen.

Für die Bahnberechnung der Amateurfunksatelliten spielt die TD, wegen der relativen Kurzlebigkeit der Objekte, keine große Rolle. Die Verwendung von aktuellen Keplerdatensätzen ist wichtiger, da diese in dieser Hinsicht korrigiert sind. Dagegen werden die Ephemeriden von Sonne, Mond und Planeten immer auf der Basis der TD berechnet. In Satellitenprogrammen, die beides können [vgl. 8], ist die Einbeziehung von DT daher notwendig

In der Praxis schlägt man DT dem für eine Berechnung maßgeblichen Julianischen Tag zu.

Das Ergebnis ist der sogenannte Julianische Ephemeridentag (JDE), also der um DT korrigierte Julianische UT-Tag (JD). Das gleiche ist auch mit dem AMSAT-Tag möglich, das ergibt dann

Da DT in Sekunden ausgedrückt ist, muss die oben angeführte Umrechnung in eine Tagesangabe erfolgen, indem man DT durch die Anzahl der Sekunden eines Tages (86400) teilt. Für 1999 ergibt das den Wert von 64/86400 = + 0.000740741 Tage. Da in der Astronomie in der Regel in Julianischen Jahrhunderten gerechnet wird ( siehe Formel 5), wird der Betrag in konkreten Programmen noch einmal durch 36525.0 geteilt.

Aus der Kleinheit der Zahlen erkennt man, dass in der Astronomie das Rechnen mit nur acht Stellen nach dem Komma, so wie es viele Satellitenprogramme machen, vollkommen unmöglich ist, weil erhebliche Fehler entstehen können. Das Rechnen mit mindestens 12-14, noch besser mit 18-20 Stellen ist unabdingbar.

Die Differenz UT zu TD kann man überschlägig selbst feststellen, indem man mit einem Programm, das auf UT-Basis rechnet, den Zeitpunkt einer Sternbedeckung durch den Mond vorausbestimmt und dann durch physische Beobachtung den wahren Zeitpunkt feststellt. Die Differenz der Zeiten ist DT.

Insgesamt merke man sich die astronomische Faustregel, dass die Weltzeit (UT) der Bestimmung der Sternzeit - und die Dynamische Zeit (TD) zur Berechnung der Sonnen-, Mond- und Planetenephemeriden dient. Der an Astronomie Interessierte sollte dazu auch die Hinweise in den einschlägigen Himmelsjahrbüchern [vgl. 5] beachten.

4. Literatur zum Thema Zeit

[1] Maday, Manfred "Satelliten und astronomischer Kalender " in AMSAT-DL Journal 2/99

[2] Manfred Maday, DC9ZP,"Amateurfunksatelliten, Übersicht, Berechnung und Software" PDF-Buch vom Autor beziehbar, Köln Oktober 2001.

[3] Maday, Manfred "Sternzeit berechnen " in AMSAT-DL-Journal 3/96

[4] Meeus, Jean , "Astronomical Algorithms", Richmond, Virginia 1991

[5] z.B. "Ahnerts Kalender für Sternfreunde", erscheint jährlich im J.A. Barth Verlag Heidelberg-Leipzig

[6] Maday, Manfred "Satelliten im Erdschatten", AMSAT-DL Journal 2/98

[7] AMSAT-DL Warenvertrieb : Sonnendienstprogramm DC9ZP

[8] AMSAT-DL Warenvertrieb : Satellitendienstprogramm DC9ZP

Gelegentlich ist es sinnvoll, sich der Satellitenbahnberechnung nicht direkt sondern über den mühevollen Weg der Grundlagenerarbeitung zu nähern. Dazu soll der folgende Exkurs über den astronomischen Kalender dienen, der als eine Grundlage der irdischen Betrachtungsweise der Zeit auch die Bahn eines Satelliten bestimmt.

Wer sich mit astronomischen Objekten beschäftigt, seien es Satelliten, Planeten oder Fixsterne, wird sich früher oder später mit Kalenderroutinen auseinandersetzen müssen, die ihn bei der Berechnung von Bahnepochen durch Umrechnung von einem Kalenderdatum auf einen numerischen Wert unterstützen.

Satellitenfreunden ist bereits der legendäre AMSAT-Tag bekannt. Er ist kein Mysterium und auch kein AMSAT-Denkmal, sondern nichts weiter als eine Hilfsgröße zur Ermittlung und zum Vergleich von Satellitenepochen. Sein kalendarischer Ursprung ist der 1.1.1978

Astronomen denken in langen Zeiträumen, weil ihre Objekte naturgemäß langlebiger als Satelliten sind; sie haben daher zur Berechnung von Epochen eine Reihe von Algorithmen entwickelt, die für einige tausend Jahre gelten. Einige davon stelle ich vor, weil sie für unsere Zwecke nützlich sind.

2.  Astronomische und geschichtliche Grundlagen

Die wichtigsten astronomischen Grundlagen unseres heutigen Kalenders sind die Erddrehung, bestimmend für die Länge des Tages und die Bahn der Erde um die Sonne, maßgeblich für die Länge des Jahres.

2.1 Mond und Monat

Der Mond gab nicht nur dem Monat seinen Namen, er sorgte auch lange Zeit für seine Länge von ca. 29-30 Tagen, die sich aus einer Erdumkreisung, dem sog. synodischen Monat ergab. Aus dem Mondkalender ergab sich für 12 Mondmonate eine Jahreslänge von 354.367 Tagen. In der moslemischen Welt wird noch heute danach gerechnet, wobei der Ursprung der Jahreszählung das Jahr 622 n. Chr. ist.

Die Griechen ( ab 7. Jh v. Chr.) hatten einen gebundenen Mondkalender, d.h. das Mondjahr wurde gelegentlich durch die Einschaltung von ganzen Monaten mit dem Sonnenjahr synchronisiert. (8 Sonnenjahre = 99 Mond-Monate, ergeben also 3 Schaltmonate).

2.2. Die 7-Tage Woche

Unsere heutige Einteilung der Woche in sieben Tage ist keine astronomische Notwendigkeit, sondern eine rein menschliche Erfindung. Sie stammt ursprünglich aus Mesopotamien, weil die alten Babylonier sieben bewegte Himmelskörper unterscheiden konnten: Sonne und Mond sowie die Planeten Merkur, Mars, Venus, Jupiter und Saturn. Die Juden übernahmen diese Wocheneinteilung und vermittelten sie über das Christentum den Römern. Der römische Kaiser Konstantin führte die uns heute bekannte Wocheneinteilung im Jahre 321 n.Chr. endgültig in seinem Reich ein.

Um den Streit zu entschärfen, welcher Tag der Woche denn der erste sei, der Sonntag oder der Montag, kann ich nur auf die Bibel verweisen. Dort steht man soll am 7. Tage ruhen. Da wir uns für den Sonntag als Ruhetag entschieden haben, ist also der Sonntag der letzte Tag der Woche. Oder haben die Juden recht, die den Samstag als Ruhetag feiern und somit den Sonntag als ersten Tag der Woche ansehen ?

2.3 Sonnen - und Mondjahr

Die alten Ägypter - verifiziert ab dem 19.Juli 4241 v.Chr. - waren wahrscheinlich die ersten, die das Mondjahr verließen und sich nach dem Sonnenjahr richteten, weil sie danach das Eintreffen der großen Nilflut besser berechnen konnten. Diese fand jährlich dann statt, wenn der Sirius im Sternbild Großer Hund aufging. Unsere heutigen kalendarischen Hundstage sowie der Name Hundsstern für den Sirius, sind aus diesem Grunde überliefert. Das ägyptische Sonnenjahr hatte 365 Tage und einige Korrekturtage, der Kalender führte aber im Laufe der Zeit zu einem erheblichen Fehler.

Die Umlaufzeit der Erde um die Sonne beträgt zur Zeit 365.2422 Tage. Um die Tage des Jahres diesem krummen Wert anzupassen sind in der Vergangenheit immer wieder Anstrengungen mit unterschiedlichem Erfolg unternommen worden.

2.4 Der römische Kalender

Im römischen Imperium sorgte Julius Cäsar 45 v. Chr. dafür, dass der Kalender grundlegend neu berechnet wurde, da nach dem alten (ägyptischen) Kalender mittlerweile der Januar in den Herbst fiel. Der ägyptische Astronom Sosigenes erstellte im Auftrag Cäsars den " Julianischen Kalender " der in Zukunft für das Jahr zwar wieder eine Länge von 365 Tagen vorsah, aber zusätzlich alle 4 Jahre einen Schalttag als 366. Tag einfügte. Zu Ehren Cäsars wurde der Monat Quintilis in Julius (unser heutiger Juli) umbenannt. Die Monate wurden in der Länge dem Sonnenjahr angepasst und waren entweder 30 oder 31 Tage lang der Februar hatte 29 Tage und nur im Schaltjahr 30 Tage.

Kaiser Augustus ließ den Kalender im Jahre 8 n.Chr. überarbeiten, da unter Cäsar, obwohl nur im vierjährigen Abstand ein Schaltjahr folgen sollte, bei der Umsetzung der Regel irrtümlicherweise alle drei Jahre ein Schaltjahr gezählt worden war. Dieser Fehler wurde bereinigt. Zu Ehren des Augustus wurde dann der Monat nach Cäsars Monat, der Sextilis , Augustus genannt. Da dieser ursprünglich nur 30 Tage hatte, verfügte Augustus aus Eifersucht auf Cäsars 31-tägigen Monat, dass der August zu Lasten des Februar einen weiteren Tag zu erhalten habe. Dies erklärt den Bruch in der Systematik des Wechsels zwischen 30 und 31 Tagen beim Juli und August und auch den 28-tägigen Februar. Eine mathematische Notwendigkeit für diesen Kunstgriff gab es nicht.

Die durch den Julianischen Kalender erzielte Genauigkeit lag bei +11 Minuten im Jahr, d.h. das Römische Jahr war um 11 Minuten zu lang und im Laufe der Jahrhunderte addierten sich diese Differenzen zu mehreren Tagen auf.

2.5 Kalender der Neuzeit

Im Jahre 1582 war dieser Fehler auf 10 Tage angewachsen und gab Papst Gregor XIII den Grund für eine umfassende Kalenderreform, die er durch eine Kommission, gebildet aus Astronomen und Mathematikern, erarbeiten ließ. Das Ergebnis war, dass man die Schaltjahresregel so änderte, dass man zwar weiterhin alle 4 Jahre ein Schaltjahr mit 366 Tagen einfügte, bei vollen Jahrhunderten, die nicht durch 400 teilbar waren fiel das Schaltjahr jedoch aus. Das ergab in einem Zeitraum von 400 Jahren exakt 97 Schaltjahre.

Dadurch näherte sich die Länge eines Jahres mit etwa 365 + 97/400 = 365.2425 dem tatsächlichen Wert eines Umlaufs um die Sonne so an, dass erst im Jahr 3300 eine Korrektur notwendig wird. Die durch den Fehler des Römischen Kalenders überflüssigen 10 Tage, beseitigte man durch den Kunstgriff, dass man auf den 4. Oktober 1582 unmittelbar den 15. Oktober folgen ließ. Der Termin wurde bewusst gewählt weil just in diesem Zeitraum kein kirchlicher Feiertag lag.

Da der Kalender nicht staatlichem Handeln entsprang sondern kirchliches (katholisches) Recht war, machten nicht alle christlichen Länder die Umstellung vom Julianischen - auf den Gregorianischen Kalender sofort mit. Die evangelischen Länder Deutschlands stellten erst zum 1.3.1700 um. England folgte 1752, Russland schloss sich erst 1918 der Neuregelung an. Geschichtliche Datierungen in diesen Ländern vor diesem Zeitpunkt sind also mit Vorsicht zu genießen. Insgesamt setzte sich aber das GK-Konzept in der Geschichte durch.

Der Gregorianische Kalender wurde außerhalb Europas von Japan (1873), China (1949) und der Türkei (1916) angenommen.

Die Griechisch-Orthodoxe Kirche nutzt einen verbesserten GK (vom 14.10.1923), der eine geringfügig andere Schaltjahresregelung enthält, und zwar sind Jahrhunderte nur dann Schaltjahre, wenn ihre Division durch 9 den Rest 2 oder 6 ergibt. Dadurch kommt man exakt auf eine Jahreslänge von 365.2422 Tagen und erspart sich somit die im GK im 4. Jahrtausend fällige Korrektur. Nachprüfen kann man das mit dem Jahr 2800. Im GK ist dieses Jahr ein Schaltjahr, da durch 400 teilbar, der Divisionsrest von 2800/9 ergibt jedoch 1, damit ist dieses Jahr im Griechisch-Orthodoxen Kalender kein Schaltjahr.

3. Die Julianische Tageszahl

Der Julianische Tag (JD) ist die fortlaufende Zählung von Tagen und deren Bruchteilen vom Beginn des Jahres 4713 v. Chr. (-4712) an. Der Julianische Tag beginnt traditionell um 12.00 UTC, die Schreibweise für einen beliebigen Tag um 0.00 UTC hat also immer eine Dezimalstelle nach dem Komma.

Zum Beispiel, der

1. Januar 2000 um 0.00 UTC hat den JD von  2451 544.5

1. Januar 2000 um 12.00 UTC hat den JD von   2451 545.0

1. Januar 2000 um 18.00 UTC hat den JD von 2451 545.25

1. Januar -4712 um 12.00 UTC hat natürlich den JD von 0.0

 

Der Julianische Tag geht auf den Chronologen Joseph Justus Scaliger ( 1540-1609) zurück, der das von ihm entwickelte Verfahren zu Ehren seines Vater Julius benannte und ist nicht zu verwechseln mit dem Julianischen Kalender der, wie bereits ausgeführt, unter Julius Cäsar im Römischen Reich eingeführt und durch Kaiser Augustus im Jahre 8 n.Chr. modifiziert wurde.

Für die Berechnung des JD aus einem Kalenderdatum gibt es einen in der Astronomie allgemein anerkannten Algorithmus[1] den ich den nachfolgenden Programmen in der Funktion "Jultage" (Zle57) verwendet habe.

Um das Rechnen mit großen Zahlen zu vermeiden, ist noch der " Modifizierte Julianische Tag" (MJD) gebräuchlich, der seinen Ursprung am 17.11.1885 hat und aus dem JD ermittelt wird mit

Ich werde auf den MJD nicht weiter eingehen, weil das Rechnen mit großen Zahlen im Zeitalter der 64-Bit-Prozessoren kein Problem mehr ist und wir außerdem mit dem AMSAT-Tag eine wesentlich praktischere Möglichkeit eingeführt haben.

Der Algorithmus gilt sowohl für den derzeit aktuellen Gregorianischen Kalender (GK) als auch für den Julianischen Kalender (JK) der bis zum 04.10.1582 gebräuchlich war. Da auf den 04.10.1582 im JK der 15.10.1582 im GK folgte, wird im Programm eine entsprechende Umrechnung vorgenommen wenn der 4.10.1582 unterschritten wird. Man kann dies mit dem Programm nachprüfen in dem man in der Option " Jultage berechnen " zunächst den 4.10.1582 eingibt, den daraufhin berechneten Julianischen Tag abliest und danach die Rechnung mit der Eingabe 15.10.1582 wiederholt. Man sieht, dass der Julianische Tag des zweiten Datum sich nur um einen Zähler vom vorhergehenden unterscheidet obwohl ja 10 Tage dazwischen liegen.

Für unsere, mehr in die Zukunft gerichteten Absichten der Satellitenbahnberechnung, ist dies natürlich nicht so wichtig. Astronomen können aber z.B. mit Hilfe des Julianischen Tages feststellen, dass am 28.08. des Jahres 1204 v.Chr. (-1203) eine Sonnenfinsternis stattfand, obwohl der Monat August zu diesem Zeitpunkt noch gar nicht erfunden war.

Für die Anwendung aller Kalenderfunktionen ist zu beachten, dass die Jahreszahl immer vierstellig zu übergeben ist. Das zweistellige Jahr 2000 beginnt mit 00, wer also bisher in Programmen zum zweistelligen Datum immer nur 1900 dazu addiert hat, wird am 1.1.2000 festgestellt haben, dass seine Programme falsche Ergebnisse bringen.

Wie bereits erwähnt, datiert sich der Ursprung des AMSAT-Tages (AD) auf den 01.01.1978 zurück, die Tage werden seit diesem Zeitpunkt fortlaufend gezählt. Beispiele für jeweils 0.00 UTC:

01.01.1992 = AD 5113

12.01.1995 = AD 6220

01.01.2000 = AD 8035

01.01.1978 = AD 0

Die Uhrzeit wird als Tagfragment angehängt, der 01.01.2000 um 12.00 UTC ergibt den AMSAT-Tag 8035.50.  

Für den AD sind verschiedene Algorithmen veröffentlicht worden, die im Grundsatz aber immer auf der Berechnung des Julianischen Tages beruhen, daher machen wir es uns mit der Berechnung einfach und konstatieren, dass der AMSAT-Tag der Julianische Tag abzüglich 2443509.5 ist.

Damit lässt sich der Algorithmus für den JD auch für die Berechnung des AMSAT-Tages bis zurück zum Tage 0 nutzen.

Der praktische Nutzen des AMSAT-Tages liegt in der Umrechnung von Satellitenepochen von einem definierten Ausgangszeitpunkt, z.B. dem des Keplerdatensatzes, auf einen beliebigen anderen Zeitpunkt. Ein praktisches Programmierbeispiel dazu ist in [2] enthalten, deshalb gehe ich an dieser Stelle nicht mehr darauf ein.

Da man auch in der Lage sein muss, aus dem JD oder AD, wieder das Kalenderdatum zu ermitteln, gibt es auch dazu im Programm Routinen. Die Routine Jultag in Datum berechnet aus dem JD Tag, Monat, Jahr (vierstellig), die etwas abgewandelte Routine AMSAT in Datum macht das gleiche für den AMSAT-Tag. Auch die Umkehrfunktionen berücksichtigen den Übergang vom Julianischen - zum Gregorianischen Kalender am 04.10.1582, bitte durch experimentale Eingaben nachprüfen.

Den laufenden Tag des Jahres, kennt man z.B. aus der Epoch time des Keplerdatensatzes. So drückt zum Beispiel der Wert "97365.5000000" aus, dass die Epoche aus dem Jahre 1997 (1-2 Stelle) und vom 31.12. = 365. Tag (Stelle 3-5) um 12.00 UTC (Nachkommastellen) stammt. Die Epoche für den 01.01.2000 um 12.00 UTC schreibt sich mit 1.5000000 und man muss innerlich 2000 dazuzählen, ein Prozess an den man sich nach dem Stichtag schnell gewöhnt hat.

Den laufenden Tag eines Jahres berechnet man relativ einfach aus dem Monat und dem Tag des Monats wie Menüpunkt "Jahrestag" verwirklicht.

Dabei müssen natürlich Schaltjahre berücksichtigt werden. Das sind nach der bereits erwähnten Regel alle durch 4 teilbaren Jahre. Volle Jahrhunderte sind aber nur dann Schaltjahre, wenn sie auch noch durch 400 teilbar sind. Für das Jahr 2000 trifft diese Regel zu.

Die Funktion " Schaltjahr " ( ab Zeile 99) stellt anhand der Übergabe eines Jahres fest, fest ob ein Schaltjahr vorliegt und gibt für ein Schaltjahr den Integerwert 1, für kein Schaltjahr den Wert 2 an das aufrufende Programm zurück.

Die Umkehrfunktion , d.h. die Umrechnung des laufenden Tages im Jahr in Monat und Tag, ist in der Funktion "Lfdtag_to_date" (117) abgebildet. Damit kann man also z.B. die Epoch time auf ein Kalenderdatum umrechnen.

Die laufende Woche berechnet man nach der Ermittlung des laufenden Tages, indem man dem laufenden Tag 6.0 dazuzählt und das Ergebnis durch 7 teilt. Die Nachkommastellen werden ignoriert.

Also:  Lfd_Woche = (Lfd_tag + 6) DIV 7

Wenn man dabei über 52 kommt, dann hat das Jahr entweder 53 Wochen oder diese Woche ist als 1. Woche des Folgejahres zu bezeichnen, aber nur dann, wenn mindestens 4 Tage in das neue Jahr fallen.

Wenn man feststellen will, auf welchen Tag der Woche ein bestimmtes Datum fällt, berechnet man zunächst den Julianischen Tag, addiert 1.5 und teilt dann das Ergebnis solange durch 7, bis entweder 0 oder ein Rest zwischen 1 und 6 herauskommt. Rest 0 ist dann ein Sonntag, Rest 6 z.B. ein Samstag. Die Prozedur "Wochentag" (92) erfüllt diese Aufgabe und gibt als Ergebnis den Wochentag als Zeichenkette zurück. Das gleiche kann man natürlich auch mit dem AMSAT-Tag machen, dann muss der Prozedur beim Aufruf der AMSAT-Tag + 2443509.5 übergeben werden.

Bei der Berechnung und Fortschreibung von Satellitenepochen ist es notwendig, die Differenz in Tagen zwischen z.T. weit auseinanderliegenden Kalendertagen zu ermitteln. Dies geschieht durch die Umwandlung von Datum 1 und Datum 2 in einen numerischen Wert in Form des Julianischen- oder AMSAT-Tages. Danach bildet man die Differenz zwischen den gefundenen Werten. Im Programm wird dies durch zweimaligen Aufruf der Funktion Jultage aus dem Hauptprogramm in der Prozedur " Differenz_tage " erreicht.

Ob zur Differenzbildung der AMSAT-Tag oder der JD genommen wird, bleibt sich zumindest für die Zwecke der Satellitenbahnberechnung gleich. Den JD muß man aber immer dann verwenden, wenn ein Datum vor dem 1.1.78 im Spiel ist, da dort der AD in negative Werte mündet.

Wenn man schon Kalenderberechnungen anstellt, dann ist es sinnvoll sich noch einige Zusammenhänge mit unseren Feiertagen klar zu machen. Feiertage sind außerdem dazu geeignet, Funkverkehr über Satelliten abzuwickeln, daher sind Kenntnisse über das Datum von Feiertagen von grundsätzlichem Nutzen für den Satellitenfreund.

Im Jahre 325 n.Chr. wurde unter Papst Sylvester I. auf dem Konzil von Nicaea das Osterfest auf den ersten Sonntag nach dem ersten Frühlingsvollmond festgelegt. Die Kopplung mit dem Mond erklärt, warum Ostern jedes Jahr zu einem anderen Termin stattfindet.

Ostern liegt früh, wenn der erste Vollmond unmittelbar nach Frühlingsanfang (21.3) stattfindet und der Tag nach diesem Vollmond bereits der Sonntag ist (frühestens also am 22.März). Der späteste Ostertermin ist der 25. April, er tritt dann ein, wenn es unmittelbar vor Frühlingsanfang einen Vollmond gab (der nicht zählt) und der fragliche Vollmond dann spät im April z.B. an einem Montag stattfindet. Der Vollmond und der Frühlingsanfang werden nach der kirchlichen Regel festgelegt und sind nicht immer identisch mit den astronomischen Terminen. So gilt für den kirchlichen Frühlingsanfang, dass er immer am 21.3. stattfindet, astronomisch gesehen kann der Frühlingsanfang jedoch auch am 19.3 oder am 20.3 stattfinden.

Im Zeitraum von 1900-2100 ergab oder ergibt die rein astronomische Konstellation in folgenden Jahren ein anderes Osterdatum als die kirchliche Regel: 1900, 1903, 1923, 1927, 1943, 1954, 1962, 1967, 1974, 1981, 2038, 2049, 2096, 2076, 2089, 2095 und 2096.

Das statistisch häufigste Osterdatum ist der 19. April; die Osterdaten wiederholen sich zyklisch erst nach 5 700 000 Jahren.

Vom Termin des Ostersonntags sind weitere Feiertage nach den folgenden Regeln abhängig:

9.3 Andere Ereignisse

Für weitere Ereignisse im Jahr ergeben sich ebenfalls kalendarische Zusammenhänge:

Das Programm berechnet die meisten dieser Tage in der Prozedur "Jahrestermine" (Zle 180-190).

Das nachstehende Programm "Kalender" , ist für Turbo-Pascal ab Version 5.0 geschrieben. Das Hauptprogramm ist Kalender.pas, die Unit Kalunit.pas enthält die auskommentierten Berechnungsroutinen.

10.1 Programmlisting Hauptprogramm

Das Hauptprogramm ruft nach Auswahl einer Menüoption über eine entsprechende Prozedur die jeweilige Kalenderroutine in der KALUNIT auf. Das nachstehende Listing ist auskommentiert, so dass weitere Erklärungen überflüssig sind.

{ 1} PROGRAM Kalender;

{ 2} {$N+E+}

{ 3} { Programm zur Berechnung von Julianischem Tag, Amsat- }

{ 4} { Tag und den Umkehrfunktionen wie Amsat-Tag in Datum und }

{ 5} { Jul-Tag in Datum, sowie lfd Tag eines Jahres und Wochen- }

{ 6} { tag. Von M. Maday, DC9ZP,Potsdamer Str. 5, 56235 Ransbach}

{ 7} USES CRT,Kalunit; { Kalenderunit einbinden}

{ 8} { Eingabe des Datums}

{ 9} PROCEDURE Eingabe_dat(VAR tag,monat,jahr:INTEGER);

{ 10} BEGIN

{ 11} wr(8,7, ' Bitte Datum eingeben 1. Tag ');READLN(tag);

{ 12} wr(8,9, ' 2. Monat ');READLN(monat);

{ 13} wr(8,11,' 3. Jahr(JJJJ) ');READLN(Jahr);

{ 14} CLRSCR;

{ 15} END;

{ 16} PROCEDURE Return(y:INTEGER);

{ 17} BEGIN wr(22,y,' Weiter mit Return');READLN;END;

{ 18} { Julianischen Tag berechnen }

{ 19} PROCEDURE Rechne_jultag;

{ 20} VAR t,m,j:INTEGER;

{ 21} BEGIN

{ 22} CLRSCR;

{ 23} eingabe_dat(t,m,j);

{ 24} Julday := jultage(t,m,j);{ Jul-Routine in Kalunit aufrufen}

{ 25} Amsatday := julday-2443509.5; { Amsat-Tag aus Jul-Dat}

{ 26} weekday := wochentag(julday);

{ 27} wr(10,2, ' Ausgabe des Berechnungsergebnisses ');

{ 28} wr(10,4, ' Eingegebenes Datum...............: '+datum(t,m,j));

{ 29} wr(10,6, ' Julianischer Tag (JD)............: '+tv(julday,7,1));

{ 30} wr(10,8, ' Korrespondierender AMSAT-Tag.....: '+tv(amsatday,5,1));

{ 31} wr(10,10,' Wochentag........................: '+weekday);

{ 32} return(13);

{ 33} END;

{ 34} { Julianischen Tag in Datum umwandeln}

{ 35} PROCEDURE Jultag_datum;

{ 36} BEGIN

{ 37} CLRSCR;

{ 38} wr(10,4, ' Bitte Julianischen Tag eingeben ');

{ 39} READLN(julday);

{ 40} jultermin := jul_TO_dat(julday); { Routine in Kalunit aufrufen}

{ 41} weekday := wochentag(julday); { Wochentag ermitteln}

{ 42} CLRSCR;

{ 43} wr(10,2,' Julianischer Tag in Datum ');

{ 44} wr(10,4,' Eingebener Julianischer Tag..........: '+tv(julday,7,1));

{ 45} wr(10,6,' Errechnetes Datum....................: '+jultermin);

{ 46} wr(10,8,' Wochentag............................: '+weekday);

{ 47} return(11);

{ 48} END;

{ 49} { AMSAT-Tag in normales Kalenderdatum umwandeln}

{ 50} PROCEDURE Amsat_datum;

{ 51} BEGIN

{ 52} CLRSCR;

{ 53} wr(10,4, ' Bitte AMSAT-Tag eingeben ');

{ 54} READLN(amsatday);

{ 55} amsat_termin := amsattag_TO_dat(amsatday);

{ 56} julday := amsatday+2443509.5;

{ 57} weekday := wochentag(julday);

{ 58} CLRSCR;

{ 59} wr(10,2,' AMSAT-Tag in Datum umrechnen');

{ 60} wr(10,4,' Eingebener AMSAT-Tag.................: +tv(amsatday,5,1));

{ 61} wr(10,6,' Korrespondierender Julianischer Tag..: '+tv(julday,7,1));

{ 62} wr(10,8,' Errechnetes Datum....................: '+amsat_termin);

{ 63} wr(10,10,' Wochentag............................: '+weekday);

{ 64} return(13);

{ 65} END;

{ 66} { Den laufenden Jahrestag berechnen }

{ 67} PROCEDURE Rechne_jahrestag;

{ 68} VAR t,m,j: INTEGER;

{ 69} BEGIN

{ 70} clrscr;eingabe_dat(t,m,j);

{ 71} lfdtag := Jahrestag(t,m,j); { Routine in KALUNIT aufrufen}

{ 72} Julday := jultage(t,m,j); { Jul-Datum berechnen}

{ 73} weekday := wochentag(julday); { Wochentag berechnen}

{ 74} wr(10,2, ' Ausgabe des Berechnungsergebnisses ');

{ 75} wr(10,4, ' Eingegebenes Datum...................: '+datum(t,m,j));

{ 76} wr(10,6, ' Ermittelter laufender Jahrestag......: +tv(lfdtag,3,0));

{ 77} wr(10,8, ' Wochentag............................: '+weekday);

{ 78} return(11);

{ 79} END;

{ 80} { Datum aus dem laufenden Jahrestag ermitteln}

{ 81} PROCEDURE Jahrestag_datum;

{ 82} var k:integer;

{ 83} BEGIN

{ 84} CLRSCR;

{ 85} wr(10,4, ' Bitte laufenden Jahrestag eingeben (1..366) ');

{ 86} READLN(lfdtag);

{ 87} wr(10,6, ' Bitte das Jahr (JJJJ) eingeben.............: ');

{ 88} READLN(jahr);

{ 89} k := schaltjahr(jahr);

{ 90} if k = 2 then if lfdtag > 365 then lfdtag:=365;

{ 91} jahrtermin := Lfdtag_TO_date(lfdtag,jahr);{KALUNIT aufrufen}

{ 92} CLRSCR;

{ 93} wr(10,2,' Laufender Tag in Datum umrechnen');

{ 94} wr(10,4,' Eingegebener Laufender Tag...........: '+tv(lfdtag,3,0));

{ 95} wr(10,6,' Errechnetes Datum....................: '+jahrtermin);

{ 96} return(9);

{ 97} END;

{ 98} { Tagesdifferenz zwischen zwei Daten ermitteln}

{ 99} PROCEDURE Differenz_tage;

{100} VAR t,m,j,t1,m1,j1 : INTEGER;

{101} jul1,jul2,diff : REAL;

{102} BEGIN

{103} CLRSCR;

{104} wr(5,5,' Bitte erstes Datum eingeben');

{105} eingabe_dat(t,m,j);

{106} CLRSCR;

{107} wr(5,5,' Bitte zweites Datum eingeben ');

{108} eingabe_dat(t1,m1,j1);

{109} jul1:=jultage(t,m,j); { Zweimal Jul-Tag berechnen }

{110} jul2:=jultage(t1,m1,j1);

{111} diff:=abs(jul2-jul1); { und die Differenz bilden }

{112} CLRSCR;

{113} wr(10,2,'Tagesdifferenzen zwischen zwei Daten berechnen');

{114} wr(10,4,'Erstes Datum.........................: '+datum(t,m,j));

{115} wr(10,6,'Zweites Datum........................: '+datum(t1,m1,j1));

{116} wr(10,8,'Tagesdifferenz.......................: '+tv(diff,0,1));

{117} return(11);

{118} END;

{119} { Kirchliche Ereignisse im laufenden Jahr berechnen }

{120} PROCEDURE Rechne_feiertage;

{121} VAR jahr:INTEGER;

{122} BEGIN

{123} CLRSCR;

{124} wr(10,4,' Bitte gewünschtes Jahr (JJJJ) eingeben ');

{125} READLN(jahr);

{126} osterdatum(jahr); { Routinen in der KALUNIT aufrufen }

{127} jahrestermine(jahr);

{128} CLRSCR;

{129} wr(10,2,' Kirchliche Feiertage im gewählten Jahr ');

{130} wr(10,4,'Datum des Rosenmontags........: '+ rosenmontag);

{131} wr(10,5,'Datum des Ostersonntags.......: '+ ostertag);

{132} wr(10,6,'Datum des Himmelfahrtstages...: '+ himmelfahrt);

{133} wr(10,7,'Datum des Pfingstsonntags.....: '+ pfingsten);

{134} wr(10,8,'Datum des Fronleichnamstages..: '+ fronleichnam);

{135} wr(10,9,'Datum des 1.Advent............: '+ advent1);

{136} wr(10,10,'Datum des 4.Advent............: '+ advent4);

{137} wr(10,11,'Datum des Totensonntags.......: '+ totensonntag);

{138} wr(10,12,'Datum des Buß & Bettags.......: '+ busstag);

{139} return(15);

{140} END;

{141} { Das Hauptmenü des Programms }

{142} PROCEDURE Kalendermenue;

{143} VAR wahl:CHAR;

{144} BEGIN

{145} REPEAT

{146} CLRSCR;

{147} wr(10,2,' Kalenderberechnungen von DC9ZP ');

{148} wr(10,4,'Datum in Julianischen Tag und AMSAT-Tag umrechnen..: A');

{149} wr(10,5,'Julianischen Tag in Datum umrechnen................: B');

{150} wr(10,6,'AMSAT-Tag in Datum umrechnen.......................: C');

{151} wr(10,7,'Den laufenden Tag des Jahres berechnen.............: D');

{152} wr(10,8,'Datum aus laufendem Tag des Jahres.................: E');

{153} wr(10,9,'Tagesdifferenzen zwischen zwei Daten...............: F');

{154} wr(10,10,'Feiertage im Jahr berechnen........................: G');

{155} wr(10,11,'Programmende.......................................: Q');

{156} wahl:=READKEY;

{157} case UPCASE(wahl) of

{158} 'A': rechne_jultag; { Aufruf der entsprechenden Routinen}

{159} 'B': jultag_datum;

{160} 'C': amsat_datum;

{161} 'D': rechne_jahrestag;

{162} 'E': jahrestag_datum;

{163} 'F': differenz_tage;

{164} 'G': rechne_feiertage;

{165} 'Q': EXIT;

{166} END;

{167} UNTIL wahl in ['A'..'G','Q'];{ Ende wenn Buchstabe = Q (uit)}

{168} END;

{169} BEGIN { Hier beginnt das Programm}

{170} Textattr := 31;

{171} kalendermenue; { Nur noch Menü aufrufen }

{172} END.

10.2 Die Kalenderunit

Die Kalenderunit enthält alle Rechenroutinen, diese werden aus dem Hauptprogramm über entsprechende Prozeduren aufgerufen. Für Einzelheiten bitte ich die Kommentierungen der Programmzeilen zu studieren.

{ 1} UNIT Kalunit;

{ 2} {$n+,e+}

{ 3} INTERFACE { UNIT mit Kalenderroutinen (c) M. Maday, DC9ZP}

{ 4} USES CRT; { Für das Astrodstprogramm 12/97}

{ 5} TYPE str12= STRING[12];

{ 6} str80= STRING[80];

{ 7} TYPE REAL=double; { Globale Variablen}

{ 8} VAR ostertag, rosenmontag, fronleichnam,pfingsten,

{ 9} himmelfahrt, weekday, jultermin, amsat_termin,

{ 10} advent4,advent1,busstag,totensonntag,jahrtermin : str12;

{ 11} julday, tag, monat,jahr,

{ 12} lfdtag, amsatday : REAL;

{ 13} day,mo,year : REAL; { Öffentliche Routinen }

{ 14} FUNCTION schaltjahr(jahr:REAL):BYTE;

{ 15} FUNCTION Jultage(tag,monat,jahr:REAL):REAL;

{ 16} FUNCTION Tv(x:REAL;x1,y1:BYTE):str12;

{ 17} FUNCTION Wochentag (jd:REAL):str12;

{ 18} FUNCTION Amsattag_TO_dat(amsattag:REAL):str12;

{ 19} FUNCTION Jul_TO_dat(JD:REAL):str12;

{ 20} FUNCTION Jahrestag(tag,monat,jahr:REAL):REAL;

{ 21} FUNCTION Lfdtag_TO_date(lfdtag,jahr:REAL):str12;

{ 22} PROCEDURE Osterdatum(jahr : INTEGER);

{ 23} PROCEDURE wr(x,y : INTEGER;xstr:str80);

{ 24} FUNCTION Datum(t,m,j:REAL):str80;

{ 25} PROCEDURE Jahrestermine(jahr:REAL);

{ 26} IMPLEMENTATION

{ 27}

{ 28} FUNCTION tv; { Umwandlung numerischer Werte in Zeichenkette}

{ 29} CONST s=' ';

{ 30} VAR xstr,ystr,astr:str12;

{ 31} BEGIN

{ 32} IF abs(x) > 10E8 THEN BEGIN str(x:0:y1,astr);tv:=astr;EXIT;END;

{ 33} str(TRUNC(x):x1,ystr);str(FRAC(abs(x)):0:y1,xstr);

{ 34} DELETE(xstr,1,1);IF (TRUNC(x)=0) AND (FRAC(x)<0) THEN

{ 35} ystr := COPY(s,1,x1-2)+'-0';

{ 36} tv := ystr+xstr;

{ 37} END;

{ 38} { Wandelt eine REAL-Zahl in eine Zeichenkette um}

{ 39} FUNCTION Tostr(x:REAL):str80;

{ 40} VAR xstr:STRING;

{ 41} BEGIN

{ 42} STR(trunc(ABS(x)):0,xstr);

{ 43} IF LENGTH(xstr)< 2 THEN xstr:='0'+xstr;

{ 44} IF x <0 THEN xstr:='-'+xstr; tostr := xstr; END;

{ 45} { Schreibt ein Datum in der bekannten Weise }

{ 46} { Übergeben werden tag,monat,Jahr (JJJJ) als Realwert}

{ 47} FUNCTION Datum;

{ 48} BEGIN datum:= tostr(t)+'.'+tostr(m)+'.'+tostr(j); END;

{ 49} { Gibt eine Zeichenkette auf dem Bildschirm an der durch }

{ 50} { x und y definierten Stelle aus }

{ 51}

{ 52} PROCEDURE Wr;

{ 53} BEGIN GOTOXY(x,y); WRITE(xstr);END;

{ 54} { Berechnet den Julianischen Tag aus einem Kalender-Datum}

{ 55} { Gültig für Julianischen Kalender bis 4.10.1582 und für }

{ 56} { den Gregorianischen Kalender ab 15.10.1582 }

{ 57} FUNCTION Jultage;

{ 58} VAR a,b,x : REAL;

{ 59} BEGIN

{ 60} x := jahr*10000.0+monat*100+tag;

{ 61} IF monat <= 2 THEN

{ 62} BEGIN jahr := jahr - 1; monat:= monat + 12; END;

{ 63} a := INT(jahr/100);

{ 64} b := 2-a+INT(a/4); { Für Greg Kalender sonst gilt..... }

{ 65} IF x <15821004.1 THEN b:=0; { wenn Tag vor dem 4.10.1582 }

{ 66} jultage := INT(365.25*(jahr+4716))+INT(30.60001*(monat+1))+

{ 67} tag + b-1524.5;

{ 68} END;

{ 69} {Wandelt Jul-Tag wieder in Kalenderdatum um}

{ 70} FUNCTION Jul_TO_dat;

{ 71} VAR z,a,b,c,d,e,x,tag,monat,jahr :REAL;

{ 72} BEGIN

{ 73} z:= int(JD+0.5);

{ 74} x:= int((z-1867216.25)/36524.25);

{ 75} a:= z+1+x-int(x/4);

{ 76} IF z < 2299161 THEN a:=z; { Wenn vor dem 4.10.1582 dann..}

{ 77} b:= a+1524;

{ 78} c:= int((b-122.1)/365.25);

{ 79} d:= int(365.25*c);

{ 80} e:= int((b-d)/30.6001);

{ 81} tag := b-d-int(30.6001*e);

{ 82} IF e < 14 THEN monat := e-1 ELSE monat:=e-13;

{ 83} IF monat > 2 THEN jahr:= c-4716 ELSE jahr:=c-4715;

{ 84} day:=tag;mo:=monat;year:=jahr;

{ 85} jul_to_dat:=datum(tag,monat,jahr);

{ 86} END;

{ 87} {Wandelt Amsattag zurück in Kalenderdatum}

{ 88} FUNCTION Amsattag_TO_dat ;

{ 89} BEGIN

{ 90} amsattag_TO_dat:=jul_to_dat(amsattag+2443509.5);

{ 91} END;

{ 92} { Ermittelt aus einem Jul-Tag den Wochentag}

{ 93} FUNCTION Wochentag;

{ 94} CONST wtage:ARRAY[0..6] of str12=('Sonntag','Montag','Dienstag',

{ 95} 'Mittwoch','Donnerstag','Freitag','Samstag');

{ 96} BEGIN

{ 97} wochentag := wtage[ TRUNC(jd+1.5) MOD 7 ];

{ 98} END;

{ 99} FUNCTION Schaltjahr (jahr:REAL):BYTE;

{100}

{101} VAR k:BYTE;

{102} BEGIN

{103} k := 2;

{104} IF (TRUNC(jahr) MOD 400=0) or

{105} ((TRUNC(jahr) MOD 4 = 0) AND (trunc(jahr) mod 100 <> 0))

{106} then k:=1;

{107} schaltjahr := k;

{108} END;

{109} {Ermittelt aus Datum den laufenden Tag des Jahres}

{110} FUNCTION Jahrestag ;

{111} VAR K:BYTE;

{112} BEGIN

{113} k := schaltjahr(jahr);

{114} jahrestag:=int(275*monat/9)-k*trunc((monat+9)/12)+tag-30;

{115} END;

{116} {Kalenderdatum aus lfd Jahrestag}

{117} FUNCTION Lfdtag_TO_date ;

{118} VAR k:INTEGER; monat,tag:REAL;

{119} BEGIN

{120} k:=schaltjahr(jahr);

{121} monat := TRUNC((9*(k+lfdtag))/275+0.98);

{122} IF lfdtag < 32 THEN monat := 1;

{123} tag := lfdtag - TRUNC((275*monat)/9) + k*trunc((monat+9)/12)+30;

{124} day := tag;mo:=monat;year:=jahr;

{125} lfdtag_TO_date:=datum(tag,monat,jahr);

{126} END;

{127} { Berechnet das Datum des Ostersonntags im Jahr }

{128} { Das Jahr wird vierstellig =JJJJ übergeben }

{129} PROCEDURE Osterdatum ;

{130} VAR

{131} a, b, c, d, e, f, g, h, i, k, l, m,

{132} wert, monat, tag : INTEGER;

{133} julian : REAL;

{134} BEGIN

{135} IF jahr < 1583 THEN

{136} { Julianisches Ostern bis zum Jahr 1582}

{137} BEGIN

{138} a := jahr MOD 4;

{139} b := jahr MOD 7;

{140} c := jahr MOD 19;

{141} d := (19*c+15) MOD 30;

{142} e := (2*a+4*b-d+34) MOD 7;

{143} wert := d + e + 114;

{144} END

{145} ELSE

{146} { Gregorianisches Ostern ab 1583 }

{147} BEGIN

{148} a := jahr MOD 19;

{149} b := jahr DIV 100;

{150} c := jahr MOD 100;

{151} d := b DIV 4;

{152} e := b MOD 4;

{153} f := (b+8) DIV 25;

{154} g := (b-f+1) DIV 3;

{155} h := (19*a+b-d-g+15) MOD 30;

{156} i := c DIV 4;

{157} k := c MOD 4;

{158} l := (32+2*e+2*i-h-k) MOD 7;

{159} m := (a+11*h+22*l) DIV 451;

{160} wert := h+l-7*m+114;

{161} END;

{162} { Und hier der Ostertermin}

{163} monat := wert DIV 31;

{164} tag := (wert MOD 31) + 1;

{165} julian := jultage(tag,monat,jahr);{ Jul-Tag Ostersonntag }

{166} ostertag := datum(tag,monat,jahr);

{167} {Termine der von den Ostern abhängigen Feiertage }

{168} rosenmontag := jul_TO_dat(julian - 48);

{169} himmelfahrt := jul_TO_dat(julian + 39);

{170} pfingsten := jul_TO_dat(julian + 49);

{171} fronleichnam:= jul_TO_dat(julian + 60);

{172} END;

{173} {Ermittelt aus einem Jul-Tag den numerischen Wochentag }

{174} FUNCTION tageszahl(jd:REAL):longint;

{175} BEGIN tageszahl:=TRUNC(jd+1.5) MOD 7; END;

{176} { Berechnet weitere Termine Advent, Totensonntag etc. }

{177} PROCEDURE Jahrestermine;

{178} VAR zahl,x:longint;

{179} BEGIN

{180} zahl:= TRUNC(jahrestag(24,12,jahr)); { Jahreszahl 24.12. }

{181} x := tageszahl(jultage(24,12,jahr));{ Wochentag ermitteln}

{182} advent4:=lfdtag_TO_date(zahl-x,jahr); { 4. Advent }

{183} advent1:=lfdtag_TO_date(zahl-x-21,jahr); { 1.Advent }

{184} totensonntag:=lfdtag_to_date(zahl-x-28,jahr);{Totensonntag }

{185} busstag:=lfdtag_TO_date(zahl-x-28-4,jahr); { Bußtag }

{186} END;

{187} BEGIN

{188} END.

10.3 Programmablauf

Nach dem Start des Programms erscheint das  Hauptmenü, die Auswahl der Optionen erfolgt durch Eingabe des jeweiligen Buchstabens.

11. Das Programm AFUKAL.EXE

Das Programm AFUKAL.EXE kann von mir gegen den geringen Ausgleich der Aufwändungen bezogen werde. Programm führt die vorgestellten Berechnungen und einige mehr, unter einer modernen Bedieneroberfläche mit Maussteuerung aus. Dieses Programm ist im Gegensatz zum rudimentärem Programmlisting, gegen Fehlbedienungen weitgehend abgesichert, d.h. es können nur Daten eingeben werden, die auch zu konkreten Ergebnissen führen. Mit diesem Programm kommen auch Nichtprogrammierer zu ihrem Recht. 

11.1 Optionen

Das  Hauptmenü enthält die verfügbaren Optionen:

Feiertage berechnen

Berechnet die von Ostern und Advent abhängigen Feiertage sowie andere kalendarische Ereignisse. Dazu nur das Jahr eingeben.

Datum in Jultag

Wandelt ein normales (Gregorianisches) Datum in den Julianischen Tag und in den AMSAT-Tag um.

Jahrestag, laufend

Wandelt ein Datum in den laufenden Jahrestag um.

Jultag in Datum

Umkehrfunktion Datum in Jultag, wandelt also einen Julianischen Tag in Datum mit

Tag, Monat, Jahr um.

Tagesdifferenz

Ermittelt nach Eingabe von Datum 1 und Datum 2 die Differenz in Tagen zwischen den Daten.

AMSAT-Tag in Datum

Wandelt AMSAT-Tag in ein normales Kalenderdatum um.

Lfd-Dat

Wandelt laufenden Jahrestag in Kalenderdatum um.

Epoch

Rechnet eine Satelliten Epoch time in Datum und UTC um.

[1] Meeus, Jean , "Astronomical Algorithms", Richmond Virginia 1992

[2] Manfred Maday, DC9ZP,"Amateurfunksatelliten, Übersicht, Berechnung und Software" PDF-Buch vom Autor beziehbar, Köln Oktober 2001.

Bearbeitungstand dieser Seite : 13.07.10