ESP32 WiFiManager: WLAN per Handy einrichten (Captive Portal)
ESP32 WiFiManager: WLAN-Passwort bequem per Handy eingeben. Captive Portal, eigene Parameter wie MQTT, Reset-Taster, softAP und AP+STA mit Webseiten-Steuerung.
ESP32 WiFiManager ist eine Bibliothek, mit der du deinen ESP32 per Handy ins Netzwerk bringst, ohne WLAN-Name und Passwort in den Code zu schreiben. Kann sich das Board mit keinem gespeicherten Netz verbinden, öffnet es ein eigenes WLAN. Sobald du dich mit dem Handy darin anmeldest, erscheint eine Einstellungsseite: Du wählst dein Netz aus der Liste, gibst das Passwort ein, und der ESP32 speichert die Daten dauerhaft und verbindet sich. So kannst du denselben Sketch zu Hause, in der Schule oder bei Freunden nutzen, ohne ihn neu hochzuladen. Smarte Steckdosen und kommerzielle IoT-Geräte, die du beim ersten Start per Handy einrichtest, funktionieren genau nach diesem Prinzip.
In dieser Anleitung lernst du zuerst die WLAN-Modi des ESP32 kennen: Station (STA), Access Point (AP) und AP+STA, bei dem beide gleichzeitig laufen. Danach installieren wir die WiFiManager-Bibliothek, schreiben einen ersten Sketch ohne Passwort, ergänzen einen Taster, der die Einstellungen löscht oder das Portal erneut öffnet, und fragen eigene Parameter wie MQTT-Server, Port und Gerätename auf derselben Seite ab und speichern sie dauerhaft. In den letzten Abschnitten baut der ESP32 mit softAP ganz ohne Router sein eigenes Netz auf, damit du eine LED per Handy steuerst. Außerdem testen wir den AP+STA-Modus und richten auf dem Raspberry Pi Pico W mit MicroPython einen Access Point ein.

Was ist der ESP32 WiFiManager und wie funktioniert er?
In einem normalen ESP32-Sketch stehen Netzwerkname und Passwort fest in der Zeile WiFi.begin("HeimNetz", "passwort"). Wechselst du den Router, änderst du das Passwort oder bringst du das Gerät in eine andere Wohnung, musst du den Code öffnen und neu hochladen. Der WiFiManager verlagert diese Aufgabe auf eine Webseite. Beim Start prüft er, ob im dauerhaften Speicher des ESP32 (NVS) ein Netz gespeichert ist, und versucht sich damit zu verbinden. Klappt das, läuft dein Code einfach weiter, ohne dass etwas angezeigt wird. Gibt es kein gespeichertes Netz oder schlägt die Verbindung fehl, öffnet der ESP32 einen eigenen Access Point, startet einen DNS-Server und stellt unter 192.168.4.1 eine Einstellungsseite bereit. Weil der DNS-Server jede vom Handy angefragte Domain mit dieser Adresse beantwortet, öffnet das Handy das Fenster „Im Netzwerk anmelden“ von selbst, sobald es verbunden ist. Das ist dasselbe Prinzip wie bei den Anmeldeseiten in Hotels und Cafés und heißt Captive Portal. Wählst du auf der Seite dein Netz und speicherst das Passwort, verbindet sich der ESP32 mit dem neuen Netz, schließt den Access Point und merkt sich die Daten für den nächsten Start. All das beruht auf den WLAN-Modi, die der ESP32 unterstützt:
| Modus | Was er macht | Wann du ihn nutzt |
|---|---|---|
| WIFI_STA (Station) | Meldet sich als Client am Router an und bekommt von ihm eine IP | Projekte, die ins Internet gehen und von jedem Gerät im Heimnetz erreichbar sind |
| WIFI_AP (Access Point) | Sendet ein eigenes Netz und vergibt 192.168.4.x-Adressen an Clients | Orte ohne Router, Einrichtungsseiten, Handysteuerung unterwegs |
| WIFI_AP_STA | Macht beides gleichzeitig, mit zwei getrennten IP-Adressen | WiFiManager-Portal, im Heimnetz bleiben, während ein Service-Netz offen ist |
| WIFI_OFF | Schaltet den Funk komplett ab | Strom sparen, Zeiten ohne WLAN-Bedarf |
WiFiManager-Bibliothek installieren
- Stelle sicher, dass das ESP32-Boardpaket in der Arduino IDE installiert ist. Falls nicht, folge den Schritten im Artikel Was ist der ESP32?.
- Öffne Werkzeuge > Bibliotheken verwalten und gib WiFiManager in das Suchfeld ein.
- Suche die WiFiManager-Bibliothek mit dem Autor tzapu und installiere die neueste Version (2.0.17 oder höher).
- Wähle dein Board unter Werkzeuge > Board (bei den meisten DevKits ESP32 Dev Module) und stelle den Port ein.
- Die Bibliothek braucht keine weiteren Pakete: WebServer, DNSServer und Preferences sind schon im ESP32-Core enthalten.
Erstes Beispiel: WLAN-Verbindung ohne Passwort im Code
Der folgende Sketch ist die einfachste Art, den WiFiManager zu nutzen. Im Code steht weder ein Netzwerkname noch ein Passwort. Kann sich das Board nicht innerhalb von 20 Sekunden mit dem gespeicherten Netz verbinden, öffnet es ein Netz namens BlueGrays-Kurulum. Das Portal-Passwort ist kurulum123; du könntest das Portal auch ohne Passwort öffnen, dann könnte aber jeder in der Nähe Netzwerkdaten in dein Gerät eintragen. Wird das Portal 180 Sekunden lang nicht benutzt, startet das Board neu und versucht es erneut mit dem gespeicherten Netz. Dieses Detail ist wichtig: Startet der Router nach einem Stromausfall langsamer als der ESP32, bleibt das Board nicht im Portal hängen, sondern kehrt nach ein paar Minuten von selbst in dein Netz zurück.
1#include <WiFi.h>
2#include <WiFiManager.h> // tzapu WiFiManager
3
4void setup() {
5 Serial.begin(115200);
6 WiFi.mode(WIFI_STA); // önce istasyon modu / start in station mode
7
8 WiFiManager wm;
9 // wm.resetSettings(); // test için kayıtlı ağı sil / erase saved network for testing
10 wm.setConnectTimeout(20); // kayıtlı ağa 20 sn dene / try the saved network for 20 s
11 wm.setConfigPortalTimeout(180); // portal 180 sn sonra kapanır / portal closes after 180 s
12
13 // Bağlanamazsa "BlueGrays-Kurulum" ağını açar / opens "BlueGrays-Kurulum" if it cannot connect
14 bool baglandi = wm.autoConnect("BlueGrays-Kurulum", "kurulum123");
15
16 if (!baglandi) {
17 Serial.println("Baglanamadi, yeniden baslatiliyor / Not connected, restarting");
18 delay(1000);
19 ESP.restart(); // kayıtlı ağı yeniden dene / try the saved network again
20 }
21
22 Serial.print("Baglandi / Connected, IP: ");
23 Serial.println(WiFi.localIP());
24}
25
26void loop() {
27 // projenin asıl kodu buraya / your project code goes here
28}Öffne nach dem Hochladen den Seriellen Monitor mit 115200 Baud. Da das Board zum ersten Mal läuft, ist kein Netz gespeichert, und in den Zeilen des WiFiManagers, die mit *wm: beginnen, siehst du, dass der Access Point geöffnet wurde. Nimm jetzt dein Handy und gehe so vor:
- Suche das Netz BlueGrays-Kurulum in der WLAN-Liste des Handys und verbinde dich mit dem Passwort kurulum123.
- Nach wenigen Sekunden öffnet sich die Anmeldeseite von selbst. Falls nicht, gib im Browser 192.168.4.1 ein.
- Tippe auf Configure WiFi. Die Netze, die der ESP32 sieht, werden mit ihrer Signalstärke aufgelistet.
- Wähle dein Netz, gib das Passwort ein und tippe auf Save.
- Der ESP32 verbindet sich mit dem neuen Netz, schließt den Access Point und schreibt die erhaltene IP-Adresse in den Seriellen Monitor. Dein Handy kehrt ebenfalls in sein Netz zurück.
- Setze das Board zurück: Diesmal öffnet sich kein Portal, der ESP32 verbindet sich in wenigen Sekunden selbst mit dem gespeicherten Netz.
Der Bereich Info im Portal zeigt MAC-Adresse, Chipdaten und Speicherzustand des Boards; Exit schließt das Portal ohne zu speichern. Diese WiFiManager-Funktionen brauchst du in diesem Artikel:
| Funktion | Was sie macht |
|---|---|
| autoConnect(name, passwort) | Versucht das gespeicherte Netz; klappt das nicht, öffnet sie das Portal. Gibt nach erfolgreicher Verbindung true zurück |
| startConfigPortal(name, passwort) | Öffnet das Portal sofort, ohne das gespeicherte Netz zu prüfen |
| setConfigPortalTimeout(s) | Schließt das Portal und gibt false zurück, wenn es so viele Sekunden unbenutzt bleibt |
| setConnectTimeout(s) | Dauer des Verbindungsversuchs mit dem gespeicherten Netz |
| resetSettings() | Löscht den gespeicherten WLAN-Namen und das Passwort |
| addParameter(¶meter) | Fügt der Portalseite ein eigenes Eingabefeld hinzu |
| setSaveParamsCallback(funktion) | Ruft deine Funktion auf, wenn die eigenen Parameter gespeichert werden |
| setConfigPortalBlocking(false) und process() | Lässt loop() weiterlaufen, während das Portal offen ist |
| setHostname("name") | Legt den Namen des Boards im Netz fest, der in der Geräteliste des Routers erscheint |
Reset-Taster und Portal auf Abruf
Steckt das Gerät erst einmal im Gehäuse, musst du vielleicht trotzdem die WLAN-Daten ändern. Am einfachsten geht das ohne neuen Upload mit einem Taster. Im folgenden Beispiel nutzen wir den BOOT-Taster der ESP32-DevKits; er hängt an GPIO 0 und liest dank des Pull-up-Widerstands auf dem Board beim Drücken LOW. Ein kurzer Druck öffnet das Portal, ohne das gespeicherte Netz zu löschen; du kannst ein neues Netz eintragen oder nur deine eigenen Einstellungen ändern. Hältst du ihn 3 Sekunden lang gedrückt, wird das gespeicherte Netz komplett gelöscht und das Board neu gestartet. Willst du einen eigenen Taster, schließe ihn an einen freien Pin wie GPIO 4 an; Details findest du unter Taster richtig anschließen. Die Board-LED an GPIO 2 zeigt den Verbindungsstatus.
1#include <WiFi.h>
2#include <WiFiManager.h>
3
4const int BUTON_PIN = 0; // DevKit üzerindeki BOOT butonu / BOOT button on the DevKit
5const int LED_PIN = 2; // dahili LED / onboard LED
6const char* PORTAL_ADI = "BlueGrays-Kurulum";
7const char* PORTAL_SIFRE = "kurulum123";
8
9WiFiManager wm;
10
11void setup() {
12 Serial.begin(115200);
13 pinMode(BUTON_PIN, INPUT_PULLUP);
14 pinMode(LED_PIN, OUTPUT);
15 WiFi.mode(WIFI_STA);
16 wm.setConfigPortalTimeout(180);
17 if (!wm.autoConnect(PORTAL_ADI, PORTAL_SIFRE)) {
18 Serial.println("Agsiz devam / Continuing offline"); // butonla tekrar denenebilir / retry with the button
19 }
20}
21
22void butonuKontrolEt() {
23 if (digitalRead(BUTON_PIN) != LOW) return;
24 delay(50); // ark önleme / debounce
25 if (digitalRead(BUTON_PIN) != LOW) return;
26
27 unsigned long basilma = millis();
28 while (digitalRead(BUTON_PIN) == LOW && millis() - basilma < 3000) {
29 delay(10); // bırakılmasını ya da 3 sn'yi bekle / wait for release or 3 s
30 }
31
32 if (millis() - basilma >= 3000) {
33 Serial.println("Wi-Fi ayarlari siliniyor / Erasing Wi-Fi settings");
34 digitalWrite(LED_PIN, HIGH);
35 wm.resetSettings(); // kayıtlı ağı sil / erase the saved network
36 delay(500);
37 ESP.restart();
38 } else {
39 Serial.println("Portal aciliyor / Opening portal");
40 if (wm.startConfigPortal(PORTAL_ADI, PORTAL_SIFRE)) {
41 Serial.print("Yeni IP / New IP: ");
42 Serial.println(WiFi.localIP());
43 } else {
44 Serial.println("Portal zaman asimi / Portal timeout");
45 }
46 }
47}
48
49void loop() {
50 butonuKontrolEt();
51 // bağlıyken LED yanar / LED is on while connected
52 digitalWrite(LED_PIN, WiFi.status() == WL_CONNECTED ? HIGH : LOW);
53}Eigene Parameter: MQTT-Server, Port und Gerätename
Eine der praktischsten Funktionen des WiFiManagers ist, dass du der Portalseite eigene Eingabefelder hinzufügen kannst. Verbindest du ein Sensorboard per MQTT mit Home Assistant, möchtest du auch Serveradresse, Portnummer und Gerätenamen nicht fest in den Code schreiben. Dafür legst du WiFiManagerParameter-Objekte an und fügst sie mit addParameter() zum Portal hinzu. Auf eines musst du achten: Der WiFiManager speichert WLAN-Name und Passwort selbst, eigene Parameter speichert er aber nicht. Die eingegebenen Werte zu sichern ist deine Aufgabe. Wir nutzen dafür die Preferences-Bibliothek aus dem ESP32-Core; sie schreibt Schlüssel-Wert-Paare in die NVS-Partition des Flash-Speichers, wo sie auch einen Stromausfall überstehen. Wie das beim Arduino funktioniert, erfährst du im Artikel Arduino EEPROM.
1#include <WiFi.h>
2#include <WiFiManager.h>
3#include <Preferences.h>
4
5Preferences ayarlar; // NVS'te kalıcı ayarlar / persistent settings in NVS
6char mqttSunucu[40] = "192.168.1.10"; // varsayılan değerler / default values
7char mqttPort[6] = "1883";
8char cihazAdi[24] = "bluegrays-sensor";
9
10WiFiManager wm;
11// id, etiket, varsayılan değer, en fazla uzunluk / id, label, default value, max length
12WiFiManagerParameter pSunucu("sunucu", "MQTT sunucusu / server", mqttSunucu, 40);
13WiFiManagerParameter pPort("port", "MQTT port", mqttPort, 6);
14WiFiManagerParameter pAd("ad", "Cihaz adi / Device name", cihazAdi, 24);
15
16void ayarlariOku() {
17 ayarlar.begin("bluegrays", true); // salt okunur aç / open read-only
18 if (ayarlar.isKey("sunucu")) {
19 ayarlar.getString("sunucu", mqttSunucu, sizeof(mqttSunucu));
20 ayarlar.getString("port", mqttPort, sizeof(mqttPort));
21 ayarlar.getString("ad", cihazAdi, sizeof(cihazAdi));
22 }
23 ayarlar.end();
24}
25
26// Portalda Kaydet'e basılınca çağrılır / called when Save is pressed in the portal
27void parametreleriKaydet() {
28 strlcpy(mqttSunucu, pSunucu.getValue(), sizeof(mqttSunucu));
29 strlcpy(mqttPort, pPort.getValue(), sizeof(mqttPort));
30 strlcpy(cihazAdi, pAd.getValue(), sizeof(cihazAdi));
31
32 ayarlar.begin("bluegrays", false); // yazma için aç / open for writing
33 ayarlar.putString("sunucu", mqttSunucu);
34 ayarlar.putString("port", mqttPort);
35 ayarlar.putString("ad", cihazAdi);
36 ayarlar.end();
37 Serial.println("Parametreler kaydedildi / Parameters saved");
38}
39
40void setup() {
41 Serial.begin(115200);
42 WiFi.mode(WIFI_STA);
43 ayarlariOku();
44
45 // Kayıtlı değerleri form kutularına yaz / put saved values into the form fields
46 pSunucu.setValue(mqttSunucu, 40);
47 pPort.setValue(mqttPort, 6);
48 pAd.setValue(cihazAdi, 24);
49
50 wm.addParameter(&pSunucu);
51 wm.addParameter(&pPort);
52 wm.addParameter(&pAd);
53 wm.setSaveParamsCallback(parametreleriKaydet);
54 wm.setHostname(cihazAdi); // modemde görünen ad / name shown in the router
55 wm.setConfigPortalTimeout(180);
56
57 if (!wm.autoConnect("BlueGrays-Kurulum", "kurulum123")) {
58 ESP.restart();
59 }
60
61 uint16_t port = atoi(mqttPort); // metni sayıya çevir / convert text to a number
62 Serial.printf("IP: %s\n", WiFi.localIP().toString().c_str());
63 Serial.printf("MQTT: %s:%u, cihaz / device: %s\n", mqttSunucu, port, cihazAdi);
64}
65
66void loop() {
67 // MQTT bağlantısı burada mqttSunucu ve port ile kurulur / connect to MQTT here with mqttSunucu and port
68}Öffnest du im Portal die Seite Configure WiFi, siehst du unter der Netzliste drei neue Felder. Sie sind mit den im NVS gespeicherten Werten vorbelegt, oder mit den Standardwerten aus dem Code, falls noch nichts gespeichert ist. Tippst du auf Save, ruft der WiFiManager zuerst deine Funktion parametreleriKaydet() auf und verbindet sich dann mit dem WLAN. Hier die Parameter und Funktionen im Überblick:
| Element | Aufgabe | Hinweis |
|---|---|---|
| WiFiManagerParameter(id, label, standard, länge) | Fügt dem Portal ein Eingabefeld hinzu | Die id muss eindeutig sein, ohne Leer- und Sonderzeichen |
| getValue() | Gibt den eingegebenen Text zurück | Es ist immer Text; für Zahlen atoi() oder atof() nutzen |
| setValue(wert, länge) | Füllt das Feld aus | Um den gespeicherten Wert im Formular anzuzeigen |
| setSaveParamsCallback() | Ruft beim Speichern deine Funktion auf | Hier ins NVS schreiben |
| setParamsPage(true) | Verschiebt die Parameter auf eine eigene Setup-Seite | Um nur Einstellungen zu ändern, ohne das WLAN anzufassen |
Achte auf den Längenwert: Arraygröße und Parameterlänge sollten übereinstimmen, sonst kann eine lange Eingabe den Speicher überlaufen lassen oder abgeschnitten werden. Deshalb kopiert der Sketch die Werte mit strlcpy(); diese Funktion schreibt nie über die Größe des Ziel-Arrays hinaus. Es ist außerdem eine gute Gewohnheit, Zahlenwerte wie die Portnummer vor der Verwendung auf einen sinnvollen Bereich zu prüfen.
Das eigene Netz des ESP32: Websteuerung per Handy mit softAP
Das Portal des WiFiManagers ist eigentlich nur eine fertige Anwendung der Access-Point-Funktion des ESP32, und die kannst du auch selbst nutzen. Beim Aufruf von WiFi.softAP() verhält sich der ESP32 wie ein Router: Er sendet ein eigenes Netz, gibt dem verbundenen Handy eine Adresse wie 192.168.4.2 und ist selbst unter 192.168.4.1 erreichbar. Das ist ideal für die Handysteuerung im Garten ohne Router, auf einer Schulausstellung oder bei einem Roboterwettbewerb. Die Funktion erwartet Netzwerkname, Passwort, Kanal, eine Option für ein verstecktes Netz und die maximale Anzahl an Verbindungen. Das Passwort muss mindestens 8 Zeichen haben; gibst du ein kürzeres an, liefert softAP() false und das Netz startet gar nicht. Standardmäßig sind höchstens 4 Verbindungen erlaubt, beim ESP32 lässt sich das auf 10 erhöhen. Der folgende Sketch stellt eine Webseite bereit, mit der du die LED an GPIO 2 per Handy ein- und ausschaltest:
1#include <WiFi.h>
2#include <WebServer.h>
3
4const char* AP_ADI = "BlueGrays-LED";
5const char* AP_SIFRE = "bluegrays1"; // en az 8 karakter / at least 8 characters
6const int LED_PIN = 2;
7
8WebServer sunucu(80);
9bool ledAcik = false;
10
11void anaSayfa() {
12 String html = "<!DOCTYPE html><html><head><meta charset='utf-8'>"
13 "<meta name='viewport' content='width=device-width,initial-scale=1'>"
14 "<title>ESP32 LED</title></head><body style='font-family:sans-serif;text-align:center'>"
15 "<h2>ESP32 softAP</h2><p>LED: <b>";
16 html += ledAcik ? "ACIK / ON" : "KAPALI / OFF";
17 html += "</b></p><p><a href='/ac'><button style='font-size:24px'>AC / ON</button></a> "
18 "<a href='/kapat'><button style='font-size:24px'>KAPAT / OFF</button></a></p>";
19 html += "<p>Bagli cihaz / Clients: " + String(WiFi.softAPgetStationNum()) + "</p></body></html>";
20 sunucu.send(200, "text/html", html);
21}
22
23void yonlendir() { // ana sayfaya geri dön / go back to the home page
24 sunucu.sendHeader("Location", "/");
25 sunucu.send(303);
26}
27
28void setup() {
29 Serial.begin(115200);
30 pinMode(LED_PIN, OUTPUT);
31
32 WiFi.mode(WIFI_AP);
33 // ad, şifre, kanal, gizli değil, en fazla 4 cihaz / ssid, password, channel, not hidden, max 4 clients
34 if (!WiFi.softAP(AP_ADI, AP_SIFRE, 6, 0, 4)) {
35 Serial.println("softAP acilamadi / softAP failed");
36 return;
37 }
38 Serial.print("Ag / Network: ");
39 Serial.println(AP_ADI);
40 Serial.print("Adres / Address: http://");
41 Serial.println(WiFi.softAPIP()); // genellikle 192.168.4.1 / usually 192.168.4.1
42
43 sunucu.on("/", anaSayfa);
44 sunucu.on("/ac", []() { ledAcik = true; digitalWrite(LED_PIN, HIGH); yonlendir(); });
45 sunucu.on("/kapat", []() { ledAcik = false; digitalWrite(LED_PIN, LOW); yonlendir(); });
46 sunucu.begin();
47}
48
49void loop() {
50 sunucu.handleClient(); // gelen istekleri işle / handle incoming requests
51}Lade den Code hoch, verbinde dein Handy mit dem Netz BlueGrays-LED und öffne im Browser 192.168.4.1. Die LED geht beim Tippen auf die Schaltflächen an und aus, und die Seite zeigt die Anzahl der verbundenen Geräte. Hier gibt es kein Captive Portal, du musst die Adresse also selbst eintippen. Lädt die Seite nicht, denk daran, dass das Handy mangels Internet vielleicht auf mobile Daten gewechselt ist. Möchtest du ein Steuerpanel, das sich ohne Neuladen sofort aktualisiert, kannst du die Methode aus dem Artikel ESP32 Webserver und WebSocket im selben softAP-Netz verwenden.
AP+STA gleichzeitig: eigenes Netz senden und im Heimnetz bleiben
Im Modus WIFI_AP_STA verbindet sich der ESP32 mit dem Router und sendet gleichzeitig sein eigenes Netz. Das Board hat dann zwei getrennte IP-Adressen: WiFi.localIP() liefert die Adresse im Heimnetz, WiFi.softAPIP() die 192.168.4.1 im eigenen Netz. Auch das WiFiManager-Portal läuft in diesem Modus, damit es Netze scannen und gleichzeitig dem Handy eine Seite liefern kann. In eigenen Projekten bietet sich AP+STA an, wenn du ein Service-Netz behalten willst, mit dem du dich auch bei ausgeschaltetem Router per Handy verbinden kannst, oder wenn du ESP-NOW und WLAN zusammen nutzt. Der folgende Sketch liefert auf beiden Schnittstellen dieselbe Seite:
1#include <WiFi.h>
2#include <WebServer.h>
3
4const char* WIFI_ADI = "EvAgi_2G"; // ev ağı / home network
5const char* WIFI_SIFRE = "sifre1234";
6const char* AP_ADI = "BlueGrays-Servis";
7const char* AP_SIFRE = "servis1234";
8
9WebServer sunucu(80);
10
11void anaSayfa() {
12 String html = "<h2>ESP32 AP+STA</h2>";
13 html += "<p>Ev agi / Home IP: " + WiFi.localIP().toString() + "</p>";
14 html += "<p>Kendi agi / Own AP IP: " + WiFi.softAPIP().toString() + "</p>";
15 html += "<p>Kanal / Channel: " + String(WiFi.channel()) + ", RSSI: " + String(WiFi.RSSI()) + " dBm</p>";
16 sunucu.send(200, "text/html", html);
17}
18
19void setup() {
20 Serial.begin(115200);
21 WiFi.mode(WIFI_AP_STA); // iki mod birlikte / both modes together
22 WiFi.softAP(AP_ADI, AP_SIFRE); // servis ağı her zaman açık / service network always on
23 WiFi.begin(WIFI_ADI, WIFI_SIFRE);
24
25 unsigned long baslangic = millis();
26 while (WiFi.status() != WL_CONNECTED && millis() - baslangic < 15000) {
27 delay(500);
28 Serial.print('.');
29 }
30 Serial.println();
31 Serial.print("STA IP: ");
32 Serial.println(WiFi.localIP()); // bağlanamadıysa 0.0.0.0 / 0.0.0.0 if not connected
33 Serial.print("AP IP: ");
34 Serial.println(WiFi.softAPIP());
35
36 sunucu.on("/", anaSayfa);
37 sunucu.begin(); // iki arayüzü de dinler / listens on both interfaces
38}
39
40void loop() {
41 sunucu.handleClient();
42}Der AP+STA-Modus hat eine wichtige Grenze: Der ESP32 besitzt nur ein Funkmodul, deshalb müssen beide Netze auf demselben Kanal laufen. Ein Netz, das du mit softAP() auf Kanal 1 öffnest, wechselt auf Kanal 11, sobald sich der ESP32 mit einem Router auf Kanal 11 verbindet. Dabei kann das Handy im Service-Netz für ein paar Sekunden die Verbindung verlieren. Weil sich zwei Netze das Funkmodul teilen, sinkt außerdem die Datenrate, und das Board braucht etwas mehr Strom. Brauchst du das Service-Netz nach der Einrichtung nicht mehr, kannst du den Access Point mit WiFi.softAPdisconnect(true) abschalten und das Board wieder in den reinen Stationsmodus versetzen.
Access Point mit dem Raspberry Pi Pico W und MicroPython
Für den Raspberry Pi Pico W gibt es kein genaues Gegenstück zum Arduino-WiFiManager, aber ein Access Point ist in MicroPython mit wenigen Zeilen eingerichtet. network.WLAN(network.AP_IF) liefert die Access-Point-Schnittstelle; Netzwerkname und Passwort setzt du mit config(), eingeschaltet wird sie mit active(True). Auch der Pico W vergibt 192.168.4.x-Adressen an Clients und ist selbst unter 192.168.4.1 erreichbar. Der folgende Code ist ein kleiner Webserver, der die Board-LED des Pico W per Handy ein- und ausschaltet:
1import network, socket, time
2from machine import Pin
3
4led = Pin("LED", Pin.OUT) # Pico W kart üstü LED / Pico W onboard LED
5
6ap = network.WLAN(network.AP_IF)
7ap.config(essid="BlueGrays-Pico", password="bluegrays1") # en az 8 karakter / at least 8 chars
8ap.active(True)
9while not ap.active():
10 time.sleep(0.1)
11print("AP IP:", ap.ifconfig()[0]) # genellikle 192.168.4.1 / usually 192.168.4.1
12
13SAYFA = """<!DOCTYPE html><html><head><meta name="viewport" content="width=device-width">
14<title>Pico W</title></head><body><h2>Pico W LED: DURUM</h2>
15<p><a href="/on">AC / ON</a> | <a href="/off">KAPAT / OFF</a></p></body></html>"""
16
17s = socket.socket()
18s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
19s.bind(("0.0.0.0", 80))
20s.listen(2)
21
22while True:
23 istemci, adres = s.accept()
24 try:
25 istek = istemci.recv(1024).decode()
26 if "GET /on " in istek:
27 led.on()
28 elif "GET /off " in istek:
29 led.off()
30 durum = "ACIK / ON" if led.value() else "KAPALI / OFF"
31 istemci.send("HTTP/1.0 200 OK\r\nContent-Type: text/html\r\n\r\n")
32 istemci.send(SAYFA.replace("DURUM", durum))
33 except OSError as hata:
34 print("Hata / Error:", hata)
35 finally:
36 istemci.close() # bağlantıyı her istekten sonra kapat / close after each requestSpeicherst du den Code mit Thonny als main.py auf dem Pico W, baut das Board sein Netz bei jedem Start automatisch auf. Verbinde dich einfach mit dem Netz BlueGrays-Pico und öffne 192.168.4.1. Möchtest du auf dem Pico W ein Captive Portal, bietet die Bibliothek phew von Pimoroni einen Access Point und einen DNS-Server, der jede Domain abfängt; das Prinzip ist dasselbe wie beim WiFiManager. Wie du den Pico W mit dem Heimnetz verbindest und im Stationsmodus einen Webserver betreibst, zeigt der Artikel Pico W WLAN-Webserver; bist du neu bei MicroPython, wirf einen Blick in die MicroPython-Grundlagen.
Projektideen mit dem WiFiManager
- Temperaturanzeige zum Verschenken: Wer ein Sensorboard bekommt, das seine Messwerte auf einer Webseite zeigt, verbindet es selbst per Handy mit dem eigenen WLAN.
- Smart-Home-Sensor: Verbinde ein Board, das seinen MQTT-Server aus dem Portal bekommt, mit Home Assistant; ändert sich die Serveradresse, ist kein neuer Upload nötig.
- Alarm mit Handy-Benachrichtigung: Baue einen ESP32-Telegram-Bot, der den Bot-Token als eigenen Parameter abfragt.
- Kabellose Updates im Gehäuse: Schicke neuen Code per OTA-Update an ein Board, das über den WiFiManager ins Netz gekommen ist.
- Internetuhr: Baue eine NTP-Uhr, deren Zeitzone im Portal gewählt wird.
- Steuerung ohne Router: Schalte eine Bewässerungspumpe im Garten per softAP vom Handy aus; für die Kommunikation zwischen mehreren Boards nutzt du ESP-NOW.
Häufige Fehler und Lösungen
| Symptom | Mögliche Ursache | Lösung |
|---|---|---|
| Das Portal-Netz erscheint nicht auf dem Handy | Das Board hat sich mit dem gespeicherten Netz verbunden, daher kein Portal | Seriellen Monitor prüfen; zum Testen resetSettings() einmal ausführen oder das Portal per Taster öffnen |
| Ich bin verbunden, aber die Seite öffnet sich nicht | Das Handy ist mangels Internet auf mobile Daten gewechselt | Mobile Daten ausschalten und 192.168.4.1 im Browser eingeben |
| Kein Portal, im Seriellen Monitor eine Passwortwarnung | Das Portal-Passwort ist kürzer als 8 Zeichen | Ein Passwort mit mindestens 8 Zeichen nutzen oder den Passwortparameter weglassen |
| wm.process() oder setParamsPage wird nicht erkannt | Falsche oder sehr alte WiFiManager-Bibliothek | Aktuellen tzapu WiFiManager installieren, ähnlich benannte Bibliotheken entfernen |
| Nach Save öffnet das Board wieder das Portal | Falsches Passwort eingegeben oder 5-GHz-Netz | Passwort prüfen, das 2,4-GHz-Netz wählen; Details in der Anleitung zu WLAN-Verbindungsproblemen |
| Eigene Parameter sind nach einem Neustart weg | Die Werte wurden nicht ins NVS geschrieben | In setSaveParamsCallback mit Preferences speichern, beim Start lesen und mit setValue() ins Formular schreiben |
| Das Board geht ständig in den Upload-Modus | Der Taster hängt an GPIO 0 und ist beim Einschalten gedrückt | Taster erst nach dem Start drücken oder einen Pin ohne Strapping-Funktion nutzen |
| Im AP+STA-Modus verliert das Handy die Verbindung | Der Access Point ist auf den Kanal des Routers gewechselt | Das ist normal; nach ein paar Sekunden neu verbinden oder danach softAPdisconnect(true) nutzen |
Der WiFiManager ist der einfachste Schritt, um aus einem ESP32-Experiment auf dem Schreibtisch ein Gerät zu machen, das auch andere benutzen können: Das Passwort verschwindet aus dem Code, die Einstellungen kommen vom Handy, und ein einziger Taster setzt alles zurück. Da du jetzt auch softAP und AP+STA kennst, kannst du Projekte bauen, die sich überall per Handy steuern lassen, mit oder ohne Router. In der BlueGrays-App findest du ESP32-Projekte wie WLAN-Verbindung, Async-Webserver, mDNS, WebSocket, OTA-Update und Telegram-Alarm, jeweils mit Schritt-für-Schritt-Schaltplänen und fertigem Code.
Häufige Fragen
Wofür braucht man den ESP32 WiFiManager?
Mit ihm verbindest du einen ESP32 per Handy mit dem Netzwerk, ohne WLAN-Name und Passwort in den Code zu schreiben. Findet das Board kein gespeichertes Netz, öffnet es einen eigenen Access Point und zeigt unter 192.168.4.1 eine Einstellungsseite. Das dort gewählte Netz und Passwort werden dauerhaft gespeichert und beim nächsten Start automatisch verwendet.
Wo speichert der WiFiManager das WLAN-Passwort?
Beim ESP32 liegen WLAN-Name und Passwort in der NVS-Partition des Flash-Speichers, als eigene Einstellungen des WLAN-Treibers. Sie bleiben auch beim Hochladen von neuem Code erhalten. Löschen kannst du sie mit resetSettings() oder indem du den Flash komplett löschst.
Wie setze ich den WiFiManager zurück?
Rufe im Code wm.resetSettings() auf und starte das Board neu. In der Praxis legst du das am besten auf einen Taster: Zum Beispiel löscht eine Abfrage die Einstellungen, wenn der BOOT-Taster 3 Sekunden gedrückt bleibt. Willst du nur das Portal öffnen, ohne das gespeicherte Netz zu löschen, nutze startConfigPortal().
Warum öffnet sich das Captive Portal des ESP32 nicht?
Meist merkt das Handy, dass es im Portal-Netz kein Internet gibt, und wechselt auf mobile Daten; schalte sie aus und gib 192.168.4.1 im Browser ein. Hat sich das Board bereits mit einem gespeicherten Netz verbunden, öffnet sich das Portal gar nicht. Achte außerdem darauf, dass das Portal-Passwort mindestens 8 Zeichen hat.
Kann der ESP32 gleichzeitig Access Point und Station sein?
Ja. Im Modus WIFI_AP_STA sendet der ESP32 sein eigenes Netz, während er mit dem Router verbunden ist, und nutzt zwei getrennte IP-Adressen. Da es nur ein Funkmodul gibt, müssen beide Netze denselben Kanal verwenden; verbindet sich das Board mit dem Router, wechselt der Access Point auf dessen Kanal.
Wie viele Geräte können sich mit einem ESP32-softAP verbinden?
Im Arduino-Core erlaubt softAP() standardmäßig bis zu 4 Geräte. Beim ESP32 lässt sich das mit dem fünften Parameter von softAP() auf 10 erhöhen. Die Zahl der verbundenen Geräte liest du mit WiFi.softAPgetStationNum() aus.
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 Async-Webserver (mit IP-Anzeige auf dem LCD)
Wir machen den ESP32 zu einem asynchronen Webserver, den du per Handy oder Computer im selben WLAN steuerst. Dank der Bibliothek ESPAsyncWebServer verarbeitet der Server mehrere Anfragen gleichzeitig (er blockiert nicht wie das klassische WebServer.h bei einer einzigen Anfrage). Öffne im Browser die IP-Adresse des ESP32 und schalte mit den Tasten ON/OFF (Adressen /on und /off) die LED an GPIO 5 ein und aus.

ESP32 mDNS: Zugriff auf das Gerät über „bluegrays-esp.local“ (mit LCD-Display)
Wir ergänzen den ESP32 um einen mDNS-Dienst (Multicast DNS), damit du ihn statt über eine IP-Adresse unter einem lesbaren Hostnamen wie bluegrays-esp.local erreichst. Auch wenn sich die per DHCP vergebene IP ändert, bleibt der Name gleich. Ein kleiner Webserver auf dem Board lässt dich die LED im Browser unter http://bluegrays-esp.local/ steuern.

ESP32-WebSocket-Zähler (2 Tasten + LCD + Web-Echtzeit)
In diesem Projekt ändern zwei am ESP32 angeschlossene Taster (GPIO 5 zählt hoch, GPIO 4 zählt herunter) einen Zähler. Der Wert wird sofort auf einem 16x2-I2C-LCD und über die WebSocket-Unterstützung von ESPAsyncWebServer in allen verbundenen Browsern aktualisiert, ohne die Seite neu zu laden. Statt HTTP-Polling wird eine einzige dauerhafte Verbindung genutzt; der ESP32 sendet den neuen Wert mit ws.textAll() an alle.

ESP32-OTA-Update – Drahtlose Firmware-Installation (mit LCD-Display)
Du lernst, neue Firmware ohne USB-Kabel per WLAN auf den ESP32 zu laden. Mit der Bibliothek ArduinoOTA wird der ESP32 im Netzwerk sichtbar und erscheint in der Arduino IDE unter "Network port" automatisch als bluegrays-ota. Das erste Hochladen läuft über USB, danach kommen alle Updates kabellos, eine wichtige Funktion für Geräte im Außeneinsatz.

ESP32: Echtzeit aus dem Internet per NTP
Der ESP32 verbindet sich mit dem WLAN und holt die Uhrzeit millisekundengenau von NTP-Servern (Network Time Protocol). Mit configTzTime() gilt automatisch die türkische Zeitzone (TRT, UTC+3); in Ländern mit Sommerzeit regelt ein POSIX-TZ-String die Umstellung (DST) von selbst. Die Uhrzeit erscheint im Serial Monitor und auf einem optionalen I2C-LCD.

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

