Lerne, wie du einen ESP32 über die Telegram Messenger-App auf deinem Handy steuerst. Mit diesem Code kannst du zum Beispiel Lichter einschalten und den Status von Sensoren oder Schaltern abfragen, indem du Nachrichten von deiner Telegram-App an einen ESP32 sendest.
Der Demo-Code zeigt dir, wie du eine LED ein- und ausschaltest und den Zustand eines an den ESP32 angeschlossenen Schalters ausliest.
Benötigte Teile
Unten findest du die benötigten Komponenten. Ich habe ein älteres ESP32-Board verwendet, das zwar veraltet ist, aber noch sehr günstig erhältlich ist. Allerdings funktioniert auch jedes andere ESP32 einwandfrei.
Du benötigst außerdem eine LED, einen 220-Ohm-Widerstand und einen Schalter oder Taster.
ESP32 lite
USB-Datenkabel
Dupont-Kabel-Set
Breadboard
Widerstands- & LED-Kit
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
Anschluss von LED und Schalter an den ESP32
Wir wollen die Telegram-App auf unserem Handy nutzen, um GPIO-Pins am ESP32 zu setzen oder auszulesen. Zur Demonstration verbinden wir eine LED und einen Schalter mit dem ESP32. Das folgende Bild zeigt die Schaltung:
Die LED ist an GPIO 33 angeschlossen und der Schalter an GPIO 14. Du kannst auch andere Pins wählen, musst dann aber die Konstanten im folgenden Code entsprechend anpassen. Das Bild unten zeigt, wie ich es auf einem Breadboard verdrahtet habe:
Telegram-Bot erstellen
Bevor du Nachrichten von der Telegram-App auf deinem Handy an einen ESP32 senden kannst, musst du einen Telegram-Bot erstellen. Falls du das noch nicht gemacht hast, erklärt das ESP32 send Telegram Message Tutorial dies ausführlich.
Am wichtigsten sind der Token des Bots, der ungefähr so aussieht: 1234567811:fakeIodw9023sjjoj982qe23dSSDCDDDSSxx, und deine User ID, die so aussieht: 7221435846. Beide Konstanten werden im Code benötigt und sind spezifisch für deinen Bot.
Bot zurücksetzen
Wenn du bereits einen Bot erstellt hast und den Chatverlauf zurücksetzen möchtest, öffne das Menü oben rechts und klicke auf Verlauf löschen:
Es öffnet sich ein Dialog, in dem du die Aktion bestätigen musst. Mein Bot heißt Marvin4, wie du im folgenden Screenshot des Dialogs sehen kannst:
Danach zeigt der Bot unten eine Start-Schaltfläche, die du anklicken kannst. Nach dem Start zeigt der Bot die verfügbaren Befehle erneut an.
Code zur Steuerung des ESP32 via Telegram
Bevor du den folgenden Code auf dem ESP32 ausführen kannst, musst du die UniversalTelegramBot Library installieren. Sie vereinfacht den Code für die Kommunikation zwischen Telegram und dem ESP32.
Um die Bibliothek zu installieren, öffne den LIBRARY MANAGER der Arduino IDE, suche nach ‚UniversalTelegramBot‘ und klicke dann auf INSTALL. Nach erfolgreicher Installation solltest du die Bibliothek so sehen:
Das folgende Arduino-Sketch zeigt dir, wie du einen ESP32 nutzt, um mit einem Telegram-Bot zu kommunizieren, der eine LED steuern und den Zustand eines Schalters per Telegram-Nachrichten auslesen kann.
#include <WiFi.h>
#include <WiFiClientSecure.h>
#include <UniversalTelegramBot.h>
const char* SSID = "xxxx";
const char* PASSWORD = "xxxx";
const String BOT_TOKEN = "xxxxxxxx:xxxxxxxxxxxxxxxxxxxx";
const String CHAT_ID = "xxxx";
const byte LED_PIN = 33;
const byte SW_PIN = 14;
const char* info =
"Commands:\n\n"
"/led_on set LED on\n"
"/led_off set LED off\n"
"/led_toggle toggle LED\n"
"/sw_state get switch state\n";
WiFiClientSecure client;
UniversalTelegramBot bot(BOT_TOKEN, client);
int getNumMessages() {
return bot.getUpdates(bot.last_message_received + 1);
}
void handleNewMessages(int numMessages) {
for (int i = 0; i < numMessages; i++) {
String chat_id = String(bot.messages[i].chat_id);
if (chat_id != CHAT_ID) continue;
String text = bot.messages[i].text;
Serial.println(text);
if (text == "/start") {
bot.sendMessage(chat_id, info, "");
}
if (text == "/led_on") {
bot.sendMessage(chat_id, "LED is ON", "");
digitalWrite(LED_PIN, HIGH);
}
if (text == "/led_off") {
bot.sendMessage(chat_id, "LED is OFF", "");
digitalWrite(LED_PIN, LOW);
}
if (text == "/led_toggle") {
bool state = digitalRead(LED_PIN);
const char* message = state ? "LED off" : "LED on";
bot.sendMessage(chat_id, message, "");
digitalWrite(LED_PIN, state ? LOW : HIGH);
}
if (text == "/sw_state") {
bool state = digitalRead(SW_PIN);
const char* message = state ? "Switch is ON" : "Switch is OFF";
bot.sendMessage(chat_id, message, "");
}
}
}
void setup() {
Serial.begin(115200);
pinMode(LED_PIN, OUTPUT);
pinMode(SW_PIN, INPUT_PULLUP);
client.setCACert(TELEGRAM_CERTIFICATE_ROOT);
WiFi.begin(SSID, PASSWORD);
while (WiFi.status() != WL_CONNECTED) delay(100);
}
void loop() {
while (int numMessages = getNumMessages()) {
handleNewMessages(numMessages);
}
delay(1000);
}
Erforderliche Bibliotheken einbinden
Die ersten Zeilen des Codes binden die notwendigen Bibliotheken ein:
#include <WiFi.h> #include <WiFiClientSecure.h> #include <UniversalTelegramBot.h>
Diese sind essenziell, damit der ESP32 sich mit dem WLAN verbindet und sicher über HTTPS mit Telegram kommuniziert.WiFi.h wird für die Verbindung zum drahtlosen Netzwerk verwendet, WiFiClientSecure.h ermöglicht sichere HTTPS-Kommunikation, und UniversalTelegramBot.h bietet eine praktische Schnittstelle zur Interaktion mit der Telegram Bot API.
Anmeldedaten und Pins definieren
Der Code definiert dann die WLAN-Zugangsdaten, den Telegram-Bot-Token und die Telegram-Chat-ID:
const char* SSID = "xxxx"; const char* PASSWORD = "xxxx"; const String BOT_TOKEN = "xxxxxxxx:xxxxxxxxxxxxxxxxxxxx"; const String CHAT_ID = "xxxx";
Ersetze diese Platzhalter durch deinen tatsächlichen WLAN-Namen und Passwort, deinen Bot-Token und die Chat-ID mit deiner User-ID.
Als Nächstes definieren wir die GPIO-Pins für die LED und den Schalter. GPIO 33 ist als Ausgang für die LED konfiguriert, und GPIO 14 wird als Eingang mit Pull-up-Widerstand für den Schalter verwendet.
const byte LED_PIN = 33; const byte SW_PIN = 14;
Der folgende String enthält eine Hilfenachricht, die angezeigt wird, wenn der /start Befehl empfangen wird. Wie du siehst, gibt es Befehle zum Ein-, Ausschalten oder Umschalten der LED und zum Abfragen des Schalters:
const char* info = "Commands:\n\n" "/led_on set LED on\n" "/led_off set LED off\n" "/led_toggle toggle LED\n" "/sw_state get switch state\n";
Bot initialisieren
Der Bot wird mit dem Token und einem sicheren Client erstellt:
WiFiClientSecure client; UniversalTelegramBot bot(BOT_TOKEN, client);
WiFiClientSecure ermöglicht dem Bot, sicher über HTTPS mit den Telegram-Servern zu kommunizieren.
Neue Nachrichten abrufen
Die getNumMessages() Funktion prüft, ob neue Nachrichten vom Bot empfangen wurden:
int getNumMessages() {
return bot.getUpdates(bot.last_message_received + 1);
}
Die bot.getUpdates() Methode holt alle Updates ab dem letzten empfangenen Nachricht, sodass Nachrichten nur einmal verarbeitet werden.
Befehle verarbeiten
Die handleNewMessages() Funktion ist zuständig für die Verarbeitung jeder neuen Nachricht. Es werden nur Nachrichten von der vordefinierten CHAT_ID verarbeitet, um unerwünschten Zugriff zu verhindern.
void handleNewMessages(int numMessages) {
for (int i = 0; i < numMessages; i++) {
String chat_id = String(bot.messages[i].chat_id);
if (chat_id != CHAT_ID) continue;
Der Bot vergleicht dann den Befehlstext und führt die entsprechenden Aktionen aus:
if (text == "/start") {
bot.sendMessage(chat_id, info, "");
}
Wenn der Nutzer /start sendet, antwortet der Bot mit der Liste der verfügbaren Befehle.
In den nächsten Codezeilen behandeln wir die verschiedenen Befehle.
if (text == "/led_on") {
bot.sendMessage(chat_id, "LED is ON", "");
digitalWrite(LED_PIN, HIGH);
}
Der /led_on Befehl schaltet die LED ein und bestätigt die Aktion per Nachricht.
if (text == "/led_off") {
bot.sendMessage(chat_id, "LED is OFF", "");
digitalWrite(LED_PIN, LOW);
}
Ebenso schaltet der /led_off Befehl die LED aus.
if (text == "/led_toggle") {
bool state = digitalRead(LED_PIN);
const char* message = state ? "LED off" : "LED on";
bot.sendMessage(chat_id, message, "");
digitalWrite(LED_PIN, state ? LOW : HIGH);
}
Der /led_toggle Befehl kombiniert im Grunde die /led_on und die /led_off Befehle. Er liest den aktuellen Zustand der LED aus und invertiert ihn. Anschließend sendet er eine Statusmeldung an den Nutzer.
if (text == "/sw_state") {
bool state = digitalRead(SW_PIN);
const char* message = state ? "Switch is ON" : "Switch is OFF";
bot.sendMessage(chat_id, message, "");
}
Schließlich liest der /sw_state Befehl den Zustand des Schalters aus und informiert den Nutzer, ob der Schalter offen (HIGH) oder gedrückt (LOW, aufgrund Pull-up als AUS interpretiert) ist.
Du kannst auf die Links in der Befehlsliste klicken, um diese Aktionen auszuführen. Der folgende Screenshot zeigt, wie ein Chat aussieht, der Befehle per Telegram an den ESP32 sendet:
Du siehst rechts die Befehle, die ich per Telegram sende, und links die Antworten des ESP32.
Setup-Funktion
In der setup() Funktion wird die serielle Kommunikation für Debugging initialisiert:
Serial.begin(115200);
Dann werden die GPIO-Pins konfiguriert:
pinMode(LED_PIN, OUTPUT); pinMode(SW_PIN, INPUT_PULLUP);
Der Schalter-Pin verwendet INPUT_PULLUP, was bedeutet, dass wir keinen externen Pull-up-Widerstand beim Anschluss des Schalters benötigen.
Das Zertifikat für Telegram wird gesetzt, um sichere HTTPS-Kommunikation zu gewährleisten:
client.setCACert(TELEGRAM_CERTIFICATE_ROOT);
Anschließend wird das WLAN in einer blockierenden Schleife verbunden:
WiFi.begin(SSID, PASSWORD); while (WiFi.status() != WL_CONNECTED) delay(100);
Das stellt sicher, dass das Gerät nicht fortfährt, bevor eine Netzwerkverbindung hergestellt ist.
Hauptschleife
Die loop() Funktion prüft ständig auf neue Nachrichten:
while (int numMessages = getNumMessages()) {
handleNewMessages(numMessages);
}
delay(1000);
Sie holt neue Telegram-Nachrichten ab, verarbeitet sie und wartet dann 1 Sekunde, bevor sie erneut prüft.
Fazit
In diesem Beitrag hast du gelernt, wie du eine LED steuerst und den Status eines Schalters ausliest, indem du Nachrichten von deiner Telegram App auf deinem Handy an einen ESP32 sendest.
Wenn dir das zu komplex ist, schau dir unser ESP32 send Telegram Message Tutorial an, das die Grundlagen des Sendens und Empfangens von Nachrichten via Telegram ausführlicher erklärt.
Wenn du Fragen hast, hinterlasse sie gerne im Kommentarbereich.
Viel Spaß beim Tüfteln ; )
