ESP32 WhatsApp Nachricht senden: Sensor-Alarm mit CallMeBot
ESP32 WhatsApp Nachricht senden mit CallMeBot: API-Key holen, URL-Kodierung, Temperatur- und Türsensor-Alarm, Sendelimit und Fehlersuche im Code.
Mit dem ESP32 eine WhatsApp-Nachricht senden ist eine der praktischsten Möglichkeiten, sofort aufs Handy informiert zu werden, wenn ein Sensor zu Hause einen Schwellwert überschreitet. Wenn die Tür aufgeht, die Kühlschranktemperatur steigt oder im Tank das Wasser knapp wird, verbindet sich der ESP32 mit dem Internet und hinterlässt mit einer einzigen HTTPS-Anfrage eine Nachricht auf deinem WhatsApp. Dafür brauchst du weder einen kostenpflichtigen Server noch eine komplizierte Authentifizierung: Der kostenlose Dienst CallMeBot leitet eingehende Web-Anfragen mit dem API-Key, den du bekommst, direkt an deine WhatsApp-Nummer weiter.
In dieser Anleitung lernst du, den API-Key zu holen, warum und wie Nachrichten mit Umlauten und Sonderzeichen eine URL-Kodierung brauchen und wie du die erste Testnachricht sendest. Danach baust du mit einem DHT22-Temperatursensor und einem Reed-Türsensor ein echtes Benachrichtigungssystem, begrenzt die Nachrichtenhäufigkeit, damit dein Handy nicht überquillt, und suchst Fehler anhand der Serverantworten. Kennst du den ESP32 noch nicht, wirf zuerst einen Blick auf Was ist der ESP32?.
Was ist CallMeBot und wie kommt die Nachricht vom ESP32 zu WhatsApp?
WhatsApp bietet für private Konten keine offene API, die Geräte direkt nutzen können. CallMeBot ist eine Brücke dazwischen: Ein Bot mit eigenem WhatsApp-Konto schickt Nachrichten an Nummern, die ihm das erlaubt haben. Vom ESP32 sendest du eine GET-Anfrage an api.callmebot.com/whatsapp.php mit deiner Telefonnummer, dem API-Key und dem Nachrichtentext; der Dienst reiht die Anfrage ein und die Nachricht erscheint nach wenigen Sekunden von der Bot-Nummer auf deinem WhatsApp. Für den ESP32 ist das also nicht mehr als das Aufrufen einer Webseite. Der Dienst ist für den privaten Gebrauch kostenlos; da er aber von einer Einzelperson betrieben wird, können sich Limits und Regeln mit der Zeit ändern. Nutze ihn deshalb bei lebenswichtigen Fällen wie Brand oder Gasleck nie als einzigen Meldeweg, sondern ergänze einen lokalen Buzzer oder einen zweiten Kanal.
| Methode | Einrichtung | Kosten | Geeignet für |
|---|---|---|---|
| CallMeBot (WhatsApp) | API-Key per einer Nachricht | Im privaten Gebrauch kostenlos | Einfache Warnungen auf dein eigenes Handy |
| Telegram-Bot | Token über BotFather | Kostenlos | Befehle in beide Richtungen, Fotos, Gruppennachrichten |
| WhatsApp Business Cloud API | Meta-Geschäftskonto und genehmigte Vorlage | Kann pro Nachricht kosten | Geschäftliche Benachrichtigungen an Kunden |
| E-Mail (SMTP) | App-Passwort nötig | Kostenlos | Ausführliche Berichte, Tageszusammenfassung |
Wie bekommst du den CallMeBot-API-Key?
- Speichere die aktuelle Bot-Nummer, die auf der WhatsApp-Seite von CallMeBot veröffentlicht ist, in den Kontakten deines Handys; die Nummer ändert sich gelegentlich, prüfe sie also immer dort und nicht in einer anderen Quelle.
- Sende diesem Kontakt in WhatsApp genau den Satz I allow callmebot to send me messages.
- Kurz darauf kommt eine Antwort, die mit "API Activated for your phone number" beginnt und den APIKEY-Wert enthält; notiere dir diese Zahl.
- Kommt keine Antwort, schick dieselbe Nachricht nicht mehrfach hintereinander; warte eine Weile (notfalls bis zum nächsten Tag) und versuche es erneut, denn bei hoher Auslastung kann sich die Aktivierung verzögern.
- Den ersten Test kannst du ganz ohne ESP32 machen: Gib eine URL im unten gezeigten Format mit deiner Nummer und deinem Key in die Adresszeile des Browsers ein; kommt die Nachricht an, ist dein Konto bereit.
Nachrichten-URL und URL-Kodierung
Die Anfrageadresse besteht aus drei Parametern: phone (Nummer mit Ländervorwahl; für Deutschland beginnt sie mit +49, die führende 0 der Nummer entfällt), apikey und text. Eine Beispielanfrage sieht so aus: api.callmebot.com/whatsapp.php?phone=%2B4915112345678&apikey=123456&text=Tuer%20offen. In URLs haben Zeichen wie Leerzeichen, &, ?, # und + eine besondere Bedeutung; ein & in deiner Nachricht schneidet zum Beispiel den Text ab und wird als neuer Parameter verstanden, ein + kann als Leerzeichen gelesen werden. Umlaute belegen in UTF-8 zwei Byte und dürfen in einer URL nicht direkt vorkommen. Die Lösung: Jedes unsichere Byte wird mit einem Prozentzeichen und zwei Hexadezimalziffern geschrieben; das nennt man URL-Kodierung (Percent-Encoding).
| Zeichen | UTF-8-Bytes | Kodierte Form |
|---|---|---|
| Leerzeichen | 0x20 | %20 |
| + | 0x2B | %2B |
| & | 0x26 | %26 |
| ı | 0xC4 0xB1 | %C4%B1 |
| ş | 0xC5 0x9F | %C5%9F |
| ü | 0xC3 0xBC | %C3%BC |
| ° | 0xC2 0xB0 | %C2%B0 |
| Zeilenumbruch | 0x0A | %0A |
In den folgenden Codes erledigt das eine kleine Funktion urlEncodeText(): Sie lässt Buchstaben, Ziffern und die Zeichen - _ . ~ unverändert und wandelt jedes andere Byte in die Form %XX um. Da die Arduino IDE Quelldateien als UTF-8 speichert, gehen Wörter wie "Temperatur" oder "Tür" mit den richtigen Bytes raus und erscheinen in WhatsApp korrekt. Möchtest du eine fertige Lösung, macht die Bibliothek UrlEncode aus dem Bibliotheksverwalter mit der Funktion urlEncode() dasselbe. Für einen Zeilenumbruch schreibst du einfach \n in den Text; die Funktion macht daraus %0A. Auch die WhatsApp-Formatierung funktioniert: Ein Wort zwischen Sternchen erscheint fett.
Erster Test: Hallo von ESP32 an WhatsApp
- Installiere in der Arduino IDE das ESP32-Boardpaket und wähle als Board ESP32 Dev Module.
- Ersetze im Code die Werte WIFI_SSID, WIFI_PASS, PHONE und API_KEY durch deine eigenen; schreibe die Nummer im Format +4915112345678.
- Lade den Code hoch und öffne den Seriellen Monitor mit 115200 Baud.
- Nach der WLAN-Verbindung solltest du im Seriellen Monitor den HTTP-Code 200 und den Antworttext von CallMeBot sehen; wenige Sekunden später kommt die Nachricht auf dein Handy.
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}| Code-Teil | Aufgabe |
|---|---|
| WiFiClientSecure + setInsecure() | Baut die HTTPS-Verbindung verschlüsselt auf, prüft aber das Serverzertifikat nicht |
| urlEncodeText() | Wandelt das + in der Nummer sowie Sonderzeichen und Umlaute in der Nachricht in die Form %XX um |
| http.begin(client, url) | Bereitet die Anfrage vor; der client-Parameter ist für HTTPS zwingend |
| http.GET() | Sendet die Anfrage; ein positiver Wert ist der HTTP-Code, ein negativer ein Verbindungsfehler |
| http.getString() | Liest den Antworttext von CallMeBot; Fehlerbeschreibungen stehen hier |
| http.end() | Schließt die Verbindung und gibt den belegten Speicher frei |
Schaltung: Temperatur- und Türsensor anschließen
Im Beispielsystem gibt es zwei Sensoren. Der DHT22 misst die Temperatur auf etwa ±0,5 °C genau und braucht nur eine Datenleitung; verwendest du den nackten Sensor, setze einen 10-kΩ-Pull-up-Widerstand zwischen Datenpin und 3,3 V, bei Modulversionen ist er schon vorhanden. Für die Tür nutzen wir einen Reed-Kontakt: Der Reed-Kontakt wird am Türrahmen, der Magnet am Türflügel befestigt. Bei geschlossener Tür schließt der Magnet den Kontakt und der Pin wird auf GND gezogen (LOW); öffnet sich die Tür, öffnet sich der Kontakt und der interne Pull-up-Widerstand setzt den Pin auf HIGH. Wie der Reed-Kontakt funktioniert, erfährst du ausführlich im Beitrag Reed-Relais. Da der Arduino Uno kein WLAN hat, stehen in der Tabelle nur Boards mit WLAN.
| Anschluss | 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 Anschluss 1 | GPIO 27 | D5 (GPIO 14) | GP15 |
| Reed Anschluss 2 | GND | GND | GND |
Benachrichtigung bei Schwellwert: Temperatur- und Türalarm
Bei einem echten Benachrichtigungssystem ist die wichtigste Frage: "Wann soll eine Nachricht gesendet werden?" Schickst du alle 5 Sekunden eine Nachricht, solange die Temperatur über 30 °C liegt, bekommst du 12 Meldungen pro Minute. Um das zu verhindern, nutzt der Code zwei Techniken. Die erste ist die Hysterese: Der Alarm löst bei 30 °C aus, wird aber erst zurückgesetzt, wenn die Temperatur auf 28 °C gefallen ist; so überschwemmt dich ein Wert, der zwischen 29,9 und 30,1 schwankt, nicht mit Benachrichtigungen. Die zweite ist eine Wartezeit (Cooldown): Zwischen zwei Nachrichten derselben Art müssen bei der Temperatur 10 Minuten und bei der Tür 1 Minute liegen. Beim Türsensor erfassen wir nicht den Dauerzustand, sondern nur den Moment des Wechsels von geschlossen auf offen. Installiere für den Code im Bibliotheksverwalter die DHT sensor library (Adafruit) samt Abhängigkeiten.
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}Weil der Code das Timing mit millis() löst, wartet loop() nie lange; nur beim Senden dauert die HTTPS-Verbindung 1–3 Sekunden. Die Prüfung MIN_GAP_MS in sendWhatsApp() lässt aus jedem Grund mindestens 15 Sekunden zwischen zwei Anfragen; ist dein API-Key falsch oder liefert der Dienst Fehler, überflutet der Code den Server nicht mit Anfragen. Ein Ereignis in dieser kurzen Pause wird nicht als Nachricht gesendet, sondern nur im Seriellen Monitor ausgegeben. Lässt sich die Temperaturmeldung nicht senden, ist das Flag tempAlarm nicht true, sodass es bei den nächsten Messungen erneut versucht wird. Den DHT22 solltest du nicht öfter als alle 2 Sekunden auslesen; hier wird er alle 5 Sekunden gelesen, und schlägt das Lesen fehl (NaN), wird ohne Nachricht nur der Fehler ausgegeben. Details zu millis statt delay findest du im Beitrag millis und delay.
Warum musst du die Nachrichtenhäufigkeit begrenzen?
CallMeBot ist ein kostenloser Dienst und kann Nummern, die in kurzer Zeit zu viele Anfragen senden, vorübergehend sperren, um Missbrauch zu verhindern. Da sich die genauen Limits mit der Zeit ändern können, ist es am sichersten, das System so zu entwerfen, dass es nie mehr als ein paar Nachrichten pro Minute schickt. Das kommt dir auch selbst zugute: Ein Handy, das ständig piept, wird irgendwann ignoriert, und ein echter Alarm geht unter. Eine gute Benachrichtigung ist selten und aussagekräftig.
- Ereignisbasiert senden: Schick eine Nachricht einmal, wenn sich der Zustand ändert (Tür geöffnet, Temperaturschwelle überschritten), und wiederhole sie nicht, solange der Zustand anhält.
- Hysterese einplanen: Wähle für Alarm- und Rücksetzschwelle mindestens 1–2 °C Abstand; bei schwankenden Werten wie der Luftfeuchtigkeit nimm einen noch größeren Abstand.
- Wartezeit pro Art: Nutze Zeiten wie 1 Minute für die Tür und 10–30 Minuten für die Temperatur.
- Sammelnachricht: Passieren in kurzer Zeit viele Ereignisse, zähle sie und melde sie in einer Nachricht wie "Tür in den letzten 10 Minuten 7-mal geöffnet".
- Tageslimit: Erlaube mit einem Zähler pro Tag höchstens zum Beispiel 50 Nachrichten; ist das Limit erreicht, schreibe nur noch in den Seriellen Monitor.
- Startnachricht begrenzen: Sendet der ESP32 bei jedem Reset eine "online"-Nachricht, kann es bei Spannungsschwankungen einen Nachrichtenregen geben; entferne sie notfalls.
Raspberry Pi Pico W mit MicroPython
Auch der Pico W mit WLAN kann denselben Dienst nutzen; das Modul urequests in MicroPython unterstützt HTTPS-Anfragen. Der folgende Code überträgt dieselbe URL-Kodierung nach Python und liest den DHT22 an GP16 und den Reed-Kontakt an GP15. In der für den Pico W gebauten MicroPython-Version ist das Modul dht bereits eingebaut, du musst also keine zusätzliche Datei kopieren. Auf dem klassischen Pico ohne WLAN läuft dieser Code nicht. Bist du neu bei MicroPython, ist MicroPython-Grundlagen ein guter Einstieg.
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)Verwendung mit dem ESP8266 (NodeMCU, Wemos D1 Mini)
Beim ESP8266 ist die Logik völlig gleich; nur die Header-Dateien ändern sich. Binde statt WiFi.h die Datei ESP8266WiFi.h und statt HTTPClient.h die Datei ESP8266HTTPClient.h ein. Die Klasse WiFiClientSecure basiert beim ESP8266 auf BearSSL und wird mit setInsecure() genauso benutzt; auch die Zeile http.begin(client, url) läuft unverändert. Da der ESP8266 deutlich weniger RAM als der ESP32 hat, belegt eine TLS-Verbindung einen großen Teil des Speichers; nutzt du ihn zusammen mit großen Bibliotheken, verringere String-Verkettungen und vergiss nicht, nach der Anfrage http.end() aufzurufen. Für die Pin-Nummern nimmst du die ESP8266-Spalte der Tabelle.
Projektideen mit WhatsApp-Benachrichtigung
- Bewegungsalarm: Schick eine Nachricht, wenn ein PIR-Sensor Bewegung erkennt, während niemand zu Hause ist.
- Gaslecksignal: Wenn der MQ-2-Gassensor den Schwellwert überschreitet, lass den Buzzer piepen und schreibe zugleich aufs WhatsApp.
- Wassermelder: Gib Bescheid, wenn ein Wasserstandssensor unter der Waschmaschine nass wird.
- Pflanzen-Gießerinnerung: Sende die Nachricht "Der Topf hat Durst", wenn der Bodenfeuchtesensor Trockenheit erkennt.
- Frostalarm: Warne, wenn die Temperatur im Gewächshaus oder auf dem Balkon unter 2 °C fällt; Details im Beitrag Frostalarm.
- Batteriebetriebener Briefkastensensor: Lass den ESP32 im Deep Sleep warten; beim Öffnen der Klappe wacht er auf, sendet eine Nachricht und schläft wieder ein.
Häufige Fehler und Fehlersuche
| Symptom | Mögliche Ursache | Lösung |
|---|---|---|
| WLAN verbindet sich gar nicht | Falsches Passwort oder 5-GHz-Netz | Der ESP32 verbindet sich nur mit 2,4-GHz-Netzen; prüfe SSID und Passwort |
| HTTP -1 oder connection refused | Kein HTTPS-Client, DNS- oder Internetproblem | Prüfe das Format http.begin(client, url) und die Zeile setInsecure() |
| HTTP 200, aber keine Nachricht | Falsches Nummernformat oder langsamer Dienst | Nutze eine Nummer mit +49 ohne führende 0; warte einige Minuten und lies den Antworttext |
| Antwort meldet ungültigen API-Key | Falscher oder unvollständiger Key | Kopiere die Zahl aus der Aktivierungsnachricht neu; Nummer und Key müssen zum selben Konto gehören |
| Nachricht wird abgeschnitten | & oder # im Text nicht kodiert | Kodiere den gesamten Text mit urlEncodeText() |
| Umlaute erscheinen als %C4%B1 o. Ä. | Text doppelt kodiert | Kodiere den Text nur ein einziges Mal |
| ESP32 startet beim Senden neu | Spannung bricht bei WLAN-Stromspitzen ein | Nutze ein gutes USB-Kabel und eine Stromversorgung mit mindestens 500 mA |
| Ständig "Tür geöffnet"-Nachrichten | Pin ohne Pull-up oder wackeliges Kabel | Nutze einen Pin mit Pull-up wie GPIO 27 und sichere die Verbindung |
Eine WhatsApp-Benachrichtigung hebt Sensorprojekte von "ich sehe es, wenn ich auf den Bildschirm schaue" auf "ich erfahre es, wo auch immer ich bin". Willst du Befehle in beide Richtungen, Fotos und Gruppennachrichten, ist ein ESP32-Telegram-Bot ein guter nächster Schritt. In der BlueGrays-App findest du Projekte wie ESP32-WLAN-Verbindung, Wetterdaten per HTTPClient, DHT22-Messung und Bewegungsalarm Schritt für Schritt mit Schaltplan und Code und kannst die WhatsApp-Funktion aus diesem Beitrag einfach dazunehmen.
Häufige Fragen
Kann man mit dem ESP32 kostenlos eine WhatsApp-Nachricht senden?
Ja. Der Dienst CallMeBot ist im privaten Gebrauch kostenlos und verlangt nur einen API-Key; der ESP32 schickt mit einer einzigen HTTPS-GET-Anfrage eine Nachricht an deine eigene Nummer. Die offizielle WhatsApp Business Cloud API braucht dagegen ein Geschäftskonto und genehmigte Vorlagen und kann pro Nachricht Kosten verursachen.
Was tun, wenn der CallMeBot-API-Key nicht ankommt?
Prüfe zuerst, ob die Bot-Nummer die aktuelle von der CallMeBot-Seite ist und du den Aktivierungssatz exakt geschrieben hast. Kommt innerhalb weniger Minuten keine Antwort, sende die Nachricht nicht mehrfach hintereinander, sondern warte eine Weile, notfalls bis zum nächsten Tag, und versuche es erneut. Bei hoher Auslastung kann sich die Aktivierung verzögern.
Kann man mit CallMeBot an eine andere Nummer schreiben?
Jeder API-Key gehört zu genau der Nummer, die die Aktivierung gemacht hat, und sendet nur an diese. Soll auch jemand aus deiner Familie Benachrichtigungen bekommen, muss diese Person den Bot ebenfalls aktivieren und ihren eigenen Key holen; der ESP32-Code kann dann zwei getrennte Anfragen senden. Für Benachrichtigungen an Gruppen ist ein Telegram-Bot die bessere Wahl.
Wie sendet man Umlaute in einer ESP32-WhatsApp-Nachricht?
Bevor du den Nachrichtentext in die URL einfügst, musst du seine UTF-8-Bytes per URL-Kodierung in die Form %XX umwandeln; ein ü geht zum Beispiel als %C3%BC raus. Die Funktion urlEncodeText() aus diesem Beitrag oder die Bibliothek UrlEncode erledigt das automatisch. Kodiere den Text nicht zweimal, sonst siehst du in WhatsApp Codes statt Buchstaben.
Was ist für ESP32-Benachrichtigungen besser: WhatsApp oder Telegram?
Willst du nur kurze Warnungen auf dein eigenes Handy senden, ist WhatsApp mit CallMeBot die schnellste Einrichtung. Möchtest du Befehle vom Handy an den ESP32 schicken, Fotos teilen oder Gruppen benachrichtigen, ist die Telegram Bot API eine offizielle, kostenlose und deutlich flexiblere Lösung.
Kann man mit dem Arduino Uno eine WhatsApp-Nachricht senden?
Der Arduino Uno hat kein WLAN und kann allein keine Nachricht senden. Man kann ihm ein WLAN-Modul wie den ESP-01 hinzufügen, aber eine HTTPS-Anfrage ist in diesem Aufbau mühsam. Am praktischsten ist es, gleich einen ESP32 oder ESP8266 zu nehmen oder die Sensordaten des Uno über die serielle Schnittstelle an einen ESP32 weiterzugeben.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
ESP32-WLAN-STA-Verbindung (mit LCD-Display)
In diesem Projekt verbinden wir den ESP32 im Station-Modus (STA) sicher und fehlertolerant mit dem heimischen WLAN. Wir lagern SSID und Passwort in eine separate secrets.h-Datei aus, um Leaks zu Git zu verhindern, richten einen Auto-Reconnect-Mechanismus ein und zeigen RSSI-Signalpegel und IP-Adresse auf einem I2C-LCD-Display an. Die interne LED dient als Statusanzeige. Ein Verbindungsmanager auf Produktionsniveau.

ESP32 HTTPClient + Wetter-API (mit LCD-Display)
Der ESP32 ruft über das Internet mit HTTPClient.h eine Wetter-API (wttr.in) per REST auf. Die JSON-Antwort wird mit ArduinoJson v7 ausgewertet; Stadt, Temperatur, Luftfeuchtigkeit, Wetterlage und Wind erscheinen auf einem I2C-LCD. wttr.in braucht keinen API-Schlüssel, du gibst einfach den Namen einer beliebigen Stadt ein.

ESP32 Bewegungsalarmsystem (PIR + Buzzer + LED + Telegram)
Eine smarte Alarmanlage: Erkennt der PIR-Sensor eine Bewegung, ertönt der Summer, die LED leuchtet und der Besitzer bekommt sofort eine Telegram-Nachricht. Eine Sperrzeit von 30 Sekunden begrenzt, wie oft der Alarm wiederholt wird; Fehlauslösungen des PIR-Sensors verhindert sie nicht. Geeignet für Haus, Garage, Lager oder Arbeitszimmer.

ESP32 DHT22 Temperatur und Luftfeuchtigkeit (mit LCD-Display)
Bei diesem Projekt werden die Umgebungstemperatur und die Luftfeuchtigkeit mit einem DHT22-Sensor gemessen und in Echtzeit auf einem 16x2 I2C-LCD angezeigt. Mithilfe der Adafruit-DHT-Bibliothek werden die Daten über das One-Wire-Protokoll vom Sensor ausgelesen. Dieses Projekt bildet die Grundlage für IoT-Wetterstationen, Smart-Home-Automatisierung oder Umgebungsüberwachungssysteme in Gewächshäusern. Die Kommunikation mit dem DHT22 erfolgt über den GPIO-4-Pin des ESP32.

ESP32 MQ-2 Gas-/Rauchmelder-Alarm
In diesem Projekt wird die Erkennung brennbarer Gase (LPG, Methan, Propan) und Rauch mit einem MQ-2-Gassensormodul durchgeführt; bei Erkennung ertönt über einen passiven Summer ein sirenenähnlicher Alarmton. Der digitale Schwellenausgang (DO) des Sensors wird an GPIO 4 des ESP32 angeschlossen; überschreiten Gas oder Rauch den Schwellenwert, geht DO auf LOW und der Alarm wird ausgelöst. Die Empfindlichkeit wird über das Potentiometer eingestellt. Der passive Summer wird mit tone() angesteuert.

Türsensor mit Reedschalter
Erkenne an einem Licht, ob deine Tür offen oder zu ist. An der Tür befestigst du einen kleinen Magneten, am Rahmen einen Schalter, der Magnete spürt; ist die Tür zu, liegen beide nebeneinander und…

ESP32 Temperatur-Datenlogger (DHT22 + DS1307 RTC + microSD + OLED)
Bau mit dem ESP32 einen zeitgesteuerten Temperatur- und Feuchtigkeitslogger! Ein DHT22 misst einmal pro Minute Temperatur und Luftfeuchtigkeit; jeder Wert landet mit einem Zeitstempel des RTC-Moduls DS1307 im CSV-Format auf einer microSD-Karte. Das OLED zeigt live und in großer Schrift die letzte Temperatur, die Luftfeuchtigkeit, den Zeitstempel und die Zahl der Einträge.
Weitere Artikel
BlueGrays-App
Diese Schaltung Schritt für Schritt auf dem Handy nachbauen
Schaltplan, Code und Teileliste auf einem Bildschirm. Über 500 Arduino-, ESP32- und Pico-Projekte zum Nachbauen.
Mit dem Handy scannen
Richte die Kamera auf den Code, dann öffnet sich der App-Store deines Handys.
oder im Store öffnen

