Module GPS NEO-6M avec Arduino : câblage, NMEA et TinyGPSPlus

Le module GPS NEO-6M est un récepteur GPS bon marché et très répandu qui ajoute à ton projet Arduino, ESP32 ou Raspberry Pi Pico la latitude, la longitude, la vitesse, l'altitude et l'heure UTC extrêmement précise fournie par les satellites. Pour l'utiliser avec un Arduino, quatre fils suffisent (VCC, GND, TX, RX) : une fois par seconde, le module envoie à 9600 bauds des lignes de texte appelées trames NMEA, et la bibliothèque TinyGPSPlus les transforme en nombres directement exploitables.

Dans ce guide, tu verras pas à pas comment fonctionne le module, comment le câbler sur un Arduino Uno, un ESP32 et un Pico, pourquoi le premier fix prend parfois plusieurs minutes, ce que signifie chaque champ des trames $GPGGA et $GPRMC, comment transformer la latitude et la longitude en lien Google Maps et comment afficher la position sur un écran OLED. À la fin, un tableau résume les causes et les solutions des deux problèmes les plus fréquents : "aucune donnée" et "pas de fix".

Qu'est-ce que le module GPS NEO-6M et comment fonctionne-t-il ?

Le GPS (Global Positioning System) se compose de plus de 30 satellites qui tournent à environ 20 200 km d'altitude. Chaque satellite diffuse en permanence l'heure de son horloge atomique et ses propres données d'orbite. Le NEO-6M mesure l'écart entre l'instant où le signal a quitté le satellite et celui où il arrive, et en déduit sa distance à chaque satellite ; dès qu'il voit au moins 4 satellites, il calcule la latitude, la longitude, l'altitude et l'erreur de sa propre horloge. Avec seulement 3 satellites, il peut fournir une position en deux dimensions (2D), sans altitude. Les signaux arrivent au sol extrêmement faibles (environ -130 dBm) et le béton, les toits métalliques et même un feuillage dense les bloquent en grande partie. D'où la règle d'or du GPS : l'antenne doit voir le ciel.

La carte que tu achètes ne se limite pas à la puce NEO-6M de 16×12 mm. Les cartes GY-NEO6MV2 courantes ajoutent une antenne patch céramique de 25×25 mm, un régulateur qui permet d'alimenter le module en 3,3–5 V, une petite EEPROM qui garde la configuration, une pile de sauvegarde rechargeable qui conserve l'heure et les données des satellites, et une LED qui clignote une fois le fix obtenu. Certaines cartes, comme celle de la photo, ont aussi un connecteur SMA ou un petit u.FL pour une antenne externe et un port micro USB pour la brancher directement à l'ordinateur.

Câblage du NEO-6M : Arduino Uno, ESP32 et Raspberry Pi Pico

Le NEO-6M communique en UART, qui fonctionne comme le port série d'un ordinateur et utilise deux lignes de données. La règle est simple : les lignes se croisent. La broche TX (émission) du module va sur la broche RX (réception) de la carte, et la broche RX du module sur la broche TX de la carte. L'unique port série matériel de l'Arduino Uno (broches 0 et 1) sert au téléversement par USB et au moniteur série, on branche donc le GPS sur D4 et D3 avec SoftwareSerial. Tu trouveras les détails de la liaison série dans l'article Communication série UART.

Le premier fix : démarrage à froid, tiède et à chaud

Il est tout à fait normal qu'un module GPS ne donne pas de position dès sa toute première mise sous tension. Pour calculer une position, il lui faut les données d'orbite précises (éphémérides) des satellites visibles, et chaque satellite ne les diffuse qu'environ toutes les 30 secondes ; télécharger l'almanach complet, la liste d'orbites approximative de tous les satellites, prend 12,5 minutes. Selon ce qu'il a conservé avant d'être éteint, le module démarre de l'une des trois manières suivantes. Les temps de la fiche technique ont été mesurés en conditions de test avec un signal fort de tous les satellites ; avec la petite antenne céramique fournie, attendre quelques minutes est normal.

• Sors à l'extérieur : En intérieur, surtout dans les bâtiments en béton, le module ne trouve souvent aucune position. Pour tester, utilise un balcon, un jardin ou au moins l'emplacement devant une fenêtre ouverte.
• Oriente bien l'antenne : La face plate et claire de l'antenne céramique doit regarder le ciel ; la retourner ou la couvrir avec la main affaiblit beaucoup le signal.
• Éloigne l'antenne de l'électronique : L'antenne Wi-Fi de l'ESP32, les régulateurs à découpage et les longs câbles USB émettent du bruit ; place l'antenne à quelques centimètres des cartes.
• Sois patient et ne bouge pas le module : Ne coupe pas l'alimentation pendant le premier fix ; chaque redémarrage reprend la recherche à zéro.
• Surveille la LED : La LED de la carte reste éteinte tant qu'il n'y a pas de fix, puis clignote une fois par seconde.
• Recharge la pile de sauvegarde : Si elle est vide, chaque mise sous tension est un démarrage à froid. Laisser le module alimenté quelques heures la recharge, et les démarrages suivants ne prennent plus que quelques secondes.

Trames NMEA : comment lire $GPGGA et $GPRMC

Le NEO-6M envoie tout ce qu'il calcule sous forme de lignes de texte séparées par des virgules, selon la norme NMEA 0183. Avec la configuration d'usine, six types de trames arrivent chaque seconde : GGA, GLL, GSA, GSV, RMC et VTG ; les trames TXT n'apparaissent en général qu'à la mise sous tension et contiennent des messages d'information comme la version du firmware. Chaque trame commence par $ ; le préfixe GP indique que les données viennent du GPS et les trois lettres suivantes le type de trame. Les deux caractères après l'* en fin de ligne forment la somme de contrôle (checksum), obtenue par un XOR de tous les caractères entre $ et *, qui permet d'écarter les lignes corrompues. Les deux trames les plus importantes pour la position sont : $GPGGA,092750.00,4100.82500,N,02858.74000,E,1,08,1.01,39.2,M,36.9,M,,*67 et $GPRMC,092750.00,A,4100.82500,N,02858.74000,E,0.512,,281026,,,A*7E

Dans les trames NMEA, la latitude et la longitude ne sont pas en degrés décimaux mais en degrés et minutes (ddmm.mmmm), alors que Google Maps et la plupart des logiciels attendent des degrés décimaux. Pour convertir, prends les deux premiers chiffres de la latitude (les trois premiers de la longitude) comme degrés, puis ajoute les minutes restantes divisées par 60 : 4100.82500 → 41 + 0,825 / 60 = 41,013750 ; 02858.74000 → 28 + 58,74 / 60 = 28,979000. Les valeurs Sud (S) et Ouest (W) s'écrivent en négatif. La sixième décimale correspond à environ 11 cm et la cinquième à 1,1 m ; avec une précision de 2,5 m pour le NEO-6M, six décimales suffisent largement.

Pas à pas : afficher les données GPS brutes avec un Arduino Uno

1. Câble le NEO-6M comme dans le tableau : VCC → 5V, GND → GND, TX du GPS → D4, RX du GPS → D3 via le pont diviseur.
2. Téléverse le code ci-dessous ; aucune bibliothèque supplémentaire n'est nécessaire, SoftwareSerial est fournie avec l'IDE Arduino.
3. Ouvre le moniteur série et règle la vitesse sur 115200 bauds.
4. Emmène le module dehors ou près d'une fenêtre et regarde défiler les lignes qui commencent par $GP.
5. Quand le deuxième champ de la ligne $GPRMC passe de V à A et que la LED se met à clignoter, le module a trouvé sa position.

1#include <SoftwareSerial.h>
2
3SoftwareSerial gpsSerial(4, 3);   // RX, TX → GPS TX D4'e, GPS RX D3'e / GPS TX to D4, GPS RX to D3
4
5void setup() {
6  Serial.begin(115200);           // Seri Monitör hızı / Serial Monitor speed
7  gpsSerial.begin(9600);          // NEO-6M varsayılan hızı / NEO-6M default baud rate
8  Serial.println(F("NEO-6M ham NMEA / raw NMEA"));
9}
10
11void loop() {
12  while (gpsSerial.available()) {
13    Serial.write(gpsSerial.read());   // gelen her baytı aynen aktar / pass every byte through
14  }
15}

Dans le moniteur série, un bloc de six à neuf lignes s'affiche chaque seconde (plus il y a de satellites visibles, plus la trame GSV est répartie sur plusieurs lignes). Si le module n'a encore trouvé aucun satellite, les lignes sont remplies de virgules vides, comme $GPRMC,,V,,,,,,,,,,N*53 et $GPGGA,,,,,,0,00,99.99,,,,,,*48 ; ce n'est pas une erreur, cela montre que le module fonctionne mais ne peut pas encore calculer de position. Les lignes $GPGSV indiquent le nombre de satellites visibles et la force du signal (dB-Hz) de chacun ; au-dessus de 30 dB-Hz, le signal est bon. Si aucune ligne n'arrive, vérifie le câblage ; si des caractères bizarres apparaissent, vérifie la vitesse en bauds.

Lire latitude, longitude, vitesse et heure avec TinyGPSPlus

Plutôt que de décoder les lignes NMEA à la main, il est bien plus pratique d'utiliser la bibliothèque TinyGPSPlus de Mikal Hart. Cherche "TinyGPSPlus" dans le gestionnaire de bibliothèques et installe-la ; les étapes sont expliquées dans l'article ajouter une bibliothèque Arduino. Attention : les exemples de la bibliothèque sont réglés sur 4800 bauds, alors que le NEO-6M utilise 9600 bauds. Si tu lances un exemple sans changer la vitesse, la position reste toujours INVALID, car la bibliothèque ne peut décoder aucune trame à partir de caractères corrompus. Le code ci-dessous affiche chaque seconde la position, la vitesse, l'altitude, le nombre de satellites, la date et l'heure, et transforme la position en lien Google Maps à ouvrir dans ton navigateur :

1#include <TinyGPSPlus.h>
2#include <SoftwareSerial.h>
3
4const int RX_PIN = 4;              // GPS TX → D4
5const int TX_PIN = 3;              // GPS RX ← D3 (bölücü üzerinden / through a divider)
6const uint32_t GPS_BAUD = 9600;    // NEO-6M varsayılanı / NEO-6M default
7
8TinyGPSPlus gps;
9SoftwareSerial gpsSerial(RX_PIN, TX_PIN);
10unsigned long lastPrint = 0;
11
12void setup() {
13  Serial.begin(115200);
14  gpsSerial.begin(GPS_BAUD);
15  Serial.println(F("NEO-6M + TinyGPSPlus"));
16}
17
18void loop() {
19  while (gpsSerial.available()) {
20    gps.encode(gpsSerial.read());        // her baytı ayrıştırıcıya ver / feed every byte to the parser
21  }
22  if (millis() - lastPrint >= 1000) {    // delay() yok, saniyede bir yaz / no delay(), print once per second
23    lastPrint = millis();
24    printInfo();
25  }
26}
27
28void printInfo() {
29  if (gps.charsProcessed() < 10) {
30    Serial.println(F("GPS verisi yok: kablolari ve baud hizini kontrol et / No GPS data: check wiring and baud"));
31    return;
32  }
33  Serial.print(F("Uydu / Sats: "));
34  Serial.println(gps.satellites.value());
35
36  if (gps.location.isValid()) {
37    Serial.print(F("Enlem / Lat: "));
38    Serial.println(gps.location.lat(), 6);
39    Serial.print(F("Boylam / Lng: "));
40    Serial.println(gps.location.lng(), 6);
41    Serial.print(F("Hiz / Speed: "));
42    Serial.print(gps.speed.kmph(), 1);
43    Serial.println(F(" km/h"));
44    Serial.print(F("Yukseklik / Alt: "));
45    Serial.print(gps.altitude.meters(), 1);
46    Serial.println(F(" m"));
47    // Google Haritalar bağlantısı / Google Maps link
48    Serial.print(F("https://www.google.com/maps/search/?api=1&query="));
49    Serial.print(gps.location.lat(), 6);
50    Serial.print(',');
51    Serial.println(gps.location.lng(), 6);
52  } else {
53    Serial.println(F("Konum yok, uydu araniyor / No fix yet, searching"));
54  }
55
56  if (gps.date.isValid() && gps.time.isValid()) {
57    char buf[32];
58    snprintf(buf, sizeof(buf), "%02d.%02d.%04d %02d:%02d:%02d UTC",
59             gps.date.day(), gps.date.month(), (int)gps.date.year(),
60             gps.time.hour(), gps.time.minute(), gps.time.second());
61    Serial.println(buf);                 // saat UTC'dir / time is UTC
62  }
63  Serial.println();
64}

La règle la plus importante de ce code est pas de delay() dans loop(). Le GPS envoie environ 500 octets par seconde, mais le tampon de réception de SoftwareSerial ne fait que 64 octets ; pendant un long delay(), il déborde, les trames sont tronquées et TinyGPSPlus les rejette pour erreur de checksum. C'est pourquoi on affiche une fois par seconde avec millis() ; tous les détails sont dans l'article millis() ou delay(). L'heure GPS est toujours en UTC : en France, ajoute 1 heure en hiver et 2 heures en été. Sur l'Arduino Uno, un double est en réalité un float de 32 bits, donc le dernier chiffre de la latitude et de la longitude est arrondi à environ un demi-mètre ; face aux 2,5 m de précision du module, c'est sans importance.

ESP32 avec Serial2 : afficher la position sur un écran OLED

Sur l'ESP32, pas besoin de SoftwareSerial : la puce possède trois UART matérielles et Serial2 peut être affecté aux broches de ton choix. Dans l'exemple ci-dessous, le GPS est relié à GPIO 16 (RX2) et GPIO 17 (TX2) ; comme l'ESP32 fonctionne en 3,3 V, aucun pont diviseur n'est nécessaire. La position, la vitesse et l'heure locale s'affichent sur un écran OLED SSD1306 de 0,96 pouce branché en I2C sur GPIO 21 (SDA) et GPIO 22 (SCL). En plus de TinyGPSPlus, le code utilise les bibliothèques Adafruit SSD1306 et Adafruit GFX.

1#include <TinyGPSPlus.h>
2#include <Wire.h>
3#include <Adafruit_GFX.h>
4#include <Adafruit_SSD1306.h>
5
6#define GPS_RX 16                 // ESP32 RX2 ← GPS TX
7#define GPS_TX 17                 // ESP32 TX2 → GPS RX
8const int UTC_OFFSET = 3;         // Türkiye UTC+3, kendi saat dilimini yaz / set your own time zone
9
10TinyGPSPlus gps;
11Adafruit_SSD1306 display(128, 64, &Wire, -1);   // OLED: SDA 21, SCL 22
12unsigned long lastDraw = 0;
13
14String mapsLink() {
15  // Google Haritalar bağlantısı üret / build a Google Maps link
16  return "https://www.google.com/maps/search/?api=1&query=" +
17         String(gps.location.lat(), 6) + "," + String(gps.location.lng(), 6);
18}
19
20void drawScreen() {
21  display.clearDisplay();
22  display.setTextSize(1);
23  display.setCursor(0, 0);
24  display.print(F("Uydu/Sat: "));
25  display.print(gps.satellites.value());
26
27  if (gps.time.isValid()) {
28    int h = (gps.time.hour() + UTC_OFFSET + 24) % 24;   // yerel saat / local time
29    char t[12];
30    snprintf(t, sizeof(t), "%02d:%02d:%02d", h, gps.time.minute(), gps.time.second());
31    display.setCursor(80, 0);
32    display.print(t);
33  }
34
35  if (gps.location.isValid()) {
36    display.setCursor(0, 16);
37    display.print(F("Lat: "));
38    display.println(gps.location.lat(), 6);
39    display.print(F("Lng: "));
40    display.println(gps.location.lng(), 6);
41    display.setTextSize(2);                  // hız büyük yazılsın / speed in large digits
42    display.setCursor(0, 44);
43    display.print(gps.speed.kmph(), 1);
44    display.print(F(" km/h"));
45  } else {
46    display.setCursor(0, 24);
47    display.println(F("Uydu araniyor..."));
48    display.println(F("Searching for fix"));
49  }
50  display.display();
51}
52
53void setup() {
54  Serial.begin(115200);
55  Serial2.begin(9600, SERIAL_8N1, GPS_RX, GPS_TX);    // donanım UART2 / hardware UART2
56  if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
57    Serial.println(F("OLED bulunamadi / OLED not found"));
58    while (true) delay(10);
59  }
60  display.setTextColor(SSD1306_WHITE);
61}
62
63void loop() {
64  while (Serial2.available()) {
65    gps.encode(Serial2.read());              // NMEA baytlarını çöz / decode NMEA bytes
66  }
67  if (millis() - lastDraw >= 1000) {         // saniyede bir güncelle / refresh once per second
68    lastDraw = millis();
69    drawScreen();
70    if (gps.location.isValid()) {
71      Serial.println(mapsLink());            // Telegram ya da SMS ile gönderilebilir / can be sent via Telegram or SMS
72    }
73  }
74}

La variable UTC_OFFSET convertit l'heure GPS en heure locale ; en France, elle vaut 1 en hiver et 2 en été. La fonction mapsLink() transforme la position en adresse Google Maps avec le paramètre query=latitude,longitude. Tu peux copier ce lien depuis le moniteur série et l'ouvrir dans un navigateur, l'envoyer sur ton téléphone avec un bot Telegram ou par SMS avec un module GSM SIM800L. Sur les cartes ESP32-WROVER avec PSRAM, les GPIO 16 et 17 servent à la mémoire : branche alors le GPS par exemple sur GPIO 26 et 27 ; sur l'ESP32-C3, qui n'a que deux UART, utilise Serial1 au lieu de Serial2.

Lire le GPS avec le Raspberry Pi Pico et MicroPython

Sur le Raspberry Pi Pico, on branche le GPS sur l'UART0 : le TX du module va sur GP1 et son RX sur GP0. En MicroPython, on peut décoder soi-même les lignes NMEA sans installer de bibliothèque, ce qui est aussi un excellent exercice pour comprendre la structure des trames. Le code vérifie la somme de contrôle de chaque ligne, récupère le nombre de satellites dans GGA et la position, la vitesse et l'heure dans RMC, puis convertit les degrés-minutes en degrés décimaux. Le réglage timeout=200 fait attendre readline() jusqu'à 200 ms la fin de la ligne ; si une demi-ligne passe quand même au démarrage, la vérification de la somme de contrôle l'écarte. Comme le type de trame est obtenu avec f[0][3:], le code reconnaît aussi les lignes $GNRMC et $GNGGA des modules qui utilisent plusieurs systèmes de satellites. Si tu ne sais pas encore lancer du code avec Thonny, jette d'abord un œil à l'article les bases de MicroPython.

1from machine import UART, Pin
2
3# GP0 (TX) → GPS RX, GP1 (RX) ← GPS TX
4gps = UART(0, baudrate=9600, tx=Pin(0), rx=Pin(1), timeout=200, rxbuf=1024)
5
6def checksum_ok(line):
7    # $ ile * arasındaki karakterlerin XOR'u / XOR of the characters between $ and *
8    try:
9        body, cs = line[1:].split('*')
10        x = 0
11        for ch in body:
12            x ^= ord(ch)
13        return x == int(cs[:2], 16)
14    except ValueError:
15        return False
16
17def to_deg(value, hemi):
18    # ddmm.mmmm → ondalık derece / decimal degrees
19    dot = value.index('.')
20    deg = int(value[:dot - 2]) + float(value[dot - 2:]) / 60
21    return -deg if hemi in ('S', 'W') else deg
22
23sats = '0'
24while True:
25    raw = gps.readline()                       # bir NMEA satırı / one NMEA line
26    if not raw:
27        continue
28    try:
29        line = raw.decode().strip()
30    except UnicodeError:
31        continue                               # bozuk bayt / corrupted byte
32    if not line.startswith('$') or not checksum_ok(line):
33        continue
34    f = line.split('*')[0].split(',')
35    kind = f[0][3:]                            # GPRMC ya da GNRMC → RMC / GPRMC or GNRMC → RMC
36    if kind == 'GGA':
37        sats = f[7]                            # kullanılan uydu sayısı / satellites in use
38    elif kind == 'RMC':
39        if f[2] != 'A':
40            print('Uydu araniyor / searching, uydu/sats:', sats)
41            continue
42        lat = to_deg(f[3], f[4])
43        lon = to_deg(f[5], f[6])
44        kmh = float(f[7] or 0) * 1.852        # knot → km/sa / knots → km/h
45        t = f[1]
46        print('UTC {}:{}:{}  uydu/sats: {}'.format(t[0:2], t[2:4], t[4:6], sats))
47        print('Konum / position: {:.6f}, {:.6f}  {:.1f} km/h'.format(lat, lon, kmh))
48        print('https://www.google.com/maps/search/?api=1&query={:.6f},{:.6f}'.format(lat, lon))

Idées de projets avec le NEO-6M

• Traceur qui envoie sa position par SMS : Avec un NEO-6M et un SIM800L, un traceur pour voiture ou vélo qui répond à un SMS "POSITION" par un lien Google Maps.
• Enregistreur de données GPS : Enregistre ton trajet chaque seconde en CSV sur un module carte SD, puis affiche-le sur une carte depuis ton ordinateur.
• Compteur de vitesse pour vélo : Affiche la vitesse actuelle, la vitesse maximale et la distance totale sur un écran OLED ; additionne la distance entre points successifs avec TinyGPSPlus::distanceBetween().
• Horloge synchronisée par satellite : Récupère l'heure du GPS et règle à la seconde près un module horloge RTC, sans Internet.
• Alarme de géorepérage (geofence) : Un système qui déclenche un buzzer ou envoie une notification quand quelque chose s'éloigne de plus de 100 mètres d'un point choisi.
• Suivi longue portée : Envoie la position à un récepteur situé à plusieurs kilomètres avec un module LoRa et économise l'énergie sur batterie grâce au deep sleep de l'ESP32.

Aucune donnée ou pas de fix : erreurs fréquentes et solutions

Le NEO-6M apporte à tes projets, pour un coût très faible, la réponse à "où suis-je, à quelle vitesse je vais et quelle heure est-il" ; le secret est de montrer le ciel à l'antenne et de laisser au premier fix le temps nécessaire. Pour mieux comprendre la liaison série, jette un œil à l'article sur l'UART. Dans l'application BlueGrays, tu trouveras des projets utiles aussi pour tes montages GPS, comme la communication série entre deux Arduino, les écrans OLED, l'enregistrement de données sur microSD, le deep sleep de l'ESP32 et une alarme avec notifications Telegram, chacun avec schéma de câblage et code pas à pas.