Componenten · 12 min leestijd

NEO-6M GPS-module met Arduino: bedrading, NMEA en TinyGPSPlus

Zo gebruik je de NEO-6M GPS-module met Arduino: TX/RX-bedrading, tijd tot de eerste fix, $GPGGA- en $GPRMC-zinnen, TinyGPSPlus-code, ESP32 met OLED en Pico MicroPython.

De NEO-6M GPS-module is een goedkope en razend populaire GPS-ontvanger die breedtegraad, lengtegraad, snelheid, hoogte en uiterst nauwkeurige UTC-tijd van de satellieten toevoegt aan je Arduino-, ESP32- of Raspberry Pi Pico-project. Om hem met een Arduino te gebruiken heb je maar vier draden nodig (VCC, GND, TX, RX): één keer per seconde stuurt de module tekstregels, de zogeheten NMEA-zinnen, met 9600 baud, en de TinyGPSPlus-bibliotheek zet die regels om in getallen die je meteen kunt gebruiken.

In deze gids zie je stap voor stap hoe de module werkt, hoe je hem aansluit op een Arduino Uno, ESP32 en Pico, waarom de eerste positiebepaling soms minuten duurt, wat elk veld van de $GPGGA- en $GPRMC-zinnen betekent, hoe je breedte- en lengtegraad omzet in een Google Maps-link en hoe je de positie toont op een OLED-display. Aan het eind vind je een tabel met oorzaken en oplossingen voor de twee meest voorkomende problemen: "geen data" en "geen fix".

NEO-6M GPS-module (u-blox NEO-6M)
NEO-6M GPS-module: de u-blox NEO-6M-ontvanger in het midden, de headerpins bovenaan, de EEPROM die de instellingen opslaat en de PPS-led links; het gouden onderdeel ernaast is een SMA-connector voor een externe antenne.

Wat is de NEO-6M GPS-module en hoe werkt hij?

GPS (Global Positioning System) bestaat uit meer dan 30 satellieten die op een hoogte van ongeveer 20.200 km rondjes draaien. Elke satelliet zendt voortdurend de tijd van zijn atoomklok aan boord en zijn eigen baangegevens uit. De NEO-6M meet het verschil tussen het moment waarop een signaal de satelliet verliet en het moment waarop het aankwam, en berekent daaruit de afstand tot elke satelliet; zodra hij minstens 4 satellieten ziet, kan hij breedtegraad, lengtegraad, hoogte en de afwijking van zijn eigen klok oplossen. Met slechts 3 satellieten kan hij een tweedimensionale (2D) positie zonder hoogte berekenen. Satellietsignalen bereiken de grond uiterst zwak (ongeveer -130 dBm), en beton, metalen daken en zelfs dichte bebladering houden de meeste tegen. Daarom is de gouden regel van GPS simpel: de antenne moet de lucht zien.

EigenschapWaarde
Ontvangerchipu-blox NEO-6M (u-blox 6-positioneringsengine)
Kanalen en signaal50 kanalen, GPS L1 C/A (1575,42 MHz), SBAS: EGNOS, WAAS, MSAS
Horizontale nauwkeurigheid2,5 m CEP (2,0 m met SBAS)
Nauwkeurigheid van snelheid en koers0,1 m/s en 0,5 graden
Tijd tot eerste fix (TTFF)Koud 27 s, warm 27 s, heet 1 s
GevoeligheidTracking -161 dBm, koude start -147 dBm
UpdatefrequentieStandaard 1 Hz, tot 5 Hz
InterfaceUART, standaard 9600 baud 8N1, NMEA 0183
VoedingBoard: 3,3–5 V (met regelaar); chip: 2,7–3,6 V
Stroomverbruik~47 mA tijdens zoeken, ~39 mA tijdens tracking
Bedrijfstemperatuur-40 tot +85 °C

Het board dat je koopt is meer dan de NEO-6M-chip van 16×12 mm. Gangbare GY-NEO6MV2-boards voegen een keramische patchantenne van 25×25 mm toe, een regelaar waarmee je de module op 3,3–5 V kunt voeden, een kleine EEPROM die de instellingen opslaat, een oplaadbare back-upbatterij die de tijd en satellietgegevens bewaart, en een led die knippert zodra er een fix is. Sommige boards, zoals die op de foto hierboven, hebben ook een SMA- of kleine u.FL-connector voor een externe antenne en een micro-USB-poort om direct op een computer aan te sluiten.

NEO-6M-bedrading: Arduino Uno, ESP32 en Raspberry Pi Pico

De NEO-6M communiceert via UART, dat werkt als de seriële poort van een computer en twee datalijnen gebruikt. De regel is simpel: de datalijnen worden gekruist. De TX-pin (zenden) van de module gaat naar de RX-pin (ontvangen) van het board, en de RX-pin van de module naar de TX-pin van het board. De enige hardware-seriële poort van de Arduino Uno (pin 0 en 1) wordt gebruikt voor het uploaden via USB en voor de Serial Monitor, dus sluiten we de GPS met SoftwareSerial aan op pin D4 en D3. De details van seriële communicatie vind je in het artikel UART seriële communicatie.

NEO-6M-pinArduino UnoESP32Raspberry Pi Pico
VCC5VVIN (5V) of 3V3VBUS (5V) of 3V3(OUT)
GNDGNDGNDGND
TXD4 (SoftwareSerial RX)GPIO 16 (RX2)GP1 (UART0 RX)
RXD3, via een 1 kΩ / 2 kΩ-spanningsdelerGPIO 17 (TX2)GP0 (UART0 TX)
PPS (indien aanwezig)Kan onaangesloten blijvenKan onaangesloten blijvenKan onaangesloten blijven
De ingangspins van de NEO-6M-chip verdragen maximaal 3,6 V. De TX-pin van de Arduino Uno geeft 5 V af, dus sluit D3 niet rechtstreeks aan op de RX-pin van de module: voeg een spanningsdeler toe (D3 → 1 kΩ → GPS RX, GPS RX → 2 kΩ → GND) of gebruik een niveauconverter. Als je alleen de positie wilt uitlezen, kun je de RX-pin van de module onaangesloten laten; die is alleen nodig om configuratiecommando's naar de module te sturen. De ESP32 en Pico werken al op 3,3 V, dus die hebben geen deler nodig.
Omdat het board zijn eigen regelaar heeft, voed je VCC bij voorkeur met 5 V; sommige boards werken onbetrouwbaar op 3,3 V door het spanningsverlies over de regelaar. Tijdens het zoeken naar satellieten trekt de module ongeveer 47 mA, dus bereken bij projecten op batterijen de looptijd vooraf met de batterijduurcalculator.

De eerste positiebepaling: koude, warme en hete start

Het is volkomen normaal dat een GPS-module niet meteen een positie geeft als je hem voor het eerst inschakelt. Om een positie te berekenen heeft de module de nauwkeurige baangegevens (ephemeris) van de zichtbare satellieten nodig, en elke satelliet zendt die ongeveer elke 30 seconden uit; het downloaden van de complete almanak, de grove baanlijst van alle satellieten, duurt 12,5 minuut. Afhankelijk van wat hij van vroeger heeft onthouden voordat hij werd uitgeschakeld, start de module op een van drie manieren. De tijden uit de datasheet zijn gemeten onder testomstandigheden met sterke signalen van elke satelliet; met de kleine keramische antenne die bij het board zit is een paar minuten wachten normaal.

Type startGegevens in de moduleDatasheetIn de praktijk (buiten)
Koude startGeen tijd-, positie- of satellietgegevens (eerste gebruik of lege back-upbatterij)27 s1–5 minuten; kan bij zwakke signalen meer dan 10 minuten duren
Warme startAlmanak, geschatte tijd en positie; ephemeris verouderd (langer dan ongeveer 4 uur uit)27 s30 seconden – 1 minuut
Hete startActuele ephemeris en tijd (pas kort geleden uitgeschakeld, back-upbatterij geladen)1 sEen paar seconden
  • Ga naar buiten: Binnen, vooral in betonnen gebouwen, vindt de module vaak helemaal geen positie. Gebruik om te testen een balkon, een tuin of in elk geval de plek vlak voor een open raam.
  • Richt de antenne goed: De platte, lichtgekleurde kant van de keramische antenne moet naar de lucht wijzen; ondersteboven draaien of met je hand bedekken verzwakt het signaal sterk.
  • Houd de antenne uit de buurt van elektronica: De wifi-antenne van de ESP32, schakelende regelaars en lange USB-kabels veroorzaken ruis; plaats de antenne een paar centimeter bij de boards vandaan.
  • Heb geduld en houd hem stil: Haal tijdens de eerste fix de stroom er niet af; elke herstart begint het zoeken opnieuw.
  • Let op de led: De led op het board blijft donker tot er een fix is en gaat dan één keer per seconde knipperen.
  • Laad de back-upbatterij op: Als de batterij leeg is, is elke start een koude start. Laat je de module een paar uur onder spanning staan, dan laadt hij op en duren latere starts nog maar seconden.

NMEA-zinnen: zo lees je $GPGGA en $GPRMC

De NEO-6M stuurt alles wat hij vindt als platte tekstregels, gescheiden door komma's, in de NMEA 0183-standaard. Met de standaardinstellingen komen er elke seconde zes soorten zinnen binnen: GGA, GLL, GSA, GSV, RMC en VTG; TXT-zinnen verschijnen meestal alleen bij het opstarten en bevatten informatieve berichten zoals de firmwareversie. Elke zin begint met $; het voorvoegsel GP betekent dat de data van GPS komt en de volgende drie letters geven het zinstype. De twee tekens na de * aan het einde van de regel vormen de checksum, die je vindt door alle tekens tussen $ en * te XOR'en; daarmee worden beschadigde regels eruit gefilterd. De twee belangrijkste zinnen voor de positie zijn: $GPGGA,092750.00,4100.82500,N,02858.74000,E,1,08,1.01,39.2,M,36.9,M,,*67 en $GPRMC,092750.00,A,4100.82500,N,02858.74000,E,0.512,,281026,,,A*7E

$GPGGA-veldVoorbeeldBetekenis
Tijd (UTC)092750.0009:27:50 UTC
Breedtegraad4100.82500,N41 graden 00,825 minuten noord
Lengtegraad02858.74000,E28 graden 58,74 minuten oost
Fixkwaliteit10 = geen fix, 1 = GPS, 2 = differentieel (SBAS) gecorrigeerd
Satellieten08Satellieten die in de positieberekening worden gebruikt
HDOP1.01Horizontale precisieverdunning (HDOP); onder 2 is zeer goed
Hoogte39.2,M39,2 m boven gemiddeld zeeniveau
Geoïdescheiding36.9,MVerschil tussen zeeniveau en de WGS84-ellipsoïde
$GPRMC-veldVoorbeeldBetekenis
Tijd (UTC)092750.00Uren, minuten, seconden
StatusAA = geldige positie, V = geen fix
Breedtegraad / lengtegraad4100.82500,N / 02858.74000,EZelfde notatie als GGA
Snelheid0.512In knopen (0,512 × 1,852 ≈ 0,95 km/u)
Koers(leeg)Rijrichting in graden; kan leeg zijn bij stilstand
Datum281026Notatie ddmmjj: 28 oktober 2026
ModusAA = autonoom, D = differentieel, N = geen data

De breedte- en lengtegraad in NMEA zijn geen decimale graden maar graden en minuten (ddmm.mmmm), terwijl Google Maps en de meeste software decimale graden willen. Om om te rekenen neem je de eerste twee cijfers van de breedtegraad (de eerste drie van de lengtegraad) als graden, deel je de resterende minuten door 60 en tel je ze erbij op: 4100.82500 → 41 + 0,825 / 60 = 41,013750; 02858.74000 → 28 + 58,74 / 60 = 28,979000. Waarden voor zuid (S) en west (W) schrijf je als negatieve getallen. De zesde decimaal komt overeen met ongeveer 11 cm en de vijfde met 1,1 m; omdat de NEO-6M tot 2,5 m nauwkeurig is, zijn zes decimalen ruim voldoende.

Stap voor stap: ruwe GPS-data bekijken met een Arduino Uno

  1. Sluit de NEO-6M aan zoals in de tabel: VCC → 5V, GND → GND, GPS TX → D4, GPS RX → D3 via de deler.
  2. Upload de onderstaande code; er is geen extra bibliotheek nodig, SoftwareSerial wordt meegeleverd met de Arduino IDE.
  3. Open de Serial Monitor en stel de snelheid in op 115200 baud.
  4. Neem de module mee naar buiten of naar een raam en kijk hoe de regels die met $GP beginnen voorbijscrollen.
  5. Als het tweede veld van de $GPRMC-regel van V naar A verandert en de led begint te knipperen, heeft de module zijn positie gevonden.
C++ (Arduino IDE)
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}

In de Serial Monitor zie je elke seconde een blok van zes tot negen regels (hoe meer satellieten in zicht, hoe meer regels de GSV-zin wordt opgesplitst). Als de module nog geen satellieten heeft gevonden, staan de regels vol lege komma's, zoals $GPRMC,,V,,,,,,,,,,N*53 en $GPGGA,,,,,,0,00,99.99,,,,,,*48; dit is geen fout, het laat zien dat de module werkt maar nog geen positie kan berekenen. In de $GPGSV-regels kun je het aantal zichtbare satellieten en de signaalsterkte (dB-Hz) van elk ervan volgen; waarden boven 30 dB-Hz betekenen een goed signaal. Komen er helemaal geen regels binnen, controleer dan de bedrading; krijg je onleesbare tekens, controleer dan de baudrate.

Breedtegraad, lengtegraad, snelheid en tijd uitlezen met TinyGPSPlus

In plaats van NMEA-regels met de hand te parsen, is het veel praktischer om de TinyGPSPlus-bibliotheek van Mikal Hart te gebruiken. Zoek in de Library Manager naar "TinyGPSPlus" en installeer hem; de stappen hebben we uitgelegd in het artikel een Arduino-bibliotheek toevoegen. Let op: de voorbeelden van de bibliotheek gebruiken 4800 baud, terwijl de NEO-6M 9600 baud gebruikt. Draai je een voorbeeld zonder de snelheid aan te passen, dan toont de locatie steeds INVALID, omdat de bibliotheek uit de onleesbare tekens geen enkele zin kan ontcijferen. De onderstaande code toont één keer per seconde de positie, snelheid, hoogte, het aantal satellieten, de datum en de tijd, en zet de positie om in een Google Maps-link die je in je browser kunt openen:

C++ (Arduino IDE)
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}
FunctieWat hij teruggeeft
gps.encode(c)Wordt aangeroepen met elke binnenkomende byte; geeft true terug als een geldige zin compleet is
gps.location.lat() / lng()Breedte- en lengtegraad in decimale graden
gps.location.isValid() / age()Of er een geldige positie is / milliseconden sinds de laatste update
gps.speed.kmph()Grondsnelheid in km/u (mps() en knots() bestaan ook)
gps.course.deg()Rijrichting in graden (0 = noord, 90 = oost)
gps.altitude.meters()Hoogte boven zeeniveau in meters
gps.satellites.value()Aantal satellieten dat voor de positie wordt gebruikt
gps.hdop.hdop()Horizontale precisieverdunning (lager = beter)
gps.date.day() / gps.time.hour()UTC-datum- en tijdvelden
TinyGPSPlus::distanceBetween(...)Afstand tussen twee coördinaten in meters
gps.failedChecksum()Aantal beschadigde zinnen; als dit blijft stijgen, gaat er data verloren

De belangrijkste regel in deze code is: gebruik nooit delay() in loop(). De GPS stuurt ongeveer 500 bytes per seconde, maar de ontvangstbuffer van SoftwareSerial is slechts 64 bytes; tijdens een lange delay() loopt de buffer over, worden zinnen afgekapt en gooit TinyGPSPlus ze weg met een checksumfout. Daarom printen we één keer per seconde met millis(); zie het artikel millis() vs delay() voor details. GPS-tijd is altijd UTC, dus tel je tijdzoneverschil erbij op (bijvoorbeeld +1 uur voor CET in de winter of +3 voor Turkije). Op de Arduino Uno is een double eigenlijk een 32-bits float, dus het laatste cijfer van de breedte- en lengtegraad is afgerond op ongeveer een halve meter; naast de nauwkeurigheid van 2,5 m van de module maakt dat verschil niet uit.

SoftwareSerial is betrouwbaar bij 9600 baud, maar blokkeert tijdens het ontvangen kort interrupts. Gebruikt je project ook timinggevoelige bibliotheken zoals Servo, kies dan op de Uno de AltSoftSerial-bibliotheek (RX = D8, TX = D9) of de hardwarepoort Serial1 van de Arduino Mega (RX1 = 19, TX1 = 18).

ESP32 met Serial2: de positie tonen op een OLED-display

Op de ESP32 heb je SoftwareSerial niet nodig: de chip heeft drie hardware-UART's en Serial2 kan aan willekeurige pins worden gekoppeld. In het onderstaande voorbeeld is de GPS aangesloten op GPIO 16 (RX2) en GPIO 17 (TX2); omdat de ESP32 op 3,3 V werkt, is ook geen deler nodig. Positie, snelheid en lokale tijd worden getoond op een 0,96-inch SSD1306 OLED-display dat via I2C is aangesloten op GPIO 21 (SDA) en GPIO 22 (SCL). Naast TinyGPSPlus heeft de code ook de bibliotheken Adafruit SSD1306 en Adafruit GFX nodig.

C++ (Arduino IDE)
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}

De variabele UTC_OFFSET zet GPS-tijd om naar lokale tijd; die is 3 voor Turkije, 1 voor Midden-Europese wintertijd. De functie mapsLink() zet de positie om in een Google Maps-adres met een query=breedtegraad,lengtegraad-parameter. Je kunt deze link uit de Serial Monitor kopiëren en in een browser openen, met een Telegram-bot naar je telefoon sturen of met een SIM800L GSM-module sms'en. Op ESP32-WROVER-boards met PSRAM worden GPIO 16 en 17 voor het geheugen gebruikt, dus sluit de GPS aan op bijvoorbeeld GPIO 26 en 27; gebruik op de ESP32-C3, die maar twee UART's heeft, Serial1 in plaats van Serial2.

GPS uitlezen met de Raspberry Pi Pico en MicroPython

Op de Raspberry Pi Pico sluiten we de GPS aan op UART0: de TX van de module gaat naar GP1 en de RX naar GP0. In MicroPython kunnen we de NMEA-regels zelf parsen zonder een bibliotheek te installeren, wat ook een mooie oefening is om te leren hoe de zinnen zijn opgebouwd. De code controleert de checksum van elke regel, haalt het aantal satellieten uit GGA en de positie, snelheid en tijd uit RMC, en zet graden-en-minuten om in decimale graden. De instelling timeout=200 laat readline() maximaal 200 ms wachten op het einde van een regel; glipt er bij het opstarten toch een halve regel doorheen, dan gooit de checksumcontrole die weg. Omdat het zinstype met f[0][3:] wordt genomen, herkent de code ook de $GNRMC- en $GNGGA-regels van modules die meerdere satellietsystemen gebruiken. Weet je nog niet hoe je code met Thonny uitvoert, bekijk dan eerst het artikel MicroPython-basis.

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))

Projectideeën met de NEO-6M

  • Tracker die zijn positie sms't: Bouw met een NEO-6M en een SIM800L een auto- of fietstracker die op een sms met "LOCATION" antwoordt met een Google Maps-link.
  • GPS-datalogger: Sla je route elke seconde als CSV op met een SD-kaartmodule en zet hem daarna op je computer uit op een kaart.
  • Fietssnelheidsmeter: Toon de huidige en maximale snelheid en de totale afstand op een OLED-display; tel de afstand tussen opeenvolgende punten op met TinyGPSPlus::distanceBetween().
  • Klok gesynchroniseerd met satellieten: Haal de tijd uit GPS en stel een RTC-klokmodule op de seconde nauwkeurig in, zonder internet.
  • Geofence-alarm: Een systeem dat een buzzer laat klinken of een melding stuurt wanneer iets zich meer dan 100 meter verplaatst van een punt dat je kiest.
  • Tracking over lange afstand: Stuur de positie met een LoRa-module naar een ontvanger op kilometers afstand en bespaar energie op batterijen met ESP32 deep sleep.

Geen data of geen fix: veelvoorkomende problemen en oplossingen

SymptoomWaarschijnlijke oorzaakOplossing
Serial Monitor helemaal leegTX en RX verwisseld, geen gemeenschappelijke GND of geen voeding naar de moduleVerbind GPS TX met de RX-pin van het board (D4 op de Uno), verbind de massa's en meet VCC
"No GPS detected: check wiring."Binnen 5 seconden kwamen er niet eens 10 tekens bij de bibliotheek aanControleer de bedrading en de pinnummers in de code; probeer TX en RX te verwisselen
Onleesbare tekensBaudrate komt niet overeenGebruik 9600 voor de GPS en de snelheid van de code in de Serial Monitor; lukt dat niet, probeer dan 4800 en 38400
Regels komen binnen maar velden zijn leeg (,V,)De module werkt maar heeft geen satellieten gevondenGa naar buiten, richt de antenne op de lucht, wacht 5–15 minuten
Aantal satellieten blijft steken op 0–3Zwak signaal, antenne ondersteboven, losse u.FL-connector of een ruisbron in de buurtControleer de antenne, duw de connector stevig aan, houd de antenne uit de buurt van de ESP32 en regelaars
Ruwe data toont een positie, TinyGPSPlus zegt INVALIDdelay() in loop() laat de buffer overlopen; failedChecksum() blijft stijgenVerwijder delay(), gebruik millis(), roep encode() continu aan
De tijd loopt een paar uur afGPS-tijd is UTCTel je tijdzoneverschil erbij op
Positie drijft een paar meter weg en snelheid is niet 0 bij stilstandNormale GPS-ruis en signalen die weerkaatsen tegen gebouwenBehandel snelheden onder 2 km/u als 0, sla metingen met hoge HDOP over, neem gemiddelden
Wacht bij elke start weer meerdere minutenBack-upbatterij leeg of ontbreektLaat de module een paar uur onder spanning staan om de batterij op te laden
Om te achterhalen of het probleem bij de module of bij je code ligt, sluit je de module rechtstreeks aan op je computer met een USB-naar-TTL-converter en open je hem in de gratis software u-center van u-blox. Die toont de signaalsterkte van elke satelliet, de fixstatus en de positie op een kaart; je kunt daar ook de baudrate en de updatefrequentie (tot 5 Hz) wijzigen en de instellingen permanent in het geheugen van de module opslaan.

De NEO-6M voegt voor heel weinig geld de antwoorden op "waar ben ik, hoe snel ga ik en hoe laat is het" toe aan je projecten; het geheim is om de antenne de lucht te laten zien en de eerste fix het geduld te geven dat hij nodig heeft. Om seriële communicatie beter te begrijpen, bekijk je het artikel over UART. In de BlueGrays-app vind je projecten die ook van pas komen bij GPS-bouwprojecten, zoals seriële communicatie tussen twee Arduino's, OLED-displays, datalogging naar microSD, ESP32 deep sleep en een alarm met Telegram-meldingen, elk met schakelschema's en code stap voor stap.

Veelgestelde vragen

Werkt de NEO-6M GPS-module binnen?

Meestal niet. Satellietsignalen bereiken de grond zeer zwak en beton of metalen daken houden de meeste tegen. Voor een open raam pikt hij misschien een paar satellieten op, maar voor een betrouwbare fix heeft de antenne direct zicht op de lucht nodig; heb je binnen een positie nodig, gebruik dan een externe actieve antenne op het dak of bij een raam.

Hoe lang duurt het voordat de NEO-6M zijn eerste fix heeft?

Volgens de datasheet duurt een koude start 27 seconden en een hete start 1 seconde. In de praktijk, met de kleine keramische antenne buiten, duurt de eerste fix meestal 1–5 minuten, en bij eerste gebruik of met een lege back-upbatterij kan het 10–15 minuten duren. Is de module pas kort geleden uitgeschakeld, dan heeft hij binnen een paar seconden weer een fix.

Hoe nauwkeurig is de NEO-6M GPS-module?

De fabrikant geeft onder open lucht een horizontale nauwkeurigheid van 2,5 m CEP op, of 2,0 m met SBAS-correctie; dat betekent dat de helft van de metingen dichter dan 2,5 m bij het ware punt ligt. In steden kunnen signalen die tegen gebouwen weerkaatsen de fout oplopen tot 5–10 meter. De hoogte is minder nauwkeurig dan de horizontale positie.

Werkt de NEO-6M op 5V en kan ik hem rechtstreeks op een Arduino aansluiten?

Gangbare GY-NEO6MV2-boards hebben een regelaar, dus VCC mag met 5 V worden gevoed. De RX-pin van de chip verdraagt echter maximaal 3,6 V, dus verlaag het 5 V-TX-signaal van de Arduino Uno met een spanningsdeler van 1 kΩ en 2 kΩ. De TX-uitgang van de module is 3,3 V, wat de Uno zonder problemen leest.

Heeft een GPS-module internet of een simkaart nodig?

Nee. De NEO-6M berekent zijn positie direct uit satellietsignalen, gratis en zonder internet. Je hebt alleen internet of een simkaart nodig als je de positie ergens anders naartoe wilt sturen, met de wifi van de ESP32 of een GSM-module zoals de SIM800L.

Wat is het verschil tussen de NEO-6M en de NEO-M8N?

De NEO-6M gebruikt alleen GPS-satellieten. De nieuwere NEO-M8N kan tegelijk met GPS ook GLONASS-, Galileo- of BeiDou-satellieten gebruiken; omdat hij meer satellieten ziet, krijgt hij in steden sneller en stabieler een fix. M8N-zinnen beginnen meestal met $GN, maar TinyGPSPlus leest beide met dezelfde code.

Alle projecten bekijken
Eenrichtingscommunicatie tussen 2 Arduino's
AR-57Gemiddeld
Premium

Eenrichtingscommunicatie tussen 2 Arduino's

Je laat twee Arduino's met elkaar praten via één draad: druk op de knop van de ene en de led van de andere gaat aan, druk nog een keer en hij gaat uit.

4.4(37)
50
Tweerichtingscommunicatie tussen 2 Arduino's
AR-58Gemiddeld
Premium

Tweerichtingscommunicatie tussen 2 Arduino's

Twee Arduino's zijn met draden aan elkaar gekoppeld en praten met elkaar: druk op de knop van de ene en het lampje van de andere gaat aan, druk nog eens en het gaat uit.

4.5(20)
26
ESP32-temperatuurlogger (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Gevorderd
Premium

ESP32-temperatuurlogger (DHT22 + DS1307 RTC + microSD + OLED)

Bouw met de ESP32 een temperatuur- en vochtigheidslogger met tijdstempel! Een DHT22-sensor meet elke minuut temperatuur en luchtvochtigheid en elke meting wordt als CSV op een microSD-kaart opgeslagen, met de actuele tijd van de DS1307 RTC-module. Het OLED-display toont in grote letters live de laatste temperatuur, vochtigheid, tijdstempel en het totale aantal records.

4.7(7)
12
ESP32 HTTPClient + weer-API (met SSD1306 OLED-display)
ES-32Gevorderd
Premium

ESP32 HTTPClient + weer-API (met SSD1306 OLED-display)

In dit project doet de ESP32 via internet een REST API-aanroep naar een weer-API (wttr.in) met HTTPClient.h. Anders dan bij de I2C-LCD-versie gebruiken we hier een SSD1306 OLED-display (128×64), met grote tekst en vectoricoontjes voor een rijkere weergave. Zeven weericonen (zonnig, regenachtig, sneeuw en meer) worden direct getekend, zonder bitmapbestanden.

4.3(10)
22
ESP32 Deep Sleep: batterij sparen (OLED + RTC RAM-teller)
ES-33Gevorderd
Premium

ESP32 Deep Sleep: batterij sparen (OLED + RTC RAM-teller)

De Deep Sleep-modus van de ESP32 schakelt de CPU en de meeste randapparatuur uit, waardoor het stroomverbruik daalt tot ongeveer 10µA; dat is cruciaal voor IoT-apparaten op batterijen. Dit project gebruikt drie wekbronnen: een timer (15 s), een externe pin (EXT0, de knop op GPIO 33) en een touchpin (T0/GPIO 4). Tellers met RTC_DATA_ATTR blijven behouden tijdens deep sleep.

4.3(10)
16
Echte tijd van internet met ESP32 en NTP
ES-26Gevorderd
Premium

Echte tijd van internet met ESP32 en NTP

De ESP32 verbindt met Wi-Fi en haalt met milliseconde-precisie de echte tijd op bij NTP-servers (Network Time Protocol). configTzTime() past de Turkse tijdzone (TRT, UTC+3) automatisch toe, en in landen met zomertijd wordt de overgang naar zomertijd (DST) geregeld met een POSIX TZ-string. De tijd wordt zowel naar de Serial Monitor als naar een optioneel I2C-lcd gestuurd.

4.5(13)
22
ESP32-bewegingsalarm (PIR + buzzer + LED + Telegram)
ES-41Gevorderd
Premium

ESP32-bewegingsalarm (PIR + buzzer + LED + Telegram)

Een slim beveiligingsalarm: als de PIR-sensor beweging detecteert, gaat de buzzer af, licht de LED op en krijgt de eigenaar direct een Telegram-melding. Een afkoeltijd van 30 seconden beperkt hoe vaak het alarm zich herhaalt; valse detecties van de PIR-sensor filtert dit niet weg. Gebruik het thuis, in een garage, een berging of een studeerkamer.

9
Digitale klok met ESP32 en DS1307-RTC (I2C + LCD)
ES-18Gemiddeld
Premium

Digitale klok met ESP32 en DS1307-RTC (I2C + LCD)

In dit project tonen we de tijd en de datum op een 16x2 I2C-LCD met de DS1307 realtimeklok-module (RTC). De DS1307 is een RTC met batterijback-up die de tijd bijhoudt, ook als de ESP32 uit staat. Beide modules delen dezelfde I2C-bus (SDA/SCL), zodat je leert hoe je met slechts twee signaaldraden meerdere apparaten bestuurt. Met dit project krijg je praktische kennis van het I2C-communicatieprotocol, de werking van RTC-modules en het dynamisch tonen van gegevens op een LCD.

4.6(26)
40