Guias · 10 min de leitura

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.

Módulo GPS NEO-6M com antena cerâmica
Módulo GPS NEO-6M: o olho da cerca virtual. O lado claro da antena cerâmica deve ficar voltado para o céu, sem metal nem bateria por cima.

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:

  1. Obter a posição: o NEO-6M envia latitude, longitude, número de satélites e HDOP a cada segundo.
  2. 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.
  3. 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.
  4. 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çaFunçãoObservação
Arduino Uno ou ESP32Cálculos e decisõesPara a versão com SMS, um ESP32 com duas UARTs de hardware
Módulo GPS NEO-6MPosiçãoA antena cerâmica deve ficar voltada para o céu
Módulo GSM SIM800LEnvio de SMSSó redes 2G, picos de corrente de até 2 A
Buzzer ativoAlarme sonoro localNo ESP32, um modelo que apite em 3,3 V ou um transistor
Célula Li-ion 18650 e módulo carregador TP4056Alimentação portátilO SIM800L pode funcionar direto da célula
Regulador LDO de 3,3 V (ex.: HT7833)Alimenta o ESP32 e o GPSBaixa corrente quiescente, pelo menos 500 mA
Resistores de 1 kΩ, 2 kΩ e 5,6 kΩDivisores de tensãoPara 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 longitude0,001° de longitude
0° (equador)111,2 km111 m
37° (Antalya)88,8 km89 m
41° (Istambul, Nova York)83,9 km84 m
52° (Berlim, Londres)68,5 km68 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:

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}

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 cercaComo é definidaComo é verificadaOnde é usada
CírculoPonto central e raioA 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áximasQuatro comparações simplesUm terreno alinhado norte-sul, um estacionamento
PolígonoCantos em ordem ao longo do limiteAlgoritmo de ray castingLimite irregular de pasto, jardim ou lote
Anel (dois círculos)Raio interno de aviso e externo de alarmeDuas comparações de distânciaAviso em etapas: primeiro bipe, depois SMS
CorredorLinha da rota e larguraDistância do ponto até a linhaRota 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:

EntornoDeriva típicaRaio mínimo recomendado
Terreno aberto, pasto2–5 m20 m
Jardim, perto de árvores5–15 m30–40 m
Entre prédios, cidade10–30 m, às vezes mais50 m ou mais
Dentro de casa, dentro de um celeiroSem fix ou deriva grandeGPS não serve
Quase todo alarme falso vem de uma única leitura ruim. Use quatro filtros no código: pelo menos 5 satélites, HDOP de 3 ou menos, um fix com no máximo 2 segundos e 3–5 leituras seguidas antes de a decisão mudar. Para uma cerca circular, adicione também uma margem de histerese: sair significa passar 5 m além do raio, voltar significa estar 5 m para dentro dele. Assim uma cabra parada bem em cima do limite não faz o seu celular tocar a cada minuto.

Esquema de ligação

Peça e pinoArduino UnoESP32Observação
NEO-6M VCC5V3V3A placa tem regulador
NEO-6M TXD4 (SoftwareSerial RX)GPIO 16 (RX2)Saída do módulo
NEO-6M RXD3, por um divisor de 1 kΩ + 2 kΩGPIO 17 (TX2)Entrada de no máx. 3,6 V
SIM800L VCCNão usado18650 (+) ou uma fonte de 4,0 VPicos de corrente de 2 A
SIM800L TXDNão usadoGPIO 26 (RX1)Saída de 2,8 V
SIM800L RXDNão usadoGPIO 27 (TX1), por um divisor de 1 kΩ + 5,6 kΩEntrada de no máx. 3,1 V
Buzzer (+)D8GPIO 25Buzzer ativo
GNDGNDGNDBateria, GPS, SIM800L e placa compartilham o terra
Nunca alimente o SIM800L pelo pino 5V ou 3,3V do Arduino: o módulo precisa de 3,4–4,4 V e puxa pulsos de corrente de até 2 A enquanto envia um SMS. Uma única célula 18650 é ideal para isso; coloque um capacitor de 470–1000 µF entre VCC e GND perto do módulo. Você pode conferir os valores do divisor com a ferramenta Divisor de Tensão, e a primeira configuração do módulo e os testes de comandos AT estão em módulo GSM SIM800L.

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:

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}
Parte do códigoO que faz
HOME_LAT, HOME_LNG, RADIUS_MDefinem o centro e o raio da zona segura
MARGIN_M = 5Margem de histerese: sair significa passar de 55 m, voltar significa cair abaixo de 45 m
NEED_FIXES = 3Quantas leituras seguidas precisam concordar antes de o estado mudar
hdop() > 3,0, satellites() < 5Deixa as leituras fracas fora do cálculo
location.age() > 2000Impede decisões com uma posição velha se o GPS ficar em silêncio
millis() % 1000 < 200Liga 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:

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}
Cada SMS custa dinheiro; tome cuidado ao encurtar o SMS_COOLDOWN_MS para que um dispositivo rondando o limite não aumente a sua conta. O SIM800L só funciona em redes 2G, e o 2G já foi ou está sendo desligado em alguns países; confira a cobertura 2G da sua operadora antes de montar. Em um jardim ao alcance do Wi-Fi, mandar notificações com um bot do Telegram em vez de SMS elimina o custo do SMS e ainda é mais rápido.

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.
As coleiras comerciais de cerca virtual fazem o animal voltar primeiro com som e, se ele cruzar o limite, com um pulso elétrico leve; esses produtos são rigorosamente testados e regulamentados. Não monte em um projeto de hobby um circuito que dê choque elétrico em um animal; use só som e notificações. Se for rastrear a localização de uma pessoa, faça isso com o conhecimento e o consentimento dela; leis de privacidade como a LGPD no Brasil e o RGPD na Europa tratam dados de localização como dados pessoais.

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çãoCorrente médiaDuração aproximada da bateria
Tudo sempre ligado (ESP32 + NEO-6M + SIM800L ocioso)Cerca de 120 mA1 dia
Um fix de 30 segundos a cada 5 minutos, deep sleep no meio, SIM800L em modo sleepCerca de 11 mA11 dias
Um fix de 20 segundos a cada 15 minutos, SIM800L ligado só para alarmesCerca de 2–3 mA6–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

SintomaCausa provávelSolução
Nenhuma distância apareceO módulo ainda não achou a posição, ou o dispositivo está em ambiente fechadoVá para fora e espere 1–5 minutos pelo primeiro fix
Alarme com o dispositivo paradoA deriva do GPS é maior que o raioAumente o raio, o MARGIN_M e o NEED_FIXES
A distância sai como milhares de quilômetrosLatitude e longitude trocadas, ou erro de sinalEscreva a latitude primeiro; coordenadas ao sul e a oeste são negativas
O polígono diz fora em todo lugarCantos fora de ordem, ou latitude e longitude trocadasEscreva os cantos em ordem ao longo do limite como {lat, lng}
O SMS não é enviadoAlimentação do SIM800L fraca demais, sem cobertura 2G ou PIN do chip ativadoUse uma fonte que forneça 2 A, teste com comandos AT, desative o PIN
O ESP32 reinicia ao enviar um SMSA tensão despenca em uma alimentação compartilhada com o SIM800LAlimente 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 Unodelay() no loop() ou estouro do buffer do SoftwareSerialNã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.

Ver todos os projetos
Uso do buzzer
AR-13Iniciante

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.

4.7(92)
170
LED piscando com ESP32
ES-1Iniciante

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.

4.7(37)
108
Melodia com buzzer e ESP32
ES-12Iniciante
Premium

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.

4.8(30)
55
Alarme de movimento com ESP32 (PIR + buzzer + LED + Telegram)
ES-41Avançado
Premium

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.

9
ESP32 em sono profundo — Economia de bateria (OLED + contador na RAM RTC)
ES-33Avançado
Premium

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.

4.3(10)
16
Registrador de temperatura com ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Avançado
Premium

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.

4.7(7)
12
ESP32 HTTPClient + API de clima (com display OLED SSD1306)
ES-32Avançado
Premium

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.

4.3(10)
22