Ratgeber · 9 Min. Lesezeit

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.

NEO-6M-GPS-Modul mit Keramikantenne
NEO-6M-GPS-Modul: das Auge des virtuellen Zauns. Die helle Seite der Keramikantenne muss zum Himmel zeigen, ohne Metall oder Akku darüber.

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:

  1. Position holen: Der NEO-6M sendet jede Sekunde Breite, Länge, Satellitenzahl und HDOP.
  2. 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.
  3. 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.
  4. 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

BauteilAufgabeHinweis
Arduino Uno oder ESP32Rechnen und entscheidenFür die SMS-Version ein ESP32 mit zwei Hardware-UARTs
NEO-6M-GPS-ModulPositionDie Keramikantenne muss zum Himmel zeigen
SIM800L-GSM-ModulSMS sendenNur 2G-Netz, Stromspitzen bis 2 A
Aktiver SummerAkustischer Alarm vor OrtAm ESP32 ein Modell, das mit 3,3 V piept, oder ein Transistor
18650-Li-Ion-Zelle und TP4056-LademodulMobile VersorgungDas SIM800L kann direkt an der Zelle hängen
3,3-V-LDO-Regler (z. B. HT7833)Versorgt ESP32 und GPSGeringer Ruhestrom, mindestens 500 mA
Widerstände 1 kΩ, 2 kΩ und 5,6 kΩSpannungsteilerFü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 entspricht0,001 Längengrad
0° (Äquator)111,2 km111 m
37° (Antalya)88,8 km89 m
41° (Istanbul, Rom)83,9 km84 m
52° (Berlin)68,5 km68 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:

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

ZauntypWie wird er festgelegt?Wie wird geprüft?Wo wird er genutzt?
KreisMittelpunkt und RadiusIst der Haversine-Abstand kleiner als der Radius?Rund um Haus und Garten, Park, Campingplatz
Rechteck (Box)Kleinste und größte Breite und LängeVier einfache VergleicheNord-süd-ausgerichteter Acker, Parkplatz
PolygonEckpunkte der Reihe nach entlang der GrenzeRay-Casting-AlgorithmusUnregelmäßige Weide, Garten- oder Grundstücksgrenze
Ring (zwei Kreise)Innerer Warn- und äußerer AlarmradiusZwei AbstandsvergleicheGestufte Warnung: erst Piepton, dann SMS
KorridorRoutenlinie und BreiteAbstand des Punkts zur LinieSchulbus- 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:

UmgebungTypische AbweichungEmpfohlener Mindestradius
Freies Gelände, Weide2–5 m20 m
Garten, Baumnähe5–15 m30–40 m
Zwischen Gebäuden, Stadt10–30 m, manchmal mehr50 m und mehr
Innenraum, im StallKeine Position oder große AbweichungGPS ungeeignet
Fast jeder Fehlalarm geht auf eine einzige schlechte Messung zurück. Nutze im Code vier Filter: mindestens 5 Satelliten, HDOP höchstens 3, eine Position, die höchstens 2 Sekunden alt ist, und 3–5 Messungen hintereinander, bevor sich die Entscheidung ändert. Beim Kreiszaun kommt noch ein Hysterese-Puffer dazu: Um als draußen zu gelten, muss das Gerät 5 m über den Radius hinaus, um wieder drinnen zu sein, 5 m innerhalb liegen. So lässt eine Ziege, die genau auf der Grenze steht, nicht jede Minute dein Handy klingeln.

Schaltplan

Bauteil und PinArduino UnoESP32Hinweis
NEO-6M VCC5V3V3Die Platine hat einen Regler
NEO-6M TXD4 (SoftwareSerial RX)GPIO 16 (RX2)Ausgang des Moduls
NEO-6M RXD3, über Teiler 1 kΩ + 2 kΩGPIO 17 (TX2)Eingang maximal 3,6 V
SIM800L VCCNicht genutzt18650 (+) oder 4,0-V-QuelleStromspitzen bis 2 A
SIM800L TXDNicht genutztGPIO 26 (RX1)2,8-V-Ausgang
SIM800L RXDNicht genutztGPIO 27 (TX1), über Teiler 1 kΩ + 5,6 kΩEingang maximal 3,1 V
Summer (+)D8GPIO 25Aktiver Summer
GNDGNDGNDAkku, GPS, SIM800L und Board an gemeinsamer Masse
Versorge das SIM800L nie über den 5V- oder 3.3V-Pin des Arduino: Das Modul braucht 3,4–4,4 V und zieht beim SMS-Versand Stromimpulse bis 2 A. Eine einzelne 18650-Zelle ist dafür ideal; setze einen Kondensator mit 470–1000 µF nah am Modul zwischen VCC und GND. Die Teilerwerte prüfst du mit dem Werkzeug Spannungsteiler, die Inbetriebnahme des Moduls und den Test mit AT-Befehlen findest du in SIM800L-GSM-Modul.

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:

C++ (Arduino IDE)
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}
CodeteilWas er macht
HOME_LAT, HOME_LNG, RADIUS_MLegen Mittelpunkt und Radius der sicheren Zone fest
MARGIN_M = 5Hysterese-Puffer: Raus heißt über 55 m, wieder rein heißt unter 45 m
NEED_FIXES = 3Wie viele Messungen hintereinander übereinstimmen müssen, bevor sich der Zustand ändert
hdop() > 3.0, satellites() < 5Lässt schwache Messungen ganz aus der Rechnung
location.age() > 2000Verhindert Entscheidungen auf Basis einer alten Position, wenn das GPS verstummt
millis() % 1000 < 200Schaltet 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:

C++ (Arduino IDE)
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}
Jede SMS kostet Geld; sei vorsichtig, wenn du SMS_COOLDOWN_MS verkürzt, damit ein Gerät, das an der Grenze pendelt, keine hohe Rechnung verursacht. Das SIM800L funktioniert nur im 2G-Netz; in manchen Ländern, etwa in der Schweiz, wurde 2G bereits weitgehend abgeschaltet, in anderen ist die Abschaltung geplant. Prüfe vor dem Bau die 2G-Abdeckung deines Anbieters oder nimm ein 4G-Modul. Im Garten mit WLAN-Empfang schickst du Benachrichtigungen besser über einen Telegram-Bot: Das spart die SMS-Kosten und ist schneller.

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.
Kommerzielle Halsbänder für virtuelle Zäune lenken ein Tier zuerst mit einem Ton und bei Überschreiten der Grenze mit einem schwachen Stromimpuls zurück; diese Produkte werden streng geprüft und reguliert und sind in manchen Ländern nur eingeschränkt erlaubt. Bau in einem Bastelprojekt keine Schaltung, die einem Tier Strom gibt; nutze nur Ton und Benachrichtigungen. Willst du die Position eines Menschen verfolgen, dann nur mit seinem Wissen und Einverständnis; in der EU gelten Standortdaten nach der DSGVO als personenbezogene Daten.

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:

BetriebsartMittlerer StromUngefähre Akkulaufzeit
Alles dauerhaft an (ESP32 + NEO-6M + SIM800L im Leerlauf)Etwa 120 mA1 Tag
Alle 5 Minuten 30 Sekunden Ortung, dazwischen Deep Sleep, SIM800L im SchlafmodusEtwa 11 mA11 Tage
Alle 15 Minuten 20 Sekunden Ortung, SIM800L nur beim Alarm anEtwa 2–3 mA6–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

SymptomWahrscheinliche UrsacheLösung
Es wird nie ein Abstand ausgegebenDas Modul hat noch keine Position oder das Gerät ist drinnenNach draußen gehen und für die erste Ortung 1–5 Minuten warten
Alarm, obwohl das Gerät stillstehtDie GPS-Drift ist größer als der RadiusRadius, MARGIN_M und NEED_FIXES erhöhen
Der Abstand beträgt Tausende KilometerBreite und Länge vertauscht oder VorzeichenfehlerZuerst die Breite schreiben; südliche und westliche Koordinaten sind negativ
Das Polygon meldet überall außenEcken durcheinander oder Breite und Länge vertauschtEcken der Reihe nach entlang der Grenze als {Breite, Länge} schreiben
Keine SMS kommt anVersorgung des SIM800L zu schwach, kein 2G-Netz oder SIM-PIN aktivEine Quelle mit 2 A nutzen, mit AT-Befehlen testen, PIN deaktivieren
ESP32 startet beim SMS-Versand neuDie Spannung bricht an der gemeinsamen Versorgung mit dem SIM800L einSIM800L über eine eigene Leitung vom Akku versorgen, 1000 µF ergänzen
Position am Uno ab und zu verstümmeltdelay() in loop() oder Pufferüberlauf bei SoftwareSerialKein 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.

Alle Projekte ansehen
Verwendung des Summers
AR-13Anfänger

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.

4.7(92)
170
LED Blinken mit ESP32
ES-1Anfänger

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.

4.7(37)
108
ESP32 Melodie-Wiedergabe mit Buzzer
ES-12Anfänger
Premium

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

4.8(30)
55
ESP32 Bewegungsalarmsystem (PIR + Buzzer + LED + Telegram)
ES-41Fortgeschritten
Premium

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.

9
ESP32 Deep Sleep – Batteriesparmodus (OLED + RTC-RAM-Zähler)
ES-33Fortgeschritten
Premium

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.

4.3(10)
16
ESP32 Temperatur-Datenlogger (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Fortgeschritten
Premium

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.

4.7(7)
12
ESP32 HTTPClient + Wetter-API (mit SSD1306-OLED-Display)
ES-32Fortgeschritten
Premium

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.

4.3(10)
22