Recinto virtuale GPS con Arduino: geofence NEO-6M e allarme SMS
Recinto virtuale GPS con Arduino ed ESP32: zona sicura con NEO-6M, distanza Haversine, recinto circolare e poligonale, allarme buzzer e SMS, autonomia.
Un recinto virtuale GPS con Arduino è un confine invisibile definito da coordinate GPS invece che da un filo o da un muro: quando il dispositivo esce da questa zona sicura suona un buzzer e, se vuoi, sul telefono arriva un SMS con un link alla sua posizione. Questo metodo, chiamato geofence (recinto geografico), serve a tenere d'occhio capre e pecore al pascolo, un cane che scappa dal giardino, una moto parcheggiata o un robot tagliaerba. Con un Arduino o un ESP32, un modulo GPS NEO-6M e un buzzer puoi costruire il tuo primo recinto virtuale in un fine settimana.
In questa guida vedrai prima la formula di Haversine, che calcola la distanza tra due posizioni, e perché non puoi convertire direttamente una differenza in gradi in metri. Poi confronteremo in una tabella i recinti circolari, rettangolari e poligonali, impareremo a filtrare i falsi allarmi causati dalla deriva del GPS e programmeremo un recinto circolare su Arduino Uno e un recinto poligonale su ESP32 che invia un SMS tramite un SIM800L. Infine parleremo di tracciamento degli animali, usi in giardino, autonomia della batteria ed errori comuni.

Che cos'è un recinto virtuale (geofence) e come funziona?
In un recinto virtuale il confine è solo una manciata di numeri nel codice: il centro e il raggio di un cerchio, oppure i vertici di un poligono. Il modulo GPS fornisce una nuova posizione ogni secondo e il microcontrollore calcola se si trova dentro o fuori dal confine. La parte difficile non è il calcolo ma la decisione: la posizione GPS si sposta di qualche metro anche su un dispositivo fermo, e una sola lettura sbagliata significa un falso allarme. Per questo un buon recinto virtuale lavora in quattro passi:
- Ottenere la posizione: il NEO-6M invia ogni secondo latitudine, longitudine, numero di satelliti e HDOP.
- Verificarne l'affidabilità: scarta la lettura se i satelliti usati sono meno di 5, se l'HDOP supera 3 o se la posizione ha più di 2 secondi.
- Confrontarla con il confine: per un cerchio calcola la distanza dal centro con Haversine; per un poligono verifica se il punto è dentro con il metodo del raggio (ray casting).
- Filtrare la decisione e dare l'allarme: cambia stato solo quando più letture di fila concordano e il confine è superato di un certo margine, poi fai suonare il buzzer e invia l'SMS.
Lista dei componenti
| Componente | Compito | Nota |
|---|---|---|
| Arduino Uno o ESP32 | Calcolo e decisione | Per la versione con SMS, un ESP32 con due UART hardware |
| Modulo GPS NEO-6M | Posizione | L'antenna ceramica deve guardare il cielo |
| Modulo GSM SIM800L | Invio di SMS | Solo rete 2G, picchi di corrente fino a 2 A |
| Buzzer attivo | Allarme sonoro locale | Sull'ESP32 un modello che suona a 3,3 V o un transistor |
| Cella Li-ion 18650 e modulo di ricarica TP4056 | Alimentazione portatile | Il SIM800L può essere alimentato direttamente dalla cella |
| Regolatore LDO da 3,3 V (es. HT7833) | Alimenta ESP32 e GPS | Bassa corrente di riposo, almeno 500 mA |
| Resistenze da 1 kΩ, 2 kΩ e 5,6 kΩ | Partitori di tensione | Per l'RX del GPS (Uno) e l'RXD del SIM800L |
La formula di Haversine: distanza tra due posizioni
Latitudine e longitudine sono in gradi e la Terra non è piatta, quindi non puoi prendere la differenza in gradi tra due punti e moltiplicarla per un numero fisso. Un grado di latitudine misura circa 111,2 km ovunque. In longitudine, invece, i meridiani si avvicinano verso i poli e la lunghezza di un grado si riduce con il coseno della latitudine:
| Latitudine (luogo di esempio) | 1° di longitudine vale | 0,001° di longitudine |
|---|---|---|
| 0° (equatore) | 111,2 km | 111 m |
| 38° (Palermo) | 87,6 km | 88 m |
| 41° (Istanbul, Roma) | 83,9 km | 84 m |
| 45° (Milano, Torino) | 78,6 km | 79 m |
La formula di Haversine tiene conto di questa curvatura e fornisce la distanza più breve sulla superficie tra due punti: a = sin²(Δφ/2) + cos φ1 · cos φ2 · sin²(Δλ/2) e d = 2R · atan2(√a, √(1−a)). Qui φ è la latitudine, λ la longitudine (in radianti) e R il raggio medio terrestre, 6.371.000 metri. Per esempio, a 41° di latitudine un punto 0,0009 gradi a nord e 0,001 gradi a est del centro si trova a 100,1 m verso nord, 83,9 m verso est e 130,6 m in totale. Dato che la maggior parte dei recinti virtuali misura qualche centinaio di metri, anche un'approssimazione piana più semplice dà lo stesso risultato: moltiplichi la differenza di longitudine per il coseno della latitudine media e applichi Pitagora. Il breve sketch qui sotto confronta le due:
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}Entrambe le funzioni stampano circa 130,6 nel Monitor seriale; a questa scala la differenza è inferiore al centimetro. L'approssimazione piana inizia a scostarsi oltre qualche chilometro, mentre Haversine resta precisa anche su centinaia di chilometri. Su Arduino Uno, double è in realtà un float a 32 bit e conserva le coordinate con una precisione di circa 0,4 metri, più che sufficiente per un recinto virtuale. Anche la funzione distanceBetween() della libreria TinyGPSPlus fa lo stesso lavoro; spieghiamo in dettaglio l'installazione della libreria e il collegamento del GPS in modulo GPS NEO-6M.
Tipi di recinto: cerchio, rettangolo e poligono
| Tipo di recinto | Come si definisce | Come si verifica | Dove si usa |
|---|---|---|---|
| Cerchio | Punto centrale e raggio | La distanza di Haversine è minore del raggio? | Intorno a casa o giardino, parco, campeggio |
| Rettangolo (riquadro) | Latitudine e longitudine minime e massime | Quattro semplici confronti | Campo allineato nord-sud, parcheggio |
| Poligono | Vertici in ordine lungo il confine | Algoritmo del raggio (ray casting) | Pascolo irregolare, confine di giardino o terreno |
| Anello (due cerchi) | Raggio interno di avviso e raggio esterno di allarme | Due confronti di distanza | Avviso graduale: prima un bip, poi l'SMS |
| Corridoio | Linea del percorso e larghezza | Distanza del punto dalla linea | Percorso dello scuolabus o di un tour |
Per iniziare il cerchio è la scelta più facile: bastano un centro e un raggio. Se il terreno ha quattro lati o una forma irregolare, usa un poligono. Per ottenere le coordinate dei vertici, su computer fai clic destro sul punto in Google Maps e copia i numeri della prima riga; sul telefono tieni premuto il punto e le coordinate compaiono nella barra di ricerca. Sei decimali corrispondono a una precisione di circa 11 centimetri. Scrivi i vertici del poligono in ordine lungo il confine, in senso orario o antiorario; vertici in ordine sparso formano una figura che si interseca da sola e la decisione dentro o fuori perde ogni senso.
Precisione del GPS: come scegliere il raggio?
I 2,5 m CEP del datasheet del NEO-6M significano che metà delle letture cade entro 2,5 metri dalla posizione reale; l'altra metà è più lontana. Alberi, edifici e tetti in lamiera riflettono i segnali dei satelliti e la posizione può saltare di 10–30 metri in pochi secondi. Se riporti su una mappa la posizione di un GPS fermo sulla scrivania, non vedi un punto ma una nuvola di qualche metro. Per questo il raggio va scelto in base all'ambiente:
| Ambiente | Deriva tipica | Raggio minimo consigliato |
|---|---|---|
| Campo aperto, pascolo | 2–5 m | 20 m |
| Giardino, vicino agli alberi | 5–15 m | 30–40 m |
| Tra edifici, in città | 10–30 m, a volte di più | 50 m o più |
| Al chiuso, dentro una stalla | Nessuna posizione o forte deriva | Il GPS non è adatto |
Schema di collegamento
| Componente e pin | Arduino Uno | ESP32 | Nota |
|---|---|---|---|
| NEO-6M VCC | 5V | 3V3 | La scheda ha un regolatore |
| NEO-6M TX | D4 (SoftwareSerial RX) | GPIO 16 (RX2) | Uscita del modulo |
| NEO-6M RX | D3, tramite partitore 1 kΩ + 2 kΩ | GPIO 17 (TX2) | Ingresso massimo 3,6 V |
| SIM800L VCC | Non usato | 18650 (+) o sorgente da 4,0 V | Picchi di corrente di 2 A |
| SIM800L TXD | Non usato | GPIO 26 (RX1) | Uscita a 2,8 V |
| SIM800L RXD | Non usato | GPIO 27 (TX1), tramite partitore 1 kΩ + 5,6 kΩ | Ingresso massimo 3,1 V |
| Buzzer (+) | D8 | GPIO 25 | Buzzer attivo |
| GND | GND | GND | Batteria, GPS, SIM800L e scheda con massa comune |
Recinto virtuale circolare con buzzer su Arduino Uno
La prima versione non richiede né internet né SIM: quando il dispositivo si allontana più di 50 metri dal centro, il buzzer suona una volta al secondo e la distanza compare nel Monitor seriale. Sostituisci HOME_LAT e HOME_LNG con il tuo punto centrale preso da Google Maps. Il codice non usa delay() nel loop(); il GPS invia circa 500 byte al secondo e il buffer da 64 byte di SoftwareSerial trabocca durante le attese lunghe:
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 codice | Cosa fa |
|---|---|
| HOME_LAT, HOME_LNG, RADIUS_M | Definiscono centro e raggio della zona sicura |
| MARGIN_M = 5 | Margine di isteresi: per uscire bisogna superare 55 m, per rientrare scendere sotto 45 m |
| NEED_FIXES = 3 | Quante letture di fila devono concordare prima che lo stato cambi |
| hdop() > 3.0, satellites() < 5 | Esclude del tutto dal calcolo le letture deboli |
| location.age() > 2000 | Evita di decidere su una posizione vecchia se il GPS smette di trasmettere |
| millis() % 1000 < 200 | Fuori dalla zona accende il buzzer nei primi 200 ms di ogni secondo |
Recinto virtuale poligonale con allarme SMS su ESP32
La seconda versione descrive la forma reale del terreno con i suoi vertici e, quando il dispositivo esce dalla zona, invia tramite il SIM800L un SMS con un link Google Maps alla posizione. Poiché l'ESP32 ha tre UART hardware, il GPS va su Serial2 e il SIM800L su Serial1, e si possono ascoltare entrambi contemporaneamente senza problemi. Il controllo del poligono usa il metodo del raggio (ray casting): dal punto si traccia un raggio immaginario verso est e si conta quante volte attraversa i lati del poligono; un numero dispari significa dentro, uno pari fuori. Il codice attende almeno 10 minuti tra un SMS e l'altro e avvisa anche quando il dispositivo rientra:
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}Tracciamento degli animali e usi in giardino
- Pascolo e gregge: fissa una scatola impermeabile a collare sulla capra o sulla pecora che guida il gregge e assicurati che l'antenna guardi in alto. Per raggiungere la cascina, un modulo LoRa non ha bisogno di operatore e offre chilometri di portata al posto degli SMS.
- Avviso cane in fuga: definisci il giardino come poligono; se il cane esce mentre il cancello è aperto, ti arriva un SMS con la sua posizione.
- Robot tagliaerba e mezzi da giardino: aggiungi un'uscita che ferma i motori se il robot supera il confine; vista la precisione del GPS, usala come sicurezza aggiuntiva accanto al filo perimetrale.
- Moto, bici e barca: definisci un cerchio di 30–50 m dove parcheggi; se il mezzo ne esce, ricevi un SMS in caso di furto.
- Campeggio e gite: un avvisatore portatile che segnala quando un gruppo di ragazzi si allontana dal campo; usalo solo con la consapevolezza e il consenso del gruppo.
Autonomia: quanti giorni dura un recinto virtuale?
In un recinto virtuale portatile è il GPS a consumare di più. Il NEO-6M assorbe circa 47 mA mentre cerca i satelliti e 39 mA mentre li segue; un ESP32 con il Wi-Fi spento richiede 30–50 mA e un SIM800L a riposo circa 15 mA. Se tutto resta acceso, una cella 18650 da 3000 mAh dura appena un giorno. La soluzione è lavorare a intervalli: l'ESP32 si sveglia dal deep sleep a intervalli regolari, accende il GPS, ottiene la posizione, controlla il confine e torna a dormire. I valori qui sotto sono stime per una cella da 3000 mAh, un modulo ESP32 nudo e un LDO a bassa corrente di riposo:
| Modalità di funzionamento | Corrente media | Autonomia indicativa |
|---|---|---|
| Tutto sempre acceso (ESP32 + NEO-6M + SIM800L a riposo) | Circa 120 mA | 1 giorno |
| Posizione di 30 secondi ogni 5 minuti, deep sleep nel mezzo, SIM800L in sleep | Circa 11 mA | 11 giorni |
| Posizione di 20 secondi ogni 15 minuti, SIM800L acceso solo per gli allarmi | Circa 2–3 mA | 6–8 settimane |
Lavorando a intervalli contano due dettagli. Primo, perché il GPS trovi in fretta la posizione, la batteria tampone della scheda NEO-6M deve essere carica; se il modulo conserva le effemeridi trova la posizione in pochi secondi (avvio a caldo), ma dopo più di qualche ora spento gli servono 30 secondi o più per un avvio tiepido. Secondo, spegnere del tutto GPS e SIM800L con un MOSFET a canale P consuma meno che lasciarli in sleep, ma il SIM800L impiega 10–30 secondi per registrarsi di nuovo sulla rete a ogni accensione. Trovi le modalità di sleep e la memoria RTC in ESP32 deep sleep, la sicurezza delle batterie in batteria Li-ion 18650 e modulo di ricarica TP4056, e puoi calcolare il tuo scenario con lo strumento Autonomia batteria.
Errori comuni e soluzioni
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| Non compare mai la distanza | Il modulo non ha ancora trovato la posizione o il dispositivo è al chiuso | Esci all'aperto e aspetta 1–5 minuti per la prima posizione |
| Allarme con il dispositivo fermo | La deriva del GPS supera il raggio | Aumenta il raggio, MARGIN_M e NEED_FIXES |
| La distanza risulta di migliaia di chilometri | Latitudine e longitudine invertite o errore di segno | Scrivi prima la latitudine; le coordinate sud e ovest sono negative |
| Il poligono dice fuori ovunque | Vertici in ordine sparso o latitudine e longitudine invertite | Scrivi i vertici in ordine lungo il confine nel formato {lat, lng} |
| L'SMS non parte | Alimentazione del SIM800L troppo debole, niente copertura 2G o PIN attivo | Usa una sorgente da 2 A, prova con i comandi AT, disattiva il PIN |
| L'ESP32 si riavvia durante l'invio dell'SMS | La tensione crolla sull'alimentazione condivisa con il SIM800L | Alimenta il SIM800L con una linea separata dalla batteria e aggiungi 1000 µF |
| Sull'Uno la posizione a volte è corrotta | delay() nel loop() o buffer di SoftwareSerial pieno | Non usare delay(); se serve passa all'ESP32 |
Un recinto virtuale GPS unisce GPS, matematica e comunicazione in un solo progetto: è tanto istruttivo quanto utile nella vita reale. Prova prima il recinto circolare con un Uno in giardino, adatta il raggio al tuo ambiente e poi passa al recinto poligonale con allarme SMS usando un ESP32 e un SIM800L. Nell'app BlueGrays puoi sviluppare passo passo la parte di allarme del sistema con i progetti di suono d'allarme con buzzer e sistema d'allarme ESP32 con notifiche Telegram, ognuno con schema e codice pronto.
Domande frequenti
Che cos'è un recinto virtuale GPS?
È un confine invisibile definito da coordinate GPS invece che da un filo. Quando il dispositivo lascia la zona sicura suona un buzzer oppure il proprietario riceve un SMS o una notifica. Si usa per il tracciamento degli animali, in giardino, per la sicurezza dei veicoli e sui robot tagliaerba.
Come si fa un recinto virtuale con Arduino?
Collega un modulo GPS come il NEO-6M a un Arduino o a un ESP32 e definisci nel codice la zona sicura come centro e raggio oppure come elenco di vertici. Ogni secondo il microcontrollore verifica se la posizione è dentro con la formula di Haversine o con un test sul poligono. Quando il dispositivo esce dalla zona suona un buzzer e con un SIM800L si può inviare un SMS.
Quanto è preciso un recinto virtuale GPS?
In campo aperto il NEO-6M dà di solito la posizione entro 2–5 metri, ma vicino ad alberi ed edifici la deriva può arrivare a 10–30 metri. Per questo il raggio deve essere di almeno 20 metri in campo aperto e di 30–40 metri in giardino. Richiedere più letture di fila e un margine di isteresi evita la maggior parte dei falsi allarmi.
Un recinto virtuale ha bisogno di internet?
No. Il GPS funziona con i satelliti e un recinto con buzzer lavora senza alcuna connessione. Per ricevere avvisi a distanza puoi usare gli SMS con un SIM800L, Telegram dove c'è il Wi-Fi o LoRa su grandi superfici come le aziende agricole.
Il recinto virtuale è sicuro per gli animali?
Un recinto virtuale che usa solo suoni e notifiche non fa alcun male all'animale. L'impulso elettrico dei collari commerciali riguarda prodotti molto regolamentati e non va mai replicato in un progetto hobbistico. Realizza una scatola da collare leggera, impermeabile e che non stringa il collo dell'animale.
Quanto dura la batteria di un localizzatore GPS?
Con GPS, ESP32 e SIM800L sempre accesi, una cella da 3000 mAh dura circa un giorno. Se il dispositivo si sveglia dal deep sleep ogni 5–15 minuti per prendere la posizione, l'autonomia sale a diverse settimane. Usare un modulo ESP32 nudo e un regolatore a bassa corrente di riposo al posto di una scheda di sviluppo fa anch'esso una grande differenza.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
Uso del cicalino
Ti sei mai chiesto come fa un campanello o un allarme a suonare? L'Arduino fa suonare un piccolo cicalino a intervalli brevi: bip, pausa, bip, pausa.

LED Lampeggiante con ESP32
Insegna l'uso di base delle uscite GPIO con l'ESP32. Otteniamo un effetto lampeggiante accendendo e spegnendo un LED dal pin digitale. Versione ESP32 del classico progetto blink su Arduino UNO; i comandi di base di blink nell'ambiente Arduino sono gli stessi, ma la disposizione dei pin e i livelli GPIO a 3,3 V dell'ESP32 sono diversi da quelli di Arduino UNO.

ESP32 Riproduzione di melodia con cicalino
Riproduzione di una semplice melodia (Twinkle Twinkle Little Star) con un buzzer passivo. Le note vengono riprodotte con le funzioni tone() e noTone() come in Arduino - la stessa sintassi funziona con ESP32 Arduino Core 3.0+. È necessario utilizzare un cicalino passivo (il cicalino attivo non riproduce la melodia).

Sistema di Allarme Movimento ESP32 (PIR + Buzzer + LED + Telegram)
Un allarme di sicurezza smart: quando il sensore PIR rileva un movimento, suona il buzzer, si accende il LED e il proprietario riceve subito una notifica su Telegram. Un'attesa di 30 secondi (cooldown) limita la frequenza degli allarmi ripetuti; non elimina i falsi rilevamenti del sensore PIR. Adatto a casa, garage, magazzino o studio.

ESP32 Deep Sleep — Risparmio della batteria (OLED + contatore in RTC RAM)
La modalità Deep Sleep dell'ESP32 spegne la CPU e quasi tutte le periferiche e riduce il consumo a circa 10µA, un aspetto cruciale per i dispositivi IoT a batteria. Il progetto usa tre sorgenti di risveglio: un timer (15 s), un pin esterno (EXT0, il pulsante su GPIO 33) e un pin touch (T0/GPIO 4). I contatori marcati con RTC_DATA_ATTR restano salvati durante il deep sleep.

Data Logger di Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
Costruisci con l'ESP32 un registratore di temperatura e umidità con orario! Un sensore DHT22 legge temperatura e umidità una volta al minuto e ogni lettura viene salvata su una scheda microSD in formato CSV con l'ora reale del modulo RTC DS1307. Il display OLED mostra in tempo reale, a caratteri grandi, l'ultima temperatura, l'umidità, l'orario e il numero totale di registrazioni.

ESP32 HTTPClient + API meteo (con display OLED SSD1306)
L'ESP32 effettua via internet una chiamata REST a un'API meteo (wttr.in) con HTTPClient.h. A differenza della versione con LCD I2C, qui usiamo un display OLED SSD1306 (128×64), con testo grande e icone vettoriali per una resa più ricca. Sette icone meteo (sole, pioggia, neve e altre) vengono disegnate al volo, senza file bitmap.
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

