GPS-Geofence mit Arduino: virtueller Zaun mit NEO-6M und SMS
GPS-Geofence mit Arduino und ESP32: sichere Zone mit NEO-6M, Haversine-Distanz, Kreis- und Polygonzaun, Summer- und SMS-Alarm, Tierortung, Akkulaufzeit.
Ein GPS-Geofence mit Arduino ist eine unsichtbare Grenze, die statt durch Draht oder Mauer durch GPS-Koordinaten festgelegt wird: Verlässt das Gerät diese sichere Zone, piept ein Summer und auf Wunsch bekommst du eine SMS mit einem Link zur Position aufs Handy. Solche virtuellen Zäune nutzt man, um Ziegen und Schafe auf der Weide, einen ausbüxenden Hund, ein abgestelltes Motorrad oder einen Mähroboter im Blick zu behalten. Mit einem Arduino oder ESP32, einem NEO-6M-GPS-Modul und einem Summer baust du deinen ersten Geofence an einem Wochenende.
In dieser Anleitung lernst du zuerst die Haversine-Formel kennen, die den Abstand zwischen zwei Positionen berechnet, und siehst, warum man eine Gradzahl nicht direkt in Meter umrechnen kann. Danach vergleichen wir Kreis-, Rechteck- und Polygonzäune in einer Tabelle, filtern Fehlalarme durch GPS-Drift heraus und programmieren einen Kreiszaun auf dem Arduino Uno sowie einen Polygonzaun auf dem ESP32, der über ein SIM800L eine SMS schickt. Zum Schluss geht es um Tierortung und Gartenanwendungen, Akkulaufzeit und häufige Fehler.

Was ist ein Geofence und wie funktioniert er?
Bei einem virtuellen Zaun besteht die Grenze nur aus ein paar Zahlen im Code: Mittelpunkt und Radius eines Kreises oder die Eckpunkte eines Polygons. Das GPS-Modul liefert jede Sekunde eine neue Position, und der Mikrocontroller berechnet, ob sie innerhalb oder außerhalb der Grenze liegt. Schwierig ist nicht die Rechnung, sondern die Entscheidung: Die GPS-Position wandert selbst bei einem Gerät, das sich nicht bewegt, um ein paar Meter, und eine einzige falsche Messung bedeutet einen Fehlalarm. Deshalb arbeitet ein guter Geofence in vier Schritten:
- Position holen: Der NEO-6M sendet jede Sekunde Breite, Länge, Satellitenzahl und HDOP.
- Zuverlässigkeit prüfen: Verwirf die Messung bei weniger als 5 Satelliten, einem HDOP über 3 oder wenn die Position älter als 2 Sekunden ist.
- Mit der Grenze vergleichen: Beim Kreis den Abstand zum Mittelpunkt mit Haversine berechnen, beim Polygon mit dem Ray-Casting-Verfahren prüfen, ob der Punkt innen liegt.
- Entscheidung filtern und Alarm auslösen: Den Zustand erst ändern, wenn mehrere Messungen hintereinander übereinstimmen und die Grenze um einen Puffer überschritten ist, dann Summer und SMS.
Materialliste
| Bauteil | Aufgabe | Hinweis |
|---|---|---|
| Arduino Uno oder ESP32 | Rechnen und entscheiden | Für die SMS-Version ein ESP32 mit zwei Hardware-UARTs |
| NEO-6M-GPS-Modul | Position | Die Keramikantenne muss zum Himmel zeigen |
| SIM800L-GSM-Modul | SMS senden | Nur 2G-Netz, Stromspitzen bis 2 A |
| Aktiver Summer | Akustischer Alarm vor Ort | Am ESP32 ein Modell, das mit 3,3 V piept, oder ein Transistor |
| 18650-Li-Ion-Zelle und TP4056-Lademodul | Mobile Versorgung | Das SIM800L kann direkt an der Zelle hängen |
| 3,3-V-LDO-Regler (z. B. HT7833) | Versorgt ESP32 und GPS | Geringer Ruhestrom, mindestens 500 mA |
| Widerstände 1 kΩ, 2 kΩ und 5,6 kΩ | Spannungsteiler | Für GPS-RX (Uno) und SIM800L-RXD |
Die Haversine-Formel: Abstand zwischen zwei Positionen
Breite und Länge werden in Grad angegeben, und die Erde ist keine Scheibe; deshalb kannst du die Gradzahl zwischen zwei Punkten nicht einfach mit einer festen Zahl multiplizieren. Ein Breitengrad ist überall etwa 111,2 km lang. Bei der Länge laufen die Meridiane dagegen zu den Polen hin zusammen, sodass ein Grad mit dem Kosinus der Breite kürzer wird:
| Breite (Beispielort) | 1 Längengrad entspricht | 0,001 Längengrad |
|---|---|---|
| 0° (Äquator) | 111,2 km | 111 m |
| 37° (Antalya) | 88,8 km | 89 m |
| 41° (Istanbul, Rom) | 83,9 km | 84 m |
| 52° (Berlin) | 68,5 km | 68 m |
Die Haversine-Formel berücksichtigt diese Krümmung und liefert den kürzesten Abstand über die Oberfläche: a = sin²(Δφ/2) + cos φ1 · cos φ2 · sin²(Δλ/2) und d = 2R · atan2(√a, √(1−a)). Dabei ist φ die Breite, λ die Länge (im Bogenmaß) und R der mittlere Erdradius von 6.371.000 Metern. Ein Punkt auf 41° Breite, der 0,0009 Grad nördlich und 0,001 Grad östlich des Mittelpunkts liegt, ist zum Beispiel 100,1 m nach Norden, 83,9 m nach Osten und insgesamt 130,6 m entfernt. Weil die meisten Geofences nur ein paar hundert Meter groß sind, liefert auch eine einfachere flache Näherung dasselbe Ergebnis: Du multiplizierst die Längendifferenz mit dem Kosinus der mittleren Breite und wendest Pythagoras an. Der kurze Sketch unten vergleicht beides:
1// İki konum arası mesafe: Haversine ve hızlı düz yaklaşım / distance between two points: Haversine and the fast flat approximation
2double haversineM(double lat1, double lon1, double lat2, double lon2) {
3 const double R = 6371000.0;
4 double dLat = radians(lat2 - lat1);
5 double dLon = radians(lon2 - lon1);
6 double a = sin(dLat / 2) * sin(dLat / 2) +
7 cos(radians(lat1)) * cos(radians(lat2)) * sin(dLon / 2) * sin(dLon / 2);
8 return 2 * R * atan2(sqrt(a), sqrt(1 - a));
9}
10
11double flatM(double lat1, double lon1, double lat2, double lon2) {
12 const double R = 6371000.0;
13 double x = radians(lon2 - lon1) * cos(radians((lat1 + lat2) / 2)); // doğu-batı / east-west
14 double y = radians(lat2 - lat1); // kuzey-güney / north-south
15 return R * sqrt(x * x + y * y);
16}
17
18void setup() {
19 Serial.begin(115200);
20 // Merkez ve bir nokta: kuzeyde 0,0009°, doğuda 0,001° / centre and a point 0.0009° north, 0.001° east
21 Serial.println(haversineM(41.015137, 28.979530, 41.016037, 28.980530), 1);
22 Serial.println(flatM(41.015137, 28.979530, 41.016037, 28.980530), 1);
23}
24
25void loop() {
26}Beide Funktionen geben im seriellen Monitor etwa 130,6 aus; in dieser Größenordnung liegt der Unterschied unter einem Zentimeter. Die flache Näherung weicht ab ein paar Kilometern ab, Haversine bleibt auch über Hunderte Kilometer genau. Auf dem Arduino Uno ist double in Wahrheit ein 32-Bit-Float und speichert Koordinaten auf etwa 0,4 Meter genau, was für einen Geofence mehr als reicht. Die Funktion distanceBetween() der Bibliothek TinyGPSPlus erledigt dasselbe; Installation und GPS-Verkabelung erklären wir ausführlich in NEO-6M-GPS-Modul.
Zauntypen: Kreis, Rechteck und Polygon
| Zauntyp | Wie wird er festgelegt? | Wie wird geprüft? | Wo wird er genutzt? |
|---|---|---|---|
| Kreis | Mittelpunkt und Radius | Ist der Haversine-Abstand kleiner als der Radius? | Rund um Haus und Garten, Park, Campingplatz |
| Rechteck (Box) | Kleinste und größte Breite und Länge | Vier einfache Vergleiche | Nord-süd-ausgerichteter Acker, Parkplatz |
| Polygon | Eckpunkte der Reihe nach entlang der Grenze | Ray-Casting-Algorithmus | Unregelmäßige Weide, Garten- oder Grundstücksgrenze |
| Ring (zwei Kreise) | Innerer Warn- und äußerer Alarmradius | Zwei Abstandsvergleiche | Gestufte Warnung: erst Piepton, dann SMS |
| Korridor | Routenlinie und Breite | Abstand des Punkts zur Linie | Schulbus- oder Tourroute |
Für den Anfang ist der Kreis am einfachsten: Ein Mittelpunkt und ein Radius genügen. Ist dein Grundstück viereckig oder unregelmäßig, nimm ein Polygon. Die Eckkoordinaten bekommst du in Google Maps am Computer per Rechtsklick auf die Stelle, dort kopierst du die Zahlen in der ersten Zeile; am Handy hältst du die Stelle gedrückt, und die Koordinaten erscheinen im Suchfeld. Sechs Nachkommastellen bedeuten eine Genauigkeit von etwa 11 Zentimetern. Schreib die Ecken des Polygons der Reihe nach entlang der Grenze auf, im oder gegen den Uhrzeigersinn; durcheinander notierte Ecken ergeben eine sich selbst schneidende Form, und die Entscheidung innen oder außen wird unsinnig.
GPS-Genauigkeit: Wie wählst du den Radius?
Die 2,5 m CEP im Datenblatt des NEO-6M bedeuten, dass die Hälfte der Messungen weniger als 2,5 Meter von der wahren Position entfernt liegt; die andere Hälfte liegt weiter weg. Bäume, Gebäude und Metalldächer reflektieren die Satellitensignale, und die Position kann innerhalb von Sekunden um 10–30 Meter springen. Trägst du die Position eines GPS, das auf dem Tisch liegt, in eine Karte ein, siehst du keinen Punkt, sondern eine Wolke von einigen Metern Durchmesser. Deshalb wählst du den Radius passend zur Umgebung:
| Umgebung | Typische Abweichung | Empfohlener Mindestradius |
|---|---|---|
| Freies Gelände, Weide | 2–5 m | 20 m |
| Garten, Baumnähe | 5–15 m | 30–40 m |
| Zwischen Gebäuden, Stadt | 10–30 m, manchmal mehr | 50 m und mehr |
| Innenraum, im Stall | Keine Position oder große Abweichung | GPS ungeeignet |
Schaltplan
| Bauteil und Pin | Arduino Uno | ESP32 | Hinweis |
|---|---|---|---|
| NEO-6M VCC | 5V | 3V3 | Die Platine hat einen Regler |
| NEO-6M TX | D4 (SoftwareSerial RX) | GPIO 16 (RX2) | Ausgang des Moduls |
| NEO-6M RX | D3, über Teiler 1 kΩ + 2 kΩ | GPIO 17 (TX2) | Eingang maximal 3,6 V |
| SIM800L VCC | Nicht genutzt | 18650 (+) oder 4,0-V-Quelle | Stromspitzen bis 2 A |
| SIM800L TXD | Nicht genutzt | GPIO 26 (RX1) | 2,8-V-Ausgang |
| SIM800L RXD | Nicht genutzt | GPIO 27 (TX1), über Teiler 1 kΩ + 5,6 kΩ | Eingang maximal 3,1 V |
| Summer (+) | D8 | GPIO 25 | Aktiver Summer |
| GND | GND | GND | Akku, GPS, SIM800L und Board an gemeinsamer Masse |
Kreisförmiger Geofence mit Summer am Arduino Uno
Die erste Version braucht weder Internet noch SIM-Karte: Ist das Gerät mehr als 50 Meter vom Mittelpunkt entfernt, piept der Summer einmal pro Sekunde, und der Abstand erscheint im seriellen Monitor. Ersetze HOME_LAT und HOME_LNG durch deinen eigenen Mittelpunkt aus Google Maps. Der Code nutzt in loop() kein delay(); das GPS sendet rund 500 Byte pro Sekunde, und der 64-Byte-Puffer von SoftwareSerial läuft bei langen Wartezeiten über:
1// Sanal çit (daire): NEO-6M + aktif buzzer, Arduino Uno / virtual fence (circle): NEO-6M + active buzzer
2#include <TinyGPSPlus.h>
3#include <SoftwareSerial.h>
4
5const double HOME_LAT = 41.015137; // güvenli bölgenin merkezi / centre of the safe zone
6const double HOME_LNG = 28.979530;
7const double RADIUS_M = 50.0; // yarıçap, metre / radius in metres
8const double MARGIN_M = 5.0; // histerezis payı / hysteresis margin
9const byte NEED_FIXES = 3; // art arda kaç ölçüm / how many readings in a row
10const int BUZZER_PIN = 8;
11
12TinyGPSPlus gps;
13SoftwareSerial gpsSerial(4, 3); // RX = D4 ← GPS TX, TX = D3 → GPS RX (bölücüyle / via divider)
14bool outside = false;
15byte outCount = 0, inCount = 0;
16unsigned long lastCheck = 0;
17
18double haversineM(double lat1, double lon1, double lat2, double lon2) {
19 const double R = 6371000.0; // Dünya yarıçapı, metre / Earth radius in metres
20 double dLat = radians(lat2 - lat1);
21 double dLon = radians(lon2 - lon1);
22 double a = sin(dLat / 2) * sin(dLat / 2) +
23 cos(radians(lat1)) * cos(radians(lat2)) * sin(dLon / 2) * sin(dLon / 2);
24 return 2 * R * atan2(sqrt(a), sqrt(1 - a));
25}
26
27void checkFence() {
28 if (!gps.location.isValid() || gps.location.age() > 2000) return; // eski konumu yok say / ignore stale fixes
29 if (gps.hdop.hdop() > 3.0 || gps.satellites.value() < 5) return; // zayıf konumu yok say / ignore weak fixes
30 double d = haversineM(HOME_LAT, HOME_LNG, gps.location.lat(), gps.location.lng());
31 if (d > RADIUS_M + MARGIN_M) { outCount++; inCount = 0; }
32 else if (d < RADIUS_M - MARGIN_M) { inCount++; outCount = 0; }
33 if (!outside && outCount >= NEED_FIXES) {
34 outside = true;
35 Serial.println(F("ALARM: bolge disi / outside the fence"));
36 }
37 if (outside && inCount >= NEED_FIXES) {
38 outside = false;
39 Serial.println(F("Bolgeye dondu / back inside"));
40 }
41 Serial.print(F("Mesafe / distance: "));
42 Serial.print(d, 1);
43 Serial.println(F(" m"));
44}
45
46void setup() {
47 Serial.begin(115200);
48 gpsSerial.begin(9600); // NEO-6M varsayılan hızı / NEO-6M default baud rate
49 pinMode(BUZZER_PIN, OUTPUT);
50}
51
52void loop() {
53 while (gpsSerial.available()) gps.encode(gpsSerial.read()); // her baytı ayrıştırıcıya ver / feed every byte
54 if (millis() - lastCheck >= 1000) { // saniyede bir kontrol / check once per second
55 lastCheck = millis();
56 checkFence();
57 }
58 // Bölge dışında 200 ms aç, 800 ms kapat / outside: 200 ms on, 800 ms off
59 bool beep = outside && (millis() % 1000 < 200);
60 digitalWrite(BUZZER_PIN, beep ? HIGH : LOW);
61}| Codeteil | Was er macht |
|---|---|
| HOME_LAT, HOME_LNG, RADIUS_M | Legen Mittelpunkt und Radius der sicheren Zone fest |
| MARGIN_M = 5 | Hysterese-Puffer: Raus heißt über 55 m, wieder rein heißt unter 45 m |
| NEED_FIXES = 3 | Wie viele Messungen hintereinander übereinstimmen müssen, bevor sich der Zustand ändert |
| hdop() > 3.0, satellites() < 5 | Lässt schwache Messungen ganz aus der Rechnung |
| location.age() > 2000 | Verhindert Entscheidungen auf Basis einer alten Position, wenn das GPS verstummt |
| millis() % 1000 < 200 | Schaltet den Summer außerhalb der Zone in den ersten 200 ms jeder Sekunde ein |
Polygon-Geofence mit SMS-Alarm am ESP32
Die zweite Version beschreibt die echte Form des Grundstücks mit Eckpunkten und schickt über das SIM800L eine SMS mit einem Google-Maps-Link zur Position, sobald das Gerät die Zone verlässt. Weil der ESP32 drei Hardware-UARTs hat, hängt das GPS an Serial2 und das SIM800L an Serial1, und beide lassen sich problemlos gleichzeitig abhören. Die Polygonprüfung nutzt das Ray-Casting-Verfahren: Vom Punkt aus wird ein gedachter Strahl nach Osten gezogen und gezählt, wie oft er die Kanten des Polygons schneidet; eine ungerade Zahl heißt innen, eine gerade außen. Zwischen zwei SMS wartet der Code mindestens 10 Minuten und meldet auch die Rückkehr in die Zone:
1// ESP32 sanal çit (çokgen) + SIM800L ile SMS / ESP32 virtual fence (polygon) + SMS with a SIM800L
2#include <TinyGPSPlus.h>
3
4#define GPS_RX 16 // ESP32 RX2 ← GPS TX
5#define GPS_TX 17 // ESP32 TX2 → GPS RX
6#define SIM_RX 26 // ESP32 RX1 ← SIM800L TXD
7#define SIM_TX 27 // ESP32 TX1 → SIM800L RXD (1k + 5,6k bölücü / divider)
8const int BUZZER_PIN = 25;
9const char PHONE[] = "+905551112233"; // SMS gidecek numara / number that gets the SMS
10
11// Güvenli bölgenin köşeleri: {enlem, boylam}, sırayla / corners of the safe zone in order: {lat, lng}
12const double POLY[][2] = {
13 {41.015600, 28.978900},
14 {41.015650, 28.980300},
15 {41.014700, 28.980450},
16 {41.014550, 28.979000}
17};
18const int N = sizeof(POLY) / sizeof(POLY[0]);
19const byte NEED_FIXES = 5; // 5 ölçüm üst üste / 5 readings in a row
20const unsigned long SMS_COOLDOWN_MS = 600000; // iki SMS arası en az 10 dk / at least 10 min between SMS
21
22TinyGPSPlus gps;
23HardwareSerial &gpsSerial = Serial2;
24HardwareSerial &sim = Serial1;
25bool outside = false;
26byte outCount = 0, inCount = 0;
27unsigned long lastCheck = 0, lastSms = 0;
28bool smsSent = false;
29
30// Işın atma: nokta çokgenin içinde mi? / ray casting: is the point inside the polygon?
31bool insidePolygon(double lat, double lng) {
32 bool in = false;
33 for (int i = 0, j = N - 1; i < N; j = i++) {
34 bool crosses = (POLY[i][0] > lat) != (POLY[j][0] > lat);
35 if (crosses) {
36 double lngAtLat = (POLY[j][1] - POLY[i][1]) * (lat - POLY[i][0]) / (POLY[j][0] - POLY[i][0]) + POLY[i][1];
37 if (lng < lngAtLat) in = !in;
38 }
39 }
40 return in;
41}
42
43bool waitFor(const char *word, unsigned long timeoutMs) { // cevapta kelimeyi bekle / wait for a word in the reply
44 String reply = "";
45 unsigned long start = millis();
46 while (millis() - start < timeoutMs) {
47 while (sim.available()) reply += (char)sim.read();
48 if (reply.indexOf(word) >= 0) return true;
49 if (reply.indexOf("ERROR") >= 0) return false;
50 }
51 return false;
52}
53
54bool sendSms(const String &text) {
55 sim.println("AT+CMGF=1"); // metin modu / text mode
56 if (!waitFor("OK", 2000)) return false;
57 sim.print("AT+CMGS=\"");
58 sim.print(PHONE);
59 sim.println("\"");
60 if (!waitFor(">", 5000)) return false;
61 sim.print(text);
62 sim.write(26); // Ctrl+Z: gönder / Ctrl+Z: send
63 return waitFor("+CMGS", 15000);
64}
65
66String mapsLink() {
67 return "https://www.google.com/maps/search/?api=1&query=" +
68 String(gps.location.lat(), 6) + "," + String(gps.location.lng(), 6);
69}
70
71void checkFence() {
72 if (!gps.location.isValid() || gps.location.age() > 2000) return;
73 if (gps.hdop.hdop() > 3.0 || gps.satellites.value() < 5) return;
74 bool in = insidePolygon(gps.location.lat(), gps.location.lng());
75 if (in) { inCount++; outCount = 0; } else { outCount++; inCount = 0; }
76
77 if (!outside && outCount >= NEED_FIXES) {
78 outside = true;
79 smsSent = false;
80 Serial.println("ALARM: bolge disi / outside the fence");
81 }
82 if (outside && inCount >= NEED_FIXES) {
83 outside = false;
84 Serial.println("Bolgeye dondu / back inside");
85 if (millis() - lastSms > SMS_COOLDOWN_MS) {
86 sendSms("Bolgeye dondu / back inside " + mapsLink());
87 lastSms = millis();
88 }
89 }
90 if (outside && !smsSent && (lastSms == 0 || millis() - lastSms > SMS_COOLDOWN_MS)) {
91 smsSent = sendSms("SANAL CIT ALARMI / FENCE ALARM " + mapsLink());
92 lastSms = millis();
93 Serial.println(smsSent ? "SMS gonderildi / sent" : "SMS gonderilemedi / failed");
94 }
95}
96
97void setup() {
98 Serial.begin(115200);
99 gpsSerial.setRxBufferSize(1024); // SMS sırasında veri taşmasın / room for data while sending SMS
100 gpsSerial.begin(9600, SERIAL_8N1, GPS_RX, GPS_TX);
101 sim.begin(9600, SERIAL_8N1, SIM_RX, SIM_TX);
102 pinMode(BUZZER_PIN, OUTPUT);
103 delay(3000); // SIM800L açılsın / let the SIM800L start
104 sim.println("ATE0"); // yankıyı kapat / echo off
105 waitFor("OK", 2000);
106}
107
108void loop() {
109 while (gpsSerial.available()) gps.encode(gpsSerial.read());
110 if (millis() - lastCheck >= 1000) {
111 lastCheck = millis();
112 checkFence();
113 }
114 bool beep = outside && (millis() % 1000 < 200);
115 digitalWrite(BUZZER_PIN, beep ? HIGH : LOW);
116}Tierortung und Gartenanwendungen
- Weide und Herdenortung: Bring an der Leitziege oder dem Leitschaf eine wasserdichte Halsband-Box an und achte darauf, dass die Antenne nach oben zeigt. Bis zum Hof kommst du statt per SMS mit einem LoRa-Modul ohne Mobilfunkanbieter und mit Kilometern Reichweite.
- Warnung bei ausgebüxtem Hund: Leg den Garten als Polygon an; schlüpft der Hund durch das offene Tor, kommt eine SMS mit seiner Position.
- Mähroboter und Gartenfahrzeuge: Ergänze einen Ausgang, der die Motoren stoppt, wenn der Roboter die Grenze überschreitet; wegen der GPS-Genauigkeit nur als zusätzliche Sicherheit neben einem Begrenzungsdraht.
- Motorrad, Fahrrad und Boot: Leg dort, wo du parkst, einen Kreis von 30–50 m fest; verlässt das Fahrzeug ihn, bekommst du eine SMS, falls es gestohlen wird.
- Camping und Ausflüge: Ein mobiler Warner, der meldet, wenn sich eine Kindergruppe vom Zeltplatz entfernt; nur mit Wissen und Einverständnis der Gruppe einsetzen.
Akkulaufzeit: Wie viele Tage hält ein Geofence?
In einem mobilen Geofence verbraucht das GPS die meiste Energie. Der NEO-6M zieht bei der Satellitensuche etwa 47 mA und beim Verfolgen 39 mA; ein ESP32 mit ausgeschaltetem WLAN braucht 30–50 mA, ein SIM800L im Leerlauf etwa 15 mA. Bleibt alles eingeschaltet, hält eine 18650-Zelle mit 3000 mAh nur rund einen Tag. Die Lösung ist ein Betrieb in Intervallen: Der ESP32 wacht in festen Abständen aus dem Deep Sleep auf, schaltet das GPS ein, holt sich eine Position, prüft die Grenze und schläft wieder. Die Werte unten sind grobe Schätzungen für eine 3000-mAh-Zelle, ein nacktes ESP32-Modul und einen LDO mit geringem Ruhestrom:
| Betriebsart | Mittlerer Strom | Ungefähre Akkulaufzeit |
|---|---|---|
| Alles dauerhaft an (ESP32 + NEO-6M + SIM800L im Leerlauf) | Etwa 120 mA | 1 Tag |
| Alle 5 Minuten 30 Sekunden Ortung, dazwischen Deep Sleep, SIM800L im Schlafmodus | Etwa 11 mA | 11 Tage |
| Alle 15 Minuten 20 Sekunden Ortung, SIM800L nur beim Alarm an | Etwa 2–3 mA | 6–8 Wochen |
Beim Intervallbetrieb zählen zwei Details. Erstens muss für eine schnelle Ortung die Pufferbatterie auf der NEO-6M-Platine geladen sein; behält das Modul seine Ephemeriden, findet es die Position in wenigen Sekunden (Heißstart), war es mehr als ein paar Stunden aus, braucht es für einen Warmstart 30 Sekunden und mehr. Zweitens spart es mehr Energie, GPS und SIM800L mit einem P-Kanal-MOSFET ganz abzuschalten, statt sie im Schlafmodus zu lassen; das SIM800L braucht allerdings bei jedem Einschalten 10–30 Sekunden, um sich wieder im Netz anzumelden. Schlafmodi und RTC-Speicher findest du in ESP32 Deep Sleep, die Akkusicherheit in 18650-Li-Ion-Akku und TP4056-Lademodul; dein eigenes Szenario rechnest du mit dem Werkzeug Akkulaufzeit durch.
Häufige Fehler und Lösungen
| Symptom | Wahrscheinliche Ursache | Lösung |
|---|---|---|
| Es wird nie ein Abstand ausgegeben | Das Modul hat noch keine Position oder das Gerät ist drinnen | Nach draußen gehen und für die erste Ortung 1–5 Minuten warten |
| Alarm, obwohl das Gerät stillsteht | Die GPS-Drift ist größer als der Radius | Radius, MARGIN_M und NEED_FIXES erhöhen |
| Der Abstand beträgt Tausende Kilometer | Breite und Länge vertauscht oder Vorzeichenfehler | Zuerst die Breite schreiben; südliche und westliche Koordinaten sind negativ |
| Das Polygon meldet überall außen | Ecken durcheinander oder Breite und Länge vertauscht | Ecken der Reihe nach entlang der Grenze als {Breite, Länge} schreiben |
| Keine SMS kommt an | Versorgung des SIM800L zu schwach, kein 2G-Netz oder SIM-PIN aktiv | Eine Quelle mit 2 A nutzen, mit AT-Befehlen testen, PIN deaktivieren |
| ESP32 startet beim SMS-Versand neu | Die Spannung bricht an der gemeinsamen Versorgung mit dem SIM800L ein | SIM800L über eine eigene Leitung vom Akku versorgen, 1000 µF ergänzen |
| Position am Uno ab und zu verstümmelt | delay() in loop() oder Pufferüberlauf bei SoftwareSerial | Kein delay() verwenden, bei Bedarf auf ESP32 umsteigen |
Ein GPS-Geofence vereint GPS, Mathematik und Kommunikation in einem Projekt und ist deshalb lehrreich und im Alltag wirklich nützlich. Probiere zuerst den Kreiszaun mit einem Uno im Garten aus, stimme den Radius auf deine Umgebung ab und steig dann mit ESP32 und SIM800L auf den Polygonzaun mit SMS-Alarm um. In der BlueGrays-App baust du die Alarmseite des Systems Schritt für Schritt mit den Projekten zum Summer-Alarmton und zur ESP32-Alarmanlage mit Telegram-Benachrichtigung aus, jeweils mit Schaltplan und fertigem Code.
Häufige Fragen
Was ist ein GPS-Geofence?
Ein Geofence ist eine unsichtbare Grenze, die statt durch einen Draht durch GPS-Koordinaten festgelegt ist. Verlässt das Gerät die sichere Zone, piept ein Summer oder der Besitzer bekommt eine SMS oder Benachrichtigung. Genutzt wird das für Tierortung, Gärten, Fahrzeugsicherung und Mähroboter.
Wie baue ich einen Geofence mit Arduino?
Schließe ein GPS-Modul wie den NEO-6M an einen Arduino oder ESP32 an und lege die sichere Zone im Code als Mittelpunkt mit Radius oder als Eckpunkte fest. Der Mikrocontroller prüft jede Sekunde mit der Haversine-Formel oder einem Polygontest, ob die Position innerhalb liegt. Verlässt das Gerät die Zone, piept ein Summer, und mit einem SIM800L lässt sich eine SMS senden.
Wie genau ist ein GPS-Geofence?
Im freien Gelände liegt der NEO-6M meist innerhalb von 2–5 Metern, in der Nähe von Bäumen und Gebäuden kann die Abweichung 10–30 Meter erreichen. Der Radius sollte deshalb im Freien mindestens 20 Meter und im Garten 30–40 Meter betragen. Mehrere Messungen hintereinander und ein Hysterese-Puffer verhindern die meisten Fehlalarme.
Braucht ein Geofence Internet?
Nein. GPS funktioniert über Satelliten, und ein Geofence mit Summer läuft ganz ohne Verbindung. Für Meldungen aus der Ferne kannst du SMS über ein SIM800L, Telegram bei WLAN-Empfang oder LoRa auf großen Flächen wie Bauernhöfen nutzen.
Sind virtuelle Zäune für Tiere sicher?
Ein virtueller Zaun, der nur Töne und Benachrichtigungen nutzt, schadet keinem Tier. Der Stromimpuls kommerzieller Halsbänder gehört zu streng regulierten Produkten und hat in Bastelprojekten nichts zu suchen. Die Halsband-Box sollte leicht, wasserdicht und so gebaut sein, dass sie den Hals des Tieres nicht einengt.
Wie lange hält der Akku eines GPS-Trackers?
Sind GPS, ESP32 und SIM800L dauernd an, hält eine Zelle mit 3000 mAh etwa einen Tag. Wacht das Gerät nur alle 5–15 Minuten aus dem Deep Sleep auf, um eine Position zu holen, sind es mehrere Wochen. Ein nacktes ESP32-Modul mit einem Regler mit geringem Ruhestrom statt eines Entwicklungsboards macht ebenfalls einen großen Unterschied.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
Verwendung des Summers
Hast du dich mal gefragt, wie eine Türklingel oder ein Alarm seinen Ton erzeugt? Der Arduino lässt einen kleinen Summer in kurzen Abständen piepen: piep, Pause, piep, Pause.

LED Blinken mit ESP32
Lehrt die grundlegende Verwendung von GPIO-Ausgängen mit ESP32. Wir erreichen einen Blinkeffekt, indem wir eine LED über einen digitalen Pin ein- und ausschalten. ESP32-Version des klassischen Blink-Projekts auf Arduino UNO; die grundlegenden Blink-Befehle in der Arduino-Umgebung bleiben gleich, aber die Pinbelegung und die GPIO-Pegel von 3,3 V des ESP32 unterscheiden sich von denen des Arduino UNO.

ESP32 Melodie-Wiedergabe mit Buzzer
Spielen einer einfachen Melodie (Twinkle Twinkle Little Star) mit einem passiven Buzzer. Wir spielen die Noten mit den Funktionen tone() und noTone() wie in Arduino - die gleiche Syntax funktioniert mit ESP32 Arduino Core 3.0+. Es muss ein passiver Buzzer verwendet werden (ein aktiver Buzzer spielt keine Melodie).

ESP32 Bewegungsalarmsystem (PIR + Buzzer + LED + Telegram)
Eine smarte Alarmanlage: Erkennt der PIR-Sensor eine Bewegung, ertönt der Summer, die LED leuchtet und der Besitzer bekommt sofort eine Telegram-Nachricht. Eine Sperrzeit von 30 Sekunden begrenzt, wie oft der Alarm wiederholt wird; Fehlauslösungen des PIR-Sensors verhindert sie nicht. Geeignet für Haus, Garage, Lager oder Arbeitszimmer.

ESP32 Deep Sleep – Batteriesparmodus (OLED + RTC-RAM-Zähler)
Im Deep-Sleep-Modus schaltet der ESP32 die CPU und die meisten Peripheriegeräte ab und senkt den Strom auf etwa 10µA, entscheidend für batteriebetriebene IoT-Geräte. Das Projekt nutzt drei Weckquellen: einen Timer (15 s), einen externen Pin (EXT0, Taster an GPIO 33) und einen Touch-Pin (T0/GPIO 4). Mit RTC_DATA_ATTR markierte Zähler bleiben im Deep Sleep erhalten.

ESP32 Temperatur-Datenlogger (DHT22 + DS1307 RTC + microSD + OLED)
Bau mit dem ESP32 einen zeitgesteuerten Temperatur- und Feuchtigkeitslogger! Ein DHT22 misst einmal pro Minute Temperatur und Luftfeuchtigkeit; jeder Wert landet mit einem Zeitstempel des RTC-Moduls DS1307 im CSV-Format auf einer microSD-Karte. Das OLED zeigt live und in großer Schrift die letzte Temperatur, die Luftfeuchtigkeit, den Zeitstempel und die Zahl der Einträge.

ESP32 HTTPClient + Wetter-API (mit SSD1306-OLED-Display)
Der ESP32 ruft über das Internet mit HTTPClient.h eine Wetter-API (wttr.in) per REST auf. Anders als die I2C-LCD-Version nutzt dieses Projekt ein SSD1306-OLED (128×64) mit großer Schrift und Vektor-Icons für eine reichere Darstellung. Sieben Wetter-Icons (sonnig, Regen, Schnee und mehr) werden ohne Bitmap-Dateien direkt gezeichnet.
Weitere Artikel
BlueGrays-App
Diese Schaltung Schritt für Schritt auf dem Handy nachbauen
Schaltplan, Code und Teileliste auf einem Bildschirm. Über 500 Arduino-, ESP32- und Pico-Projekte zum Nachbauen.
Mit dem Handy scannen
Richte die Kamera auf den Code, dann öffnet sich der App-Store deines Handys.
oder im Store öffnen

