ESP32 Blynk Anleitung: LED, Relais und Sensor per Handy steuern

ESP32 und Blynk sind der schnellste Weg, einen ESP32 von überall auf der Welt zu steuern, ohne eine eigene Handy-App zu programmieren. Blynk IoT bietet dir einen Cloud-Server, mit dem sich der ESP32 verbindet (Blynk.Cloud), eine Handy-App, in der du per Drag and Drop ein Dashboard baust, und ein Web-Dashboard. Tippst du auf dem Handy auf einen Schalter, geht der Befehl zuerst in die Cloud und von dort zum ESP32; die Temperatur, die der ESP32 misst, kommt auf demselben Weg als Zahl und Diagramm auf dein Handy. Handy und Board müssen dafür nicht im selben Haus sein: Es funktioniert sogar, wenn dein Handy im Mobilfunknetz ist.

In dieser Anleitung baust du von Grund auf ein funktionierendes Projekt: Du legst ein Blynk.Cloud-Konto an, definierst eine Vorlage (Template) und Datastreams (V0, V1, V2, V3), holst dir den Auth Token des Geräts, installierst die Bibliothek, schaltest eine LED und ein Relais per Handy, zeigst die Daten eines DHT11 als Diagramm an und bekommst eine Benachrichtigung aufs Handy, wenn die Temperatur steigt. Außerdem lernst du, warum du kein delay() verwenden solltest und was BlynkTimer stattdessen macht, wie du das Nachrichtenlimit des Gratis-Tarifs berechnest, warum Code aus dem alten Blynk nicht mehr kompiliert und wie du die häufigsten Verbindungsfehler behebst.

Was ist Blynk IoT und wie funktioniert es?

Bei Blynk verbinden sich ESP32 und Handy nie direkt miteinander; beide verbinden sich mit Blynk.Cloud, und der Server überträgt die Nachrichten. Beim Start meldet sich der ESP32 zuerst im WLAN an, verbindet sich dann mit dem Blynk-Server und weist sich mit seinem Auth Token aus. Die Daten fließen über virtuelle Pins (Virtual Pins, V0–V255): Ein virtueller Pin ist kein echter Anschluss des ESP32, sondern ein nummerierter Datenkanal zwischen deinem Code und der App. Der Schalter in der App schreibt eine 1 auf V1, die Funktion BLYNK_WRITE(V1) in deinem Code fängt sie ab und zieht das Relais an; führt dein Code Blynk.virtualWrite(V2, 24.5) aus, aktualisiert sich die Anzeige auf dem Handy. Das sind die Grundbegriffe:

Unterschiede zwischen dem alten Blynk und dem neuen Blynk IoT

Die meisten Blynk-Videos und -Sketches im Netz wurden für die alte Version (Blynk Legacy) gemacht, die nicht mehr funktioniert. Die neue Plattform startete im Mai 2021; die alte App verschwand im Juni 2022 aus den Stores, und die alten Cloud-Server wurden am 31. Dezember 2022 endgültig abgeschaltet. Ein Token aus einem alten Projekt, gekaufte Energy-Punkte oder die Adresse blynk-cloud.com sind heute also nutzlos; du musst das Projekt auf der neuen Plattform neu anlegen. Die gute Nachricht: Der Großteil des ESP32-Codes (BLYNK_WRITE, virtualWrite, BlynkTimer) ist gleich geblieben.

Bauteile und Verkabelung

Für dieses Projekt brauchst du ein ESP32-Entwicklungsboard, ein 5-V-Relaismodul, einen DHT11-Temperatur- und Feuchtigkeitssensor, optional eine LED mit 220-Ω-Widerstand, ein Breadboard und Jumperkabel. Als LED reicht die eingebaute blaue LED an GPIO 2; für eine externe LED findest du den passenden Widerstand mit dem LED-Vorwiderstandsrechner. Prüfe außerdem die Pinbelegung deines Boards im Tool Pinout; auf manchen Boards heißt der 5-V-Pin VIN, auf anderen 5V.

Schritt 1: Blynk.Cloud-Konto und Vorlage anlegen

1. Öffne am Computer blynk.cloud, registriere dich kostenlos mit deiner E-Mail-Adresse und lege dein Passwort über den Link in der E-Mail fest.
2. Gehe im linken Menü zu Developer Zone > My Templates und klicke auf + New Template.
3. Gib der Vorlage einen Namen (zum Beispiel ESP32 Zuhause), wähle ESP32 als Hardware und WiFi als Verbindungsart und erstelle die Vorlage.
4. Die Werte BLYNK_TEMPLATE_ID und BLYNK_TEMPLATE_NAME auf der Vorlagenseite kommen später in deinen Code; merk dir jetzt nur, wo sie stehen.
5. Falls bei der Registrierung ein Quickstart-Assistent erscheint, kannst du ihn überspringen; in dieser Anleitung erledigen wir jeden Schritt von Hand, damit du siehst, wofür jede Einstellung gut ist.

Schritt 2: Datastreams anlegen (V0, V1, V2, V3)

Ein Datastream ist der Steckbrief eines virtuellen Pins: Er legt fest, welcher Pin es ist, den Datentyp (Integer für ganze Zahlen, Double für Kommazahlen, String für Text), den kleinsten und größten Wert, die Einheit und die Zahl der angezeigten Nachkommastellen. Öffne die Vorlage im Bearbeitungsmodus, wähle im Tab Datastreams den Weg + New Datastream > Virtual Pin und lege diese vier Kanäle an:

Schritt 3: Gerät anlegen und Auth Token holen

Die Vorlage ist das Rezept, das Gerät ist das echte Board, das danach gebaut wird. Öffne im linken Menü Devices, klicke auf + New Device, wähle über From template die Vorlage ESP32 Zuhause und gib dem Gerät einen Namen. Danach erscheint eine dreizeilige Konfiguration: BLYNK_TEMPLATE_ID, BLYNK_TEMPLATE_NAME und BLYNK_AUTH_TOKEN. Kopiere diese Zeilen; du findest sie später auch im Bereich Device Info der Geräteseite (in manchen Versionen der Oberfläche heißt er Developer Tools).

Schritt 4: Blynk-Bibliothek in der Arduino IDE installieren

1. Falls das ESP32-Boardpaket in der Arduino IDE noch fehlt, installiere es zuerst; die Schritte stehen in Was ist der ESP32?
2. Öffne den Bibliotheksverwalter, tippe Blynk ins Suchfeld und installiere die offizielle Bibliothek Blynk von Volodymyr Shymanskyy. Werden Abhängigkeiten abgefragt, wähle Install all.
3. Installiere für den Sensor an derselben Stelle die DHT sensor library von Adafruit und die dafür nötige Adafruit Unified Sensor. Bei Problemen hilft die Anleitung Arduino-Bibliothek hinzufügen.
4. Wähle unter Werkzeuge > Board das ESP32 Dev Module, schließe das Board mit einem datenfähigen USB-Kabel an und wähle den richtigen Port.
5. Die Bibliothek bringt fertige Beispiele mit: Datei > Beispiele > Blynk > Boards_WiFi > ESP32_WiFi ist die einfachste Form des ersten Sketches unten.

Erster Sketch: LED per Handy ein- und ausschalten (V0)

Ersetze im Code unten die drei obersten Zeilen durch die, die du von deiner Geräteseite kopiert hast, und WLAN-Name und Passwort durch deine eigenen Daten. Diese drei #define-Zeilen müssen unbedingt vor den #include-Zeilen stehen; die Bibliothek sucht beim Kompilieren nach diesen Werten und bricht mit einem Fehler ab, wenn sie sie nicht findet.

1// Bu üç satırı Blynk.Console'daki cihaz sayfasından kopyala / copy these three lines from the device page in Blynk.Console
2#define BLYNK_TEMPLATE_ID   "TMPLxxxxxxxx"
3#define BLYNK_TEMPLATE_NAME "ESP32 Ev"
4#define BLYNK_AUTH_TOKEN    "CihazTokeniniBurayaYapistir"
5
6#define BLYNK_PRINT Serial          // bağlantı günlüğünü Seri Monitör'e yaz / print the connection log to the Serial Monitor
7
8#include <WiFi.h>
9#include <WiFiClient.h>
10#include <BlynkSimpleEsp32.h>
11
12char ssid[] = "AgAdi";              // Wi-Fi adın (yalnız 2,4 GHz) / your Wi-Fi name (2.4 GHz only)
13char pass[] = "Sifre123";           // Wi-Fi şifren / your Wi-Fi password
14
15const int LED_PIN = 2;              // çoğu DevKit'te dahili LED / onboard LED on most DevKits
16
17// Uygulama V0'a her değer yazdığında çalışır / runs every time the app writes a value to V0
18BLYNK_WRITE(V0) {
19  int deger = param.asInt();        // anahtar: 0 ya da 1 / switch: 0 or 1
20  digitalWrite(LED_PIN, deger);
21  Serial.print("V0 = ");
22  Serial.println(deger);
23}
24
25// Buluta her bağlanışta son V0 değerini iste / ask for the last V0 value on every connection
26BLYNK_CONNECTED() {
27  Blynk.syncVirtual(V0);
28}
29
30void setup() {
31  Serial.begin(115200);
32  pinMode(LED_PIN, OUTPUT);
33  Blynk.begin(BLYNK_AUTH_TOKEN, ssid, pass);   // Wi-Fi'ye ve Blynk.Cloud'a bağlan / connect to Wi-Fi and Blynk.Cloud
34}
35
36void loop() {
37  Blynk.run();                      // gelen komutları işler, bağlantıyı canlı tutar / handles commands, keeps the link alive
38}

Lädst du den Code hoch und öffnest den seriellen Monitor mit 115200 Baud, solltest du nacheinander Zeilen wie "Connecting to AgAdi", "Connected to WiFi", die IP-Adresse, "Connecting to blynk.cloud:80" und zum Schluss "Ready (ping: 45ms)." sehen. Sobald die Ready-Zeile kommt, erscheint das Gerät in Blynk.Console als Online. Bei der ersten Verbindung siehst du eventuell auch eine Zeile, die mit "Redirecting to" beginnt; die Bibliothek wechselt automatisch auf den regionalen Server deines Kontos, das ist normal.

Handy- und Web-Dashboard einrichten

Der Code steht, jetzt platzieren wir die Schalter. Bei Blynk werden das mobile Dashboard und das Web-Dashboard getrennt gestaltet; da beide dieselben Datastreams nutzen, siehst du eine Änderung in einem sofort auch im anderen.

1. Installiere die App Blynk IoT auf deinem Handy (nicht das alte Blynk oder Blynk Legacy) und melde dich mit demselben Konto an.
2. Aktiviere auf deiner Profilseite den Developer Mode und tippe dann in der Developer Zone auf die Vorlage ESP32 Zuhause.
3. Tippe auf die leere Fläche, um Widgets hinzuzufügen: je einen Button oder Switch für V0 und V1, eine Gauge oder Labeled Value für V2 und V3 und ein SuperChart für den Verlauf.
4. Tippe jedes Widget an und wähle in seinen Einstellungen den passenden Datastream; dem SuperChart kannst du V2 und V3 gemeinsam zuweisen. Änderungen werden automatisch gespeichert.
5. Für das Web-Dashboard bearbeitest du die Vorlage in Blynk.Console, ziehst im Tab Web Dashboard Widgets auf die Fläche, wählst über das Zahnrad jedes Widgets den Datastream und speicherst mit Save.
6. Tippe in der App auf den Namen deines Geräts und probiere den Schalter aus: Die LED an GPIO 2 sollte sofort leuchten, und im seriellen Monitor sollte "V0 = 1" erscheinen.

Relais und Sensor: Messen ohne delay() mit BlynkTimer

Die goldene Regel bei Blynk lautet: In loop() stehen nur Blynk.run() und timer.run(). Packst du delay(2000) in loop, sieht der ESP32 während dieser Zeit keine Befehle vom Handy, und der Schalter reagiert verzögert; sehr lange Wartezeiten führen dazu, dass der Server das Gerät als offline einstuft. Noch schlimmer: Schreibst du Blynk.virtualWrite() direkt in loop, versucht der ESP32, Hunderte Nachrichten pro Sekunde zu senden; der Server drosselt das Gerät, und dein monatliches Nachrichtenkontingent ist schnell aufgebraucht. Die Lösung ist BlynkTimer, der nach dem millis()-Prinzip arbeitet: Er ruft die Funktion deiner Wahl im gewünschten Abstand auf, und loop bleibt dazwischen frei. Das Prinzip erklären wir ausführlich in Arduino millis() und delay().

Der folgende Code schaltet das Relais über V1, sendet alle 60 Sekunden die vom DHT11 gemessene Temperatur an V2 und die Luftfeuchtigkeit an V3 und löst ein Benachrichtigungs-Event aus, sobald die Temperatur über 30 °C steigt. Wie der Sensor funktioniert, liest du in DHT11 Temperatur- und Feuchtigkeitssensor.

1#define BLYNK_TEMPLATE_ID   "TMPLxxxxxxxx"
2#define BLYNK_TEMPLATE_NAME "ESP32 Ev"
3#define BLYNK_AUTH_TOKEN    "CihazTokeniniBurayaYapistir"
4#define BLYNK_PRINT Serial
5
6#include <WiFi.h>
7#include <WiFiClient.h>
8#include <BlynkSimpleEsp32.h>
9#include <DHT.h>
10
11char ssid[] = "AgAdi";
12char pass[] = "Sifre123";
13
14const int ROLE_PIN = 26;            // röle modülünün IN pini / relay module IN pin
15const int DHT_PIN  = 4;             // DHT11 veri pini / DHT11 data pin
16const bool ROLE_AKTIF_LOW = true;   // çoğu modül LOW'da çeker / most modules switch on with LOW
17
18DHT dht(DHT_PIN, DHT11);            // DHT22 kullanıyorsan DHT22 yaz / write DHT22 if you use a DHT22
19BlynkTimer timer;                   // delay() yerine zamanlayıcı / a timer instead of delay()
20bool alarmGitti = false;            // aynı bildirimin tekrarını önler / stops the same alert repeating
21
22void roleYaz(bool acik) {
23  if (ROLE_AKTIF_LOW) digitalWrite(ROLE_PIN, acik ? LOW : HIGH);
24  else                digitalWrite(ROLE_PIN, acik ? HIGH : LOW);
25}
26
27// V1: uygulamadaki röle anahtarı / relay switch in the app
28BLYNK_WRITE(V1) {
29  roleYaz(param.asInt() == 1);
30}
31
32// Elektrik gidip gelince rölenin son durumunu geri al / restore the relay state after a power cut
33BLYNK_CONNECTED() {
34  Blynk.syncVirtual(V1);
35}
36
37// Zamanlayıcının çağırdığı fonksiyon / the function called by the timer
38void sensorGonder() {
39  float sicaklik = dht.readTemperature();
40  float nem = dht.readHumidity();
41  if (isnan(sicaklik) || isnan(nem)) {
42    Serial.println("DHT okunamadi / DHT read failed");
43    return;
44  }
45  Blynk.virtualWrite(V2, sicaklik);   // V2: sıcaklık (°C) / temperature (°C)
46  Blynk.virtualWrite(V3, nem);        // V3: nem (%) / humidity (%)
47
48  // 30 °C'yi geçince tek bildirim, 28 °C'nin altında yeniden kur / one alert above 30 °C, re-arm below 28 °C
49  if (sicaklik > 30.0 && !alarmGitti) {
50    Blynk.logEvent("yuksek_sicaklik", String("Sicaklik / Temp: ") + sicaklik + " C");
51    alarmGitti = true;
52  } else if (sicaklik < 28.0) {
53    alarmGitti = false;
54  }
55}
56
57void setup() {
58  Serial.begin(115200);
59  pinMode(ROLE_PIN, OUTPUT);
60  roleYaz(false);                   // açılışta röle kapalı / relay off at boot
61  dht.begin();
62  Blynk.begin(BLYNK_AUTH_TOKEN, ssid, pass);
63  timer.setInterval(60000L, sensorGonder);   // 60 saniyede bir ölç ve gönder / measure and send every 60 seconds
64}
65
66void loop() {
67  Blynk.run();
68  timer.run();                      // loop'ta delay() ya da virtualWrite olmasın / no delay() or virtualWrite in loop
69}

Die Zeile timer.setInterval(60000L, sensorGonder) ruft die Funktion alle 60.000 Millisekunden auf; das L am Ende kennzeichnet die Zahl als long. Für einmalige Aufgaben gibt es timer.setTimeout(), etwa um das Relais einzuschalten und nach 5 Sekunden wieder auszuschalten. Ein BlynkTimer-Objekt verwaltet bis zu 16 Timer, was für die meisten Projekte mehr als genug ist. Die Prüfung mit isnan() verhindert, dass ein sinnloser NaN-Wert in die Cloud geht, wenn der Sensor nicht gelesen werden kann. Das Flag alarmGitti und der Abstand zwischen den Schwellen 30 und 28 °C (Hysterese) sorgen dafür, dass nicht bei jeder Messung eine neue Benachrichtigung kommt, während die Temperatur um 30 °C pendelt.

Sensordaten als Diagramm anzeigen

Damit sich das Diagramm füllt, braucht es zwei Dinge: Der ESP32 muss mit virtualWrite Daten senden, und der Datastream muss einen Verlauf speichern. Ist in den Datastream-Einstellungen beim Verlauf (History) Last Value gewählt, speichert der Server nur den letzten Wert, und es wird kein Diagramm gezeichnet; der Minutenmittelwert (1 Minute AVG) reicht für Diagramme aus. Im Gratis-Tarif bleibt der Verlauf 1 Woche erhalten, das Speichern von Rohdaten (RAW) ist kostenpflichtigen Tarifen vorbehalten. Im SuperChart wechselst du zwischen Zeiträumen wie Stunden, Tagen und Wochen und siehst Temperatur und Feuchte in zwei Farben im selben Diagramm. Weil alle 60 Sekunden Daten kommen, dauert es ein paar Minuten, bis die ersten Punkte erscheinen; setz das Intervall nicht ungeduldig auf 1 Sekunde, warum, siehst du im Abschnitt zum Gratis-Tarif.

Benachrichtigungen senden: Events und Blynk.logEvent()

Im neuen Blynk laufen Benachrichtigungen über Events. Du legst das Event zuerst in der Vorlage an und löst es dann im Code mit Blynk.logEvent() aus; Blynk trägt das Event in die Timeline des Geräts ein und schickt je nach Einstellung eine Push-Benachrichtigung oder eine E-Mail an dein Handy. Eine Event-Beschreibung darf bis zu 300 Zeichen lang sein, da der Sendepuffer der Bibliothek aber klein ist, hältst du sie besser kurz.

1. Öffne die Vorlage im Bearbeitungsmodus und wechsle zum Tab Events & Notifications.
2. Klicke auf + Create Event, gib dem Event einen Namen wie "Hohe Temperatur" und setze den Event-Code auf yuksek_sicaklik. Der Code darf nur Buchstaben, Ziffern und Unterstriche enthalten und muss exakt dem Text im Sketch entsprechen.
3. Wähle als Event-Typ Warning; Info, Warning und Critical geben an, wie ernst die Meldung ist. Achte darauf, dass die Timeline-Option aktiv ist, damit das Event in der App erscheint.
4. Schalte im Tab Notifications die Benachrichtigungen ein, wähle dein eigenes Konto als Empfänger und Push sowie E-Mail als Kanäle; auf Wunsch begrenzt du die Benachrichtigungen auf eine pro Stunde.
5. Speichere die Vorlage mit Save und bestätige die Aktualisierung des Geräts. Vergiss nicht, der Blynk-IoT-App auf dem Handy Benachrichtigungen zu erlauben.

Limits im Gratis-Tarif: So rechnest du die Nachrichten aus

Der kostenlose Tarif von Blynk reicht zum Lernen und für kleine Projekte, aber ein Projekt, das ohne Kenntnis der Limits gebaut wird, kann mitten im Monat verstummen. Stand Oktober 2026 nennt die Preisseite von Blynk für den Gratis-Tarif diese Werte: 5 Geräte, 1 Nutzer, 100.000 Gerätenachrichten pro Monat, 1 Woche Datenverlauf, 10 Vorlagen, 5 Events pro Vorlage, 1 Webhook und 5 Automationen. Diese Limits haben sich in den letzten Jahren mehrmals geändert; prüfe vor einem Langzeitprojekt die aktuellen Werte auf der Preisseite von Blynk oder in den Tarifeinstellungen deines Kontos. Am stärksten zählen die Befehle virtualWrite, syncVirtual und logEvent, die dein Gerät sendet, und jedes einzelne virtualWrite ist eine Nachricht. Ein Monat hat rund 2.592.000 Sekunden, also ist die Rechnung einfach:

Eine Verbindung, die ohne WLAN nicht hängen bleibt

Blynk.begin() ist bequem, hat aber einen Nachteil: Kommt keine WLAN- oder Blynk-Verbindung zustande, wartet es in setup() ewig, und der Rest des Programms läuft nie. Bei Projekten, die auch ohne Internet weiterarbeiten müssen, etwa ein Thermostat oder eine Bewässerung, solltest du die Verbindung selbst verwalten. Das Grundgerüst unten startet das WLAN ohne zu warten, übernimmt mit Blynk.config() nur die Einstellungen und prüft die Verbindung alle 10 Sekunden; die lokalen Aufgaben, die du dem Timer hinzufügst, laufen in der Zwischenzeit unabhängig vom Internet weiter.

1#define BLYNK_TEMPLATE_ID   "TMPLxxxxxxxx"
2#define BLYNK_TEMPLATE_NAME "ESP32 Ev"
3#define BLYNK_AUTH_TOKEN    "CihazTokeniniBurayaYapistir"
4#define BLYNK_PRINT Serial
5
6#include <WiFi.h>
7#include <WiFiClient.h>
8#include <BlynkSimpleEsp32.h>
9
10char ssid[] = "AgAdi";
11char pass[] = "Sifre123";
12
13BlynkTimer timer;
14
15// Wi-Fi varsa ama Blynk bağlı değilse yeniden dene / retry Blynk when Wi-Fi is up but Blynk is not
16void baglantiKontrol() {
17  if (WiFi.status() == WL_CONNECTED && !Blynk.connected()) {
18    Serial.println("Blynk'e yeniden baglaniliyor / reconnecting to Blynk");
19    Blynk.connect(3000);            // en fazla 3 saniye bekle / wait at most 3 seconds
20  }
21}
22
23void setup() {
24  Serial.begin(115200);
25  WiFi.mode(WIFI_STA);
26  WiFi.begin(ssid, pass);           // beklemeden başlat / start without waiting
27  Blynk.config(BLYNK_AUTH_TOKEN);   // yalnız ayarla, bağlanmayı bekleme / configure only, don't block
28  timer.setInterval(10000L, baglantiKontrol);   // 10 saniyede bir kontrol / check every 10 seconds
29}
30
31void loop() {
32  if (Blynk.connected()) {
33    Blynk.run();
34  }
35  timer.run();                      // yerel işler internet yokken de çalışır / local tasks keep running offline
36}

Der ESP32 versucht nach einem Verbindungsabbruch selbstständig, sich wieder mit dem WLAN zu verbinden; der Code verbindet sich erst dann neu mit Blynk, wenn das WLAN wieder da ist. Möchtest du deine Daten verschlüsselt übertragen, bindest du statt BlynkSimpleEsp32.h einfach BlynkSimpleEsp32_SSL.h ein; die Verbindung läuft dann per TLS über Port 443 statt 80 und kommt auch an Portsperren in manchen Schul- oder Firmennetzen vorbei. Willst du die WLAN-Daten nicht fest in den Code schreiben, kannst du mit dem Beispiel Blynk.Edgent > Edgent_ESP32 Netzwerkname und Passwort in der Blynk-IoT-App auf dem Handy eingeben; dabei wird der Auth Token beim Hinzufügen des Geräts automatisch vergeben, und der Code lässt sich drahtlos (OTA) aktualisieren. Derselbe Code läuft auch auf ESP8266-Boards: Für einen NodeMCU nimmst du einfach ESP8266WiFi.h und BlynkSimpleEsp8266.h.

Blynk mit dem Raspberry Pi Pico W und MicroPython

Blynk ist nicht nur etwas für den ESP32. Nutzt du MicroPython auf einem Raspberry Pi Pico W, musst du nur die einzelne Datei BlynkLib.py aus der Python-Bibliothek von Blynk mit Thonny auf den Pico kopieren. Beachte, dass diese Bibliothek nicht mehr aktiv weiterentwickelt wird und Blynk für neue Projekte seine MQTT-API empfiehlt; zum Lernen und für einfache Projekte reicht sie aber. Der folgende Code steuert mit V0 die eingebaute LED des Pico W und sendet einmal pro Minute den Wert des Temperatursensors im Chip an V2. Lege für den Pico W in Blynk.Console ein eigenes Gerät an und nutze dessen Token. Bist du neu bei MicroPython, ist MicroPython Grundlagen ein guter Einstieg.

1import network, time
2from machine import Pin, ADC
3import BlynkLib                      # BlynkLib.py Pico'da olmalı / BlynkLib.py must be on the Pico
4
5WIFI_SSID = "AgAdi"
6WIFI_PASS = "Sifre123"
7BLYNK_AUTH = "PicoTokeniniBurayaYapistir"
8
9led = Pin("LED", Pin.OUT)            # Pico W dahili LED / Pico W onboard LED
10sensor = ADC(4)                      # yongadaki sıcaklık sensörü / on-chip temperature sensor
11
12wlan = network.WLAN(network.STA_IF)
13wlan.active(True)
14wlan.connect(WIFI_SSID, WIFI_PASS)
15while not wlan.isconnected():
16    time.sleep(0.5)
17print("IP:", wlan.ifconfig()[0])
18
19blynk = BlynkLib.Blynk(BLYNK_AUTH, insecure=True)   # 80 portu, TLS'siz / port 80, no TLS
20
21@blynk.on("V0")
22def v0_yazildi(value):               # uygulamadaki anahtar / switch in the app
23    led.value(int(value[0]))
24
25@blynk.on("connected")
26def baglandi(ping):
27    print("Blynk hazir / ready, ping:", ping, "ms")
28    blynk.sync_virtual(0)            # son V0 değerini iste / ask for the last V0 value
29
30son = time.ticks_ms()
31while True:
32    blynk.run()
33    if time.ticks_diff(time.ticks_ms(), son) >= 60000:   # 60 saniyede bir / every 60 seconds
34        son = time.ticks_ms()
35        volt = sensor.read_u16() * 3.3 / 65535
36        sicaklik = 27 - (volt - 0.706) / 0.001721
37        blynk.virtual_write(2, round(sicaklik, 1))      # V2: sıcaklık / temperature

Im Beispiel wird die Verbindung mit insecure=True unverschlüsselt über Port 80 aufgebaut; das ist die Variante mit dem geringsten Speicherbedarf und entspricht BlynkSimpleEsp32.h auf dem ESP32. Entfernst du diesen Parameter, versucht die Bibliothek, TLS auf Port 443 zu nutzen. Dass wir in der Schleife mit ticks_ms statt mit time.sleep() die Zeit messen, hat denselben Grund wie auf der Arduino-Seite: Wird blynk.run() nicht oft aufgerufen, kommen Befehle verspätet an, und die Verbindung bricht ab. Der Temperatursensor im Chip kann ein paar Grad von der Raumtemperatur abweichen; für echte Messungen schließ einen DHT11 oder DS18B20 an.

Projektideen mit Blynk

• Smarte Steckdose: Schalte mit einem Relais eine Schreibtischlampe oder einen Ventilator von überall auf der Welt; zur Verkabelung siehe Was ist ein Relaismodul?
• Pflanzen aus der Ferne gießen: Starte die Pumpe, wenn der Bodenfeuchtesensor Trockenheit meldet, und verfolge die Feuchte im Diagramm.
• Smartes Gewächshaus: Schalte einen Lüfter ein, wenn Temperatur und Feuchte steigen, und erhalte eine Benachrichtigung bei Grenzwertüberschreitung; Details in Projekt smartes Gewächshaus.
• Einbruchalarm: Schick per logEvent eine kritische Benachrichtigung aufs Handy, sobald der PIR-Bewegungsmelder jemanden erkennt.
• Gaswarner: Überschreitet der MQ-2-Gassensor seinen Grenzwert, piept ein Buzzer und dein Handy vibriert.
• Wetterstation: Vergleiche Temperatur, Feuchte und Luftdruck eines BME280 im Wochendiagramm.
• Tür- und Fensterüberwachung: Sieh in der App mit einem Reedkontakt, ob die Tür offen geblieben ist.

Häufige Fehler und Lösungen

Blynk, eigener Webserver oder MQTT?

Kurz gesagt: Blynk ist der einfachste Weg, mit einem fertigen, schicken Dashboard schnell ans Ziel zu kommen und dein Projekt von unterwegs zu erreichen. Willst du ein unbegrenztes, rein lokales System, lies ESP32 Webserver und WebSocket oder ESP32 mit MQTT und Home Assistant; willst du nur Warnungen aufs Handy schicken, schau dir die Anleitung ESP32 Telegram-Bot an.

Hast du das Trio aus Vorlage, Datastream und Auth Token einmal verstanden, ist ein neues ESP32-Projekt mit Blynk in wenigen Minuten mit dem Handy verbunden. Kombiniere die LED-, Relais- und Sensorbeispiele von hier, und schon hast du den Grundstein für dein eigenes Smart Home. In der BlueGrays-App findest du außerdem ESP32-Projekte wie LED-Steuerung, WLAN-Verbindung, Temperaturmessung mit dem DHT22, smarte Beleuchtung, Pflanzenbewässerung und einen Bewegungsalarm mit Telegram, jeweils mit Schaltplan und Code Schritt für Schritt.