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".

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.
| Eigenschap | Waarde |
|---|---|
| Ontvangerchip | u-blox NEO-6M (u-blox 6-positioneringsengine) |
| Kanalen en signaal | 50 kanalen, GPS L1 C/A (1575,42 MHz), SBAS: EGNOS, WAAS, MSAS |
| Horizontale nauwkeurigheid | 2,5 m CEP (2,0 m met SBAS) |
| Nauwkeurigheid van snelheid en koers | 0,1 m/s en 0,5 graden |
| Tijd tot eerste fix (TTFF) | Koud 27 s, warm 27 s, heet 1 s |
| Gevoeligheid | Tracking -161 dBm, koude start -147 dBm |
| Updatefrequentie | Standaard 1 Hz, tot 5 Hz |
| Interface | UART, standaard 9600 baud 8N1, NMEA 0183 |
| Voeding | Board: 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-pin | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| VCC | 5V | VIN (5V) of 3V3 | VBUS (5V) of 3V3(OUT) |
| GND | GND | GND | GND |
| TX | D4 (SoftwareSerial RX) | GPIO 16 (RX2) | GP1 (UART0 RX) |
| RX | D3, via een 1 kΩ / 2 kΩ-spanningsdeler | GPIO 17 (TX2) | GP0 (UART0 TX) |
| PPS (indien aanwezig) | Kan onaangesloten blijven | Kan onaangesloten blijven | Kan onaangesloten blijven |
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 start | Gegevens in de module | Datasheet | In de praktijk (buiten) |
|---|---|---|---|
| Koude start | Geen tijd-, positie- of satellietgegevens (eerste gebruik of lege back-upbatterij) | 27 s | 1–5 minuten; kan bij zwakke signalen meer dan 10 minuten duren |
| Warme start | Almanak, geschatte tijd en positie; ephemeris verouderd (langer dan ongeveer 4 uur uit) | 27 s | 30 seconden – 1 minuut |
| Hete start | Actuele ephemeris en tijd (pas kort geleden uitgeschakeld, back-upbatterij geladen) | 1 s | Een 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-veld | Voorbeeld | Betekenis |
|---|---|---|
| Tijd (UTC) | 092750.00 | 09:27:50 UTC |
| Breedtegraad | 4100.82500,N | 41 graden 00,825 minuten noord |
| Lengtegraad | 02858.74000,E | 28 graden 58,74 minuten oost |
| Fixkwaliteit | 1 | 0 = geen fix, 1 = GPS, 2 = differentieel (SBAS) gecorrigeerd |
| Satellieten | 08 | Satellieten die in de positieberekening worden gebruikt |
| HDOP | 1.01 | Horizontale precisieverdunning (HDOP); onder 2 is zeer goed |
| Hoogte | 39.2,M | 39,2 m boven gemiddeld zeeniveau |
| Geoïdescheiding | 36.9,M | Verschil tussen zeeniveau en de WGS84-ellipsoïde |
| $GPRMC-veld | Voorbeeld | Betekenis |
|---|---|---|
| Tijd (UTC) | 092750.00 | Uren, minuten, seconden |
| Status | A | A = geldige positie, V = geen fix |
| Breedtegraad / lengtegraad | 4100.82500,N / 02858.74000,E | Zelfde notatie als GGA |
| Snelheid | 0.512 | In knopen (0,512 × 1,852 ≈ 0,95 km/u) |
| Koers | (leeg) | Rijrichting in graden; kan leeg zijn bij stilstand |
| Datum | 281026 | Notatie ddmmjj: 28 oktober 2026 |
| Modus | A | A = 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
- Sluit de NEO-6M aan zoals in de tabel: VCC → 5V, GND → GND, GPS TX → D4, GPS RX → D3 via de deler.
- Upload de onderstaande code; er is geen extra bibliotheek nodig, SoftwareSerial wordt meegeleverd met de Arduino IDE.
- Open de Serial Monitor en stel de snelheid in op 115200 baud.
- Neem de module mee naar buiten of naar een raam en kijk hoe de regels die met $GP beginnen voorbijscrollen.
- 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.
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:
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}| Functie | Wat 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.
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.
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.
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
| Symptoom | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| Serial Monitor helemaal leeg | TX en RX verwisseld, geen gemeenschappelijke GND of geen voeding naar de module | Verbind 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 aan | Controleer de bedrading en de pinnummers in de code; probeer TX en RX te verwisselen |
| Onleesbare tekens | Baudrate komt niet overeen | Gebruik 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 gevonden | Ga naar buiten, richt de antenne op de lucht, wacht 5–15 minuten |
| Aantal satellieten blijft steken op 0–3 | Zwak signaal, antenne ondersteboven, losse u.FL-connector of een ruisbron in de buurt | Controleer 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 INVALID | delay() in loop() laat de buffer overlopen; failedChecksum() blijft stijgen | Verwijder delay(), gebruik millis(), roep encode() continu aan |
| De tijd loopt een paar uur af | GPS-tijd is UTC | Tel je tijdzoneverschil erbij op |
| Positie drijft een paar meter weg en snelheid is niet 0 bij stilstand | Normale GPS-ruis en signalen die weerkaatsen tegen gebouwen | Behandel snelheden onder 2 km/u als 0, sla metingen met hoge HDOP over, neem gemiddelden |
| Wacht bij elke start weer meerdere minuten | Back-upbatterij leeg of ontbreekt | Laat de module een paar uur onder spanning staan om de batterij op te laden |
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.
Projecten om hierna te bouwen
Alle projecten bekijken
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.

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.

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.

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.

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.

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.

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.

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.
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

