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:

• Teilen Sie 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.
• Teilen Sie jeden Breiten- und Längengrad in 20 Abschnitte auf. Jeder Abschnitt entspricht 2 Grad Breite und 4 Grad Länge.
• Nummerieren Sie 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:

• Teilen Sie jeden Abschnitt erneut in 10 Abschnitte auf, wobei jeder Abschnitt 0,2 Grad Breite und 0,4 Grad Länge entspricht.
• Verwenden Sie 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 Sie den Locator für eine bestimmte Position berechnen können. Sie können 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. Runden Sie die erhaltenen Werte auf den nächsten ganzzahligen Wert ab.
2. Konvertieren Sie die ganzzahligen Werte in Buchstaben und Zahlen:

• Verwenden Sie 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 Sie 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, können Sie 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. Multiplizieren Sie den Buchstabenwert mit 20 und subtrahieren Sie 180, um den Längengrad zu erhalten.
• Breitengrad: Die ersten beiden Locator-Zahlen repräsentieren den groben Breitenabschnitt. Multiplizieren Sie den Zahlenwert mit 10 und subtrahieren Sie 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. Verwenden Sie 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. Verwenden Sie den Zahlenwert, multipliziert mit 1, um die Breitenposition innerhalb des Abschnitts zu erhalten.

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

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

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

/**
 * by Conny Henn 
 * https://www.dl2fbo.de
 *
 * @Errechnet aus dem Locator den Längen- und Breitengrad
 * @license GPL 2.0
 */
function locatorToCoordinates(locator) {
  // Konvertiere die ersten beiden Zeichen des Locators in Längen- und Breitengradabschnitte
  var longitudeSection = locator.charAt(0).toUpperCase().charCodeAt(0) - 65;
  var latitudeSection = parseInt(locator.charAt(1));

  // Konvertiere die restlichen Zeichen des Locators in genaue Positionen innerhalb der Abschnitte
  var longitudePosition = locator.charAt(2).toLowerCase().charCodeAt(0) - 97;
  var latitudePosition = locator.charAt(3).toLowerCase().charCodeAt(0) - 97;

  // Berechne die genauen Längen- und Breitengrade
  var longitude = (longitudeSection * 20) - 180 + (longitudePosition * 2);
  var latitude = (latitudeSection * 10) - 90 + (latitudePosition * 1);

  return { longitude: longitude, latitude: latitude };
}

// Beispielaufruf
var locator = "FN31pr";
var coordinates = locatorToCoordinates(locator);
console.log("Längengrad:", coordinates.longitude);
console.log("Breitengrad:", coordinates.latitude);

Dieses JavaScript-Beispiel verwendet die Funktion locatorToCoordinates, um den Locator-Code in Längen- und Breitengrade umzurechnen. Sie können die Funktion mit einem Locator-Code aufrufen und die resultierenden Längen- und Breitengrade erhalten.

Bitte beachten Sie, dass dieser Code die Umrechnung für den 4-stelligen Locator durchführt. Wenn Sie einen anderen Locator-Typ verwenden, müssen möglicherweise Anpassungen vorgenommen werden.

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

/**
 * by Conny Henn 
 * https://www.dl2fbo.de
 *
 * @Errechnet aus dem Längen- und Breitengrad den Locator
 * @license GPL 2.0
 */
function coordinatesToLocator(latitude, longitude) {
  // Berechne den groben Längen- und Breitenabschnitt
  var longitudeSection = Math.floor((longitude + 180) / 20);
  var latitudeSection = Math.floor((latitude + 90) / 10);

  // Berechne die genaue Position innerhalb der Abschnitte
  var longitudePosition = Math.floor(((longitude + 180) % 20) / 2);
  var latitudePosition = Math.floor(((latitude + 90) % 10) / 1);

  // Konvertiere die Längen- und Breitenabschnitte und -positionen in Locator-Zeichen
  var locator = String.fromCharCode(longitudeSection + 65) +
    latitudeSection.toString() +
    String.fromCharCode(longitudePosition + 97) +
    String.fromCharCode(latitudePosition + 97);

  return locator;
}

// Beispielaufruf
var latitude = 40.7128;
var longitude = -74.0060;
var locator = coordinatesToLocator(latitude, longitude);
console.log("Locator:", locator);

Dieses JavaScript-Beispiel verwendet die Funktion coordinatesToLocator, um die Längen- und Breitengrade in den Locator-Code umzurechnen. Sie können die Funktion mit den gewünschten Längen- und Breitengraden aufrufen und den resultierenden Locator-Code erhalten.

Bitte beachten Sie, dass dieser Code den 4-stelligen Locator-Code generiert. Wenn Sie einen anderen Locator-Typ benötigen, müssen möglicherweise Anpassungen vorgenommen werden.

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:

/**
 * (c)opyright by Conny Henn - www.DL2FBO.de
 * @Berechnung der Entfernung zwischen zwei Locator-Code
 * @license GPL 2.0
 */
function calculateDistance(locator1, locator2) {
  // Konvertiere Locator-Codes in Längen- und Breitengrade
  var coordinates1 = locatorToCoordinates(locator1);
  var coordinates2 = locatorToCoordinates(locator2);

  // Längen- und Breitengrade in Radianten umrechnen
  var lat1 = coordinates1.latitude * (Math.PI / 180);
  var lon1 = coordinates1.longitude * (Math.PI / 180);
  var lat2 = coordinates2.latitude * (Math.PI / 180);
  var lon2 = coordinates2.longitude * (Math.PI / 180);

  // Haversine-Formel zur Berechnung der Entfernung
  var dlon = lon2 - lon1;
  var dlat = lat2 - lat1;
  var a = Math.sin(dlat / 2) * Math.sin(dlat / 2) +
    Math.cos(lat1) * Math.cos(lat2) *
    Math.sin(dlon / 2) * Math.sin(dlon / 2);
  var c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
  var distance = 6371 * c; // Radius der Erde in Kilometern

  return distance;
}

// Beispielaufruf
var locator1 = "FN31pr";
var locator2 = "JN48qp";
var distance = calculateDistance(locator1, locator2);
console.log("Entfernung (km):", distance);

Dieses JavaScript-Beispiel verwendet die Funktion calculateDistance, um die Entfernung zwischen zwei Locator-Codes zu berechnen. Sie können die Funktion mit den gewünschten Locator-Codes aufrufen und die resultierende Entfernung erhalten. Beachten Sie, dass die Entfernung in Kilometern berechnet wird.

Um die locatorToCoordinates-Funktion zu verwenden, können Sie 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:

/**
 * (c)opyright by Conny Henn - www.DL2FBO.de
 * @Berechnung der Entfernung zwischen zwei Längen- und Breitengraden
 * @license GPL 2.0
 */
function calculateDistance(lat1, lon1, lat2, lon2) {
  // Längen- und Breitengrade in Radianten umrechnen
  var latRad1 = lat1 * (Math.PI / 180);
  var lonRad1 = lon1 * (Math.PI / 180);
  var latRad2 = lat2 * (Math.PI / 180);
  var lonRad2 = lon2 * (Math.PI / 180);

  // Haversine-Formel zur Berechnung der Entfernung
  var dlon = lonRad2 - lonRad1;
  var dlat = latRad2 - latRad1;
  var a = Math.sin(dlat / 2) * Math.sin(dlat / 2) +
    Math.cos(latRad1) * Math.cos(latRad2) *
    Math.sin(dlon / 2) * Math.sin(dlon / 2);
  var c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
  var distance = 6371 * c; // Radius der Erde in Kilometern

  return distance;
}

// Beispielaufruf
var lat1 = 40.7128;
var lon1 = -74.0060;
var lat2 = 48.8566;
var lon2 = 2.3522;
var distance = calculateDistance(lat1, lon1, lat2, lon2);
console.log("Entfernung (km):", distance);

In diesem Beispiel wird die Funktion calculateDistance verwendet, um die Entfernung zwischen zwei Koordinaten in Längen- und Breitengraden zu berechnen. Sie können die Funktion mit den gewünschten Koordinaten aufrufen und die resultierende Entfernung erhalten. Beachten Sie, 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

/**
 * Berechnung der Entfernung und der Himmelsrichtung in Grad zwischen zwei Locatoren
 * sowie Bestimmung der Himmelsrichtung
 * (c)opyright by Conny Henn - www.DL2FBO.de
 * gerne nutzbar gegen kurze Info an mich conny@hennweb.de
 * @license GPL 2.0
 */

        
        function calculateDistanceAndDirection() {
            const locator1 = document.getElementById('locator1').value.toUpperCase();
            const locator2 = document.getElementById('locator2').value.toUpperCase();

            const latlon1 = locatorToLatLon(locator1);
            const latlon2 = locatorToLatLon(locator2);

            const distance  = calculateGreatCircleDistance(latlon1, latlon2);
            const direction = calculateGreatCircleDirection(latlon1, latlon2);
            const distancemiles = kilometersToMiles(distance);

            document.getElementById('distance').textContent = distance.toFixed(2);
            document.getElementById('distancemiles').textContent = distancemiles.toFixed(2);
            document.getElementById('direction').textContent = direction.toFixed(2);
        }

        function locatorToLatLon(locator) {
            const grid = locator.trim();
            const latBand = grid.charAt(1);
            const lonBand = grid.charAt(0);
            const lat1 = (latBand.charCodeAt(0) - 65) * 10 - 90;
            const lon1 = (lonBand.charCodeAt(0) - 65) * 20 - 180;
            const lat2 = lat1 + parseInt(grid.charAt(3)) * 2;
            const lon2 = lon1 + parseInt(grid.charAt(2)) * 4;

            return { lat: (lat1 + lat2) / 2, lon: (lon1 + lon2) / 2 };
        }

        function calculateGreatCircleDistance(latlon1, latlon2) {
            const R = 6371; // Radius der Erde in Kilometern

            const lat1 = latlon1.lat;
            const lon1 = latlon1.lon;
            const lat2 = latlon2.lat;
            const lon2 = latlon2.lon;

            const dLat = (lat2 - lat1) * (Math.PI / 180);
            const dLon = (lon2 - lon1) * (Math.PI / 180);

            const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
                Math.cos(lat1 * (Math.PI / 180)) * Math.cos(lat2 * (Math.PI / 180)) *
                Math.sin(dLon / 2) * Math.sin(dLon / 2);

            const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));

            const distance = R * c;
            return distance;
        }

        function calculateGreatCircleDirection(latlon1, latlon2) {
            const lat1 = latlon1.lat;
            const lon1 = latlon1.lon;
            const lat2 = latlon2.lat;
            const lon2 = latlon2.lon;

            const dLon = (lon2 - lon1) * (Math.PI / 180);

            const y = Math.sin(dLon) * Math.cos(lat2 * (Math.PI / 180));
            const x = Math.cos(lat1 * (Math.PI / 180)) * Math.sin(lat2 * (Math.PI / 180)) -
                Math.sin(lat1 * (Math.PI / 180)) * Math.cos(lat2 * (Math.PI / 180)) * Math.cos(dLon);

            let direction = Math.atan2(y, x) * (180 / Math.PI);

            direction = (direction + 360) % 360; // Konvertiere Richtung in den Bereich von 0 bis 360 Grad
			
            return direction;
        }
        function kilometersToMiles(kilometers) {
            const miles = kilometers * 0.621371;
            return miles;
        }

Locator Entfernung und Richtung mit Excel 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

Zeitunterschied zwischen zwei Locatoren bestimmen

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Locator Zeitunterschied</title>
    <script>
        function calculateTimeDifference() {
            // Eingabe-Locators abrufen
            var locator1 = document.getElementById('locator1').value.toUpperCase();
            var locator2 = document.getElementById('locator2').value.toUpperCase();

            // Eingabe-Locators in Breitengrad und Längengrad umwandeln
            var lat1 = locatorToDecimalDegrees(locator1.substring(0, 2));
            var lon1 = locatorToDecimalDegrees(locator1.substring(2, 4));

            var lat2 = locatorToDecimalDegrees(locator2.substring(0, 2));
            var lon2 = locatorToDecimalDegrees(locator2.substring(2, 4));

            // Zeitzone der aktuellen Position ermitteln
            var timeZone1 = getTimezone(lon1);
            var timeZone2 = getTimezone(lon2);

            // UTC-Zeit ermitteln
            var utcTime = new Date().toUTCString();

            // Sommerzeit überprüfen (Annahme: März bis Oktober)
            var isDaylightSavingTime = new Date().getTimezoneOffset() < Math.max(timeZone1, timeZone2);

            // Zeitunterschied in Stunden berechnen
            var timeDifference = Math.abs(lon1 - lon2) * 4 + (isDaylightSavingTime ? 1 : 0);

            // Ergebnis anzeigen
            document.getElementById('result').innerHTML = 'UTC-Zeit: ' + utcTime + '<br>Der Zeitunterschied beträgt: ' + timeDifference + ' Stunden';
        }

        function locatorToDecimalDegrees(locatorPart) {
            // Umwandlung des Locator-Teils in Dezimalgrad
            return (locatorPart.charCodeAt(0) - 'A'.charCodeAt(0)) * 10 + parseInt(locatorPart.charAt(1));
        }

        function getTimezone(longitude) {
            // Vereinfachte Annahme: Pro 15 Grad Längengrad eine Zeitzone
            var offset = Math.floor(longitude / 15);
            return offset;
        }
    </script>
</head>
<body>
    <h1>Locator Zeitunterschied Berechnung</h1>
    <form>
        <label for="locator1">Locator 1:</label>
        <input type="text" id="locator1" maxlength="6" pattern="[A-R]{2}[0-9]{2}" required>
        <br>
        <label for="locator2">Locator 2:</label>
        <input type="text" id="locator2" maxlength="6" pattern="[A-R]{2}[0-9]{2}" required>
        <br>
        <button type="button" onclick="calculateTimeDifference()">Zeitunterschied berechnen</button>
    </form>
    <p id="result"></p>
</body>
</html>

Lesezeit ca.: 8 min. - geändert am: 06.02.2024 um 11:25 Uhr - ID: 4459