Ostereier suchen mit GPS (GPS / GSM SIM 808) - [Teil 2]

Im ersten Teil der Blog-Reihe haben wir den Osterhasen unterstützt, damit er die Ostereier in spannenden Verstecken ablegen kann, die wir nur mit technischer Unterstützung wiederfinden werden. Dafür hatten wir ihn mit einem GPS-Empfänger ausgestattet. Das Verstecken und Ablesen der Position war ein leichtes Spiel, denn die Werte wurden auf unserem Display angezeigt und mussten nur notiert werden.

Das Suchen stellt uns diesmal vor größere Herausforderungen, denn zunächst müssen wir unsere aktuelle Position bestimmen und dann Kurs und Entfernung zum Ziel berechnen. Das erfordert schon ein gewisses Maß an Mathematik-Kenntnissen, bei der wir aber aufgrund kurzer Distanzen bei uns in Deutschland oder Mitteleuropa einige Vereinfachungen machen können.

Was brauchen wir? Wie für den ersten Teil:

 
Zunächst machen wir einen Gedankenversuch und greifen noch einmal das Bild von der Apfelsine auf, die von der Form her unserer Erde ähnlich ist. Wir schälen die Apfelsine und versuchen, ein möglichst großes Stück Schale auf dem Tisch platt zu drücken. Das Ergebnis kennen Sie: die Schale wird an einigen Stellen einreißen. Aber je kleiner das Stück Schale ist, desto besser wird es gelingen und man wird den Unterschied nicht oder kaum bemerken. Diesen Umstand machen wir uns bei den folgenden Betrachtungen zunutze. Anstelle der Berechnungsformeln für die Großkreisnavigation, die aus der sphärischen Trigonometrie (Erd-Kugel) stammen, leite ich im Folgenden genügend genaue Formeln her.

Aber ganz ohne Dreiecksberechnungen (Trigonometrie ist das griechische Wort für Dreiecksmessung) mit Herrn Pythagoras, den Winkelfunktionen sin, cos und tan und ein wenig Strahlensatz kommen wir nicht aus. Kurze Wiederholung: Wir zeichnen im kartesischen Koordinatensystem (x,y-Achsen) einen Einheitskreis (Radius=1) und eine Gerade vom Mittelpunkt zu einem Punkt auf dem Kreis. In der Mathematik zählen wir (anders als in der Navigation) den Winkel  (alpha) entgegen dem Uhrzeigersinn von der x-Achse aus. Im nächsten Schritt zeichnen wir ein rechtwinkliges Dreieck mit unserer Geraden als Hypotenuse und den Katheten jeweils parallel zu den Achsen. Es gilt:

Satz von Pythagoras: H² = A² + G² mit H=Hypotenuse, A=Ankathete und G=Gegenkathete

sin  = G / H      cos  = A / H      tan  = G/A   und   tan  = G’/A’,

wobei am Einheitskreis die Länge von H und A‘ jeweils 1 ist. Wir können also die jeweiligen Werte für die Winkelfunktionen direkt der Zeichnung entnehmen (z.B. an einem Kreis mit 10 cm Radius).

Man erkennt, dass die Werte für Sinus und Cosinus zwischen -1 und +1 liegen können, für Tangens sind die Werte bei Winkeln kleiner als 45° kleiner als 1, über 45° größer als 1 und (aufgepasst:) bei 90° und 270° unendlich. Das müssen wir später berücksichtigen.

Etwas Weiteres müssen wir berücksichtigen: Es gibt in der Mathematik für die Beschreibung des Winkels nicht nur das uns vertraute Gradmaß. Der Kreisbogen vom Punkt (1,0) auf der x-Achse zum Punkt P ist ebenfalls ein gebräuchlicher Wert. Die Umrechnung erfolgt ganz einfach: Der Einheitskreis hat einen Umfang von 2πr mit r=1, also 2π entspricht 360°, gekürzt lautet der Umrechnungsfaktor also  π/180. In unserer Programmiersprache wurde festgelegt, dass bei der Berechnung der Winkelfunktionen dieses Bogenmaß angewendet wird. Wenn wir also gleich den Cosinus der geografischen Breite benötigen, müssen wir den Winkel mit π multiplizieren und durch 180 teilen. Wenn wir dann mit der Umkehrfunktion des Tangens den Winkel berechnen, aus dem wir den Kurs bestimmen, müssen wir den Wert mit 180 multiplizieren und durch π teilen.

Wir halten fest: Die Erde ist keine Scheibe,

sondern ein abgewickelter Zylindermantel (zumindest unsere Karte mit Mercator-Projektion). Wir können unsere Berechnungen vereinfachen, weil wir in den gemäßigten Breiten leben und Kurs und Distanz für verhältnismäßig kurze Entfernungen zwischen Start- und Zielpunkt ermitteln, bei denen die Unterschiede zwischen Orthodrome (Großkreis) und Loxodrome (Kursgleiche) nicht ins Gewicht fallen.

Wir benötigen nur die jeweiligen Winkeldifferenzen der geografischen Positionen; im Programm nennen wir sie deltaPhi für die Differenz der Breite und deltaLambda für die Differenz der Länge. Daraus berechnen wir die Katheten unseres Hilfsdreiecks, denn wir benötigen ja Längeneinheiten. Das geht bei deltaPhi ganz leicht. Aus dem ersten Teil wissen wir, dass eine Bogenminute auf dem Meridian/Großkreis = eine Seemeile = 1,852 km ist. Mit diesem Multiplikator ist also unsere Gegenkathete (im Programm deltaY) schnell berechnet. Wir erinnern uns auch, dass der Abstand der Meridiane, also für unser deltaLambda zum Pol hin immer schmaler wird. Deshalb kommt als weiterer Multiplikator der Cosinus der mittleren Breite, vereinfacht cos des Startpunkts dazu, also  deltaX=deltaPhi(MM)*1,852*cos(Phi).

Mit deltaY und deltaX kann ich nun die Distanz und den mathematischen Winkel zwischen unserem Start- und Zielpunkt berechnen. Die Distanz ist die Luftlinie, also sicherlich kürzer als der Weg in der freien Natur. Und bei der Kursberechnung müssen wir wie oben bereits angedeutet den math. Winkel in einen Kurswinkel umrechnen. Das geht ganz einfach: tCourse = 90 – , mit =180*atan2(deltaY,deltaX) / π. Der Kurs soll zwischen 000 und 360 liegen, also ggf. 360 addieren oder subtrahieren. Für die Funktion Arcus Tangens benötigen wir übrigens die Bibliothek math.h

Bei dem Sketch aus dem ersten Teil hatten wir die ganze linke Taste unseres LCD-Keypad-Shields nur mit dem Text AZ-Delivery.com belegt. Diese Taste nehmen wir jetzt für die Berechnung und Anzeige von Kurs und Distanz zu den Wegpunkten. Beispielhaft habe ich fünf Wegpunkte im Sketch eingefügt. Mit der Taste SELECT wird dann zu den jeweiligen Wegpunkten „getoggled“. Berechnet werden immer Kurs und Distanz von der aktuellen Position zum jeweiligen Wegpunkt, der über den Index angewählt wird.

Um den Sketch für die Ostereiersuche zu benutzen, müssen Sie nur die vom Osterhasen genannten Koordinaten in die Zeilen

float LATWP[] = {5354.0000,4850.0000,5231.0000,5237.0000,5541.0000};

float LONWP[] = {952.0000,1258.0000,1324.0000,973.0000,1235.0000};

eingeben und die Anzahl der Wegpunkte bei waypointMAX = 5 festlegen.

Download Sketch:

 /****************************************************************************
GPS mit LCD-Anzeige
basierend auf Bibliothek DFRobot_sim808 und Beispiel SIM808_GetGPS von jason.ling@dfrobot.com
Angepasst für UNO, Nano und kompatible MCUs und LCD1602 Keypad Shield
Offset für MEZ = 1 Stunde, ggf. anpassen für MESZ --> Offset=2
Uhrzeit und Tag werden kurz nach Mitternacht angepasst, jedoch Monat und Jahr nicht.

Anschlüsse:
TX des GPS verbinden mit A3 = GPIO 17 des LCD Keypad
RX des GPS verbinden mit A4 = GPIO 18 des LCD Keypad

Die Umlaute der Texte wurden durch die Escape-Sequenzen ersetzt.
lcd.print("\xE1"); // gibt ein ä aus
lcd.print("\xEF"); // gibt ein ö aus
lcd.print("\xF5"); // gibt ein ü aus
lcd.print("\xE2"); // gibt ein ß aus
lcd.print("\xDF"); // gibt ein ° aus
lcd.print("\x22"); // gibt ein " aus
lcd.print("\xE4"); // gibt ein µ aus
lcd.print("\xF4"); // gibt ein Ω aus
*****************************************************************************/

#include <DFRobot_sim808.h>
#include <SoftwareSerial.h>
#define PIN_TX 17
#define PIN_RX 18

// LCD has no I2C-Adapter, data transfer with Pins D4 to D7
#include <LiquidCrystal.h>
//LCD pin to Arduino
//const int pin_BL = 15;
const int pin_EN = 9;
const int pin_RS = 8;
const int pin_D4 = 4;
const int pin_D5 = 5;
const int pin_D6 = 6;
const int pin_D7 = 7;

LiquidCrystal lcd( pin_RS, pin_EN, pin_D4, pin_D5, pin_D6, pin_D7);

// Offset for Time, here UTC zu MEZ / MESZ
// Summertime MESZ: 2, Wintertime MEZ: 1
#define Offset 2

SoftwareSerial mySerial(PIN_TX,PIN_RX);
DFRobot_SIM808 sim808(&mySerial); //Connect RX,TX,PWR

// unterbrechungsfreie Zeitsteuerung
unsigned long previousMillis = 0;
const long interval = 1000;

int MONTH = 0;
int DAY = 0;
int DAYLCL = 0;
int HOUR = 0;
int HOURLCL = 0;
int MINUTE = 0;
int SECOND = 0;
float LAT = 0.0;
int LATDD = 0;
float LATMMmmmm = 0.0;
int LATMM = 0;
int LATDDWP = 0;
float LATMMmmmmWP = 0.0;
float LATSSs = 0.0;
float deltaPhi = 0.0;
float deltaY = 0.0;
float LON = 0.0;
int LONDDD = 0;
float LONMMmmmm = 0.0;
int LONMM = 0;
int LONDDWP = 0;
float LONMMmmmmWP = 0.0;
float LONSSs = 0.0;
float deltaLambda = 0.0;
float deltaX = 0.0;
float SPEED = 0.0;

float LATWP[] = {5354.0000,4850.0000,5231.0000,5237.0000,5541.0000};
float LONWP[] = {952.0000,1258.0000,1324.0000,973.0000,1235.0000};
int waypointIndex = 0;
int waypointMAX = 5;

char dirSN = 'N';
char dirEW = 'E';
int tCourse;
float distance;

// Buttons
int buttonInput = -1;
int buttonSelect = 0;
int buttonInput_old = 0;
bool buttonHold = false;

void setup() {
  mySerial.begin(9600);
  Serial.begin(9600);
  lcd.begin(16,2); // initialize the lcd
  lcd.clear();
  lcd.setCursor(0,0); //Zählung beginnt bei Null, erst Zeichen, dann Zeile
  lcd.print("AZ-Delivery.com");
  lcd.setCursor(0,1); // 0=Erstes Zeichen, 1=zweite Zeile

  //******** Initialize sim808 module *************
  while(!sim808.init()) {
    delay(1000);
    Serial.print("Sim808 init error\r\n");
  }

  //************* Turn on the GPS power************
  if( sim808.attachGPS())
    Serial.println("Open the GPS power success");
  else
    Serial.println("Open the GPS power failure");
}

void loop() {

  buttonInput = Button();
  // Button muss losgelassen werden
  if (!buttonHold) {
    buttonInput_old = buttonInput;
    if (buttonInput==4) waypointIndex+=1;
    buttonHold = true;
  }
  switch (buttonInput) {
    case 0: Serial.println("0");buttonSelect=0; break;
    case 1: Serial.println("1");buttonSelect=1; break;
    case 2: Serial.println("2");buttonSelect=2; break;
    case 3: Serial.println("3");buttonSelect=3; break;
    case 4: Serial.println("4");

  if (waypointIndex>waypointMAX-1) waypointIndex=0;
  buttonSelect=4;
  Serial.print("waypointIndex ");
  Serial.println(waypointIndex); break;
  default: break;
  }
  //Button loslassen pruefen
  if (buttonInput != buttonInput_old) {
    buttonHold = false;
  }


  if (millis() - previousMillis >= interval) {
  //************** Get GPS data *******************
  if (sim808.getGPS()) {
    MONTH = sim808.GPSdata.month;
    DAY = sim808.GPSdata.day;
    DAYLCL = DAY;
    HOUR = sim808.GPSdata.hour;
    HOURLCL = HOUR + Offset;
    MINUTE = sim808.GPSdata.minute;
    SECOND = sim808.GPSdata.second;
    if (HOURLCL>24) {
      HOURLCL = HOURLCL-24;
      DAYLCL = DAYLCL + 1; }
    Serial.print(sim808.GPSdata.year);
    Serial.print("/");
    Serial.print(MONTH);
    Serial.print("/");
    Serial.print(DAY);
    Serial.print(" ");
    Serial.print(HOUR);
    Serial.print(":");
    Serial.print(MINUTE);
    Serial.print(":");
    Serial.println(SECOND);
    LAT = sim808.GPSdata.lat;
    LATDD = int(LAT);
    LATMMmmmm = (LAT - LATDD)*100;
    LATDDWP = int(LATWP[waypointIndex]/100);
    LATMMmmmmWP = LATWP[waypointIndex] - 100*LATDDWP;
    deltaPhi = 60*(LATDDWP - LATDD) + (LATMMmmmmWP - LATMMmmmm);
    deltaY = deltaPhi * 1.852;
    Serial.print("deltaPhi = ");
    Serial.println(deltaPhi);
    Serial.println(deltaY);

    LON = sim808.GPSdata.lon;
    LONDDD = int(LON);
    LONMMmmmm = (LON - LONDDD)*100;
    LONDDWP = int(LONWP[waypointIndex]/100);
    LONMMmmmmWP = LONWP[waypointIndex] - 100*LONDDWP;
    deltaLambda = 60*(LONDDWP - LONDDD) + (LONMMmmmmWP - LONMMmmmm);
    deltaX = deltaLambda * 1.852 * cos(DEG_TO_RAD * LAT);
    Serial.print("deltaLambda = ");
    Serial.println(deltaLambda);
    Serial.println(deltaX);
    Serial.print("latitude: ");
    Serial.print(LATDD);
    Serial.print("°");
    Serial.print(LATMMmmmm,4);
    Serial.println("'N");
    Serial.print("longitude: ");
    if (LON<100.0) Serial.print("0");
    if (LON<10.0) Serial.print("0");
    Serial.print(LONDDD);
    Serial.print("°");
    Serial.print(LONMMmmmm,4);
    Serial.println("'E");

    if (deltaX>0) {
      dirEW = "E";
      Serial.println(dirEW);
    }

    else if (deltaLambda<0) {
      dirEW = "W";
      Serial.println(dirEW);
    }

    else {Serial.print("NSNS"); }
    Serial.print("LON ");
    Serial.println(LON);
    Serial.print("LONDDD ");
    Serial.println(LONDDD);
    Serial.print("LONWP");
    Serial.print(LONWP[waypointIndex]);
    Serial.println("");
    Serial.print("latitude: ");
    Serial.print(LATDD);
    Serial.print("°");
    Serial.print(LATMMmmmm,4);
    Serial.println("'N");

    Serial.print("longitude: ");
    if (LON<100.0) Serial.print("0");
    if (LON<10.0) Serial.print("0");
    Serial.print(LONDDD);
    Serial.print("°");
    Serial.print(LONMMmmmm,4);
    Serial.println("'E");

    if (abs(deltaY)<0.5) {
      if (deltaX < 0.1 && deltaX > -0.1) {
        tCourse = 1359;
        distance = 0;
      }
      else if (deltaX > 0) {
        tCourse = 90;
        distance = deltaX;
      }
      else if (deltaX < 0) {
        tCourse = 270;
        distance = - deltaX;
      }
    }
 
    else if (deltaY>0) {
      if (deltaX < 0.1 && deltaX > -0.1) {
        tCourse = 360;
        distance = deltaY;
      }
      else if (deltaX > 0) {
        tCourse = (90 - RAD_TO_DEG*atan2(deltaY,deltaX));
        distance = sqrt(square(deltaX) + square(deltaY));
      }
      else if (deltaX < 0) {
        tCourse = (90 - RAD_TO_DEG*atan2(deltaY,deltaX));
        distance = sqrt(square(deltaX) + square(deltaY));
      }
    }
    else if (deltaY<0) {
      if (deltaX < 0.1 && deltaX > -0.1) {
        tCourse = 180;
        distance = -deltaY;
      }
      else if (deltaX > 0) {
        tCourse = (90 - RAD_TO_DEG*atan2(deltaY,deltaX));
        distance = sqrt(square(deltaX) + square(deltaY));
      }
      else if (deltaX < 0) {
        tCourse = (90 - RAD_TO_DEG*atan2(deltaY,deltaX));
        distance = sqrt(square(deltaX) + square(deltaY));
      }
    }
    if (tCourse < 0) tCourse = tCourse+360;
    if (tCourse > 360) tCourse = tCourse-360;
    Serial.print("True Course = ");
    Serial.println(tCourse);
    Serial.print("Distance = ");
    Serial.println(distance);




    SPEED = sim808.GPSdata.speed_kph;
    if (SPEED >= 3.0) {
      Serial.print("speed_kph: ");
      Serial.println(SPEED);
      Serial.print("heading: ");
      Serial.println(sim808.GPSdata.heading); }
    else {
      Serial.print("speed_kph :");
      Serial.println("below 3");
      Serial.print("heading :");
      Serial.println("not determined"); }

    if (buttonSelect==0) {
      lcd.clear();
      lcd.setCursor(0,0);
      lcd.print(LATDD);
      lcd.print("\xDF");
      LATMM = int(LATMMmmmm);
      LATSSs = (LATMMmmmm-LATMM)*60;
      lcd.print(LATMM);
      lcd.print("'");
      lcd.print(LATSSs,1);
      lcd.print("\x22\ N");
      lcd.setCursor(0,1);
      if (LON<100.0) lcd.print("0");
      if (LON<10.0) lcd.print("0");
      lcd.print(LONDDD);
      lcd.print("\xDF");
      LONMM = int(LONMMmmmm);
      LONSSs = (LONMMmmmm-LONMM)*60;
      if (LONMM<10) lcd.print("0");
      lcd.print(LONMM);
      lcd.print("'");
      if (LONSSs<10.0) lcd.print("0");
      lcd.print(LONSSs,1);
      lcd.print("\x22\ E"); }

    else if (buttonSelect==1) {
      lcd.clear();
      lcd.setCursor(0,0);
      lcd.print("EUR: ");
      if (DAYLCL<10) lcd.print("0");
      lcd.print(DAYLCL);
      lcd.print(".");
      if (MONTH<10) lcd.print("0");
      lcd.print(MONTH);
      lcd.print(".");
      lcd.print(sim808.GPSdata.year);
      lcd.setCursor(5,1);
      if (HOURLCL<10) lcd.print("0");
      lcd.print(HOURLCL);
      lcd.print(":");
      if (MINUTE<10) lcd.print("0");
      lcd.print(MINUTE);
      lcd.print(":");
      if (SECOND<10) lcd.print("0");
      lcd.print(SECOND);
    }
    else if (buttonSelect==2) {
      lcd.clear();
      lcd.setCursor(0,0);
      lcd.print("UTC: ");
      lcd.print(sim808.GPSdata.year);
      lcd.print("/");
      if (MONTH<10) lcd.print("0");
      lcd.print(MONTH);
      lcd.print("/");
      if (DAY<10) lcd.print("0");
      lcd.print(DAY);
      lcd.setCursor(5,1);
      if (HOUR<10) lcd.print("0");
      lcd.print(HOUR);
      lcd.print(":");
      if (MINUTE<10) lcd.print("0");
      lcd.print(MINUTE);
      lcd.print(":");
      if (SECOND<10) lcd.print("0");
      lcd.print(SECOND);
    }
    else if (buttonSelect==3) {
      lcd.clear();
      lcd.setCursor(0,0);
      lcd.print(LATDD);
      lcd.print("\xDF");
      lcd.print(LATMMmmmm,4);
      lcd.print("' N");
      lcd.setCursor(0,1);
      if (LON<100.0) lcd.print("0");
      if (LON<10.0) lcd.print("0");
      lcd.print(LONDDD);
      lcd.print("\xDF");
      if (LONMMmmmm<10.0) lcd.print("0");
      lcd.print(LONMMmmmm,4);
      lcd.print("' E"); }
      else if (buttonSelect==4) {
      lcd.clear();
      lcd.setCursor(0,0);
      lcd.print("WP");
      lcd.print(waypointIndex);
      lcd.setCursor(5,0);
      lcd.print("Kurs ");
      lcd.print(tCourse);
      lcd.setCursor(0,1);
      lcd.print("Distanz ");
      lcd.print(distance);
    }
  //
  // //************* Turn off the GPS power ************
  // sim808.detachGPS();
    previousMillis = millis();
    }
  }
}

int Button() {
  int A0;
  // all buttons are connected to A0 via voltage divider
  // Values of ADC are between 0 and 1023
  // if necessary, values must be changed slightly
  A0 = analogRead(0); //
  if (A0 < 60) {
    return 0;
  }
  else if (A0 >= 60 && A0 < 250) {
    return 1;
  }
  else if (A0 >= 250 && A0 < 450){
    return 2;
  }
  else if (A0 >= 450 && A0 < 700){
    return 3;
  }
  else if (A0 >= 700 && A0 < 900){
    return 4;
  }
  else {
    buttonHold = false;
    return -1;
  }
} //end Button()

Nun sollte die Ostereiersuche mit GPS keine Probleme mehr bereiten. Wir wünschen Ihnen schöne und sonnige Osterfeiertage in der freien Natur.

Wichtiger Hinweis für diejenigen, die den Sketch ohne Sim-Karte benutzen möchten. Bitte diese Zeilen auskommentieren, weil ohne Sim-Karte Endlosschleife.

//******** Initialize sim808 module *************
while(!sim808.init()) {
  delay(1000);
  Serial.print(“Sim808 init error\r\n”);
}

Download Teil 2