Inviare messaggio WhatsApp con ESP32: notifiche con CallMeBot
Come inviare un messaggio WhatsApp con ESP32: chiave API CallMeBot, codifica URL, avvisi da sensore di temperatura e porta, limite dei messaggi e debug.
Inviare un messaggio WhatsApp con ESP32 è uno dei modi più pratici per essere avvisato subito sul telefono quando un sensore in casa supera una soglia. Quando una porta si apre, la temperatura del frigo sale o il livello dell'acqua nel serbatoio scende, l'ESP32 si collega a internet e ti lascia un messaggio su WhatsApp con un'unica richiesta HTTPS. Non servono un server a pagamento né un'autenticazione complicata: il servizio gratuito CallMeBot inoltra al tuo numero WhatsApp le richieste web che arrivano con la chiave API che ti assegna.
In questa guida imparerai a ottenere la chiave API, a capire perché e come i messaggi con caratteri accentati richiedono la codifica URL e a inviare il primo messaggio di prova. Poi costruirai un vero sistema di notifica con un sensore di temperatura DHT22 e un sensore reed per la porta, limiterai la frequenza dei messaggi per non riempire il telefono di notifiche e farai il debug leggendo le risposte del server. Se non conosci ancora l'ESP32, dai prima un'occhiata a Cos'è l'ESP32?.
Cos'è CallMeBot e come arriva il messaggio dall'ESP32 a WhatsApp?
WhatsApp non offre per gli account personali un'API aperta che i dispositivi possano usare direttamente. CallMeBot fa da ponte: un bot con un proprio account WhatsApp invia messaggi ai numeri che gli hanno dato il permesso. Dall'ESP32 fai una richiesta GET a api.callmebot.com/whatsapp.php con il tuo numero di telefono, la chiave API e il testo del messaggio; il servizio mette la richiesta in coda e in pochi secondi il messaggio arriva sul tuo WhatsApp dal numero del bot. Per l'ESP32, quindi, il lavoro è come aprire una pagina web. Il servizio è gratuito per uso personale, ma essendo un servizio di terze parti gestito da un privato, limiti e regole possono cambiare nel tempo. Per questo non usarlo come unico canale di avviso in situazioni vitali come incendio o fuga di gas: affiancagli un buzzer locale o un secondo canale.
| Metodo | Configurazione | Costo | Quando conviene |
|---|---|---|---|
| CallMeBot (WhatsApp) | Chiave API con un solo messaggio | Gratis per uso personale | Semplici avvisi sul tuo telefono |
| Bot Telegram | Token ottenuto con BotFather | Gratis | Comandi bidirezionali, foto, messaggi di gruppo |
| WhatsApp Business Cloud API | Account Meta Business e template approvato | Può essere a pagamento per messaggio | Notifiche commerciali ai clienti |
| E-mail (SMTP) | Serve una password per le app | Gratis | Report dettagliati, riepiloghi giornalieri |
Come ottenere la chiave API di CallMeBot?
- Salva in rubrica il numero attuale del bot pubblicato nella pagina WhatsApp del sito di CallMeBot; il numero cambia ogni tanto, quindi controllalo sempre lì e non da altre fonti.
- Su WhatsApp invia a quel contatto esattamente la frase I allow callmebot to send me messages.
- Dopo poco arriva una risposta che inizia con "API Activated for your phone number" e contiene il valore APIKEY; annota quel numero.
- Se la risposta non arriva, non rimandare lo stesso messaggio a raffica; aspetta un po' (se serve fino al giorno dopo) e riprova, perché quando il servizio è molto usato l'attivazione può slittare.
- Puoi fare la prima prova senza ESP32: scrivi nella barra degli indirizzi del browser l'URL nel formato qui sotto con il tuo numero e la tua chiave; se il messaggio arriva, il tuo account è pronto.
URL del messaggio e codifica URL
L'indirizzo della richiesta ha tre parametri: phone (numero con prefisso internazionale; per l'Italia inizia con +39), apikey e text. Una richiesta di esempio è questa: api.callmebot.com/whatsapp.php?phone=%2B393331234567&apikey=123456&text=Porta%20aperta. Negli URL caratteri come spazio, &, ?, # e + hanno un significato speciale; per esempio un & nel messaggio tronca il testo e ciò che segue viene scambiato per un nuovo parametro, mentre un + può essere interpretato come uno spazio. Le lettere accentate in UTF-8 occupano due byte e non possono comparire direttamente in un URL. La soluzione è scrivere ogni byte non sicuro con il simbolo di percentuale e due cifre esadecimali: si chiama codifica URL (percent-encoding).
| Carattere | Byte UTF-8 | Forma codificata |
|---|---|---|
| spazio | 0x20 | %20 |
| + | 0x2B | %2B |
| & | 0x26 | %26 |
| ı | 0xC4 0xB1 | %C4%B1 |
| ş | 0xC5 0x9F | %C5%9F |
| ü | 0xC3 0xBC | %C3%BC |
| ° | 0xC2 0xB0 | %C2%B0 |
| a capo | 0x0A | %0A |
Nei codici qui sotto c'è una piccola funzione urlEncodeText() che fa proprio questo: lascia invariati lettere, cifre e i caratteri - _ . ~ e converte ogni altro byte nella forma %XX. Poiché l'Arduino IDE salva i file sorgente in UTF-8, una parola come "Temperatura" o "è" scritta nel codice parte con i byte giusti e su WhatsApp si vede correttamente. Se preferisci una soluzione pronta, la libreria UrlEncode del Gestore librerie fa lo stesso con la funzione urlEncode(). Per andare a capo nel messaggio basta scrivere \n nel testo; la funzione lo trasforma in %0A. Funziona anche la formattazione di WhatsApp: se metti una parola tra asterischi, appare in grassetto.
Primo test: un ciao da ESP32 a WhatsApp
- Nell'Arduino IDE installa il pacchetto schede ESP32 e scegli come scheda ESP32 Dev Module.
- Sostituisci nel codice i valori WIFI_SSID, WIFI_PASS, PHONE e API_KEY con i tuoi; scrivi il numero nel formato +393331234567.
- Carica il codice e apri il Monitor seriale a 115200 baud.
- Dopo la connessione Wi-Fi dovresti vedere nel Monitor seriale il codice HTTP 200 e il testo di risposta di CallMeBot; in pochi secondi il messaggio arriva sul telefono.
1#include <WiFi.h>
2#include <WiFiClientSecure.h>
3#include <HTTPClient.h>
4
5const char* WIFI_SSID = "WIFI_ADIN"; // Wi-Fi ağ adı / Wi-Fi network name
6const char* WIFI_PASS = "WIFI_SIFREN"; // Wi-Fi şifresi / Wi-Fi password
7const char* PHONE = "+905551234567"; // ülke kodlu numaran / your number with country code
8const char* API_KEY = "123456"; // CallMeBot API anahtarı / CallMeBot API key
9
10// UTF-8 metni URL için kodlar / URL-encodes UTF-8 text
11String urlEncodeText(const String &s) {
12 const char *digits = "0123456789ABCDEF";
13 String out;
14 out.reserve(s.length() * 3);
15 for (unsigned int i = 0; i < s.length(); i++) {
16 uint8_t c = (uint8_t)s[i];
17 bool safe = (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') ||
18 (c >= '0' && c <= '9') || c == '-' || c == '_' || c == '.' || c == '~';
19 if (safe) {
20 out += (char)c;
21 } else {
22 out += '%';
23 out += digits[c >> 4];
24 out += digits[c & 0x0F];
25 }
26 }
27 return out;
28}
29
30// WhatsApp mesajı gönderir / sends a WhatsApp message
31bool sendWhatsApp(const String &message) {
32 if (WiFi.status() != WL_CONNECTED) {
33 Serial.println("Wi-Fi yok / no Wi-Fi");
34 return false;
35 }
36 WiFiClientSecure client;
37 client.setInsecure(); // sertifika doğrulaması yok / no certificate check
38 HTTPClient http;
39 String url = String("https://api.callmebot.com/whatsapp.php?phone=") +
40 urlEncodeText(PHONE) + "&apikey=" + API_KEY +
41 "&text=" + urlEncodeText(message);
42 if (!http.begin(client, url)) {
43 Serial.println("Baglanti baslatilamadi / begin failed");
44 return false;
45 }
46 http.setTimeout(10000); // 10 sn zaman aşımı / 10 s timeout
47 int code = http.GET();
48 if (code > 0) {
49 Serial.printf("HTTP %d\n", code);
50 Serial.println(http.getString()); // CallMeBot yanıtı / CallMeBot reply
51 } else {
52 Serial.printf("Hata / error: %s\n", HTTPClient::errorToString(code).c_str());
53 }
54 http.end();
55 return code == 200;
56}
57
58void setup() {
59 Serial.begin(115200);
60 WiFi.mode(WIFI_STA);
61 WiFi.begin(WIFI_SSID, WIFI_PASS);
62 Serial.print("Wi-Fi baglaniyor / connecting");
63 unsigned long start = millis();
64 while (WiFi.status() != WL_CONNECTED && millis() - start < 20000) {
65 delay(500);
66 Serial.print(".");
67 }
68 Serial.println();
69 if (WiFi.status() == WL_CONNECTED) {
70 Serial.print("IP: ");
71 Serial.println(WiFi.localIP());
72 sendWhatsApp("Merhaba! ESP32 çevrimiçi.\nSıcaklık testi: 24,5 °C");
73 } else {
74 Serial.println("Wi-Fi baglantisi kurulamadi / Wi-Fi failed");
75 }
76}
77
78void loop() {
79}| Parte di codice | Cosa fa |
|---|---|
| WiFiClientSecure + setInsecure() | Stabilisce la connessione HTTPS cifrata ma non verifica il certificato del server |
| urlEncodeText() | Converte in %XX il + del numero e i caratteri speciali o accentati del messaggio |
| http.begin(client, url) | Prepara la richiesta; il parametro client è indispensabile per HTTPS |
| http.GET() | Invia la richiesta; un valore positivo è il codice HTTP, uno negativo è un errore di connessione |
| http.getString() | Legge il testo di risposta di CallMeBot; le spiegazioni degli errori sono qui |
| http.end() | Chiude la connessione e libera la memoria usata |
Circuito: collegare il sensore di temperatura e quello della porta
Il sistema di esempio ha due sensori. Il DHT22 misura la temperatura con una precisione di circa ±0,5 °C e usa una sola linea dati; se usi il sensore nudo, aggiungi una resistenza di pull-up da 10 kΩ tra il pin dati e 3,3 V, mentre nei moduli questa resistenza è già presente. Per la porta usiamo un interruttore reed: il reed si fissa sullo stipite e il magnete sull'anta. Con la porta chiusa il magnete chiude il contatto e il pin viene portato a GND (LOW); quando la porta si apre il contatto si apre e il pull-up interno porta il pin a HIGH. Trovi il funzionamento del reed nell'articolo Relè reed. Arduino Uno non ha il Wi-Fi, quindi la tabella riporta solo schede con Wi-Fi.
| Collegamento | ESP32 | ESP8266 (NodeMCU) | Raspberry Pi Pico W |
|---|---|---|---|
| DHT22 VCC | 3V3 | 3V3 | 3V3(OUT) |
| DHT22 DATA | GPIO 4 | D2 (GPIO 4) | GP16 |
| DHT22 GND | GND | GND | GND |
| Reed, terminale 1 | GPIO 27 | D5 (GPIO 14) | GP15 |
| Reed, terminale 2 | GND | GND | GND |
Notifica al superamento della soglia: allarme temperatura e porta
In un vero sistema di notifica la domanda più importante è "quando devo mandare il messaggio?". Se la temperatura resta sopra 30 °C e mandi un messaggio ogni 5 secondi, ricevi 12 notifiche al minuto. Per evitarlo il codice usa due tecniche. La prima è l'isteresi: l'allarme scatta a 30 °C ma non si azzera finché la temperatura non scende a 28 °C; così un valore che oscilla tra 29,9 e 30,1 non ti sommerge di notifiche. La seconda è il tempo di attesa (cooldown): tra due messaggi dello stesso tipo devono passare 10 minuti per la temperatura e 1 minuto per la porta. Per il sensore della porta non rileviamo lo stato continuo, ma solo il momento del passaggio da chiusa ad aperta. Per il codice installa dal Gestore librerie la libreria DHT sensor library (Adafruit) con le sue dipendenze.
1#include <WiFi.h>
2#include <WiFiClientSecure.h>
3#include <HTTPClient.h>
4#include <DHT.h>
5
6const char* WIFI_SSID = "WIFI_ADIN";
7const char* WIFI_PASS = "WIFI_SIFREN";
8const char* PHONE = "+905551234567";
9const char* API_KEY = "123456";
10
11#define DHT_PIN 4 // DHT22 veri pini / DHT22 data pin
12#define DOOR_PIN 27 // reed röle / reed switch
13
14DHT dht(DHT_PIN, DHT22);
15
16const float TEMP_HIGH = 30.0; // alarm eşiği / alarm threshold
17const float TEMP_RESET = 28.0; // sıfırlama eşiği (histerezis) / reset threshold (hysteresis)
18const unsigned long READ_MS = 5000; // ölçüm aralığı / read interval
19const unsigned long TEMP_GAP_MS = 600000UL; // sıcaklık mesajları arası 10 dk / 10 min between temp messages
20const unsigned long DOOR_GAP_MS = 60000UL; // kapı mesajları arası 1 dk / 1 min between door messages
21const unsigned long MIN_GAP_MS = 15000UL; // iki istek arası en az 15 sn / at least 15 s between requests
22
23bool tempAlarm = false;
24bool lastDoorOpen = false;
25unsigned long lastRead = 0;
26unsigned long lastTempMsg = 0;
27unsigned long lastDoorMsg = 0;
28unsigned long lastRequest = 0;
29
30// UTF-8 metni URL için kodlar / URL-encodes UTF-8 text
31String urlEncodeText(const String &s) {
32 const char *digits = "0123456789ABCDEF";
33 String out;
34 out.reserve(s.length() * 3);
35 for (unsigned int i = 0; i < s.length(); i++) {
36 uint8_t c = (uint8_t)s[i];
37 bool safe = (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') ||
38 (c >= '0' && c <= '9') || c == '-' || c == '_' || c == '.' || c == '~';
39 if (safe) {
40 out += (char)c;
41 } else {
42 out += '%';
43 out += digits[c >> 4];
44 out += digits[c & 0x0F];
45 }
46 }
47 return out;
48}
49
50bool sendWhatsApp(const String &message) {
51 if (WiFi.status() != WL_CONNECTED) { // ESP32 kendisi yeniden bağlanır / ESP32 reconnects itself
52 Serial.println("Wi-Fi yok / no Wi-Fi");
53 return false;
54 }
55 if (lastRequest != 0 && millis() - lastRequest < MIN_GAP_MS) {
56 Serial.println("Cok sik istek, atlandi / too frequent, skipped");
57 return false;
58 }
59 lastRequest = millis();
60 WiFiClientSecure client;
61 client.setInsecure();
62 HTTPClient http;
63 String url = String("https://api.callmebot.com/whatsapp.php?phone=") +
64 urlEncodeText(PHONE) + "&apikey=" + API_KEY +
65 "&text=" + urlEncodeText(message);
66 if (!http.begin(client, url)) {
67 return false;
68 }
69 http.setTimeout(10000);
70 int code = http.GET();
71 if (code > 0) {
72 Serial.printf("HTTP %d: %s\n", code, http.getString().c_str());
73 } else {
74 Serial.printf("Hata / error: %s\n", HTTPClient::errorToString(code).c_str());
75 }
76 http.end();
77 return code == 200;
78}
79
80void setup() {
81 Serial.begin(115200);
82 pinMode(DOOR_PIN, INPUT_PULLUP); // kapalı kapı = LOW / closed door = LOW
83 dht.begin();
84 WiFi.mode(WIFI_STA);
85 WiFi.begin(WIFI_SSID, WIFI_PASS);
86 unsigned long start = millis();
87 while (WiFi.status() != WL_CONNECTED && millis() - start < 20000) {
88 delay(500);
89 Serial.print(".");
90 }
91 Serial.println(WiFi.status() == WL_CONNECTED ? "\nWi-Fi OK" : "\nWi-Fi yok / no Wi-Fi");
92 lastDoorOpen = digitalRead(DOOR_PIN) == HIGH; // açılıştaki durum / initial state
93}
94
95void loop() {
96 unsigned long now = millis();
97
98 // Kapı: yalnızca kapalı -> açık geçişi / door: only closed -> open edge
99 bool doorOpen = digitalRead(DOOR_PIN) == HIGH;
100 if (doorOpen && !lastDoorOpen) {
101 if (lastDoorMsg == 0 || now - lastDoorMsg >= DOOR_GAP_MS) {
102 if (sendWhatsApp("Kapı açıldı!")) {
103 lastDoorMsg = millis();
104 }
105 } else {
106 Serial.println("Kapi acildi, bekleme suresinde / door opened, in cooldown");
107 }
108 }
109 lastDoorOpen = doorOpen;
110
111 // Sıcaklık: 5 sn'de bir oku / temperature: read every 5 s
112 if (now - lastRead >= READ_MS) {
113 lastRead = now;
114 float t = dht.readTemperature();
115 if (isnan(t)) {
116 Serial.println("DHT22 okunamadi / read failed");
117 } else {
118 Serial.printf("Sicaklik / temp: %.1f C\n", t);
119 if (!tempAlarm && t >= TEMP_HIGH) {
120 if (lastTempMsg == 0 || now - lastTempMsg >= TEMP_GAP_MS) {
121 String msg = String("Uyarı: sıcaklık ") + String(t, 1) + " °C (eşik " + String(TEMP_HIGH, 1) + " °C)";
122 if (sendWhatsApp(msg)) {
123 tempAlarm = true;
124 lastTempMsg = millis();
125 }
126 }
127 } else if (tempAlarm && t <= TEMP_RESET) {
128 tempAlarm = false; // alarm sıfırlandı / alarm reset
129 sendWhatsApp(String("Sıcaklık normale döndü: ") + String(t, 1) + " °C");
130 }
131 }
132 }
133 delay(20);
134}Nel codice si usa una temporizzazione basata su millis(), quindi loop() non resta mai bloccato a lungo; solo durante l'invio la connessione HTTPS richiede 1–3 secondi. Il controllo MIN_GAP_MS in sendWhatsApp() lascia comunque almeno 15 secondi tra due richieste, per qualunque motivo; se la chiave API è sbagliata o il servizio restituisce errori, il codice non bombarda il server. Un evento che arriva in questo breve intervallo non viene inviato come messaggio, ma solo scritto nel Monitor seriale. Se l'invio del messaggio di temperatura non riesce, il flag tempAlarm non diventa true e la misura successiva riprova. Il DHT22 non va letto più spesso di ogni 2 secondi; qui viene letto ogni 5 secondi e, se la lettura fallisce (NaN), viene scritto l'errore senza inviare messaggi. Per i dettagli su millis al posto di delay vedi l'articolo millis e delay.
Perché è indispensabile limitare la frequenza dei messaggi?
CallMeBot è un servizio gratuito e, per prevenire abusi, può bloccare temporaneamente i numeri che inviano troppe richieste in poco tempo. Poiché i limiti esatti possono cambiare nel tempo, l'approccio più sicuro è progettare il sistema in modo che non superi mai qualche messaggio al minuto. Ti conviene anche per un altro motivo: un telefono che squilla in continuazione finisce per essere ignorato e un vero allarme passa inosservato. Una buona notifica è rara e significativa.
- Invia in base agli eventi: manda un messaggio una sola volta quando lo stato cambia (porta aperta, soglia di temperatura superata); non ripeterlo finché la situazione dura.
- Lascia un'isteresi: scegli soglie di allarme e di azzeramento distanti almeno 1–2 °C; per valori instabili come l'umidità usa un intervallo ancora più ampio.
- Attesa per tipo di evento: usa tempi come 1 minuto per la porta e 10–30 minuti per la temperatura.
- Messaggio riepilogativo: se in poco tempo ci sono molti eventi, contali e comunicali in un solo messaggio, ad esempio "negli ultimi 10 minuti la porta è stata aperta 7 volte".
- Tetto giornaliero: con un contatore consenti al massimo, per esempio, 50 messaggi al giorno; raggiunto il limite, scrivi solo nel Monitor seriale.
- Limita il messaggio di avvio: se l'ESP32 manda "online" a ogni reset, gli sbalzi di alimentazione possono causare una pioggia di notifiche; se serve, elimina questo messaggio.
Raspberry Pi Pico W con MicroPython
Anche il Pico W con Wi-Fi può usare lo stesso servizio; il modulo urequests di MicroPython supporta le richieste HTTPS. Il codice qui sotto porta la stessa logica di codifica URL in Python, legge il DHT22 da GP16 e il reed da GP15. Nella versione di MicroPython per Pico W il modulo dht è già integrato, quindi non devi copiare file aggiuntivi. Questo codice non funziona sul Pico classico senza Wi-Fi. Se sei nuovo di MicroPython, l'articolo Basi di MicroPython è un buon punto di partenza.
1import network
2import time
3import urequests
4import dht
5from machine import Pin
6
7SSID = "WIFI_ADIN"
8PASSWORD = "WIFI_SIFREN"
9PHONE = "+905551234567" # ülke kodlu numara / number with country code
10API_KEY = "123456" # CallMeBot API anahtarı / CallMeBot API key
11
12TEMP_HIGH = 30.0 # alarm eşiği / alarm threshold
13TEMP_RESET = 28.0 # sıfırlama eşiği / reset threshold
14DOOR_GAP = 60000 # kapı mesajları arası 1 dk / 1 min between door messages
15
16sensor = dht.DHT22(Pin(16))
17door = Pin(15, Pin.IN, Pin.PULL_UP) # kapalı kapı = 0 / closed door = 0
18
19def url_encode(s):
20 out = ""
21 for b in s.encode("utf-8"):
22 if 48 <= b <= 57 or 65 <= b <= 90 or 97 <= b <= 122 or b in (45, 46, 95, 126):
23 out += chr(b)
24 else:
25 out += "%{:02X}".format(b)
26 return out
27
28def send_whatsapp(msg):
29 url = ("https://api.callmebot.com/whatsapp.php?phone=" + url_encode(PHONE)
30 + "&apikey=" + API_KEY + "&text=" + url_encode(msg))
31 try:
32 r = urequests.get(url)
33 ok = r.status_code == 200
34 print("HTTP", r.status_code, r.text)
35 r.close()
36 return ok
37 except Exception as e:
38 print("Hata / error:", e)
39 return False
40
41wlan = network.WLAN(network.STA_IF)
42wlan.active(True)
43wlan.connect(SSID, PASSWORD)
44for _ in range(40): # en fazla 20 sn bekle / wait up to 20 s
45 if wlan.isconnected():
46 break
47 time.sleep(0.5)
48print("IP:", wlan.ifconfig()[0])
49
50last_open = door.value() == 1
51last_door_msg = None
52temp_alarm = False
53last_read = time.ticks_ms()
54
55while True:
56 now = time.ticks_ms()
57 is_open = door.value() == 1
58 if is_open and not last_open: # kapalı -> açık / closed -> open
59 if last_door_msg is None or time.ticks_diff(now, last_door_msg) >= DOOR_GAP:
60 if send_whatsapp("Kapı açıldı! (Pico W)"):
61 last_door_msg = time.ticks_ms()
62 last_open = is_open
63
64 if time.ticks_diff(now, last_read) >= 5000:
65 last_read = now
66 try:
67 sensor.measure()
68 t = sensor.temperature()
69 print("Sicaklik / temp:", t)
70 if not temp_alarm and t >= TEMP_HIGH:
71 if send_whatsapp("Uyarı: sıcaklık {:.1f} °C".format(t)):
72 temp_alarm = True
73 elif temp_alarm and t <= TEMP_RESET:
74 temp_alarm = False
75 send_whatsapp("Sıcaklık normale döndü: {:.1f} °C".format(t))
76 except OSError:
77 print("DHT22 okunamadi / read failed")
78 time.sleep_ms(50)Usarlo con ESP8266 (NodeMCU, Wemos D1 Mini)
Sulle schede ESP8266 la logica è identica; cambiano solo i file di intestazione. Al posto di WiFi.h includi ESP8266WiFi.h e al posto di HTTPClient.h includi ESP8266HTTPClient.h. La classe WiFiClientSecure sull'ESP8266 è basata su BearSSL e si usa allo stesso modo con setInsecure(); anche la riga http.begin(client, url) funziona senza modifiche. Poiché la RAM dell'ESP8266 è molto inferiore a quella dell'ESP32, una connessione TLS occupa una parte importante della memoria; se la usi insieme a librerie grandi, riduci le concatenazioni di String e ricorda di chiamare http.end() a richiesta finita. Per i numeri dei pin usa la colonna ESP8266 della tabella.
Idee di progetto con notifiche WhatsApp
- Allarme movimento: invia un messaggio se il sensore PIR rileva movimento quando in casa non c'è nessuno.
- Avviso di fuga di gas: quando il sensore di gas MQ-2 supera la soglia, fai suonare il buzzer e scrivi su WhatsApp.
- Rilevatore di allagamento: avvisa quando il sensore di livello dell'acqua sotto la lavatrice si bagna.
- Promemoria per l'irrigazione: quando il sensore di umidità del terreno rileva secchezza, invia il messaggio "il vaso ha sete".
- Allarme gelo: avvisa quando la temperatura della serra o del balcone scende sotto i 2 °C; i dettagli sono nell'articolo sull'allarme gelo.
- Sensore per la cassetta della posta a batteria: tieni l'ESP32 in deep sleep; quando lo sportello si apre si sveglia, manda un solo messaggio e torna a dormire.
Errori comuni e debug
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| Il Wi-Fi non si connette mai | Password errata o rete a 5 GHz | L'ESP32 si collega solo a reti a 2,4 GHz; controlla SSID e password |
| HTTP -1 o connection refused | Manca il client HTTPS, problema di DNS o di internet | Controlla il formato http.begin(client, url) e la riga setInsecure() |
| HTTP 200 ma il messaggio non arriva | Formato del numero errato o servizio lento | Usa un numero che inizia con +39 e aspetta qualche minuto; leggi il testo della risposta |
| La risposta dice che la chiave API non è valida | Chiave errata o incompleta | Copia di nuovo il numero dal messaggio di attivazione; numero e chiave devono appartenere allo stesso account |
| Il messaggio viene troncato | & o # nel testo non codificati | Codifica tutto il testo con urlEncodeText() |
| Le lettere accentate appaiono come %C4%B1 | Il testo è stato codificato due volte | Codifica il testo una sola volta |
| L'ESP32 si riavvia durante l'invio | Il Wi-Fi provoca un calo di tensione negli picchi di corrente | Usa un buon cavo USB e un'alimentazione da almeno 500 mA |
| Messaggi "porta aperta" continui | Pin senza pull-up o cavo allentato | Usa un pin con pull-up come GPIO 27 e fissa bene i collegamenti |
La notifica WhatsApp porta i progetti con sensori dal livello "lo capisco guardando lo schermo" a "lo so ovunque io sia". Se vuoi comandi bidirezionali, foto e messaggi di gruppo, un buon passo successivo è il bot Telegram con ESP32. Nell'app BlueGrays trovi passo passo, con schema del circuito e codice, progetti come la connessione Wi-Fi dell'ESP32, il meteo con HTTPClient, la misura con il DHT22 e l'allarme di movimento, e potrai aggiungere facilmente a ciascuno la funzione WhatsApp di questo articolo.
Domande frequenti
Si può inviare gratis un messaggio WhatsApp con ESP32?
Sì. Il servizio CallMeBot è gratuito per uso personale e chiede solo una chiave API; l'ESP32 invia un messaggio al tuo numero con una sola richiesta HTTPS GET. La WhatsApp Business Cloud API ufficiale, invece, richiede un account aziendale e template approvati e può essere a pagamento per messaggio.
Cosa faccio se la chiave API di CallMeBot non arriva?
Controlla prima che il numero del bot sia quello aggiornato sul sito di CallMeBot e di aver scritto la frase di attivazione esattamente com'è. Se la risposta non arriva in pochi minuti, non rimandare il messaggio a raffica: aspetta un po', se serve fino al giorno dopo, e riprova. Quando il servizio è molto usato l'attivazione può ritardare.
Con CallMeBot si può scrivere a un altro numero?
Ogni chiave API è legata al solo numero che ha fatto l'attivazione e invia messaggi esclusivamente a quel numero. Perché anche un familiare riceva le notifiche, deve attivare a sua volta il bot e ottenere la propria chiave; il codice ESP32 può inviare due richieste separate. Se vuoi notificare dei gruppi, un bot Telegram è la scelta più adatta.
Come si inviano caratteri accentati in un messaggio WhatsApp da ESP32?
Prima di inserire il testo nell'URL devi convertire i suoi byte UTF-8 in %XX con la codifica URL; per esempio la lettera ı viene inviata come %C4%B1. La funzione urlEncodeText() di questo articolo o la libreria UrlEncode lo fanno in automatico. Fai attenzione a non codificare il testo due volte, altrimenti su WhatsApp vedrai i codici al posto delle lettere.
Per le notifiche ESP32 è meglio WhatsApp o Telegram?
Se devi solo mandare brevi avvisi al tuo telefono, WhatsApp con CallMeBot è la configurazione più rapida. Se vuoi inviare comandi dal telefono all'ESP32, condividere foto o scrivere in un gruppo, l'API dei bot Telegram è una soluzione ufficiale, gratuita e molto più flessibile.
Si può inviare un messaggio WhatsApp con Arduino Uno?
Arduino Uno non ha il Wi-Fi, quindi da solo non può farlo. Si può aggiungere un modulo Wi-Fi come l'ESP-01, ma con questa configurazione la richiesta HTTPS è laboriosa. La soluzione più pratica è usare direttamente un ESP32 o un ESP8266, oppure passare i dati dei sensori dell'Uno a un ESP32 tramite la linea seriale.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
Connessione Wi-Fi STA con ESP32 (con display LCD)
In questo progetto colleghiamo l'ESP32 alla rete Wi-Fi domestica in modalità Station (STA) in modo sicuro e tollerante agli errori. Separiamo SSID e password in un file secrets.h per impedire fughe su Git, impostiamo un meccanismo di riconnessione automatica e visualizziamo il livello del segnale RSSI e l'indirizzo IP su un display LCD I2C. Il LED interno funge da indicatore di stato.

ESP32 HTTPClient + API meteo (con schermo LCD)
L'ESP32 effettua via internet una chiamata REST a un'API meteo (wttr.in) con HTTPClient.h. La risposta JSON viene analizzata con ArduinoJson v7 e città, temperatura, umidità, condizioni meteo e vento compaiono su un display LCD I2C. wttr.in non richiede una chiave API: basta scrivere il nome di una città qualsiasi.

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 DHT22 Temperatura e umidità (con display LCD)
Si tratta di un progetto che misura la temperatura e l'umidità dell'ambiente tramite il sensore DHT22 e le visualizza in tempo reale su un display LCD I2C 16x2. I dati vengono letti dal sensore utilizzando il protocollo one-wire tramite la libreria Adafruit DHT. Questo progetto costituisce la base per stazioni meteorologiche IoT, sistemi di automazione domestica intelligente o sistemi di monitoraggio ambientale nelle serre. La comunicazione con il DHT22 avviene tramite il pin GPIO 4 dell'ESP32.

Allarme rilevatore di gas/fumo ESP32 MQ-2
In questo progetto, il rilevamento di gas combustibili (GPL, metano, propano) e fumo viene effettuato tramite un modulo sensore di gas MQ-2; al rilevamento viene emesso un segnale acustico simile a una sirena tramite un cicalino passivo. L'uscita digitale di soglia (DO) del sensore viene collegata al GPIO 4 dell'ESP32; quando gas o fumo superano la soglia, DO passa a LOW e l'allarme si attiva. La sensibilità si regola tramite il potenziometro del modulo. Il cicalino è pilotato con tone().

Sensore porta con contatto reed
Capisci se la tua porta è aperta o chiusa guardando una luce. Metti un piccolo magnete sulla porta e sul telaio un interruttore che sente i magneti; a porta chiusa stanno vicini e si accende il LED…

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

