Locator berechnen

Info

Der Locator (auch als Grid Locator oder Maidenhead Locator System bezeichnet) ist ein System zur geografischen Koordinatendarstellung, das häufig im Amateurfunk verwendet wird. Es teilt die Erdoberfläche in Gitterfelder auf, um genaue Positionsinformationen zu übermitteln. Die Berechnung des Locators erfolgt in zwei Schritten:

1. Grobe Berechnung:

• Teile die Welt in Breiten- und Längengrade auf. Die Breite wird von Nord (90 Grad) bis Süd (-90 Grad) und die Länge von West (-180 Grad) nach Ost (180 Grad) gemessen.
• Teile jeden Breiten- und Längengrad in 20 Abschnitte auf. Jeder Abschnitt entspricht 2 Grad Breite und 4 Grad Länge.
• Nummeriere die Abschnitte von 180 (West) bis 180 (Ost) für die Länge und von 90 (Nord) bis -90 (Süd) für die Breite.

1. Feinere Berechnung:

• Teile jeden Abschnitt erneut in 10 Abschnitte auf, wobei jeder Abschnitt 0,2 Grad Breite und 0,4 Grad Länge entspricht.
• Verwende Buchstaben und Zahlen, um die genaue Position innerhalb des Abschnitts anzugeben. Buchstaben werden für die Längenangabe verwendet (A bis Q) und Zahlen für die Breitenangabe (0 bis 9).

Zum Beispiel kann der Locator für New York City (40.7128° N, -74.0060° E) „FN31pr“ sein. „FN“ gibt den groben Längenabschnitt an (der von -75 bis -74 Grad reicht) und „31“ gibt den groben Breitenabschnitt an (der von 40 bis 41 Grad reicht). „pr“ gibt die genaue Position innerhalb des Abschnitts an.

Es gibt verschiedene Online-Rechner und Softwareprogramme, mit denen man den Locator für eine bestimmte Position berechnen kann. Man kann auch spezielle Karten und Tabellen verwenden, die die Zuordnung von Längen- und Breitengraden zu Locator-Codes anzeigen.

Formel: Berechnung des Locators aus Längen- und Breitengrad

Die Berechnung des Locator-Codes basiert auf einer bestimmten Formel, die die Breiten- und Längengrade in Locator-Zeichen umwandelt. Hier ist die grundlegende Formel für die Berechnung des Locator-Codes:

1. Breiten- und Längengrade aufteilen:

• Latitude = (90 – Breitengrad) / 10
• Longitude = (180 + Längengrad) / 20

1. Runde die erhaltenen Werte auf den nächsten ganzzahligen Wert ab.
2. Konvertiere die ganzzahligen Werte in Buchstaben und Zahlen:

• Verwenden den Buchstaben „A“ für Längengrade von 0 bis 9, „B“ für 10 bis 19, „C“ für 20 bis 29 usw.
• Verwenden die Zahlen 0 bis 9 für Breitengrade von 0 bis 9, 10 bis 19 usw.

Die resultierenden Buchstaben und Zahlen werden dann zusammengefügt, um den Locator-Code zu bilden. Die ersten beiden Zeichen repräsentieren den groben Längenabschnitt und die nächsten beiden Zeichen den groben Breitenabschnitt. Die restlichen Zeichen geben die genaue Position innerhalb des Abschnitts an.

Es ist zu beachten, dass es verschiedene Varianten des Locator-Systems gibt, wie beispielsweise den 6-stelligen Locator, der noch genauere Positionsinformationen liefert. Die oben genannte Formel ist für den 4-stelligen Locator gebräuchlich, der am weitesten verbreitet ist.

Formel: Locator in Längen- und Breitengrad umrechnen

Um die Locator-Formel in Längen- und Breitengrad umzuwandeln, kann man die folgenden Schritte befolgen:

1. Breiten- und Längengrade für den Locator-Code berechnen:

• Längengrad: Der erste Locator-Buchstabe repräsentiert den groben Längenabschnitt. Multipliziere den Buchstabenwert mit 20 und subtrahiere 180, um den Längengrad zu erhalten.
• Breitengrad: Die ersten beiden Locator-Zahlen repräsentieren den groben Breitenabschnitt. Multipliziere den Zahlenwert mit 10 und subtrahiere 90, um den Breitengrad zu erhalten.

1. Genauere Position innerhalb des Abschnitts berechnen:

• Längengrad: Jeder Buchstabe im Locator-Code für die Längenangabe entspricht einem Abschnitt von 2 Grad Länge. Verwende den Buchstabenwert, multipliziert mit 2, um die Längenposition innerhalb des Abschnitts zu erhalten.
• Breitengrad: Jede Zahl im Locator-Code für die Breitenangabe entspricht einem Abschnitt von 1 Grad Breite. Verwende den Zahlenwert, multipliziert mit 1, um die Breitenposition innerhalb des Abschnitts zu erhalten.

1. Addiere die genauen Positionen zur groben Position, um die endgültigen Längen- und Breitengrade zu erhalten.

Beachte, dass dies die allgemeine Methode ist, um Längen- und Breitengrade aus dem Locator-Code abzuleiten. Es gibt auch spezielle Tabellen und Konvertierungstools, die helfen können, die Umrechnung durchzuführen.

Javascript: Errechnet aus dem Locator den Längen- und Breitengrad

Dieser Code kann mit 6,8 und 10 stelligen Locatoren umgehen

Javascript: Errechnet aus dem Längen- und Breitengrad den Locator

Dieses JavaScript-Beispiel verwendet die Funktion latLngToLocator, um die Längen- und Breitengrade in den Locator-Code umzurechnen. Man kann die Funktion mit den gewünschten Längen- und Breitengraden aufrufen und den resultierenden Locator-Code erhalten.

Dieses Beispiel erzeugt den 10 Stelligen Locator Wert:

Javascript: Berechnung der Entfernung zwischen zwei Locator-Codes

Die Berechnung der Entfernung zwischen zwei Locator-Codes kann mithilfe der Haversine-Formel erfolgen. Die Haversine-Formel verwendet Breiten- und Längengrade, um den Abstand auf einer Kugeloberfläche zu berechnen. Hier ist ein Beispiel für JavaScript-Code, der die Entfernung zwischen zwei Locator-Codes berechnet:

Dieses JavaScript-Beispiel verwendet die Funktion calculateDistance, um die Entfernung zwischen zwei Locator-Codes zu berechnen. Man kann die Funktion mit den gewünschten Locator-Codes aufrufen um die resultierende Entfernung erhalten. Beachte, dass die Entfernung in Kilometern berechnet wird.

Um die locatorToCoordinates-Funktion zu verwenden, kann man den oben genannten Code verwenden, der die Umwandlung von Locator-Codes in Längen- und Breitengrade erklärt.

Javascript: Berechnung der Entfernung zwischen zwei Längen- und Breitengraden

Die Berechnung der Entfernung zwischen zwei Längen- und Breitengraden kann mithilfe der Haversine-Formel erfolgen. Hier ist ein Beispiel für JavaScript-Code, der die Entfernung zwischen zwei Koordinaten in Längen- und Breitengraden berechnet:

In diesem Beispiel wird die Funktion calculateDistance verwendet, um die Entfernung zwischen zwei Koordinaten in Längen- und Breitengraden zu berechnen. Man kann die Funktion mit den gewünschten Koordinaten aufrufen und die resultierende Entfernung erhalten. Beachte, dass die Entfernung in Kilometern berechnet wird.

Die Haversine-Formel ist eine Näherung und liefert genügend Genauigkeit für die meisten Anwendungen. Es ist jedoch zu beachten, dass die Formel eine sphärische Erde annimmt und keine Berücksichtigung von Höhenunterschieden oder der Abplattung der Erde macht.

Javascript: Berechnung der Entfernung und der Himmelsrichtung in Grad zwischen zwei Locatoren

Javascript: Zeitunterschied zwischen zwei Locatoren bestimmen

Diese Berechnung basiert auf dem geografischen Zeitunterschied. Sie berücksichtigt keine Zeitzonen, die durch politische Entscheidungen beeinflusst werden (z. B. Sommerzeit, Zeitverschiebung zwischen benachbarten Ländern).

Zeitzonen-Rechner

Javascript: Lat und Lon zu Dezimalgrad (DD) Grad/Minute Sekunde

Javascript: Berechnung der Richtung zwischen zwei Lat/Lon

Javascript: Zeitzonen Berechnung

Alternative:

Standort Information mit GeoNames API abrufen

Bitte bei Benutzung des Script unbedingt User Name ändern. Dazu bitte kostenlos auf https://www.geonames.org registrieren. Der Einsatz ist NUR auf nicht kommerziellen Seiten erlaubt.

Excel: Locator Entfernung und Richtung bestimmen

DJ1DZ hat auf seiner Seite eine Excel Sheet erstellt mit dem man die Entfernung und Richtung zwische zwei Locatorn berechnen kann.

https://dj1dz.darc.de/meine-website6/amateurfunk.html

PHP: aus Längen- und Breitengrad den Locator ermitteln

<?php
/**
 * by Conny Henn 
 * https://www.dl2fbo.de
 *
 * @Errechnet aus dem Längen- und Breitengrad den Locator mit detaillierter Ausgabe
 *
 * z.B.  JO40PF 40JK
 *
 * @license GPL 2.0
 */

function latLngToLocator($lat, $lon) {
    if ($lon < -180) $lon += 360;
    if ($lon > 180) $lon -= 360;
    $lat += 90;
    $lon += 180;
    $locator = '';

    $locator .= calcChar($lon, 65, 20);
    $locator .= calcChar($lat, 65, 10);
    $lon = safeModulo($lon, 20);
    $lat = safeModulo($lat, 10);
    $locator .= calcChar($lon, 48, 2);
    $locator .= calcChar($lat, 48, 1);
    $lon = safeModulo($lon, 2);
    $lat = safeModulo($lat, 1);
    $locator .= calcChar($lon, 65, 1/12);
    $locator .= calcChar($lat, 65, 1/24);
    $lon = safeModulo($lon, 1/12);
    $lat = safeModulo($lat, 1/24);
    
    $locator .= " ";
    
    $locator .= calcChar($lon, 48, 1/120);
    $locator .= calcChar($lat, 48, 1/240);
    $lon = safeModulo($lon, 1/120);
    $lat = safeModulo($lat, 1/240);
    $locator .= calcChar($lon, 65, 1/2880);
    $locator .= calcChar($lat, 65, 1/5760);
    return $locator;
}

function calcChar($val, $base, $range) {
    if ($range == 0) {
        return chr($base);
    }
    return chr($base + floor($val / $range));
}

function safeModulo($a, $n) {
    if (abs($n) < 1e-10) {
        return 0;
    }
    return $a - $n * floor($a / $n);
}

Ergebnis z.B.: JO41RC 29WM

PHP: aus Locator den Längen und Breitengrad errechnen

<?php
/**
 * by Conny Henn 
 * https://www.dl2fbo.de
 *
 * @Errechnet aus dem Locator den Längen- und Breitengrad 
 *
 * z.B.  JO40PF 40JK
 *
 * @license GPL 2.0
 */
function locatorToLatLng($locator) {
    $locator = strtoupper($locator);
    $locator = preg_replace('/\s+/', '', $locator);  // Entfernt Leerzeichen
    
    if (!preg_match('/^[A-R]{2}[0-9]{2}[A-X]{2}([0-9]{2}[A-X]{2})?$/', $locator)) {
        return false;  // Ungültiges Locator-Format
    }

    $lon = -180;
    $lat = -90;

    $lon += (ord($locator[0]) - ord('A')) * 20;
    $lat += (ord($locator[1]) - ord('A')) * 10;

    $lon += (ord($locator[2]) - ord('0')) * 2;
    $lat += (ord($locator[3]) - ord('0'));

    $lon += (ord($locator[4]) - ord('A')) / 12;
    $lat += (ord($locator[5]) - ord('A')) / 24;

    if (strlen($locator) >= 8) {
        $lon += (ord($locator[6]) - ord('0')) / 120;
        $lat += (ord($locator[7]) - ord('0')) / 240;
    }

    if (strlen($locator) == 10) {
        $lon += (ord($locator[8]) - ord('A')) / 2880;
        $lat += (ord($locator[9]) - ord('A')) / 5760;
    }

    $lon += 1 / (2 * pow(2, strlen($locator)));
    $lat += 1 / (2 * pow(2, strlen($locator) + 1));

    return array('lat' => $lat, 'lon' => $lon);
}

// Beispielnutzung:
$locator = "JO40XO 71PD";
$coordinates = locatorToLatLng($locator);
if ($coordinates) {
    echo "Latitude: " . $coordinates['lat'] . ", Longitude: " . $coordinates['lon'];
} else {
    echo "Ungültiger Locator";
}