Recherche d'œufs de Pâques avec GPS (GPS / GSM SIM 808) - partie 2

Partie 2

Dans la première partie de la série de blogs, nous avons aidé le lapin de Pâques à placer les œufs de Pâques dans des cachettes excitantes, que nous ne retrouverons qu'avec une assistance technique. Pour cela, nous l'avions équipé d'un récepteur GPS. La dissimulation et la lecture de la position ont été un jeu facile, car les valeurs étaient affichées sur notre écran et il suffisait de les noter.

Cette fois, la recherche nous pose de plus grands défis, car nous devons d'abord déterminer notre position actuelle, puis calculer le cap et la distance jusqu'à la destination. Cela nécessite un certain nombre de connaissances mathématiques, mais nous pouvons faire quelques simplifications en raison des courtes distances ici en Allemagne ou en Europe centrale.

De quoi avons-nous besoin ? Quant à la première partie :

Nombre	Composants
1	Carte microcontrôleur avec câble USB, compatible avec Arduino Uno R3
1	LCD, z.B. das LCD-Keypad-Shield
1	GPS/GSM Modul SIM 808 (im dritten Teil mit Sim-Karte)
	Pile ou batterie rechargeable

Nous faisons d'abord une expérience de pensée et reprenons l'image de l'orange, dont la forme est similaire à celle de notre terre. On épluche l'orange et on essaie d'aplatir un morceau d'écorce aussi grand que possible sur la table. Vous connaissez le résultat : la pelure se déchire à certains endroits. Mais plus le morceau d'épluchure est petit, plus il réussira et vous ne remarquerez pas la différence, ou à peine. Nous allons tirer parti de ce fait dans les considérations suivantes. Au lieu des formules de calcul pour la navigation au grand cercle, qui proviennent de la trigonométrie sphérique (sphère terrestre), je dérive des formules suffisamment exactes dans ce qui suit.

Mais on ne peut se passer des calculs de triangle (la trigonométrie est le mot grec pour mesure de triangle) avec M. Pythagore, les fonctions d'angle sin, cos et tan et un petit théorème des rayons. Récapitulons rapidement : nous traçons un cercle unitaire (rayon = 1) dans le système de coordonnées cartésiennes (axes x, y) et une ligne droite allant du centre à un point du cercle. En mathématiques (contrairement à la navigation), on compte l'angle (alpha) dans le sens inverse des aiguilles d'une montre à partir de l'axe des x. Ensuite, nous dessinons un triangle rectangle avec notre ligne droite comme hypoténuse et les cathéters parallèles aux axes. Il tient :

Le théorème de Pythagore :  H² = A² + g² avec H=Hypoténuse, A=Ancathetus et G=Countercathetus

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

où, au niveau du cercle unitaire, la longueur de H et de A' est de 1 chacun. Nous pouvons donc prendre les valeurs respectives des fonctions d'angle directement sur le dessin (par exemple, sur un cercle de 10 cm de rayon).

Vous pouvez voir que les valeurs du sinus et du cosinus peuvent être comprises entre -1 et +1, que pour la tangente, les valeurs sont inférieures à 1 pour les angles inférieurs à 45°, supérieures à 1 au-dessus de 45° et (attention :) infinies à 90° et 270°. Nous devrons en tenir compte plus tard.

Il y a autre chose que nous devons considérer : Il existe en mathématiques pour la description de l'angle non seulement la mesure du degré qui nous est familière. L'arc allant du point (1,0) sur l'axe des x au point P est également une valeur courante. La conversion est assez simple : le cercle des unités a une circonférence de 2πr avec r=1, donc 2π correspond à 360°, raccourci le facteur de conversion est donc π/180. Dans notre langage de programmation, il a été spécifié que ce radian est appliqué lors du calcul des fonctions d'angle. Ainsi, si nous avons immédiatement besoin du cosinus de la latitude, nous devons multiplier l'angle par π et le diviser par 180. Si nous utilisons ensuite la fonction inverse de la tangente pour calculer l'angle à partir duquel nous déterminons la trajectoire, nous devons multiplier la valeur par 180 et diviser par π.

On tient bon : la terre n'est pas un disque,

mais une enveloppe cylindrique déroulée (du moins notre carte avec projection Mercator). Nous pouvons simplifier nos calculs parce que nous vivons sous des latitudes tempérées et que nous déterminons le cap et la distance pour des distances relativement courtes entre le point de départ et la destination, où les différences entre les orthodromes (grand cercle) et les lignes de rhumb (égales au cap) n'ont pas d'importance.

Nous avons seulement besoin des différences d'angle respectives des positions géographiques ; dans le programme, nous les appelons deltaPhi pour la différence de latitude et deltaLambda pour la différence de longitude. A partir de là, nous calculons les cathetes de notre triangle auxiliaire, car nous avons besoin d'unités de longueur. C'est assez facile avec deltaPhi. D'après la première partie, nous savons qu'une minute d'arc sur le méridien/grand cercle = un mille nautique = 1,852 km. Ainsi, avec ce multiplicateur, notre cathetus opposé (dans le programme deltaY) est rapidement calculé. On se souvient aussi que la distance des méridiens, donc pour notre deltaLambda au pôle devient de plus en plus étroite. Par conséquent, le cosinus de la largeur moyenne, cos simplifié du point de départ, est ajouté comme multiplicateur supplémentaire, ainsi deltaX=deltaPhi(MM)*1,852*cos(Phi).

Avec deltaY et deltaX, je peux maintenant calculer la distance et l'angle mathématique entre notre point de départ et notre point d'arrivée. La distance est à vol d'oiseau, donc certainement plus courte que le chemin dans la nature. Et pour le calcul du cours, comme déjà indiqué ci-dessus, on doit convertir les mathématiques. Angle dans un angle de parcours. C'est très simple : tCourse = 90 - , avec =180*atan2(deltaY,deltaX) / π. Le parcours doit être compris entre 000 et 360, donc ajoutez ou soustrayez 360 si nécessaire. A propos, pour la fonction Arcus Tangente nous avons besoin de la bibliothèque math.h

Dans le croquis de la première partie, toute la touche gauche de notre écran de clavier LCD était occupée uniquement par le texte AZ-Delivery.com. Nous utilisons maintenant ce bouton pour le calcul et l'affichage du cap et de la distance aux points de passage. À titre d'exemple, j'ai inséré cinq points de repère dans le croquis. La touche SELECT est alors utilisée pour "basculer" vers les points de cheminement respectifs. Le cap et la distance sont toujours calculés à partir de la position actuelle jusqu'au waypoint correspondant, qui est sélectionné via l'index.

Pour utiliser le sketch pour la chasse aux œufs de Pâques, il suffit d'entrer dans les lignes les coordonnées données par le lapin de Pâques.

Flotter letwp [] = {5354.0000,4850.0000.5231.0000.5237.0000.5541.0000};

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

Entrez et définissez le nombre de points de passage à WaypointMax = 5.

The Sketch:

 /****************************************************************************
GPS avec écran LCD
Basé sur la bibliothèque DFROBOT_SIM808 et exemple SIM808_GETGPS par jason.lung@dfrobot.com
Adapté pour l'ONU, Nano et Compatible MCU et LCD1602 KeyPad Shield
Décalage pour MEZ = 1 heure, peut-être personnaliser pour Mesz -> Offset = 2
Le temps et le jour seront ajustés peu de temps après minuit, mais mois et année non.

Connexions:
TX du GPS Connect à A3 = GPIO 17 du clavier LCD
RX du GPS Connect à A4 = GPIO 18 du clavier LCD

Les Umlautes des textes ont été remplacées par les séquences d'échappement.
LCD.Print ("\ xe1"); // donne un ä
LCD.PRINT ("\ XEF"); // donne un Ö
LCD.PRINT ("\ XF5"); // donne un ü
lcd.print ("\ xe2"); // donne un ß
LCD.Print ("\ xdf"); // sorties a °
lcd.print ("\ x22"); // donne un "Out
LCD.Print ("\ xe4"); // sortira un μ
lcd.print ("\ xf4"); // sorties un Ω
*****************************************************************************/

#include
#include <softwaresérial.h>
#define pin_tx 17
#define pin_rx 18

// LCD n'a pas d'adaptateur I2C, transfert de données avec broches D4 à D7
#include
// broche LCD à Arduino
// const int pin_bl = 15;
const int pin_fr = 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;

LIBLECRYSTAL LCD (PIN_RS, PIN_EN, PIN_D4, PIN_D5, PIN_D6, PIN_D7);

// Décalage pour le temps, ici UTC ZU MEZ / MESZ
// Summertime Mesz: 2, Wintertime Mez: 1
#define offset 2

Mystère logiciel myserial (pin_tx, pin_rx);
DFROBOT_SIM808 SIM808 (& Myserial); // Connect RX, TX, PWR

// Unterbrechungsfreie Zaiteeuerung
non signé de long précédentsMillis = 0;
const long intervalle = 1000;

intent mois = 0;
int jour = 0;
int DayLClC = 0;
heures heure = 0;
int hourlcl = 0;
int minute = 0;
int seconde = 0;
flotteur lat = 0,0;
int LATDD = 0;
flotter latmmmmmm = 0,0;
int Latmm = 0;
INT LATDDDWP = 0;
flotter latmmmmmmwp = 0,0;
flotteur LATSSS = 0.0;
flotteur deltaphi = 0,0;
Float Deltay = 0.0;
flotteur lon = 0,0;
int londdd = 0;
flotteur lonmmmmmm = 0,0;
int Lonmm = 0;
int londdwp = 0;
flotteur lonmmmmmmwp = 0.0;
float lonss = 0.0;
flotteur Deltalambda = 0.0;
float deltax = 0,0;
vitesse de flotteur = 0,0;

flotter letwp [] = {5354.0000,4850.0000.5231.0000.5237.0000.5541.0000};
flotteur LONWP [] = {952.0000,1258.0000,1324.0000,973.0000 1235.0000};
int waypointindex = 0;
int waypointMax = 5;

Char Dirsn = 'n';
Charirew = 'E';
int tshourse;
distance flottante;

// Boutons
int botsinput = -1;
ButSonselect int = 0;
int botsinput_old = 0;
BOOL Buttonhold = False;

void setup() {
myserial.begin (9600);
Série.begin (9600);
lcd.begin (16,2); // initialiser l'écran LCD
lcd.clear ();
lcd.setcursor (0,0); // zählung débutant bei null, ts zeichen, Dann Zeile
LCD.Print ("az-delivery.com");
lcd.setcursor (0,1); // 0 = erstes Zeichen, 1 = Zeile Zweite

// ******** initialiser le module SIM808 *************
tandis que (! sim808.init ()) {
retard (1000);
Série.Print ("sim808 init erreur \ r \ n");
  }

// **************************************************************************************
Si (SIM808.ATTACHGPS ())
Serial.println ("Ouvrez le succès énergétique GPS");
autre
Série.println ("Ouvrir la panne de courant GPS");
}

Vide boucle () {

BoutonInput = bouton ();
// bouton muss losgelassen werden
Si (! Buttonhold) {
BoutonInput_old = BottonInput;
if (BottonInput == 4) WayPoindex + = 1;
boutonnée = vrai;
  }
Switch (BottonInput) {
Case 0: Serial.println ("0"); ButSonselect = 0; Pause;
Cas 1: Serial.println ("1"); ButSonselect = 1; Pause;
CAS 2: SERIAL.PRINTLN ("2"); ButSonselect = 2; Pause;
Cas 3: Serial.println ("3"); ButSonselect = 3; Pause;
CAS 4: SERIAL.PRINTLN ("4");

Si (WayPoindexDex> WayPointMax-1) WayPoindex = 0;
ButSonselect = 4;
Série.print ("waypoindexex");
Série.println (waypoindpoindex); Pause;
Par défaut: pause;
  }
// bouton loslassen pruefen
Si (BottonInput! = BottonInput_old) {
boutonnée = false;
  }


Si (millis () - PrécédentMillis> = Intervalle) {
// ************** Obtenir des données GPS *******************
Si (sim808.getgps ()) {
Mois = sim808.gpsdata.month;
Jour = sim808.gpsdata.day;
Daylcl = jour;
Heure = sim808.gpsdata.hour;
Hourlcl = heure + offset;
Minute = sim808.gpsdata.minute;
Deuxièmement = sim808.gpsdata.seconde;
Si (hourlcl> 24) {
Hourlcl = hourlcl-24;
Daylcl = daylcl + 1; }
Série.Print (sim808.gpsdata.year);
Série.Print ("/");
Série.Print (mois);
Série.Print ("/");
Série.Print (jour);
Série.Print ("");
Série.Print (heure);
Série.Print (":");
Séries.print (minute);
Série.Print (":");
Série.println (deuxième);
Lat = sim808.gpsdata.lat;
LATDD = INT (LAT);
LATMMMMMM = (LAT-LADDD) * 100;
LATDDDWP = INT (Latthp [WayPointindex] / 100);
LATMMMMMMWP = LATTWP [WayPointindex] - 100 * LATDDDDWP;
Deltaaphi = 60 * (LATDDDWP - LADDD) + (Latmmmmmmwp - Latmmmmmmm);
Deltay = Deltaphi * 1.852;
Série.Print ("Deltaphi =");
Série.println (Deltaphi);
Série.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 - LONMMMMMMM);
Deltax = Deltalambda * 1.852 * COS (DEG_TO_RAD * LAT);
Série.Print ("Deltalambda =");
Serial.println (Deltalambda);
Série.println (Deltax);
Série.Print ("latitude:");
Série.Print (LADD);
Série.Print ("°");
Série.Print (Latmmmmmmm, 4);
Série.println ("" n ");
Série.Print ("longitude:");
Si (LON <100.0) série.Print ("0");
Si (LON <10,0) série.Print ("0");
Série.Print (Londdd);
Série.Print ("°");
Série.Print (LONMMMMMMM, 4);
Série.println ("" E ");

Si (Deltax> 0) {
direw = "e";
Série.println (DIRET);
    }

sinon si (Deltalambda <0) {
direw = "w";
Série.println (DIRET);
    }

else {série.print ("NSNS"); }
Série.Print ("lon");
Série.println (lon);
Série.Print ("Londdd");
Série.println (Londdd);
Série.Print ("lonwp");
Série.Print (LONWP [WayPointindex]);
Série.println ("");
Série.Print ("latitude:");
Série.Print (LADD);
Série.Print ("°");
Série.Print (Latmmmmmmm, 4);
Série.println ("" n ");

Série.Print ("longitude:");
Si (LON <100.0) série.Print ("0");
Si (LON <10,0) série.Print ("0");
Série.Print (Londdd);
Série.Print ("°");
Série.Print (LONMMMMMMM, 4);
Série.println ("" E ");

Si (ABS (Deltay) <0.5) {
Si (Deltax <0.1 && Deltax> -0,1) {
Tcours = 1359;
Distance = 0;
      }
sinon si (Deltax> 0) {
Tcourse = 90;
Distance = Deltax;
      }
sinon si (Deltax <0) {
Tcourse = 270;
Distance = - Deltax;
      }
    }
 
sinon si (Deltay> 0) {
Si (Deltax <0.1 && Deltax> -0,1) {
Tcourse = 360;
Distance = Deltay;
      }
sinon si (Deltax> 0) {
Tcourse = (90 - rad_to_deg * Atan2 (Deltay, Deltax));
Distance = SQRT (carré (Deltax) + carré (Deltay));
      }
sinon si (Deltax <0) {
Tcourse = (90 - rad_to_deg * Atan2 (Deltay, Deltax));
Distance = SQRT (carré (Deltax) + carré (Deltay));
      }
    }
sinon si (Deltay <0) {
Si (Deltax <0.1 && Deltax> -0,1) {
Tcourse = 180;
Distance = -Deltay;
      }
sinon si (Deltax> 0) {
Tcourse = (90 - rad_to_deg * Atan2 (Deltay, Deltax));
Distance = SQRT (carré (Deltax) + carré (Deltay));
      }
sinon si (Deltax <0) {
Tcourse = (90 - rad_to_deg * Atan2 (Deltay, Deltax));
Distance = SQRT (carré (Deltax) + carré (Deltay));
      }
    }
Si (Tcourse <0) Tcourse = Tcourse + 360;
Si (Totours> 360) Tcourse = Tcours-360;
Série.Print ("vrai cours =");
Série.println (Tcourse);
Série.Print ("Distance =");
Série.println (distance);




Vitesse = sim808.gpsdata.speed_kph;
Si (vitesse> = 3.0) {
Série.Print ("vitesse_kph:");
Série.println (vitesse);
Série.Print ("Rubrique:");
Série.println (sim808.gpsdata.heading); }
autre {
Série.Print ("vitesse_kph:");
Série.println ("en dessous de 3");
Série.Print ("Rubrique:");
Série.println ("non déterminé"); }

Si (ButSonselect == 0) {
lcd.clear ();
      lcd.setcursor (0,0);
      LCD.Print (LADDD);
      LCD.Print ("\ xdf");
      Latmm = int (latmmmmmmm);
      LATSSSS = (LATMMMMMMM-LAMM) * 60;
      LCD.PRINT (LATMM);
      LCD.Print ("'");
      LCD.Print (LATSSS, 1);
      LCD.Print ("\ x22 \ n");
      lcd.setcursor (0,1);
      Si (LON <100.0) LCD.Print ("0");
      Si (LON <10,0) LCD.Print ("0");
      LCD.Print (Londdd);
      LCD.Print ("\ xdf");
      Lonmm = int (lonmmmmmmm);
      Lonss = (lonmmmmmmm-lonmm) * 60;
      Si (Lonmm <10) LCD.Print ("0");
      LCD.Print (Lonmm);
      LCD.Print ("'");
      Si (Lonss <10.0) LCD.Print ("0");
      LCD.Print (lonss, 1);
      lcd.print ("\ x22 \ e"); }

sinon si (boutonselect == 1) {
      lcd.clear ();
      lcd.setcursor (0,0);
      LCD.Print ("EUR:");
      si (daylcl <10) lcd.print ("0");
      LCD.Print (DayLCl);
      LCD.Print (".");
      Si (mois <10) LCD.Print ("0");
      LCD.Print (mois);
      LCD.Print (".");
      LCD.PRINT (SIM808.GPSDATA.YEAR);
      lcd.setcursor (5,1);
      if (hourlcl <10) lcd.print ("0");
      LCD.Print (hourlcl);
      LCD.Print (":");
      si (minute <10) LCD.Print ("0");
      LCD.Print (minute);
      LCD.Print (":");
      Si (deuxième <10) LCD.PRINT ("0");
      LCD.Print (deuxième);
    }
    sinon si (boutonselect == 2) {
      lcd.clear ();
      lcd.setcursor (0,0);
      LCD.Print ("UTC:");
      LCD.PRINT (SIM808.GPSDATA.YEAR);
      LCD.Print ("/");
      Si (mois <10) LCD.Print ("0");
      LCD.Print (mois);
      LCD.Print ("/");
      Si (jour <10) LCD.Print ("0");
      LCD.Print (jour);
      lcd.setcursor (5,1);
      if (heure <10) LCD.Print ("0");
      LCD.Print (heure);
      LCD.Print (":");
      Si (minute <10) LCD.Print ("0");
      LCD.Print (minute);
      LCD.Print (":");
      Si (deuxième <10) LCD.PRINT ("0");
      LCD.Print (deuxième);
    }
    sinon si (boutonselect == 3) {
      lcd.clear ();
      lcd.setcursor (0,0);
      LCD.Print (LADDD);
      LCD.Print ("\ xdf");
      LCD.Print (Latmmmmmmmm, 4);
      LCD.Print ("" N ");
      lcd.setcursor (0,1);
      Si (LON <100.0) LCD.Print ("0");
      Si (LON <10,0) LCD.Print ("0");
      LCD.Print (Londdd);
      LCD.Print ("\ xdf");
      Si (LONMMMMMM <10.0) LCD.PRINT ("0");
      LCD.PRINT (LONMMMMMMM, 4);
      LCD.Print ("" E "); }
      sinon si (boutonselect == 4) {
      lcd.clear ();
      lcd.setcursor (0,0);
      LCD.Print ("WP");
      LCD.PRINT (WayPointIndex);
      lcd.setcursor (5,0);
      LCD.Print ("Kurs");
      LCD.PRINT (TOTORE);
      lcd.setcursor (0,1);
      LCD.Print ("distanz");
      LCD.Print (distance);
    }
  //
// // ************** Éteignez la puissance GPS *************
// sim808.deachgps ();
PrécédentMillis = Millis ();
    }
  }
}

bouton int () {
int A0;
// Tous les boutons sont connectés à A0 via un diviseur de tension
// Les valeurs de l'ADC sont comprises entre 0 et 1023
// Si nécessaire, les valeurs doivent être légèrement modifiées
A0 = analogogread (0); //
Si (A0 <60) {
retour 0;
  }
sinon si (a0> = 60 && a0 <250) {
retour 1;
  }
sinon si (A0> = 250 && A0 <450) {
retour 2;
  }
sinon si (A0> = 450 && A0 <700) {
retour 3;
  }
sinon si (A0> = 700 && A0 <900) {
retour 4;
  }
autre {
boutonnée = false;
retour -1;
  }
} // bouton end ()

Maintenant, la chasse aux œufs de Pâques avec GPS ne devrait pas poser de problèmes. Nous vous souhaitons de belles vacances de Pâques en plein air et ensoleillées.