Module GPS ESP32 NEO-M8N: enregistreur et affichage sur Google Earth

Apprenez à interfacer le module GPS NEO-M8N avec l’ESP32 programmé avec Arduino IDE pour obtenir des données GPS: latitude, la longitude, l’altitude, le temps UTC, le nombre de satellites visibles, et plus encore. Enfin, nous vous montrerons comment enregistrer les données GPS dans un fichier sur une carte microSD et comment gérer ces données pour afficher un chemin sur Google Earth.

En résumé, dans ce tutoriel, vous apprendrez à:

• Câblez le module GPS NEO-M8N à l’ESP32 via la série;
• Obtenir des données GPS brutes;
• Analyser les données brutes pour obtenir des informations GPS sélectionnées et lisibles;
• Obtenez votre emplacement actuel;
• Enregistrez l’emplacement à un fichier sur la carte microSD;
• Transformez vos données en un fichier .kml que Google Earth peut lire;
• Téléchargez le fichier .kml sur Google Earth pour afficher un chemin.

Table des matières

Nous couvrirons les sujets suivants:

Condition préalable

Ce tutoriel se concentre sur la programmation de l’ESP32 à l’aide du noyau Arduino. Avant de continuer, vous devriez avoir le noyau Arduino ESP32 installé dans votre IDE Arduino. Suivez le prochain tutoriel pour installer l’ESP32 sur l’ide Arduino, si vous ne l’avez pas déjà fait.

Présentation du module GPS NEO-M8N

Le module GPS NEO-M8N est l’un des récepteurs GPS les plus populaires utilisés avec les microcontrôleurs dans les projets de navigation et de suivi. Il peut obtenir des données sur la latitude, la longitude, l’altitude et le temps.

Il prend en charge plusieurs systèmes satellites, y compris GPS, Galileo, Glonass et Beidou. Il offre un meilleur suivi des satellites que le NEO-6M, ce qui le rend plus fiable dans des conditions difficiles.

Selon la fiche technique, il a une précision de position horizontale de 2,5 à 4 mètres et des temps de démarrage rapides (1 seconde pour le démarrage à chaud, 26 à 57 secondes pour le démarrage à froid – il est perfectionné des temps plus longs si vous êtes proche des bâtiments).

Le module comprend une batterie de sauvegarde, une EEPROM intégrée et un indicateur LED qui clignote lorsqu’un correctif de position est atteint.

Ce module est généralement livré avec une antenne GPS en céramique. Mais, vous pouvez le changer en toute autre antenne compatible qui pourrait mieux convenir à votre projet. Par exemple, j’aime utiliser celui à droite dans l’image ci-dessous car il est étanche, et l’antenne est livrée avec un long câble qui permet plus de flexibilité.

Le module GPS NEO-M8N communique avec un microcontrôleur utilisant le protocole de communication série et fonctionne avec des phrases NMEA standard. NMEA signifie National Marine Electronics Association, et dans le monde du GPS, il s’agit d’un format de données standard soutenu par les fabricants GPS.

Où acheter?

Vous pouvez consulter notre page d’outils de conseiller Maker pour comparer le prix du module du récepteur GPS NEO-M8N dans différents magasins:

Vous pouvez utiliser les liens précédents ou aller directement à makeradvisor.com/tools pour trouver toutes les pièces de vos projets au meilleur prix!

Câblage du module GPS NEO-M8N à l’ESP32

Nous connecterons le module GPS NEO-M8N à l’aide des broches UART2 par défaut ESP32. Vous pouvez utiliser l’image et la table suivantes comme référence.

Obtenir des données GPS brutes – Tester le module GPS NEO-M8N avec l’ESP32

Pour obtenir des données GPS brutes, vous devez démarrer une communication série avec le module GPS et lire les données disponibles.

Le code suivant établit une communication série avec le module GPS et lit les données disponibles.

/*********
  Rui Santos & Sara Santos - Raspberryme.com
  Complete instructions at https://Raspberryme.com/esp32-neo-m8n-gps-logger-google-earth/
  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files.
  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*********/

 // Define the RX and TX pins for Serial 2
#define RXD2 16
#define TXD2 17

#define GPS_BAUD 9600

// Create an instance of the HardwareSerial class for Serial 2
HardwareSerial gpsSerial(2);

void setup(){
  // Serial Monitor
  Serial.begin(115200);
  
  // Start Serial 2 with the defined RX and TX pins and a baud rate of 9600
  gpsSerial.begin(GPS_BAUD, SERIAL_8N1, RXD2, TXD2);
  Serial.println("Serial 2 started at 9600 baud rate");
}

void loop(){
  while (gpsSerial.available() > 0){
    // get the byte data from the GPS
    char gpsData = gpsSerial.read();
    Serial.print(gpsData);
  }
  delay(1000);
  Serial.println("-------------------------------");
}

Afficher le code brut

Comment fonctionne le code?

Ce croquis suppose que vous utilisez GPIO 16 et GPIO 17 comme broches en série RX et TX pour établir une communication série avec le module GPS. Si vous utilisez d’autres broches, vous devez le modifier sur les lignes suivantes:

// Define the RX and TX pins for Serial 2
#define RXD2 16
#define TXD2 17

De plus, si votre module utilise un taux de bauds par défaut différent de 9600 bps, vous devez modifier le code sur la ligne suivante:

#define GPS_BAUD 9600

Ensuite, nous créons une instance du hardwareserial pour utiliser UART 2 appelé gpserial.

// Create an instance of the HardwareSerial class for Serial 2
HardwareSerial gpsSerial(2);

Dans la configuration (), nous initions le moniteur série.

// Serial Monitor
Serial.begin(115200);

Ensuite, nous initialisons une communication série avec le module GPS.

// Start Serial 2 with the defined RX and TX pins and a baud rate of 9600
gpsSerial.begin(GPS_BAUD, SERIAL_8N1, RXD2, TXD2);
Serial.println("Serial 2 started at 9600 baud rate");

Dans la boucle (), le code écoute le port série GPS, et lorsque les données sont reçues du module, il est imprimé dans le moniteur série.

void loop(){
  while (gpsSerial.available() > 0){
    // get the byte data from the GPS
    char gpsData = gpsSerial.read();
    Serial.print(gpsData);
  }
  delay(1000);
  Serial.println("-------------------------------");
}

Tester le code

Téléchargez le code sur votre carte.

Assurez-vous que l’antenne est connectée et que le module ou l’antenne est placé à l’extérieur ou à côté d’une fenêtre afin qu’il puisse obtenir des données des satellites.

La LED bleue du module commencera à clignoter lorsqu’il trouvera une solution de position.

Le moniteur série affichera les phrases NMEA avec les données GPS.

IMPORTANT: Si vous exécutez ce croquis pour la première fois, cela peut prendre quelques minutes jusqu’à ce que le module obtienne un correctif de position. Vous commencerez à obtenir des données réelles lorsque la LED bleue commencera à clignoter. Si vous êtes dans un bâtiment, il est très peu probable que vous puissiez obtenir des données GPS. Sortez ou placez votre antenne à l’extérieur pour maximiser vos chances d’attraper un signal satellite.

Vous devriez obtenir un tas d’informations dans la langue standard GPS, NMEA. Chaque ligne que vous obtenez dans le moniteur série est une phrase NMEA.

NMEA signifie National Marine Electronics Association, et dans le monde du GPS, il s’agit d’un format de données standard soutenu par les fabricants GPS.

Phrases NMEA

Les phrases NMEA commencent par le caractère $ et chaque champ de données est séparé par une virgule.

$GNRMC,115209.00,A,4114.5500,N,00861.4900,W,0.129,,160125,,,D*XX
$GNVTG,,T,,M,0.129,N,0.239,K,D*XX
$GNGGA,115209.00,4114.5500,N,00861.4900,W,2,10,0.93,130.6,M,50.1,M,,0000*XX
$GNGSA,A,3,24,25,28,32,29,,,,,,,,1.65,0.93,1.37*XX
$GNGSA,A,3,78,66,67,77,,86,26,083,20*XX
$GLGSV,3,3,09,87,13,131,*XX
$GNGLL,4114.5500,N,00861.4900,W,115209.00,A,D*XX

Il existe différents types de phrases NMEA. Le type de message est indiqué par les caractères avant la première virgule.

Le GN après le $ indique qu’il s’agit d’une position GPS. Le $ GNGGA est le message GNSS NMEA de base, qui fournit des données d’emplacement et de précision 3D.

Dans la phrase suivante:

$GNGGA,110827.00,4114.32485,N,00831.79799,W,1,10,0.93,130.6,M,50.1,M,,*5F

Voici comment les champs recherchent le M8N:

• $ GNGGA: données de localisation GNSS globales.
• 110827.00: Temps en UTC (11:08:27).
• 4114.32485, n: latitude.
• 00831.79799, W: Longitude.
• 1: Fix Quality (1 = correction GPS, 2 = DGPS, etc.).
• 10: Nombre de satellites suivis (plus élevés pour M8N par rapport à NEO-6M).
• 0,93: dilution horizontale de précision (plus bas est meilleur).
• 130,6, M: Altitude au-dessus du niveau moyen de la mer (en mètres).
• 50.1, M: hauteur du géoïde au-dessus de l’ellipsoïde WGS84.
• * 5f: somme de contrôle recalculée pour le NEO-M8N.

Les autres phrases NMEA fournissent des informations supplémentaires:

• $ Gnrmc – Données essentielles GNSS Pvt (position, vitesse, temps)
• $ Gnvtg – Informations sur la vitesse et la suite
• $ GNGGA – GNSS Correction des informations
• $ GNGSA – GNSS DOP et satellites actifs
• $ GLGSV – Informations sur satellite détaillées (GLONASS)
• $ Gngll – latitude géographique et la longitude.

Pour plus d’informations sur les phrases NMEA, j’ai trouvé ce site Web avec des informations très détaillées.

Vous pouvez utiliser cet analyseur NME en ligne et coller vos phrases là-bas pour interpréter les données GPS.

Cependant, le moyen le plus simple d’obtenir et d’interpréter les données GPS que vous souhaitez est d’analyser vos phrases NMEA directement dans le code. Pour cela, nous pouvons utiliser la bibliothèque TinyGPSPlus qui fournit facilement des méthodes pour extraire les données des phrases NMEA.

Analyser les phrases NMEA avec une bibliothèque TinygPsplus

La bibliothèque TinyGPSPlus permet d’obtenir des données GPS simples dans un format facile à comprendre. Vous pouvez cliquer ici pour plus d’informations sur la bibliothèque TinyGPSPlus.

Installation de la bibliothèque TinyGPSPlus

Dans le Arduino IDE, allez dans Sketch> Inclure la bibliothèque> Gérer les bibliothèques ou cliquez sur l’icône du gestionnaire de bibliothèque dans la barre latérale gauche.

Recherchez TinyGPSPlus et installez la bibliothèque par Mikal Hart.

Obtenir des données GPS à l’aide du module GPS NEO-M8N et de la bibliothèque TinyGPSPlus

Le code suivant montre comment obtenir des données GPS à l’aide de la bibliothèque TinyGPSPlus. Nous obtiendrons la date, l’heure, la vitesse, l’altitude, le nombre de satellites visibles et le HDOP (une mesure de la précision du signal).

/*********
  Rui Santos & Sara Santos - Raspberryme.com
  Complete instructions at https://Raspberryme.com/esp32-neo-m8n-gps-logger-google-earth/
  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files.
  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*********/

#include 

// Define the RX and TX pins for Serial 2
#define RXD2 16
#define TXD2 17

#define GPS_BAUD 9600

// The TinyGPS++ object
TinyGPSPlus gps;

// Create an instance of the HardwareSerial class for Serial 2
HardwareSerial gpsSerial(2);

void setup() {
  // Serial Monitor
  Serial.begin(115200);
  
  // Start Serial 2 with the defined RX and TX pins and a baud rate of 9600
  gpsSerial.begin(GPS_BAUD, SERIAL_8N1, RXD2, TXD2);
  Serial.println("Serial 2 started at 9600 baud rate");
}

void loop() {
  // This sketch displays information every time a new sentence is correctly encoded.
  unsigned long start = millis();

  while (millis() - start < 1000) {
    while (gpsSerial.available() > 0) {
      gps.encode(gpsSerial.read());
    }
    if (gps.location.isUpdated()) {
      Serial.print("LAT: ");
      Serial.println(gps.location.lat(), 6);
      Serial.print("LONG: "); 
      Serial.println(gps.location.lng(), 6);
      Serial.print("SPEED (km/h) = "); 
      Serial.println(gps.speed.kmph()); 
      Serial.print("ALT (min)= "); 
      Serial.println(gps.altitude.meters());
      Serial.print("HDOP = "); 
      Serial.println(gps.hdop.value() / 100.0); 
      Serial.print("Satellites = "); 
      Serial.println(gps.satellites.value()); 
      Serial.print("Time in UTC: ");
      Serial.println(String(gps.date.year()) + "/" + String(gps.date.month()) + "/" + String(gps.date.day()) + "," + String(gps.time.hour()) + ":" + String(gps.time.minute()) + ":" + String(gps.time.second()));
      Serial.println("");
    }
  }
}

Afficher le code brut

Comment fonctionne le code?

Vous commencez par importer la bibliothèque TinyGPSPlus.

#include 
#include 

Ensuite, vous définissez les broches UART 2 RX et TX et le taux de bauds GPS. Si votre carte utilise différentes broches UART 2, ou si le module GPS utilise un taux de bauds différent, vous pouvez les modifier sur les lignes suivantes.

// Define the RX and TX pins for Serial 2
#define RXD2 16
#define TXD2 17

#define GPS_BAUD 9600

Ensuite, vous créez un objet TinyGPSPlus:

TinyGPSPlus gps;

Créez une instance de la classe Hardwareserial pour Serial 2 appelé gpserial.

HardwareSerial gpsSerial(2);

Dans la configuration (), initialisez le moniteur série et la communication série avec le module GPS.

void setup() {
  // Serial Monitor
  Serial.begin(115200);
  
  // Start Serial 2 with the defined RX and TX pins and a baud rate of 9600
  gpsSerial.begin(GPS_BAUD, SERIAL_8N1, RXD2, TXD2);
  Serial.println("Serial 2 started at 9600 baud rate");
}

Dans la boucle (), vous demandez les informations. Analyser les données du module GPS dans l’objet TinyGPSPlus à l’aide de la méthode Encode () comme suit.

while (gpsSerial.available() > 0) {
  gps.encode(gpsSerial.read());
}

Ensuite, vous pouvez interroger l’objet GPS pour voir si des champs de données ont été mis à jour:

if (gps.location.isUpdated()) {

S’il y a de nouvelles données, nous pouvons l’obtenir comme suit:

Dans le code, nous obtenons les données et imprimons toutes les informations du moniteur série.

Serial.print("LAT: ");
Serial.println(gps.location.lat(), 6);
Serial.print("LONG: "); 
Serial.println(gps.location.lng(), 6);
Serial.print("SPEED (km/h) = "); 
Serial.println(gps.speed.kmph()); 
Serial.print("ALT (min)= "); 
Serial.println(gps.altitude.meters());
Serial.print("HDOP = "); 
Serial.println(gps.hdop.value() / 100.0); 
Serial.print("Satellites = "); 
Serial.println(gps.satellites.value()); 
Serial.print("Time in UTC: ");
Serial.println(String(gps.date.year()) + "/" + String(gps.date.month()) + "/" + String(gps.date.day()) + "," + String(gps.time.hour()) + ":" + String(gps.time.minute()) + ":" + String(gps.time.second()));
Serial.println("");

Tester le code

Téléchargez le code sur votre carte ESP32. Ouvrez le moniteur en série à un taux en bauds de 115200. Assurez-vous que votre module GPS est placé à l’extérieur ou à côté d’une fenêtre pour obtenir des données à partir de satellites.

Remarque: vous devrez peut-être attendre quelques secondes ou minutes jusqu’à ce que le module puisse obtenir un correctif de position.

Vous obtiendrez des données sur le moniteur en série sur votre emplacement actuel, votre vitesse, votre altitude, votre nombre de satellites visibles HDOP et votre temps.

HDOP signifie dilution horizontale de précision. Il s’agit d’une mesure de la précision de fixation de position. Plus la valeur HDOP est élevée, moins le correctif de position sera précis. Idéalement, vous devriez obtenir une valeur inférieure à 2. Une valeur inférieure signifie une meilleure précision.

Enregistreur GPS et chemin d’affichage sur Google Earth

Maintenant que vous êtes plus familier avec l’utilisation du module GPS NEO-M8N avec l’ESP32, créons un enregistreur GPS qui enregistre votre emplacement au fil du temps dans un fichier sur une carte microSD. Ensuite, vous pouvez modifier et utiliser ce fichier sur Google Earth pour visualiser comment l’emplacement a changé au fil du temps (chemin).

Aperçu du projet

Voici un aperçu rapide du fonctionnement de ce projet:

• L’ESP32 est connecté au module GPS NEO-M8N et obtient des données sur l’emplacement;
• Lorsque l’emplacement change au moins un mètre, nous enregistrons les données de localisation (latitude, longitude et altitude) dans un fichier sur la carte microSD;
• Pour visualiser les données sur Google Earth, nous vous montrerons comment convertir manuellement un fichier .txt avec les coordonnées d’emplacement en un fichier .kml que Google Earth peut lire;
• Nous vous montrerons comment télécharger le .KML sur Google Earth pour visualiser ce chemin.

Pièces requises

Voici une liste des pièces requises pour ce projet:

Vous pouvez utiliser les liens précédents ou aller directement à makeradvisor.com/tools pour trouver toutes les pièces de vos projets au meilleur prix!

Câblage du circuit

Tirez le module GPS vers les broches UART2 par défaut ESP32 (comme nous l’avons fait précédemment) et le module de carte microSD vers les broches SPI par défaut ESP32. Vous pouvez utiliser le diagramme suivant ou les tables suivantes comme référence.

Vous aimerez peut-être également lire: ESP32: Guide pour le module de carte microSD à l’aide d’Arduino IDE.

Code

Le code suivant initialise la carte microSD et le module GPS et enregistre les données GPS dès que les points de données sont disponibles et que le nouveau point est à au moins 1 mètre de la précédente.

/*********
  Rui Santos & Sara Santos - Raspberryme.com
  Complete instructions at https://Raspberryme.com/esp32-neo-m8n-gps-logger-google-earth/
  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files.
  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*********/

#include 
#include 
#include 
#include 

// Define the RX and TX pins for Serial 2
#define RXD2 16
#define TXD2 17

#define GPS_BAUD 9600

// The TinyGPS++ object
TinyGPSPlus gps;

// Create an instance of the HardwareSerial class for Serial 2
HardwareSerial gpsSerial(2);

String GPSdataToAppend;

// Previous GPS coordinates
double lastLat = 0.0;
double lastLng = 0.0;

// Initialize SD card
void initSDCard() {
  if (!SD.begin()) {
    Serial.println("Card Mount Failed");
    return;
  }
  uint8_t cardType = SD.cardType();

  if (cardType == CARD_NONE) {
    Serial.println("No SD card attached");
    return;
  }
  Serial.print("SD Card Type: ");
  if (cardType == CARD_MMC) {
    Serial.println("MMC");
  } else if (cardType == CARD_SD) {
    Serial.println("SDSC");
  } else if (cardType == CARD_SDHC) {
    Serial.println("SDHC");
  } else {
    Serial.println("UNKNOWN");
  }
  uint64_t cardSize = SD.cardSize() / (1024 * 1024);
  Serial.printf("SD Card Size: %lluMB\n", cardSize);
}

// Append data to the SD card
void appendFile(fs::FS &fs, const char *path, const char *message) {
  Serial.printf("Appending to file: %s\n", path);

  File file = fs.open(path, FILE_APPEND);
  if (!file) {
    Serial.println("Failed to open file for appending");
    return;
  }
  if (file.print(message)) {
    Serial.println("Message appended");
  } else {
    Serial.println("Append failed");
  }
  file.close();
}

void setup() {
  // Serial Monitor
  Serial.begin(115200);

  // Initialize the microSD card
  initSDCard();

  // Start Serial 2 with the defined RX and TX pins and a baud rate of 9600
  gpsSerial.begin(GPS_BAUD, SERIAL_8N1, RXD2, TXD2);
  Serial.println("Serial 2 started at 9600 baud rate");
}

void loop() {
  unsigned long start = millis();

  while (millis() - start < 1000) {
    while (gpsSerial.available() > 0) {
      gps.encode(gpsSerial.read());
    }
    if (gps.location.isUpdated()) {
      double currentLat = gps.location.lat();
      double currentLng = gps.location.lng();

      // Check if the distance from the last point is at least 1 meter
      double distance = TinyGPSPlus::distanceBetween(lastLat, lastLng, currentLat, currentLng);

      if (distance >= 1.0) {
        lastLat = currentLat;
        lastLng = currentLng;

        // Prepare data to append
        GPSdataToAppend = String(currentLng, 6) + "," + String(currentLat, 6) + "," + String(gps.altitude.meters());
        Serial.println(GPSdataToAppend);

        // Append to file
        appendFile(SD, "/data.txt", GPSdataToAppend.c_str());
      }
    }
  }
}

Afficher le code brut

Pour enregistrer des données dans un format que Google Earth peut lire, nous devons sauver la longitude, la latitude et l’altitude dans cet ordre séparés par des virgules. C’est ce que nous faisons dans cet exemple. Plus tard, nous devons convertir ces informations en fichier .kml.

Comment fonctionne le code?

Nous commençons par importer les bibliothèques requises.

#include 
#include 
#include 
#include 

Ensuite, nous définissons les broches qui seront utilisées pour communiquer avec le module GPS via le protocole de communication série. Comme nous l’avons vu précédemment, nous utilisons des broches par défaut UART2.

// Define the RX and TX pins for Serial 2
#define RXD2 16
#define TXD2 17

Nous définissons le taux de bauds GPS, créons une instance TinyGPSPlus appelée GPS et commençons le matériel série 2.

#define GPS_BAUD 9600

// The TinyGPS++ object
TinyGPSPlus gps;

// Create an instance of the HardwareSerial class for Serial 2
HardwareSerial gpsSerial(2);

Nous créons une variable de chaîne qui conservera toutes les informations à stocker sur la carte microSD (longitude, latitude et altitude dans cet ordre).

String GPSdataToAppend;

Ensuite, nous initialisons les variables suivantes pour enregistrer les dernières valeurs de latitude et de longitude. Nous avons besoin de ces variables pour comparer la position actuelle au dernier.

// Previous GPS coordinates
double lastLat = 0.0;
double lastLng = 0.0;

La fonction initsdcard () appelle toutes les méthodes nécessaires pour initialiser la carte microSD.

// Initialize SD card
void initSDCard() {
  if (!SD.begin()) {
    Serial.println("Card Mount Failed");
    return;
  }
  uint8_t cardType = SD.cardType();

  if (cardType == CARD_NONE) {
    Serial.println("No SD card attached");
    return;
  }
  Serial.print("SD Card Type: ");
  if (cardType == CARD_MMC) {
    Serial.println("MMC");
  } else if (cardType == CARD_SD) {
    Serial.println("SDSC");
  } else if (cardType == CARD_SDHC) {
    Serial.println("SDHC");
  } else {
    Serial.println("UNKNOWN");
  }
  uint64_t cardSize = SD.cardSize() / (1024 * 1024);
  Serial.printf("SD Card Size: %lluMB\n", cardSize);
}

La fonction appendFile () appelle les données à un fichier sur la carte microSD. Il crée ce fichier s’il n’existe pas encore.

// Append data to the SD card
void appendFile(fs::FS &fs, const char *path, const char *message) {
  Serial.printf("Appending to file: %s\n", path);

  File file = fs.open(path, FILE_APPEND);
  if (!file) {
    Serial.println("Failed to open file for appending");
    return;
  }
  if (file.print(message)) {
    Serial.println("Message appended");
  } else {
    Serial.println("Append failed");
  }
  file.close();
}

Pour plus d’informations sur les fonctions de carte microSD, consultez ce tutoriel: ESP32: Guide du module de carte microSD à l’aide d’Arduino IDE.

Dans la configuration (), nous initialisons le moniteur série, la carte microSD et le module GPS.

void setup() {
  // Serial Monitor
  Serial.begin(115200);

  // Initialize the microSD card
  initSDCard();

  // Start Serial 2 with the defined RX and TX pins and a baud rate of 9600
  gpsSerial.begin(GPS_BAUD, SERIAL_8N1, RXD2, TXD2);
  Serial.println("Serial 2 started at 9600 baud rate");
}

Dans le Loop (), nous vérifions si de nouvelles données sont disponibles à partir du module GPS à chaque seconde. S’il y en a, nous codant pour les données disponibles et obtenons la latitude et la longitude actuelles.

unsigned long start = millis();

while (millis() - start < 1000) {
  while (gpsSerial.available() > 0) {
    gps.encode(gpsSerial.read());
  }
  if (gps.location.isUpdated()) {
    double currentLat = gps.location.lat();
    double currentLng = gps.location.lng();

Ensuite, nous vérifions si la position actuelle est à au moins un mètre de la précédente.

// Check if the distance from the last point is at least 1 meter
double distance = TinyGPSPlus::distanceBetween(lastLat, lastLng, currentLat, currentLng);

S’ils le sont, nous mettons à jour les variables Lastlat et Lastlng vers la position actuelle.

if (distance >= 1.0) {
  lastLat = currentLat;

Nous préparons également les données d’une chaîne à enregistrer sur la carte microSD.

GPSdataToAppend = String(currentLng, 6) + "," + String(currentLat, 6) + "," + String(gps.altitude.meters());

Nous imprimons les données dans le moniteur série.

Serial.println(GPSdataToAppend);

Et enfin, nous ajoutons les données à un fichier appelé data.txt sur la carte microSD.

appendFile(SD, "/data.txt", GPSdataToAppend.c_str());

Tester le projet

Téléchargez le code sur votre carte. Il devrait initialiser la carte microSD et après quelques secondes, il devrait commencer à ajouter des données sur la carte microSD (assurez-vous que vous êtes à l’extérieur ou à proximité d’une fenêtre).

Si tout semble fonctionner comme prévu, déconnectez l’ESP32 de votre ordinateur et appliquez l’alimentation à l’aide d’un chargeur ou d’une batterie portable. Faites une promenade avec votre circuit afin qu’il commence à enregistrer vos coordonnées au fil du temps et vous pouvez obtenir une quantité considérable de points pour concevoir un chemin.

Après avoir enregistré certaines données, déconnectez la carte microSD du module et connectez-la à votre ordinateur. La carte microSD doit avoir un fichier data.txt avec les coordonnées de votre chemin.

Pour que vous puissiez télécharger ces données sur Google Earth et concevoir un chemin, nous devons convertir ce fichier au format .kml.

Fichiers KML

KML est un format de fichier utilisé pour afficher les données géographiques dans un navigateur de terre telles que Google Earth. KML utilise une structure basée sur des balises avec des éléments et des attributs imbriqués et est basé sur la norme XML. Nous n’entrerons pas dans les détails de la structure de ce fichier. Si vous souhaitez en savoir plus, vous pouvez consulter ce tutoriel sur les fichiers KML par Google.

Convertir votre fichier data.txt au format .kml

1) Ouvrez le fichier data.txt avec les données GPS recueillies à partir du module GPS.

2) Modifiez votre fichier afin que vos coordonnées soient entre les balises comme suit:

#yellowPoly

1
1
absolute

YOUR COORDINATES GO HERE

3) Enregistrez ce fichier.

4) Modifiez son nom de data.txt à data.kml. Vous recevrez un avertissement de modifier le format de fichier. L’acceptez. Désormais, le fichier devrait être utilisable de télécharger sur Google Earth.

Afficher le chemin sur Google Earth

Maintenant, suivez les étapes suivantes pour afficher et visualiser votre chemin sur Google Earth.

1) Accédez au site Web de Google Earth.

2) Créez un nouveau projet et donnez-lui un nom.

3) Accédez à Fichier> Importer le fichier dans le projet> Télécharger à partir de l’appareil.

4) Sélectionnez le fichier .kml créé précédemment.

5) Votre chemin sera affiché sur Google Earth avec un contour jaune.

Emballage

Dans ce guide, vous avez appris à utiliser le module GPS NEO-M8N avec l’ESP32 et à obtenir des informations sur l’emplacement et l’heure.

Nous vous avons également montré comment enregistrer les données GPS à une carte microSD et comment modifier ces données dans un format que Google Earth peut interpréter pour afficher votre chemin.

Nous espérons que vous avez trouvé ce guide utile. Nous avons d’autres projets que vous pourriez aimer:

Si vous souhaitez en savoir plus sur l’ESP32, assurez-vous de consulter nos ressources:

Merci d’avoir lu.

Cette vidéo vous emmène dans l’histoire de Raspberry Pi :