Cerca virtual GPS con Arduino: geocerca con NEO-6M y alerta SMS
Haz una cerca virtual GPS con Arduino y ESP32: zona segura con NEO-6M, distancia Haversine, cerca circular y poligonal, alarma con buzzer y SMS, y batería.
Una cerca virtual GPS con Arduino es un límite invisible definido por coordenadas GPS en lugar de un alambre o un muro: cuando el equipo sale de esa zona segura suena un buzzer y, si quieres, te llega al celular un SMS con un enlace a su ubicación. Este método, llamado geocerca (geofence), se usa para vigilar cabras y borregos en el potrero, un perro que se escapa del patio, una moto estacionada o una podadora robot. Con un Arduino o un ESP32, un módulo GPS NEO-6M y un buzzer puedes armar tu primera cerca virtual en un fin de semana.
En esta guía primero verás la fórmula de Haversine, que calcula la distancia entre dos posiciones, y por qué no puedes convertir una diferencia en grados directamente a metros. Después compararemos en una tabla las cercas circulares, rectangulares y poligonales, aprenderemos a filtrar las falsas alarmas que provoca la deriva del GPS y programaremos una cerca circular en un Arduino Uno y una cerca poligonal en un ESP32 que manda un SMS con un SIM800L. Al final veremos aplicaciones para rastrear animales y para el jardín, la duración de la batería y los errores más comunes.

¿Qué es una geocerca y cómo funciona?
En una cerca virtual el límite son solo unos números dentro del código: el centro y el radio de un círculo, o las esquinas de un polígono. El módulo GPS entrega una posición nueva cada segundo y el microcontrolador calcula si está dentro o fuera del límite. Lo difícil no es el cálculo sino la decisión: la posición del GPS se mueve unos metros incluso en un equipo que no se mueve, y una sola lectura mala significa una falsa alarma. Por eso una buena geocerca trabaja en cuatro pasos:
- Obtener la posición: El NEO-6M envía cada segundo latitud, longitud, número de satélites y HDOP.
- Revisar si es confiable: Descarta la lectura si se usan menos de 5 satélites, si el HDOP es mayor que 3 o si la posición tiene más de 2 segundos.
- Compararla con el límite: En un círculo, calcula la distancia al centro con Haversine; en un polígono, averigua si el punto está dentro con el método de trazado de rayos (ray casting).
- Filtrar la decisión y dar la alarma: Cambia de estado solo cuando varias lecturas seguidas coinciden y el límite se rebasa por un margen; entonces suena el buzzer y se envía el SMS.
Lista de materiales
| Material | Función | Nota |
|---|---|---|
| Arduino Uno o ESP32 | Cálculo y decisión | Para la versión con SMS, un ESP32 con dos UART por hardware |
| Módulo GPS NEO-6M | Posición | La antena cerámica debe mirar al cielo |
| Módulo GSM SIM800L | Enviar SMS | Solo red 2G, picos de corriente de hasta 2 A |
| Buzzer activo | Alarma sonora local | En el ESP32, uno que suene con 3,3 V o un transistor |
| Celda Li-ion 18650 y cargador TP4056 | Alimentación portátil | El SIM800L puede alimentarse directo de la celda |
| Regulador LDO de 3,3 V (p. ej. HT7833) | Alimenta el ESP32 y el GPS | Baja corriente en reposo, al menos 500 mA |
| Resistencias de 1 kΩ, 2 kΩ y 5,6 kΩ | Divisores de voltaje | Para el RX del GPS (Uno) y el RXD del SIM800L |
La fórmula de Haversine: distancia entre dos posiciones
La latitud y la longitud están en grados y la Tierra no es plana, así que no puedes tomar la diferencia en grados entre dos puntos y multiplicarla por un número fijo. Un grado de latitud mide unos 111,2 km en cualquier lugar. En la longitud, en cambio, los meridianos se juntan hacia los polos, y la longitud de un grado se reduce con el coseno de la latitud:
| Latitud (lugar de ejemplo) | 1° de longitud equivale a | 0,001° de longitud |
|---|---|---|
| 0° (ecuador, Quito) | 111,2 km | 111 m |
| 19° N (Ciudad de México) | 105,1 km | 105 m |
| 34° S (Buenos Aires, Santiago) | 92,2 km | 92 m |
| 41° N (Madrid, Estambul) | 83,9 km | 84 m |
La fórmula de Haversine toma en cuenta esa curvatura y da la distancia más corta sobre la superficie entre dos puntos: a = sin²(Δφ/2) + cos φ1 · cos φ2 · sin²(Δλ/2) y d = 2R · atan2(√a, √(1−a)). Aquí φ es la latitud, λ la longitud (en radianes) y R el radio medio de la Tierra, 6 371 000 metros. Por ejemplo, a 41° de latitud un punto situado 0,0009 grados al norte y 0,001 grados al este del centro está a 100,1 m hacia el norte, 83,9 m hacia el este y 130,6 m en total. Como la mayoría de las geocercas miden unos cuantos cientos de metros, una aproximación plana más sencilla da el mismo resultado: multiplicas la diferencia de longitud por el coseno de la latitud media y aplicas Pitágoras. El siguiente código corto compara las dos:
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}Las dos funciones muestran unos 130,6 en el Monitor Serie; a esta escala la diferencia entre ellas es menor a un centímetro. La aproximación plana empieza a desviarse a partir de unos kilómetros, mientras que Haversine sigue siendo exacta en cientos de kilómetros. En el Arduino Uno, double en realidad es un float de 32 bits y guarda las coordenadas con una precisión de unos 0,4 metros, más que suficiente para una geocerca. La función distanceBetween() de la librería TinyGPSPlus hace lo mismo; explicamos con detalle cómo instalar la librería y conectar el GPS en módulo GPS NEO-6M.
Tipos de cerca: círculo, rectángulo y polígono
| Tipo de cerca | Cómo se define | Cómo se revisa | Dónde se usa |
|---|---|---|---|
| Círculo | Punto central y radio | ¿La distancia Haversine es menor que el radio? | Alrededor de la casa o el patio, parques, campamentos |
| Rectángulo (caja) | Latitud y longitud mínimas y máximas | Cuatro comparaciones simples | Parcela alineada norte-sur, estacionamiento |
| Polígono | Esquinas en orden a lo largo del límite | Algoritmo de trazado de rayos (ray casting) | Potreros irregulares, límites de jardín o terreno |
| Anillo (dos círculos) | Radio interior de aviso y exterior de alarma | Dos comparaciones de distancia | Aviso escalonado: primero pitido, luego SMS |
| Corredor | Línea de ruta y ancho | Distancia del punto a la línea | Ruta de transporte escolar o de un recorrido |
Para empezar, el círculo es lo más fácil: basta con un centro y un radio. Si tu terreno tiene cuatro lados o una forma irregular, usa un polígono. Para obtener las coordenadas de las esquinas, en la computadora haz clic derecho sobre el punto en Google Maps y copia los números de la primera línea; en el celular mantén presionado el punto y las coordenadas aparecen en la barra de búsqueda. Seis decimales equivalen a una precisión de unos 11 centímetros. Escribe las esquinas del polígono en orden a lo largo del límite, en el sentido de las manecillas del reloj o al revés; si las escribes desordenadas, se forma una figura que se cruza a sí misma y la decisión de dentro o fuera deja de tener sentido. En toda Latinoamérica la longitud es negativa (oeste), y al sur del ecuador también lo es la latitud: copia los números con su signo.
Precisión del GPS: ¿cómo elegir el radio?
Los 2,5 m CEP de la hoja de datos del NEO-6M significan que la mitad de las lecturas cae a menos de 2,5 metros de la posición real; la otra mitad cae más lejos. Los árboles, los edificios y los techos de lámina reflejan las señales de los satélites, y la posición puede saltar 10–30 metros en segundos. Si graficas en un mapa la posición de un GPS que está quieto sobre la mesa, no verás un punto sino una nube de varios metros. Por eso el radio se elige según el entorno:
| Entorno | Desviación habitual | Radio mínimo recomendado |
|---|---|---|
| Campo abierto, potrero | 2–5 m | 20 m |
| Jardín, cerca de árboles | 5–15 m | 30–40 m |
| Entre edificios, ciudad | 10–30 m, a veces más | 50 m o más |
| Interiores, dentro de un corral techado | Sin posición o con mucha desviación | El GPS no sirve |
Diagrama de conexión
| Pieza y pin | Arduino Uno | ESP32 | Nota |
|---|---|---|---|
| NEO-6M VCC | 5V | 3V3 | La placa trae regulador |
| NEO-6M TX | D4 (SoftwareSerial RX) | GPIO 16 (RX2) | Salida del módulo |
| NEO-6M RX | D3, con divisor de 1 kΩ + 2 kΩ | GPIO 17 (TX2) | Entrada de máximo 3,6 V |
| SIM800L VCC | No se usa | 18650 (+) o fuente de 4,0 V | Picos de corriente de 2 A |
| SIM800L TXD | No se usa | GPIO 26 (RX1) | Salida de 2,8 V |
| SIM800L RXD | No se usa | GPIO 27 (TX1), con divisor de 1 kΩ + 5,6 kΩ | Entrada de máximo 3,1 V |
| Buzzer (+) | D8 | GPIO 25 | Buzzer activo |
| GND | GND | GND | Batería, GPS, SIM800L y placa con tierra común |
Cerca virtual circular con buzzer en el Arduino Uno
La primera versión no necesita internet ni chip: cuando el equipo se aleja más de 50 metros del centro, el buzzer pita una vez por segundo y la distancia se muestra en el Monitor Serie. Cambia HOME_LAT y HOME_LNG por tu propio punto central tomado de Google Maps. El código no usa delay() en loop(); el GPS envía unos 500 bytes por segundo y el búfer de 64 bytes de SoftwareSerial se desborda durante las esperas largas:
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}| Parte del código | Qué hace |
|---|---|
| HOME_LAT, HOME_LNG, RADIUS_M | Definen el centro y el radio de la zona segura |
| MARGIN_M = 5 | Margen de histéresis: para salir hay que pasar de 55 m y para volver hay que bajar de 45 m |
| NEED_FIXES = 3 | Cuántas lecturas seguidas deben coincidir antes de cambiar de estado |
| hdop() > 3.0, satellites() < 5 | Deja fuera del cálculo las lecturas débiles |
| location.age() > 2000 | Evita decidir con una posición vieja si el GPS deja de enviar datos |
| millis() % 1000 < 200 | Fuera de la zona, enciende el buzzer los primeros 200 ms de cada segundo |
Cerca virtual poligonal con alarma por SMS en el ESP32
La segunda versión define la forma real del terreno con sus esquinas y, cuando el equipo sale de la zona, envía por el SIM800L un SMS con un enlace de Google Maps a la posición. Como el ESP32 tiene tres UART por hardware, el GPS va en Serial2 y el SIM800L en Serial1, y ambos se pueden escuchar al mismo tiempo sin problemas. La revisión del polígono usa el método de trazado de rayos: desde el punto se traza un rayo imaginario hacia el este y se cuenta cuántas veces cruza los lados del polígono; un número impar significa dentro y uno par, fuera. El código espera al menos 10 minutos entre un SMS y otro, y también avisa cuando el equipo regresa a la zona:
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}Rastreo de animales y usos en el jardín
- Potrero y rebaño: Ponle una caja impermeable tipo collar a la cabra o al borrego que guía al rebaño y asegúrate de que la antena mire hacia arriba. Para llegar hasta la casa del rancho, un módulo LoRa no necesita compañía telefónica y alcanza kilómetros en lugar de mandar SMS.
- Aviso de perro escapado: Define el patio como polígono; si el perro se sale cuando queda abierto el portón, te llega un SMS con su ubicación.
- Podadora robot y vehículos de jardín: Agrega una salida que detenga los motores si el robot cruza el límite; por la precisión del GPS, úsala como seguridad extra junto a un cable perimetral.
- Moto, bicicleta y lancha: Define un círculo de 30–50 m donde estacionas; si el vehículo sale de él, recibe un SMS por si lo están robando.
- Campamentos y excursiones: Un aviso portátil que alerta cuando un grupo de niños se aleja del campamento; úsalo solo con el conocimiento y el permiso del grupo.
Duración de la batería: ¿cuántos días aguanta una cerca virtual?
En una cerca virtual portátil, el GPS es lo que más energía gasta. El NEO-6M consume unos 47 mA mientras busca satélites y 39 mA mientras los sigue; un ESP32 con el WiFi apagado necesita 30–50 mA y un SIM800L en reposo unos 15 mA. Si todo se queda encendido, una celda 18650 de 3000 mAh dura apenas un día. La solución es trabajar por ratos: el ESP32 despierta del deep sleep cada cierto tiempo, enciende el GPS, obtiene la posición, revisa el límite y vuelve a dormir. Los valores de abajo son estimaciones para una celda de 3000 mAh, un módulo ESP32 solo y un LDO de baja corriente en reposo:
| Modo de trabajo | Corriente promedio | Duración aproximada |
|---|---|---|
| Todo encendido siempre (ESP32 + NEO-6M + SIM800L en reposo) | Unos 120 mA | 1 día |
| Posición de 30 segundos cada 5 minutos, deep sleep entre medio, SIM800L en modo de sueño | Unos 11 mA | 11 días |
| Posición de 20 segundos cada 15 minutos, SIM800L encendido solo para alarmas | Unos 2–3 mA | 6–8 semanas |
Al trabajar por ratos importan dos detalles. Primero, para que el GPS se ubique rápido, la pila de respaldo de la placa del NEO-6M debe estar cargada; si el módulo conserva las efemérides encuentra la posición en segundos (arranque en caliente), pero si estuvo apagado más de unas horas necesita 30 segundos o más para un arranque tibio. Segundo, apagar por completo el GPS y el SIM800L con un MOSFET de canal P gasta menos energía que dejarlos en modo de sueño, aunque el SIM800L tarda 10–30 segundos en registrarse en la red cada vez que arranca. Encontrarás los modos de sueño y la memoria RTC en ESP32 deep sleep, la seguridad de la batería en batería Li-ion 18650 y módulo de carga TP4056, y puedes calcular tu propio caso con la herramienta Duración de batería.
Errores comunes y soluciones
| Síntoma | Causa probable | Solución |
|---|---|---|
| Nunca aparece la distancia | El módulo aún no encuentra posición o el equipo está bajo techo | Sal al aire libre y espera 1–5 minutos a que tome la primera posición |
| Alarma con el equipo quieto | La deriva del GPS es mayor que el radio | Aumenta el radio, MARGIN_M y NEED_FIXES |
| La distancia sale de miles de kilómetros | Latitud y longitud invertidas o error de signo | Escribe primero la latitud; las coordenadas sur y oeste son negativas |
| El polígono dice fuera en todos lados | Esquinas desordenadas o latitud y longitud invertidas | Escribe las esquinas en orden a lo largo del límite como {lat, lng} |
| No llega el SMS | Alimentación débil del SIM800L, sin cobertura 2G o chip con PIN activado | Usa una fuente de 2 A, prueba con comandos AT, desactiva el PIN |
| El ESP32 se reinicia al mandar el SMS | El voltaje cae en la alimentación compartida con el SIM800L | Alimenta el SIM800L con su propia línea desde la batería y agrega 1000 µF |
| En el Uno la posición sale corrupta a ratos | delay() en loop() o desbordamiento del búfer de SoftwareSerial | No uses delay(); si hace falta, pásate al ESP32 |
Una cerca virtual GPS reúne GPS, matemáticas y comunicación en un solo proyecto, por eso es tan didáctica como útil en la vida real. Prueba primero la cerca circular con un Uno en tu jardín, ajusta el radio a tu entorno y luego pasa a la cerca poligonal con alarma por SMS usando un ESP32 y un SIM800L. En la app BlueGrays puedes desarrollar paso a paso la parte de alarma del sistema con los proyectos de sonido de alarma con buzzer y sistema de alarma con ESP32 y avisos por Telegram, cada uno con su diagrama y código listo.
Preguntas frecuentes
¿Qué es una cerca virtual GPS?
Es un límite invisible definido con coordenadas GPS en lugar de un alambre. Cuando el equipo sale de la zona segura suena un buzzer o el dueño recibe un SMS o una notificación. Se usa para rastrear ganado y mascotas, en jardines, para la seguridad de vehículos y en podadoras robot.
¿Cómo hacer una geocerca con Arduino?
Conecta un módulo GPS como el NEO-6M a un Arduino o un ESP32 y define en el código la zona segura como un centro con radio o como una lista de esquinas. Cada segundo, el microcontrolador calcula si la posición está dentro con la fórmula de Haversine o con una prueba de polígono. Al salir de la zona suena un buzzer y, con un SIM800L, se puede enviar un SMS.
¿Qué tan precisa es una cerca virtual con GPS?
En campo abierto el NEO-6M suele dar la posición con 2–5 metros de error, pero cerca de árboles y edificios la desviación llega a 10–30 metros. Por eso el radio debe ser de al menos 20 metros en campo abierto y de 30–40 metros en un jardín. Pedir varias lecturas seguidas y un margen de histéresis evita la mayoría de las falsas alarmas.
¿Una cerca virtual necesita internet?
No. El GPS funciona con satélites y una cerca con buzzer trabaja sin ninguna conexión. Si quieres recibir avisos a distancia, puedes usar SMS con un SIM800L, Telegram donde haya WiFi o LoRa en terrenos grandes como ranchos.
¿La cerca virtual es segura para el ganado?
Una cerca virtual que solo usa sonido y avisos no lastima al animal. El pulso eléctrico de los collares comerciales es propio de productos muy regulados y no debe armarse en proyectos caseros. Haz que la caja del collar sea ligera, impermeable y que no apriete el cuello del animal.
¿Cuánto dura la batería de un rastreador GPS?
Con el GPS, el ESP32 y el SIM800L siempre encendidos, una celda de 3000 mAh dura cerca de un día. Si el equipo despierta del deep sleep cada 5–15 minutos para tomar la posición, la duración sube a varias semanas. Usar un módulo ESP32 solo y un regulador de baja corriente en reposo en lugar de una placa de desarrollo también hace una gran diferencia.
Proyectos para hacer después de leer esto
Ver todos los proyectos
Uso del zumbador
¿Alguna vez te has preguntado cómo suena un timbre o una alarma? El Arduino hace pitar un pequeño zumbador a intervalos cortos: pip, silencio, pip, silencio.

LED Parpadeante con ESP32
Enseña el uso básico de la salida GPIO con ESP32. Conseguimos un efecto de parpadeo encendiendo y apagando un LED desde el pin digital. Versión para ESP32 del clásico proyecto blink en Arduino UNO; los comandos básicos de blink en el entorno Arduino son los mismos, pero la distribución de pines y los niveles GPIO de 3,3 V del ESP32 difieren de los del Arduino UNO.

ESP32 Reproducción de melodías con zumbador
Tocando una melodía simple (Twinkle Twinkle Little Star) con un zumbador pasivo. Tocamos las notas con las funciones tone() y noTone() como en Arduino - la misma sintaxis funciona con ESP32 Arduino Core 3.0+. Se debe utilizar un zumbador pasivo (el zumbador activo no reproduce la melodía).

Sistema de Alarma de Movimiento ESP32 (PIR + Buzzer + LED + Telegram)
Una alarma de seguridad inteligente: cuando el sensor PIR detecta movimiento, suena el zumbador, se enciende el LED y el dueño recibe al instante una notificación por Telegram. Una espera de 30 segundos (cooldown) limita cada cuánto se repite la alarma; no elimina las falsas detecciones del sensor PIR. Sirve para casa, garaje, almacén o estudio.

Modo de suspensión profunda del ESP32 — Ahorro de batería (OLED + contador en RTC RAM)
El modo Deep Sleep del ESP32 apaga la CPU y la mayoría de los periféricos y reduce el consumo a unos 10µA, algo clave para dispositivos IoT con batería. Este proyecto usa tres fuentes de activación: un temporizador (15 s), un pin externo (EXT0, el botón en GPIO 33) y un pin táctil (T0/GPIO 4). Los contadores marcados con RTC_DATA_ATTR se conservan durante el deep sleep.

Registrador de Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
¡Monta con el ESP32 un registrador de temperatura y humedad con hora! Un sensor DHT22 lee la temperatura y la humedad una vez por minuto, y cada lectura se guarda en una tarjeta microSD en formato CSV con la hora real del módulo RTC DS1307. La pantalla OLED muestra en vivo y con letra grande la última temperatura, la humedad, la marca de tiempo y el total de registros.

ESP32 HTTPClient + API del tiempo (con pantalla OLED SSD1306)
El ESP32 hace una llamada REST por internet a una API del tiempo (wttr.in) con HTTPClient.h. A diferencia de la versión con LCD I2C, aquí usamos una pantalla OLED SSD1306 (128×64), con letra grande e iconos vectoriales para una vista más rica. Siete iconos del tiempo (soleado, lluvia, nieve y más) se dibujan al momento, sin archivos bitmap.
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

