Ratgeber · 10 Min. Lesezeit

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.

MethodeEinrichtungKostenGeeignet für
CallMeBot (WhatsApp)API-Key per einer NachrichtIm privaten Gebrauch kostenlosEinfache Warnungen auf dein eigenes Handy
Telegram-BotToken über BotFatherKostenlosBefehle in beide Richtungen, Fotos, Gruppennachrichten
WhatsApp Business Cloud APIMeta-Geschäftskonto und genehmigte VorlageKann pro Nachricht kostenGeschäftliche Benachrichtigungen an Kunden
E-Mail (SMTP)App-Passwort nötigKostenlosAusführliche Berichte, Tageszusammenfassung

Wie bekommst du den CallMeBot-API-Key?

  1. 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.
  2. Sende diesem Kontakt in WhatsApp genau den Satz I allow callmebot to send me messages.
  3. Kurz darauf kommt eine Antwort, die mit "API Activated for your phone number" beginnt und den APIKEY-Wert enthält; notiere dir diese Zahl.
  4. 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.
  5. 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.
Der API-Key funktioniert nur zum Senden an deine eigene Nummer und sollte wie ein Passwort geschützt werden. Entferne deine Nummer und deinen Key, bevor du Code auf GitHub oder in ein Forum hochlädst; wer den Key in die Finger bekommt, kann dir beliebig viele unerwünschte Nachrichten schicken lassen, und der Dienst kann deine Nummer sperren.

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

ZeichenUTF-8-BytesKodierte Form
Leerzeichen0x20%20
+0x2B%2B
&0x26%26
ı0xC4 0xB1%C4%B1
ş0xC5 0x9F%C5%9F
ü0xC3 0xBC%C3%BC
°0xC2 0xB0%C2%B0
Zeilenumbruch0x0A%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

  1. Installiere in der Arduino IDE das ESP32-Boardpaket und wähle als Board ESP32 Dev Module.
  2. Ersetze im Code die Werte WIFI_SSID, WIFI_PASS, PHONE und API_KEY durch deine eigenen; schreibe die Nummer im Format +4915112345678.
  3. Lade den Code hoch und öffne den Seriellen Monitor mit 115200 Baud.
  4. 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.
C++ (Arduino IDE)
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-TeilAufgabe
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
setInsecure() verschlüsselt die Verbindung trotzdem, es prüft nur nicht die Identität des Servers. Für Hobby-Benachrichtigungen reicht das aus und verhindert, dass dein Code kaputtgeht, wenn das Zertifikat abläuft. Willst du mehr Sicherheit, kannst du das Root-Zertifikat des Servers mit client.setCACert() übergeben; dann musst du den Code aber aktualisieren, sobald sich das Zertifikat ändert.

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.

AnschlussESP32ESP8266 (NodeMCU)Raspberry Pi Pico W
DHT22 VCC3V33V33V3(OUT)
DHT22 DATAGPIO 4D2 (GPIO 4)GP16
DHT22 GNDGNDGNDGND
Reed Anschluss 1GPIO 27D5 (GPIO 14)GP15
Reed Anschluss 2GNDGNDGND
Die Pins GPIO 34, 35, 36 und 39 des ESP32 funktionieren nur als Eingänge und haben keine internen Pull-up-Widerstände. Schließt du den Reed-Kontakt an einen davon an und nutzt INPUT_PULLUP, schwebt der Pin und du bekommst ständig falsche "Tür geöffnet"-Meldungen. Vermeide außerdem Strapping-Pins wie GPIO 0, 2, 12 und 15 für Sensoren; das Board kann sonst beim Start im falschen Modus hochfahren.

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.

C++ (Arduino IDE)
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.

MicroPython
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

SymptomMögliche UrsacheLösung
WLAN verbindet sich gar nichtFalsches Passwort oder 5-GHz-NetzDer ESP32 verbindet sich nur mit 2,4-GHz-Netzen; prüfe SSID und Passwort
HTTP -1 oder connection refusedKein HTTPS-Client, DNS- oder InternetproblemPrüfe das Format http.begin(client, url) und die Zeile setInsecure()
HTTP 200, aber keine NachrichtFalsches Nummernformat oder langsamer DienstNutze eine Nummer mit +49 ohne führende 0; warte einige Minuten und lies den Antworttext
Antwort meldet ungültigen API-KeyFalscher oder unvollständiger KeyKopiere die Zahl aus der Aktivierungsnachricht neu; Nummer und Key müssen zum selben Konto gehören
Nachricht wird abgeschnitten& oder # im Text nicht kodiertKodiere den gesamten Text mit urlEncodeText()
Umlaute erscheinen als %C4%B1 o. Ä.Text doppelt kodiertKodiere den Text nur ein einziges Mal
ESP32 startet beim Senden neuSpannung bricht bei WLAN-Stromspitzen einNutze ein gutes USB-Kabel und eine Stromversorgung mit mindestens 500 mA
Ständig "Tür geöffnet"-NachrichtenPin ohne Pull-up oder wackeliges KabelNutze einen Pin mit Pull-up wie GPIO 27 und sichere die Verbindung
Teste die Kette bei der Fehlersuche Stück für Stück: Gib die erzeugte URL im Seriellen Monitor aus, kopiere sie und öffne sie im Browser. Kommt die Nachricht im Browser an, liegt das Problem beim ESP32 (WLAN, HTTPS-Client, Stromversorgung); kommt sie nicht an, hängt es an Nummer, Key oder Dienst. Bei WLAN-Problemen hilft ESP32 verbindet sich nicht mit dem WLAN, bei plötzlichen Resets ESP32 Brownout. Teile die URL mit deinem echten API-Key mit niemandem.

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.

Alle Projekte ansehen
ESP32-WLAN-STA-Verbindung (mit LCD-Display)
ES-25Fortgeschritten

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.

4.4(21)
38
ESP32 HTTPClient + Wetter-API (mit LCD-Display)
ES-31Fortgeschritten
Premium

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.

4.7(13)
20
ESP32 Bewegungsalarmsystem (PIR + Buzzer + LED + Telegram)
ES-41Fortgeschritten
Premium

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.

9
ESP32 DHT22 Temperatur und Luftfeuchtigkeit (mit LCD-Display)
ES-15Mittel

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.

4.8(38)
57
ESP32 MQ-2 Gas-/Rauchmelder-Alarm
ES-20Mittel

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.

4.7(29)
44
Türsensor mit Reedschalter
AR-38Anfänger
Premium

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…

4.7(34)
44
ESP32 Temperatur-Datenlogger (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Fortgeschritten
Premium

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.

4.7(7)
12