La géolocalisation autonome : concevoir un tracker GPS sous ESP32

Intégrer la géolocalisation dans un projet IoT (Internet des Objets) ouvre des perspectives passionnantes, qu’il s’agisse de suivre un véhicule, de cartographier un itinéraire ou de concevoir un système de sécurité nomade. L’association d’une carte ESP32 et d’un module GPS permet de créer un tracker autonome performant à faible coût.

Cependant, la gestion des coordonnées géographiques et l’extraction des données brutes reçues du satellite demandent une approche logicielle rigoureuse. Cet article détaille le fonctionnement d’un tracker GPS et fournit un code d’acquisition asynchrone et fonctionnel.

Le matériel et le protocole NMEA

Pour ce projet, le choix se porte généralement sur un module GPS standard du marché, comme le NEO-6M ou le NEO-8M de chez u-blox. Ces modules communiquent avec l’ESP32 via une liaison série asynchrone classique (UART).

Dès qu’il est alimenté et qu’il capte les signaux satellites, le module GPS envoie en continu des lignes de texte sur son port série. Ces lignes suivent une norme internationale appelée NMEA-0183. Elles ressemblent à cela :

Plaintext

$GPRMC,160634.00,A,4440.1234,N,00110.5678,W,0.023,,040626,,,A*7C

Lire et décoder manuellement ces chaînes de caractères (calculer la latitude, la longitude, l’altitude et l’heure UTC) est un travail fastidieux et source d’erreurs. C’est ici qu’intervient la bibliothèque TinyGPS++, qui analyse et extrait proprement ces structures de données pour le développeur.

Le défi technique : ne pas rater les trames série

Le module GPS envoie ses données point par point, octet par octet. Si l’ESP32 est occupé à effectuer une autre tâche lourde dans sa boucle principale (loop), le tampon du port série matériel risque de déborder, ce qui corrompt la trame NMEA en cours de réception.

Pour éviter cela, le code doit interroger le port série du GPS de manière prioritaire et continue à chaque passage dans la boucle, tout en filtrant les données pour n’afficher les résultats que lorsque la position est validée par les satellites (GPS Fix).

Code complet et fonctionnel pour PlatformIO

Voici le code standardisé en C++ pour PlatformIO. Il utilise le port série matériel secondaire de l’ESP32 (HardwareSerial 2) sur les broches de réception par défaut (GPIO 16 pour RX, GPIO 17 pour TX).

C++

#include <Arduino.h>
#include <TinyGPS++.h>

// Déclaration de l'objet TinyGPS++
TinyGPSPlus gps;

// Initialisation du port série matériel 2 de l'ESP32
// Broche 16 = RX (à relier sur le TX du module GPS)
// Broche 17 = TX (à relier sur le RX du module GPS)
HardwareSerial gpsSerial(2);

void setup() {
    // Initialisation de la console série pour le débogage
    Serial.begin(115200);
    
    // Initialisation de la liaison avec le module GPS (9600 bauds par défaut pour le NEO-6M)
    gpsSerial.begin(9600, SERIAL_8N1, 16, 17);
    
    Serial.println(F("Démarrage du Tracker GPS ESP32..."));
}

void loop() {
    // 1. Lecture continue de la liaison série du GPS
    while (gpsSerial.available() > 0) {
        // On envoie chaque octet reçu à TinyGPS++
        if (gps.encode(gpsSerial.read())) {
            
            // 2. Si une nouvelle trame valide est décodée et que la position est actualisée
            if (gps.location.isUpdated() && gps.location.isValid()) {
                
                Serial.print(F("Latitude : "));
                Serial.println(gps.location.lat(), 6); // Précision à 6 décimales
                
                Serial.print(F("Longitude : "));
                Serial.println(gps.location.lng(), 6);
                
                if (gps.altitude.isValid()) {
                    Serial.print(F("Altitude : "));
                    Serial.print(gps.altitude.meters());
                    Serial.println(F(" m"));
                }
                
                if (gps.speed.isValid()) {
                    Serial.print(F("Vitesse : "));
                    Serial.print(gps.speed.kmph());
                    Serial.println(F(" km/h"));
                }
                
                Serial.println(F("------------------------------------"));
            }
        }
    }
}

En conclusion

Grâce à la bibliothèque TinyGPS++ et à la fiabilité des ports séries matériels de l’ESP32, la récupération des coordonnées géographiques devient une tâche simple et stable. Ce code constitue la brique de base essentielle pour tout projet plus ambitieux, comme l’enregistrement des données sur une carte SD (Data Logger) ou l’envoi de la position en temps réel via un réseau 4G, LoRa ou Wi-Fi.