Umrechnung von äquatoriales in horizontales Koordinatensystem

  • Ersteller des Themas Ersteller des Themas efbe68
  • Erstellungsdatum Erstellungsdatum

efbe68

Mitglied
Hallo zusammen,

ich baue gerade an einer Teleskopmontierung (Azimutal), die ich von „Stellarium“ steuern lassen möchte.

Zum besseren Verständniss, beschreibe ich mal kurz was ich vor habe…
Der Träger bzw. die Komponenten kommen überwiegend aus dem 3D-Drucker. Bei den nötigen Getrieben habe ich mich für Zykloid-Getriebe entschieden. Diese werden durch Schrittmotoren und Zahnriemen angetrieben. Die Schrittmotoren werden von einem Arduino mit CNC-Shield angesteuert. Das Arduino übernimmt auch die Kommunikation mit Stellarium und steuert die Motoren. Um das Arduino beim Start zu initialisieren, habe ich ein kleines .NET-Programm geschrieben, die den Arduino mit dem aktuelle Datum, Uhrzeit, Geografische Länge und Breite des Standortes sowie der Sternzeit und die EQ-Koordinaten des im Sucher (Teleskop) befindlichen Objektes initialisiert.

Da mir über das LX200-Protokoll ja nur die Rektaszension/Deklination übertragen wird, muss da eine Umrechnung (Arduino) in das Horizontale-Koordinatensystems erfolgen.
Ich habe mir nun mehrfach den entsprechenden Artikel auf Wikipedia durchgelesen. Komme da aber nicht weite, da dort keine Beispiele bzw. Zwischenwerte aufgeführt sind.

Zu meinem Wissensstand muss ich gestehen, dass ich zwar eine gute Vorstellung von vielem habe, aber nichts wirklich gut kann. Sollte sich jemand also die Mühe machen, mir das weiter zu helfen, wäre es nett, dies ein bisschen ausführlicher zu tun. Also evtl. die Zwischenwerte in die Beschreibung einfließen zu lassen.

Ich bedanke mich schon mal im Voraus und hoffe auf Unterstützung.
Viele Grüße efbe68
 
Hallo efbe68,

welche Daten hast du genau als Ausgangspukt? Die geozentrischen äquatorialen Koordinaten? Falls dies der Fall ist würde ich sagen folgen die Umwandlungen:
1.) geozentrisch äquatorial → topozentrisch äquatorial
2.) topozentrisch äquatorial → horizontal

Schau mal in die EphemPedia, Kapitel 6: Koordinatentransformation

cs,
harald

--
 
Zuletzt bearbeitet:
Einfach mal ChatGPT fragen und dann den - ziemlich gut dokumentierten - Code anschauen.

"create a .net function that converts from equatorial coordinates to horicontal"

Code: 
using System;

public class CoordinateConverter
{
    // Method to convert Equatorial coordinates to Horizontal coordinates
    public static (double Azimuth, double Altitude) EquatorialToHorizontal(
        double rightAscension, double declination, double latitude, double longitude, DateTime utcTime)
    {
        // Convert the observer's longitude to radians
        double longitudeRad = DegreesToRadians(longitude);

        // Calculate local sidereal time in radians
        double lst = LocalSiderealTime(utcTime, longitudeRad);

        // Convert right ascension and declination from degrees to radians
        double raRad = HoursToRadians(rightAscension);
        double decRad = DegreesToRadians(declination);
       
        // Convert latitude from degrees to radians
        double latRad = DegreesToRadians(latitude);

        // Hour angle in radians
        double hourAngle = lst - raRad;

        // Calculate altitude in radians
        double sinAlt = Math.Sin(decRad) * Math.Sin(latRad) +
                        Math.Cos(decRad) * Math.Cos(latRad) * Math.Cos(hourAngle);
        double altitude = Math.Asin(sinAlt);

        // Calculate azimuth in radians
        double cosA = (Math.Sin(decRad) - Math.Sin(altitude) * Math.Sin(latRad)) /
                      (Math.Cos(altitude) * Math.Cos(latRad));
        double azimuth = Math.Acos(cosA);

        // Convert azimuth from radians to degrees, adjusting for the quadrant
        if (Math.Sin(hourAngle) >= 0)
            azimuth = 2 * Math.PI - azimuth;
        azimuth = RadiansToDegrees(azimuth);

        // Convert altitude from radians to degrees
        altitude = RadiansToDegrees(altitude);

        return (azimuth, altitude);
    }

    // Helper method to convert degrees to radians
    private static double DegreesToRadians(double degrees)
    {
        return degrees * Math.PI / 180.0;
    }

    // Helper method to convert hours to radians
    private static double HoursToRadians(double hours)
    {
        return hours * Math.PI / 12.0;
    }

    // Helper method to convert radians to degrees
    private static double RadiansToDegrees(double radians)
    {
        return radians * 180.0 / Math.PI;
    }

    // Method to calculate the Local Sidereal Time
    private static double LocalSiderealTime(DateTime utc, double longitude)
    {
        // Convert UTC to Julian date
        double jd = utc.ToOADate() + 2415018.5;
        double t = (jd - 2451545.0) / 36525.0;
        double gst = 280.46061837 + 360.98564736629 * (jd - 2451545) + t * t * (0.000387933 - t / 38710000);

        // Adjust GST to be within the range [0, 360]
        gst = (gst + 360.0) % 360.0;

        // Convert GST from degrees to radians
        double gstRad = DegreesToRadians(gst);

        // Local Sidereal Time in radians
        return (gstRad + longitude) % (2 * Math.PI);
    }
}

Solche Sachen zählen zu den Dingen, die ChatGPT ziemlich gut kann. Ich habe den Code allerdings NICHT geprüft. Das sollte man in jedem Fall nochmal tun. Der weiter oben verlinkte Artikel hilft dabei, zu verstehen, was hier getan wird.
 
Hallo Harald / @h_c_greier ,

danke für deine Antwort. Deine Nachfrage würde ich jetzt erst einmal bejahen. Ausgehend davon, dass die Koordinaten in Stellarium geozentrisch sind.

Als Beispiel:
Standort: Greenwich (N51°28’40.12‘‘;W0°0‘5.31‘‘)
Ortszeit: 13.05.2024 12:40:12
Objekt: Diphda (Rekt/Dekl zum Datum 0h44m47.43s/-17°51’12.4‘‘)

Dankbare Grüße,
Frank

PS: Du hast mir unwissentlich schon einmal sehr weitergeholfen. Am 27.09.2005 hast du auf eine Frage zur Sternzeit geantwortet. Das hat mir sehr weitergeholfen!
 
@growers
Ja cool... Auf diese Idee währe ich nie gekommen. Die 68 in meinem Nickname lässt auf mein Jahrgang schließen ;)
Für mich ist ChatGPT Teufelszeug :D
 
Mit BJ 68 ist man dafür aber nicht zu alt ;-) Also schnell anfangen! Gerade "Standardfunktionen" kann das Ding gut, bei exotischeren APIs wird dann eher mal etwas rumphantasiert. Für solche einfachen Sachen dürfte das kostenlose GPT 3.5 ausreichen.
 
Hi @efbe68 ,

ich habe meine Dobsons mit Schrittmotoren motorisiert und steuere diese auch über einen Arduino mit CNC Shield, also praktisch gleiche Aufgabe.

Ich benutze auch Stellarium. Da kann man sich von einem Objekt auch die Alt/Az Koordinaten an seinem Standort zu einer Uhrzeit geben lassen.
Darüber mache ich dann mittels Plate-Solving, das die aktuelle Position des Teleskops bestimmt, ein einfaches GoTo.
Man muss nur einmal die Umsetzung von Schritten auf Alt/Az Winkel der Montierung bestimmen. Das kann man sehr einfach an der Montierung einmal messen oder berechnen.
Dann geht es nur noch darum den Abstand in Alt/Az von der aktuellen Position der Montierung aus dem Platesolving zum Objekt zu berechnen und damit die Schrittmotoren entsprechende Schritte machen lassen. Funktioniert sehr gut.

Was ich noch machen will, dass die Dobson-Montierung ein Tracking macht. Dazu muss man aus der Drehung der Rek-Achse, die entsprechende Winkel Drehungen im Alt/Az System berechnen. Daran bin ich bisher recherchemässig gescheitert.
Ich denke das hier könnte mir dabei auch helfen.

Gruß
Peter
 
Zuletzt bearbeitet:
@AstroPZ
Gibt es hier im Forum einen Bereich/Thread für DIY ?
Mich würde es interessieren, wie du das umgesetzt hast.
Hier wäre das nicht so gut aufgehoben.
 
Zitat von efbe68:
@AstroPZ
Gibt es hier im Forum einen Bereich/Thread für DIY ?
Mich würde es interessieren, wie du das umgesetzt hast.
Hier wäre das nicht so gut aufgehoben.
Klicke in dieses Feld, um es in vollständiger Größe anzuzeigen.
soweit ich weiss eigentlich nicht.

Ich wollte mal einen Faden zu meiner Motorisierung der Dobson-Montierungen machen.
Ist eigentlich ganz einfach. ;)
Vielleicht kann ich mich mal aufraffen. ;)

Die programmatische Umsetzung für die Schrittmotoren fand ich so einfach, dass ich das selber programmiert habe.
Inzwischen läuft auf dem Arduino nur noch ein einfaches Programm, das ganz allgemein die Schrittmotoren über einfache Befehle an der USB Schnittstelle steuert.

Die ganzen astronomischen Berechnungen laufen auf dem PC in einem Java Programm. Da hat man einfach mehr Möglichkeiten und der Code auf dem Arduino bleibt dabei völlig unverändert.

Gruß
Peter
 
@P_E_T_E_R
Für eine Überprüfung könnte ich da auch Stellarium benutzen. Ich versuche ja die Berechnung in meinen Programm-Code zu bringen. Dabei ist es für mich total wichtig Zwischenwerte zu bekommen.

Mal so als Anekdote:
Erst durch eine Antwort mit ausführlichem Beispiel durch @h_c_greier war es mir möglich die Sternzeit zu berechnen. Um nun diese auf dem Microcontroller weiter zu führen, habe ich einen internen Zeitgeber verwendet. Leider "hinkte" die Berechnete Zeit mit zuhname immer weiter hinterher.
Zunächst hatte ich den "ungenauen" interne Zeitgeber in Verdacht. Darum habe ich mir ein Platinchen mit einer Echtzeituhr gekauft und diese an den Controller angeschlossen. Dann habe ich noch mal schlappe 30Std. investiert, um endlich ein "sauberes" Sekunden-Signal zu erhalten.
Gleiches Ergebnis. Die berechnete Sternzeit hinkt nach!
Nach einigem Grübeln kam mir noch einmal die "Synodische Tageslänge" in den Sinn. Also die RTC wieder raus, und die interne Zeit mit dem synodischen Zeitfaktor multipliziert. Voilà... plötzlich läuft die Zeit annähernd syncron.
 
Wie war das bei Monty Pythons mit dem König "Artüs"? Dasselbe mache ich mit ChatGPT :cool:

OK, für den Stern beta Ceti (Diphda) kannst du die Transformation auf topozentrisch getrost weglassen, die Parallaxe ist so klein dass das für deine Zwecke keinen Unterschied macht.

Dein Beispiel:
Standort: N 51°28'40.12" W 0°0'5.31"
Ortszeit: 13.05.2024 12:40:12 UT
Objekt: Diphda (Rekt/Dekl zum Datum RA = 0h 44m 47.43s DEC = -17°51'12.4"

Ich lasse mal alle Kommastellen zur Nachvollziehbarkeit stehen, mir ist schon klar, dass das absurd ist.

ACHTUNG: Die nachstehenden trigonometrischen Funktionen nehmen Argumente in GRAD! Bei den meisten Sprachen muss das umgerechnet werden, indem man mit dem Faktor DEGS = 3.141592653589793/180 multipliziert.

Zuerst alles umrechnen in Winkel:
lon = (0 + 0 + 5.31/3600) = 0.001475° (West hier posotiv!)
lat = (51 + 28/60 + 40.12/3600) = 51.477811111111116°

RA = (0 + 44/60 + 47.43/3600)*15 = 11.197208333333332°
DEC = -(17 + 51/60 + 12.4/3600) = -17.853444444444445°

Julianischer Tag: JD = 2460444.0279166666 → separate Berechnung

Eigentlich müsste man jetzt die 69 Sekunden von ΔT berücksichtigen, lass'ma wech.

Mittlere Sternzeit in GW: (Greenwich siderial time, in Grad)
T = (JD - 2451545.0)/36525
gwst = 280.46061837 + 360.98564736629 (JD - 2451545.0) + 0.000387933*T*T (- höherer T³ Term ist wurscht)
gwst = 61.814069972373545°

Ortssternzeit: local mean siderial time
lmst = gwst + lon =
lmst = 61.814069972373545° + 0.001475° = 61.815544972373544°

Stundenwinkel des Objekts
theta = lmst - RA = 61.815544972373544° - 11.197208333333332° = 50.61833663904021°

Umrechnung äquatorial → horizontal:

Höhe:
h = arcsin( sin(lat)*sin(DEC) + cos(lat)*cos(DEC)*cos(theta) ) / DEGS
h = 7.832464929593859°

Azimut:
az = arctan2(y, x) mit
az = arctan2( sin(theta), cos(theta)*sin(lat) - tan(DEC)*cos(lat) )
az = 47.95707210933331

Guide gibt mir die (gerundeten) Daten:
h = 7.8°
az = 48.0°

Fragen?

cs,
harald

--
 
Zuletzt bearbeitet:
Falls du den julianischen Tag JD wie von der Maschine vorgeschlagen aus Bordmitteln ermitteln kannst, OK.
Falls du eine Routine brauchst, hier:

Code: 
function getJD(yrs, mth, dys, hrs, mins, secs) {
  let a, b, q, jd;
  if (mth <= 2) {
      yrs--;
      mth += 12;
  }
  q = 10000*yrs + 100*mth + dys;
  if (q > 15821004) {
      // Gregorianischer Kalender
      a = Math.floor(yrs/100);
      b = 2 - a + Math.floor(a/4);
  } else {
      // Julianischer Kalender
      b = 0;
  }
  // Tagesbruchteil addieren
  dys += (hrs + mins/60 + secs/3600)/24;
  // Der Algorithmus verwendet nur positive Zahlen,
  // man kann daher mit Math.floor rechnen.
  jd = Math.floor(365.25*(yrs + 4716))
       + Math.floor(30.6001*(mth + 1))
       + dys + b - 1524.5;
  return jd;
}

Ist zwar JavaScript, aber sicherlich umwandelbar.

cs,
harald

--
 
Zuletzt bearbeitet:
Ich habe das so implementiert...
Code: 
    lDate = TimeZoneInfo.ConvertTimeToUtc(Now)
    lYear = IIf(lDate.Month > 2, lDate.Year, lDate.Year - 1)
    lMonth = IIf(lDate.Month > 2, lDate.Month, lDate.Month + 12)
    lDay = lDate.Day
    lTime = lDate.Hour / 24 + lDate.Minute / 1440 + lDate.Second / 86400
    lRef = 2 - Math.Floor(lYear / 100) + Math.Floor(lYear / 400)
    lJD = Math.Floor(365.25 * (lYear + 4716)) + Math.Floor(30.6001 * (lMonth + 1)) + lDay + lTime + lRef - 1524.5
    lT = (lJD - 2451545.0) / 36525
    lTheta = 280.46061837 + 360.98564736629 * (lJD - 2451545.0) + 0.000387933 * lT ^ 2 - lT ^ 3 / 38710000 'mittlere Sternzeit in Greenwich im Gradmaß
    lTheta = ((lTheta Mod 360 + 360) Mod 360) / 15

Vielleicht erkennst du da deinen Einfluss. Und ja... es ist VB.NET!! Ich mag gewscheifte Klammern nicht :D
 
@growers : Der Code von ChatGPT liefert falsche Werte.

@h_c_greier
Leider kann ich deine Rechnung nicht nachvollziehen.

lat, lon, RA und DEC sind mit deinen Angaben identisch.
Für JD habe ich einen etwas abweichenden Wert (2460443.9445833266). Diese entspricht dem, der mir auch in Stellarium angezeigt wird.

Bereits bei der Berechnung von gwst erhalte ich jedoch einen anderen Wert (gwst = 31.731930282432586)
Auch wenn ich mit deinem gwst-Wert weiter rechne, erhalte ich für...
h = 74.795120217077582
az = 0.79721986863547822

Code: 
    Dim lmst As Double
    Dim theta As Double
    Dim h As Double
    Dim az As Double

    lGwst = 61.814069972373545

    lmst = lGwst + lon
    theta = lmst - RA
    h = Math.Asin(Math.Sin(lat) * Math.Sin(DEC) + Math.Cos(lat) * Math.Cos(DEC) * Math.Cos(theta)) / (Math.PI / 180)
    az = Math.Atan2(Math.Sin(theta), Math.Cos(theta) * Math.Sin(lat) - Math.Tan(DEC) * Math.Cos(lat))

Auch wird mir in Stellarium für Diphda zu den oben genannten Daten folgendes angezeigt:
Azimut = 200°35'53.9''
Höhe = 18°22'44.0''

Hast du vielleicht noch eine Idee, warum das so weit auseinander läuft?
 
Hallo Frank,

Zitat von efbe68:
Der Code von ChatGPT liefert falsche Werte.
Klicke in dieses Feld, um es in vollständiger Größe anzuzeigen.
Den Code direkt verwenden ist auch Humbug. Man muss Anpassungen machen.

Zitat von efbe68:
lat, lon, RA und DEC sind mit deinen Angaben identisch.
Für JD habe ich einen etwas abweichenden Wert (2460443.9445833266). Diese entspricht dem, der mir auch in Stellarium angezeigt wird.
Klicke in dieses Feld, um es in vollständiger Größe anzuzeigen.
Hast du alle Winkel in Radiant umgerechnet, bevor du sie in Math.Sin(...) bzw. Math.Cos(...) steckst?

cs,
harald

--
 
Hoppla!

13.5.2024, 12:40:12 UT → JD 2460444.0279166666
13.5.2024, 10:40:12 UT → JD 2460443.9445833336

Du hast in Stellarium wahrscheinlich gesetzt

13.5.2024, 12:40:12 MESZ = 10:40:12 UT => 2460443.9445833336

Ich habe den falschen JD Wert gepostet bzw. die Rechnung damit gemacht. Da der Standort ja N51°28'40.12" W0°0'5.31" ist, bin ich davon ausgegangen, dass die Ortszeit 12:40:12 in UT ist.

GWST kommt dann gwst = 31.731932803988457° raus = 2.1154621869325636h = 2h 6m 56.2s

h = 18.4°
az = 20.6°

Dein Stellarium rechnet scheinbar den Azimut von Norden! (*schauder*:ROFLMAO:)

cs,
harald

--
 
Zuletzt bearbeitet:
Hi,

ist jetzt der Code weiter oben doch richtig?

Ich denke damit könnte ich nämlich super mein Tracking meiner Dobson-Montierungen programmieren.
Es ist so verständlich, dass es ich es programmieren kann ( ;) ) und auch schön kompakt.

Um die Winkel-Geschwindigkeit von AZ und ALT zu berechnen könnte man selbstverständlich auch die Ableitung nach der Zeit berechnen.
Das ist mir im Moment durch die Winkelfunktionen zu schwierig. Bin schon etwas länger aus der Mathematik raus.

Es reicht mM wenn ich einfach 2 Werte im Abstand von 1s berechne und von einander abziehe (Computer ist eh schnell genug).
Es ist ja auch klar, dass die Winkelgeschwindigkeit konstant ist.

Gruß
Peter
 
Sodele, der folgende Code ist in JavaScript und sollte hinhauen. ACHTUNG: ich habe den Standard-Beobachtungsort N50° 10°E genommen!

Javascript: 
// JD berechnen im Zeitraum 1.3.1900-28.2.2100
function getJD(yrs, mth, dys, hrs, mins, secs) {
  let a, b, jd;
  if (mth <= 2) {
      yrs--;
      mth += 12;
  }
  a = Math.floor(yrs/100);
  b = -13;
  dys += (hrs + mins/60 + secs/3600)/24;
  jd = Math.floor(365.25*(yrs + 4716))
       + Math.floor(30.6001*(mth + 1))
       + dys + b - 1524.5;
  return jd;
}

// Zeitpunkt
// 12:40:12 MESZ = 10:40:12 UT
let JD = getJD(2024, 5, 13, 10, 40, 12)
console.log('JD =', JD);

// Standortdaten
const lon = -10.0; // Ost negativ, West positiv
const lat = 50.0;

console.log('lon =', lon);
console.log('lat =', lat);

// Sterndaten (zum Äquinoktium des Datums)
let RA = (0 + 44/60 + 47.43/3600)*15;
let DEC = -(17 + 51/60 + 12.4/3600);
console.log('RA =', RA);
console.log('DEC =', DEC);

// Sternzeit in Greenwich in GRAD
let T = (JD - 2451545.0)/36525;
let gwst = 280.46061837
           +360.98564736629*(JD - 2451545.0)
           +0.000387933*T*T
           -T*T*T/38710000;
console.log('gwst=', gwst);

// Winkel in Intervall [0-360°] bringen
gwst = gwst % 360;
console.log('gwst ° =', gwst);
console.log('gwst h =', gwst/15);

// Ortssternzeit
let lmst = gwst - lon;
console.log('lmst °=', lmst);
console.log('lmst h=', lmst/15);

// Stundenwinkel des Objekts
let theta = lmst - RA;
console.log('theta =', theta);

// Umrechnung äquatorial → horizontal
// Alle Winkel in Radiant umrechnen!
const DEGS = Math.PI/180;
// Höhe
let h = Math.asin( Math.sin(lat*DEGS)*Math.sin(DEC*DEGS) + Math.cos(lat*DEGS)*Math.cos(DEC*DEGS)*Math.cos(theta*DEGS) ) / DEGS;
console.log('h =', h);

// Azimut (von Südpunkt)
let az = Math.atan2( Math.sin(theta*DEGS), Math.cos(theta*DEGS)*Math.sin(lat*DEGS) - Math.tan(DEC*DEGS)*Math.cos(lat*DEGS) ) / DEGS;
console.log('az =', az);

// Dieser Script: h = +16.9855...°, az = +30.3742...°
// GUIDE: h = +17.0°, az = +30.4°
// Stellarium: h = +16.9853°, az = +30.3751°


Test: Copy+Paste und dann hier rein.

cs,
harald

--
 
Zuletzt bearbeitet:
Also jetzt VB:

Code: 
Public Module Program
  ' JD berechnen im Zeitraum 1.3.1900-28.2.2100
  Public Function GetJD(ByVal yrs As Integer, ByVal mth As Integer, ByVal dys As Double, ByVal hrs As Double, ByVal mins As Double, ByVal secs As Double) As Double
      Dim a As Double, b As Double, jd As Double
 
      If mth <= 2 Then
          yrs -= 1
          mth += 12
      End If
 
      a = Math.Floor(yrs / 100)
      b = -13
      dys += (hrs + mins / 60 + secs / 3600) / 24
      jd = Math.Floor(365.25 * (yrs + 4716)) + Math.Floor(30.6001 * (mth + 1)) + dys + b - 1524.5
 
      Return jd
  End Function
 
  Public Sub Main(args() As string)
    ' Zeitpunkt
    ' 12:40:12 MESZ = 10:40:12 UT
    Dim JD As Double = GetJD(2024, 5, 13, 10, 40, 12)
    Console.WriteLine("JD = " & JD)
    
    ' Standortdaten
    Dim lon As Double = -10.0 ' Ost negativ, West positiv
    Dim lat As Double = 50.0
    Console.WriteLine("lon = " & lon)
    Console.WriteLine("lat = " & lat)
    
    ' Sterndaten (zum Äquinoktium des Datums)
    Dim RA As Double = (0 + 44 / 60 + 47.43 / 3600) * 15
    Dim DEC As Double = -(17 + 51 / 60 + 12.4 / 3600)
    Console.WriteLine("RA = " & RA)
    Console.WriteLine("DEC = " & DEC)
    
    ' Sternzeit in Greenwich in GRAD
    Dim T As Double = (JD - 2451545.0) / 36525
    Dim gwst As Double = 280.46061837 + 360.98564736629 * (JD - 2451545.0) + 0.000387933 * T * T - T * T * T / 38710000
    Console.WriteLine("gwst= " & gwst)
    
    ' Winkel in Intervall [0-360°] bringen
    gwst = gwst Mod 360
    Console.WriteLine("gwst ° = " & gwst)
    Console.WriteLine("gwst h = " & gwst / 15)
    
    ' Ortssternzeit
    Dim lmst As Double = gwst - lon
    Console.WriteLine("lmst °= " & lmst)
    Console.WriteLine("lmst h= " & lmst / 15)
    
    ' Stundenwinkel des Objekts
    Dim theta As Double = lmst - RA
    Console.WriteLine("theta = " & theta)
    
    ' Umrechnung äquatorial → horizontal
    ' Alle Winkel in Radiant umrechnen!
    Const DEGS As Double = Math.PI / 180
    ' Höhe
    Dim h As Double = Math.Asin(Math.Sin(lat * DEGS) * Math.Sin(DEC * DEGS) + Math.Cos(lat * DEGS) * Math.Cos(DEC * DEGS) * Math.Cos(theta * DEGS)) / DEGS
    Console.WriteLine("h = " & h)
    
    ' Azimut (von Südpunkt)
    Dim az As Double = Math.Atan2(Math.Sin(theta * DEGS), Math.Cos(theta * DEGS) * Math.Sin(lat * DEGS) - Math.Tan(DEC * DEGS) * Math.Cos(lat * DEGS)) / DEGS
    Console.WriteLine("az = " & az)
  End Sub
End Module

Test: Copy+Paste → hier

Und funktioniert es?

cs,
harald

--
 
Um antworten zu können musst du eingeloggt sein.
Zurück
Oben