ESP32 Telegram-Bot bauen: Relais schalten & Sensorwerte aufs Handy – ohne eigene App

Warum Telegram die perfekte IoT-Fernbedienung ist

Ein ESP32-Webserver ist großartig – solange du im heimischen WLAN bist. Von unterwegs erreichst du ihn nur mit Portfreigaben oder VPN, beides mit Sicherheits- und Bastelaufwand verbunden. Der Telegram-Trick dreht die Richtung um: Nicht du verbindest dich zum ESP32, sondern der ESP32 fragt regelmäßig bei den Telegram-Servern nach, ob neue Nachrichten für ihn vorliegen (Polling). Ausgehende Verbindungen erlaubt jeder Router – es funktioniert also im Heimnetz, im Uni-WLAN und am Handy-Hotspot, komplett ohne Netzwerk-Konfiguration.

• Keine eigene App nötig: Telegram hast du (oder deine Familie) vermutlich eh auf dem Handy
• Beide Richtungen: Befehle an den ESP32 senden und Alarme vom ESP32 empfangen
• Kostenlos: Die Telegram-Bot-API ist gratis und ohne Limits für Hobby-Projekte
• Verschlüsselt: Die Verbindung läuft über HTTPS/TLS

Das brauchst du

Verkabelung

1Bot anlegen beim BotFather

Telegram-Bots werden – sehr passend – vom BotFather verwaltet, einem offiziellen Telegram-Bot. So bekommst du in zwei Minuten deinen eigenen:

1. Öffne Telegram und suche nach @BotFather (blauer Haken = der echte)
2. Sende /newbot und folge dem Dialog: erst ein Anzeigename (z. B. „Bastelkeller Bot"), dann ein Benutzername, der auf bot enden muss (z. B. bastelkeller_42_bot)
3. Der BotFather antwortet mit deinem Bot-Token – einer langen Zeichenkette wie 7123456789:AAH3xF.... Das ist der Generalschlüssel zu deinem Bot: kopieren und geheim halten!
4. Jetzt fehlt noch deine Chat-ID: Suche den Bot @userinfobot, sende ihm eine beliebige Nachricht – er antwortet mit deiner numerischen ID (z. B. 123456789)
5. Wichtig: Öffne den Chat mit deinem neuen Bot und sende einmal /start – erst danach darf der Bot dir Nachrichten schicken

2Erster Test: Der ESP32 meldet sich bei dir

Installiere im Bibliotheksverwalter der Arduino IDE die Bibliotheken UniversalTelegramBot (von Brian Lough) und ArduinoJson. Dieser Minimal-Sketch verbindet sich mit dem WLAN und schickt dir eine Startnachricht aufs Handy:

#include <WiFi.h>
#include <WiFiClientSecure.h>
#include <UniversalTelegramBot.h>

const char* WLAN_NAME     = "DeinWLAN";
const char* WLAN_PASSWORT = "DeinPasswort";
const char* BOT_TOKEN     = "7123456789:AAH3xF...";  // vom BotFather
const char* CHAT_ID       = "123456789";             // deine Chat-ID

WiFiClientSecure client;
UniversalTelegramBot bot(BOT_TOKEN, client);

void setup() {
  Serial.begin(115200);

  WiFi.mode(WIFI_STA);
  WiFi.begin(WLAN_NAME, WLAN_PASSWORT);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("\nWLAN verbunden!");

  // Telegram-Root-Zertifikat setzen - noetig fuer die TLS-Verbindung
  client.setCACert(TELEGRAM_CERTIFICATE_ROOT);

  bot.sendMessage(CHAT_ID, "ESP32 ist online und hoert auf deine Befehle!", "");
}

void loop() {}

Wenn nach dem Upload die Nachricht auf deinem Handy aufploppt, steht die Verbindung – der spannendste Moment des Projekts. Kommt nichts an, hilft der Troubleshooting-Abschnitt unten.

3Befehle empfangen: Relais per Chat schalten

Jetzt die Rückrichtung: Der ESP32 fragt alle Sekunde bei Telegram nach neuen Nachrichten und reagiert auf Befehle. Der Sketch versteht /an, /aus und /status – und ignoriert Nachrichten von Fremden:

#include <WiFi.h>
#include <WiFiClientSecure.h>
#include <UniversalTelegramBot.h>

const char* WLAN_NAME     = "DeinWLAN";
const char* WLAN_PASSWORT = "DeinPasswort";
const char* BOT_TOKEN     = "7123456789:AAH3xF...";
const char* CHAT_ID       = "123456789";

const int RELAIS = 26;

WiFiClientSecure client;
UniversalTelegramBot bot(BOT_TOKEN, client);

unsigned long letzteAbfrage = 0;
const unsigned long ABFRAGE_INTERVALL = 1000;   // alle 1000 ms nachsehen

void verarbeiteNachrichten(int anzahl) {
  for (int i = 0; i < anzahl; i++) {
    String absender = bot.messages[i].chat_id;
    String text     = bot.messages[i].text;

    // Sicherheits-Check: nur DEINE Chat-ID darf steuern
    if (absender != CHAT_ID) {
      bot.sendMessage(absender, "Keine Berechtigung.", "");
      continue;
    }

    if (text == "/start") {
      String hilfe = "Befehle:\n";
      hilfe += "/an - Relais einschalten\n";
      hilfe += "/aus - Relais ausschalten\n";
      hilfe += "/status - aktueller Zustand";
      bot.sendMessage(CHAT_ID, hilfe, "");
    }
    else if (text == "/an") {
      digitalWrite(RELAIS, HIGH);
      bot.sendMessage(CHAT_ID, "Relais ist AN", "");
    }
    else if (text == "/aus") {
      digitalWrite(RELAIS, LOW);
      bot.sendMessage(CHAT_ID, "Relais ist AUS", "");
    }
    else if (text == "/status") {
      bool an = digitalRead(RELAIS);
      bot.sendMessage(CHAT_ID, an ? "Relais laeuft (AN)" : "Relais ist AUS", "");
    }
  }
}

void setup() {
  Serial.begin(115200);
  pinMode(RELAIS, OUTPUT);
  digitalWrite(RELAIS, LOW);

  WiFi.mode(WIFI_STA);
  WiFi.begin(WLAN_NAME, WLAN_PASSWORT);
  while (WiFi.status() != WL_CONNECTED) delay(500);

  client.setCACert(TELEGRAM_CERTIFICATE_ROOT);
  bot.sendMessage(CHAT_ID, "Relais-Bot bereit! /start fuer Hilfe", "");
}

void loop() {
  // nicht-blockierend: alle 1000 ms bei Telegram nachfragen
  if (millis() - letzteAbfrage >= ABFRAGE_INTERVALL) {
    letzteAbfrage = millis();
    int anzahl = bot.getUpdates(bot.last_message_received + 1);
    while (anzahl) {
      verarbeiteNachrichten(anzahl);
      anzahl = bot.getUpdates(bot.last_message_received + 1);
    }
  }
}

4Sensorwerte abfragen & automatischer Temperatur-Alarm

Zum Abschluss das Komplettpaket: Auf /temperatur antwortet der Bot mit den aktuellen DHT22-Werten – und überschreitet die Temperatur einen Grenzwert, schlägt der ESP32 von selbst Alarm (aber nur einmal pro Grenzwert-Überschreitung, nicht im Sekundentakt):

#include <WiFi.h>
#include <WiFiClientSecure.h>
#include <UniversalTelegramBot.h>
#include <DHT.h>

const char* WLAN_NAME     = "DeinWLAN";
const char* WLAN_PASSWORT = "DeinPasswort";
const char* BOT_TOKEN     = "7123456789:AAH3xF...";
const char* CHAT_ID       = "123456789";

#define DHT_PIN  4
#define DHT_TYP  DHT22
DHT dht(DHT_PIN, DHT_TYP);

const float ALARM_GRENZE = 30.0;   // Grad Celsius
bool alarmAktiv = false;           // merkt sich, ob schon gewarnt wurde

WiFiClientSecure client;
UniversalTelegramBot bot(BOT_TOKEN, client);

unsigned long letzteAbfrage = 0;
unsigned long letzteMessung = 0;

void verarbeiteNachrichten(int anzahl) {
  for (int i = 0; i < anzahl; i++) {
    if (bot.messages[i].chat_id != CHAT_ID) continue;
    String text = bot.messages[i].text;

    if (text == "/temperatur") {
      float t = dht.readTemperature();
      float h = dht.readHumidity();
      if (isnan(t) || isnan(h)) {
        bot.sendMessage(CHAT_ID, "Sensorfehler - bitte Verkabelung pruefen.", "");
      } else {
        String antwort = "Aktuell: " + String(t, 1) + " Grad, ";
        antwort += String(h, 0) + " % Luftfeuchte";
        bot.sendMessage(CHAT_ID, antwort, "");
      }
    }
  }
}

void setup() {
  Serial.begin(115200);
  dht.begin();

  WiFi.mode(WIFI_STA);
  WiFi.begin(WLAN_NAME, WLAN_PASSWORT);
  while (WiFi.status() != WL_CONNECTED) delay(500);

  client.setCACert(TELEGRAM_CERTIFICATE_ROOT);
  bot.sendMessage(CHAT_ID, "Temperatur-Waechter aktiv! /temperatur fuer Werte", "");
}

void loop() {
  // Aufgabe 1: alle Sekunde Telegram-Befehle abholen
  if (millis() - letzteAbfrage >= 1000) {
    letzteAbfrage = millis();
    int anzahl = bot.getUpdates(bot.last_message_received + 1);
    while (anzahl) {
      verarbeiteNachrichten(anzahl);
      anzahl = bot.getUpdates(bot.last_message_received + 1);
    }
  }

  // Aufgabe 2: alle 30 Sekunden messen und ggf. Alarm ausloesen
  if (millis() - letzteMessung >= 30000) {
    letzteMessung = millis();
    float t = dht.readTemperature();
    if (isnan(t)) return;

    if (t > ALARM_GRENZE && !alarmAktiv) {
      alarmAktiv = true;   // nur EINMAL warnen
      bot.sendMessage(CHAT_ID,
        "ALARM: " + String(t, 1) + " Grad - Grenzwert ueberschritten!", "");
    }
    if (t < ALARM_GRENZE - 2.0 && alarmAktiv) {
      alarmAktiv = false;  // 2 Grad Hysterese gegen Alarm-Pingpong
      bot.sendMessage(CHAT_ID,
        "Entwarnung: " + String(t, 1) + " Grad - wieder im gruenen Bereich.", "");
    }
  }
}

Die Hysterese (Entwarnung erst 2 Grad unter der Alarmgrenze) verhindert, dass der Bot dich bei 29,9–30,1 Grad mit Alarm/Entwarnung im Minutentakt bombardiert – ein kleiner Kniff mit großer Wirkung. Mehr zum DHT22 und seinen Eigenheiten steht im ESP32-Wetterstations-Tutorial.

Ideen zum Weiterbauen

Troubleshooting