Cerca virtual GPS com Arduino: alarme de geofence com NEO-6M e SMS
Monte uma cerca virtual GPS com Arduino: zona segura com NEO-6M, distância de Haversine, cercas circulares e poligonais, alertas por buzzer e SMS, rastreio de animais e bateria.
Uma cerca virtual GPS com Arduino (geofence) é um limite invisível definido por coordenadas GPS em vez de um arame ou muro físico: quando o dispositivo sai dessa zona segura, um buzzer toca e, se você quiser, o seu celular recebe um SMS com um link para a localização. Esse tipo de cerca virtual é usado para acompanhar cabras e ovelhas no pasto, um cachorro que foge do quintal, uma moto estacionada ou um cortador de grama robô. Com um Arduino ou ESP32, um módulo GPS NEO-6M e um buzzer você monta a sua primeira geofence em um fim de semana.
Neste guia você vai ver primeiro a fórmula de Haversine, que calcula a distância entre duas posições, e por que não dá para converter uma diferença em graus direto em metros. Depois vamos comparar em uma tabela as cercas circulares, retangulares e poligonais, aprender a filtrar os alarmes falsos causados pela deriva do GPS e programar uma cerca circular em um Arduino Uno e uma cerca poligonal em um ESP32 que manda SMS por um SIM800L. Por fim, vamos ver o uso no rastreio de animais e no jardim, a duração da bateria e os erros comuns.

O que é uma geofence e como funciona?
Em uma cerca virtual o limite é só alguns números no código: o centro e o raio de um círculo, ou os cantos de um polígono. O módulo GPS dá uma nova posição a cada segundo, e o microcontrolador calcula se essa posição está dentro ou fora do limite. A parte difícil não é a matemática, e sim a decisão: a posição do GPS anda alguns metros mesmo em um dispositivo que nunca se move, e uma única leitura ruim significa um alarme falso. Por isso uma boa geofence trabalha em quatro etapas:
- Obter a posição: o NEO-6M envia latitude, longitude, número de satélites e HDOP a cada segundo.
- Verificar se é confiável: ignore a leitura se forem usados menos de 5 satélites, se o HDOP passar de 3 ou se o fix tiver mais de 2 segundos.
- Comparar com o limite: para um círculo, calcule a distância até o centro com Haversine; para um polígono, descubra se o ponto está dentro pelo método de ray casting.
- Filtrar a decisão e disparar o alarme: mude de estado só quando várias leituras seguidas concordarem e o limite for ultrapassado com uma margem; aí toque o buzzer e mande um SMS.
Lista de peças
| Peça | Função | Observação |
|---|---|---|
| Arduino Uno ou ESP32 | Cálculos e decisões | Para a versão com SMS, um ESP32 com duas UARTs de hardware |
| Módulo GPS NEO-6M | Posição | A antena cerâmica deve ficar voltada para o céu |
| Módulo GSM SIM800L | Envio de SMS | Só redes 2G, picos de corrente de até 2 A |
| Buzzer ativo | Alarme sonoro local | No ESP32, um modelo que apite em 3,3 V ou um transistor |
| Célula Li-ion 18650 e módulo carregador TP4056 | Alimentação portátil | O SIM800L pode funcionar direto da célula |
| Regulador LDO de 3,3 V (ex.: HT7833) | Alimenta o ESP32 e o GPS | Baixa corrente quiescente, pelo menos 500 mA |
| Resistores de 1 kΩ, 2 kΩ e 5,6 kΩ | Divisores de tensão | Para o RX do GPS (Uno) e o RXD do SIM800L |
A fórmula de Haversine: distância entre duas posições
Latitude e longitude são em graus e a Terra não é plana, então você não pode pegar a diferença em graus entre dois pontos e multiplicar por um número fixo. Um grau de latitude tem cerca de 111,2 km em qualquer lugar. Já na longitude, os meridianos se aproximam em direção aos polos, então o comprimento de um grau diminui com o cosseno da latitude:
| Latitude (lugar de exemplo) | Comprimento de 1° de longitude | 0,001° de longitude |
|---|---|---|
| 0° (equador) | 111,2 km | 111 m |
| 37° (Antalya) | 88,8 km | 89 m |
| 41° (Istambul, Nova York) | 83,9 km | 84 m |
| 52° (Berlim, Londres) | 68,5 km | 68 m |
A fórmula de Haversine leva essa curvatura em conta e dá a menor distância pela superfície entre dois pontos: a = sin²(Δφ/2) + cos φ1 · cos φ2 · sin²(Δλ/2) e d = 2R · atan2(√a, √(1−a)). Aqui φ é a latitude e λ a longitude (em radianos), e R é o raio médio da Terra, 6.371.000 metros. Por exemplo, a 41° de latitude, um ponto 0,0009 grau ao norte e 0,001 grau a leste do centro fica a 100,1 m ao norte, 83,9 m a leste e 130,6 m no total. Como a maioria das geofences tem algumas centenas de metros, uma aproximação plana mais simples dá o mesmo resultado: multiplique a diferença de longitude pelo cosseno da latitude média e aplique Pitágoras. O sketch curto abaixo compara os dois:
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}As duas funções mostram cerca de 130,6 no Monitor Serial; nessa escala a diferença entre elas é menor que um centímetro. A aproximação plana começa a se desviar além de alguns quilômetros, enquanto a Haversine continua precisa por centenas de quilômetros. No Arduino Uno, o double na verdade é um float de 32 bits e guarda coordenadas com precisão de cerca de 0,4 metro, mais que suficiente para uma geofence. A função distanceBetween() da biblioteca TinyGPSPlus faz o mesmo trabalho; explicamos em detalhes como instalar a biblioteca e ligar o GPS em módulo GPS NEO-6M.
Tipos de cerca: círculo, retângulo e polígono
| Tipo de cerca | Como é definida | Como é verificada | Onde é usada |
|---|---|---|---|
| Círculo | Ponto central e raio | A distância de Haversine é menor que o raio? | Em volta de uma casa ou quintal, um parque, um acampamento |
| Retângulo (caixa) | Latitude e longitude mínimas e máximas | Quatro comparações simples | Um terreno alinhado norte-sul, um estacionamento |
| Polígono | Cantos em ordem ao longo do limite | Algoritmo de ray casting | Limite irregular de pasto, jardim ou lote |
| Anel (dois círculos) | Raio interno de aviso e externo de alarme | Duas comparações de distância | Aviso em etapas: primeiro bipe, depois SMS |
| Corredor | Linha da rota e largura | Distância do ponto até a linha | Rota de ônibus escolar ou de passeio |
O círculo é o jeito mais fácil de começar: basta um centro e um raio. Se o seu terreno tem quatro lados ou é irregular, use um polígono. Para obter as coordenadas dos cantos, clique com o botão direito no ponto no Google Maps pelo computador e copie os números da primeira linha; no celular, pressione e segure o ponto e as coordenadas aparecem na caixa de busca. Seis casas decimais significam uma precisão de cerca de 11 centímetros. Escreva os cantos do polígono em ordem ao longo do limite, no sentido horário ou anti-horário; cantos fora de ordem formam uma figura que cruza a si mesma e a decisão de dentro/fora vira bobagem.
Precisão do GPS: como escolher o raio
O CEP de 2,5 m no datasheet do NEO-6M significa que metade das leituras fica a menos de 2,5 metros da posição real; a outra metade fica mais longe. Árvores, prédios e telhados metálicos refletem os sinais dos satélites, e a posição pode pular 10–30 metros em segundos. Se você plotar a posição de um GPS parado em uma mesa, não obtém um ponto, e sim uma nuvem de vários metros. Por isso escolha o raio de acordo com o entorno:
| Entorno | Deriva típica | Raio mínimo recomendado |
|---|---|---|
| Terreno aberto, pasto | 2–5 m | 20 m |
| Jardim, perto de árvores | 5–15 m | 30–40 m |
| Entre prédios, cidade | 10–30 m, às vezes mais | 50 m ou mais |
| Dentro de casa, dentro de um celeiro | Sem fix ou deriva grande | GPS não serve |
Esquema de ligação
| Peça e pino | Arduino Uno | ESP32 | Observação |
|---|---|---|---|
| NEO-6M VCC | 5V | 3V3 | A placa tem regulador |
| NEO-6M TX | D4 (SoftwareSerial RX) | GPIO 16 (RX2) | Saída do módulo |
| NEO-6M RX | D3, por um divisor de 1 kΩ + 2 kΩ | GPIO 17 (TX2) | Entrada de no máx. 3,6 V |
| SIM800L VCC | Não usado | 18650 (+) ou uma fonte de 4,0 V | Picos de corrente de 2 A |
| SIM800L TXD | Não usado | GPIO 26 (RX1) | Saída de 2,8 V |
| SIM800L RXD | Não usado | GPIO 27 (TX1), por um divisor de 1 kΩ + 5,6 kΩ | Entrada de no máx. 3,1 V |
| Buzzer (+) | D8 | GPIO 25 | Buzzer ativo |
| GND | GND | GND | Bateria, GPS, SIM800L e placa compartilham o terra |
Geofence circular com buzzer no Arduino Uno
A primeira versão não precisa de internet nem de chip: quando o dispositivo está a mais de 50 metros do centro, o buzzer apita uma vez por segundo e a distância aparece no Monitor Serial. Troque HOME_LAT e HOME_LNG pelo seu próprio ponto central do Google Maps. O código não usa delay() no loop(); o GPS envia cerca de 500 bytes por segundo, e o buffer de 64 bytes do SoftwareSerial transborda em esperas longas:
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 do código | O que faz |
|---|---|
| HOME_LAT, HOME_LNG, RADIUS_M | Definem o centro e o raio da zona segura |
| MARGIN_M = 5 | Margem de histerese: sair significa passar de 55 m, voltar significa cair abaixo de 45 m |
| NEED_FIXES = 3 | Quantas leituras seguidas precisam concordar antes de o estado mudar |
| hdop() > 3,0, satellites() < 5 | Deixa as leituras fracas fora do cálculo |
| location.age() > 2000 | Impede decisões com uma posição velha se o GPS ficar em silêncio |
| millis() % 1000 < 200 | Liga o buzzer nos primeiros 200 ms de cada segundo enquanto estiver fora da zona |
Geofence poligonal com alertas por SMS no ESP32
A segunda versão define o formato real do terreno com cantos e, quando o dispositivo sai da zona, manda pelo SIM800L um SMS com um link do Google Maps para a posição. Como o ESP32 tem três UARTs de hardware, o GPS fica no Serial2 e o SIM800L no Serial1, e os dois podem ser ouvidos ao mesmo tempo sem problema. A verificação do polígono usa o método de ray casting: traça-se um raio imaginário do ponto para o leste e conta-se quantas vezes ele cruza as arestas do polígono; um número ímpar significa dentro, um número par significa fora. O código espera pelo menos 10 minutos entre SMS e também manda um quando o dispositivo volta:
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}Rastreio de animais e uso no jardim
- Pasto e acompanhamento de rebanho: prenda uma caixa à prova d'água em uma coleira na cabra ou ovelha que lidera o rebanho e garanta que a antena fique para cima. Para chegar até a casa da fazenda, um módulo LoRa não precisa de operadora e dá quilômetros de alcance no lugar do SMS.
- Alerta de cachorro fugido: defina o quintal como polígono; se o cachorro escapar com o portão aberto, você recebe um SMS com a posição dele.
- Cortador de grama robô e veículos de jardim: adicione uma saída que pare os motores se o robô cruzar o limite; por causa da precisão do GPS, use isso como segurança extra junto de um fio de limite físico.
- Moto, bicicleta e barco: defina um círculo de 30–50 m onde você estaciona; se o veículo sair dele, receba um SMS caso esteja sendo roubado.
- Acampamentos e passeios: um alarme portátil que avisa quando um grupo de crianças se afasta do acampamento; use só com o conhecimento e o consentimento do grupo.
Duração da bateria: quantos dias dura uma geofence?
Em uma geofence portátil, o GPS é o que mais gasta energia. O NEO-6M consome cerca de 47 mA procurando satélites e 39 mA rastreando; um ESP32 com Wi-Fi desligado precisa de 30–50 mA e um SIM800L ocioso de uns 15 mA. Se tudo ficar ligado, uma célula 18650 de 3000 mAh dura só cerca de um dia. A solução é rodar o sistema em rajadas: o ESP32 acorda do deep sleep em intervalos definidos, liga o GPS, obtém um fix, verifica o limite e volta a dormir. Os números abaixo são estimativas aproximadas para uma célula de 3000 mAh, um módulo ESP32 nu e um LDO de baixa corrente quiescente:
| Modo de operação | Corrente média | Duração aproximada da bateria |
|---|---|---|
| Tudo sempre ligado (ESP32 + NEO-6M + SIM800L ocioso) | Cerca de 120 mA | 1 dia |
| Um fix de 30 segundos a cada 5 minutos, deep sleep no meio, SIM800L em modo sleep | Cerca de 11 mA | 11 dias |
| Um fix de 20 segundos a cada 15 minutos, SIM800L ligado só para alarmes | Cerca de 2–3 mA | 6–8 semanas |
Dois detalhes importam ao rodar em rajadas. Primeiro, para obter um fix rápido, a bateria de backup da placa do NEO-6M precisa estar carregada; se o módulo mantém os dados de efeméride, ele acha a posição em segundos (hot start), mas depois de mais de algumas horas desligado precisa de 30 segundos ou mais para um warm start. Segundo, desligar o GPS e o SIM800L por completo com um MOSFET de canal P gasta menos energia do que deixá-los nos modos de sono, mas o SIM800L precisa de 10–30 segundos para se registrar na rede toda vez que liga. Os modos de sono e a memória RTC estão em deep sleep no ESP32, a segurança da bateria em bateria Li-ion 18650 e módulo carregador TP4056, e você pode calcular o seu próprio cenário com a ferramenta Duração da Bateria.
Erros comuns e soluções
| Sintoma | Causa provável | Solução |
|---|---|---|
| Nenhuma distância aparece | O módulo ainda não achou a posição, ou o dispositivo está em ambiente fechado | Vá para fora e espere 1–5 minutos pelo primeiro fix |
| Alarme com o dispositivo parado | A deriva do GPS é maior que o raio | Aumente o raio, o MARGIN_M e o NEED_FIXES |
| A distância sai como milhares de quilômetros | Latitude e longitude trocadas, ou erro de sinal | Escreva a latitude primeiro; coordenadas ao sul e a oeste são negativas |
| O polígono diz fora em todo lugar | Cantos fora de ordem, ou latitude e longitude trocadas | Escreva os cantos em ordem ao longo do limite como {lat, lng} |
| O SMS não é enviado | Alimentação do SIM800L fraca demais, sem cobertura 2G ou PIN do chip ativado | Use uma fonte que forneça 2 A, teste com comandos AT, desative o PIN |
| O ESP32 reinicia ao enviar um SMS | A tensão despenca em uma alimentação compartilhada com o SIM800L | Alimente o SIM800L por uma linha própria da bateria, adicione um capacitor de 1000 µF |
| A posição sai embaralhada de vez em quando no Uno | delay() no loop() ou estouro do buffer do SoftwareSerial | Não use delay(); se preciso, passe para um ESP32 |
Uma geofence GPS junta GPS, matemática e comunicação em um só projeto, então é ao mesmo tempo educativa e útil de verdade. Teste primeiro a cerca circular com um Uno no seu quintal, ajuste o raio ao entorno e depois passe para a cerca poligonal e o alarme por SMS com ESP32 e SIM800L. No app BlueGrays você monta o lado do alarme passo a passo com os projetos Som de Alarme com Buzzer e Sistema de Alarme com ESP32 e notificações no Telegram, com esquemas de ligação e código pronto.
Perguntas frequentes
O que é uma geofence GPS?
Uma geofence é um limite invisível definido por coordenadas GPS em vez de um arame físico. Quando o dispositivo sai dessa zona segura, um buzzer toca ou o dono recebe um SMS ou uma notificação. É usada no rastreio de animais, em jardins, na segurança de veículos e em cortadores de grama robôs.
Como fazer uma geofence com Arduino?
Ligue um módulo GPS como o NEO-6M a um Arduino ou ESP32 e defina a zona segura no código como centro e raio ou como cantos. A cada segundo, o microcontrolador calcula se a posição está dentro da zona com a fórmula de Haversine ou um teste de polígono. Quando o dispositivo sai da zona, um buzzer toca e um SMS pode ser enviado com um SIM800L.
Qual é a precisão de uma geofence GPS?
Em terreno aberto o NEO-6M costuma dar a posição com 2–5 metros de erro, mas perto de árvores e prédios a deriva pode chegar a 10–30 metros. Então o raio de uma geofence deve ter pelo menos 20 metros em terreno aberto e 30–40 metros em um jardim. Exigir várias leituras seguidas mais uma margem de histerese evita a maioria dos alarmes falsos.
Uma geofence precisa de internet?
Não. O GPS funciona com satélites, e uma geofence com buzzer roda sem conexão nenhuma. Se você quer alertas à distância, pode usar SMS com um SIM800L, Telegram onde houver Wi-Fi ou LoRa em áreas grandes como fazendas.
Cercas virtuais são seguras para os animais?
Uma cerca virtual que usa só som e notificações não machuca o animal. O pulso elétrico das coleiras comerciais pertence a produtos rigorosamente regulamentados e não deve ser montado em projetos de hobby. Faça a caixa da coleira leve, à prova d'água e folgada o bastante para não apertar o pescoço do animal.
Quanto dura a bateria de um rastreador GPS?
Com o GPS, o ESP32 e o SIM800L sempre ligados, uma célula de 3000 mAh dura cerca de um dia. Se o dispositivo acordar do deep sleep a cada 5–15 minutos para obter um fix, isso sobe para várias semanas. Usar um módulo ESP32 nu e um regulador de baixa corrente quiescente no lugar de uma placa de desenvolvimento também faz muita diferença.
Projetos para montar depois desta leitura
Ver todos os projetos
Uso do buzzer
Já se perguntou como uma campainha ou um alarme produz som? O Arduino faz um pequeno buzzer emitir bipes em intervalos curtos: bipe, pausa, bipe, pausa.

LED piscando com ESP32
Ensina o uso básico de uma saída GPIO no ESP32. Fazemos um LED piscar ligando e desligando um pino digital. É a versão para ESP32 do clássico projeto blink do Arduino UNO: os comandos básicos de blink no ambiente Arduino são os mesmos, mas a disposição dos pinos e os níveis de 3,3 V dos GPIOs do ESP32 diferem dos do Arduino UNO.

Melodia com buzzer e ESP32
Toque uma melodia simples (Brilha, brilha, estrelinha) com um buzzer passivo. Usamos as funções tone() e noTone() para tocar as notas, como no Arduino. A mesma sintaxe funciona com ESP32 Arduino Core 3.0+. É preciso usar um buzzer passivo, pois o ativo não toca melodias.

Alarme de movimento com ESP32 (PIR + buzzer + LED + Telegram)
Um sistema de alarme de segurança inteligente que aciona o buzzer e o LED quando o sensor PIR detecta movimento e, ao mesmo tempo, envia uma notificação instantânea ao proprietário pelo Telegram. Inclui um intervalo de espera de 30 segundos para limitar a frequência dos alarmes repetidos; esse mecanismo não valida as detecções do PIR nem elimina disparos falsos. Pode ser usado na segurança de casas, no monitoramento de garagens, depósitos ou salas de trabalho.

ESP32 em sono profundo — Economia de bateria (OLED + contador na RAM RTC)
O modo de sono profundo do ESP32 reduz o consumo de corrente para ~10 µA ao desligar a CPU e a maioria dos periféricos, sendo essencial para dispositivos IoT alimentados por bateria. Neste projeto, usamos três fontes de despertar: um temporizador (15 segundos), um pino externo (EXT0 — botão no GPIO 33) e toque (T0/GPIO 4). As variáveis marcadas com RTC_DATA_ATTR são preservadas durante o sono profundo, mantendo os contadores de inicializações e de despertares por temporizador e botão.

Registrador de temperatura com ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
Monte um registrador de temperatura com data e hora usando ESP32. O DHT22 mede a temperatura e a umidade a cada minuto, o DS1307 RTC fornece a hora real e cada leitura é gravada em CSV no cartão microSD. O OLED mostra em letras grandes a temperatura atual, além da umidade, da data e hora e do total de registros. Abra o arquivo /temp_log.csv no Excel, no Google Sheets ou com pandas para acompanhar uma estufa ou a temperatura de casa.

ESP32 HTTPClient + API de clima (com display OLED SSD1306)
Neste projeto, usamos o ESP32 para fazer uma chamada REST à API de clima wttr.in pela internet com HTTPClient.h. Diferentemente da versão anterior com LCD I2C, aqui usamos um display OLED SSD1306 (128×64), que permite usar fontes grandes, ícones vetoriais e uma apresentação visual rica em uma única tela. Sete ícones vetoriais de condições do tempo (ensolarado, parcialmente nublado, nublado, chuvoso, com neve, com tempestade e com neblina) são desenhados durante a execução, sem arquivos bitmap.
Mais artigos
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

