ESP32 WiFiManager: wifi instellen vanaf je telefoon (captive portal)
Met ESP32 WiFiManager voer je het wifiwachtwoord in vanaf je telefoon: captive portal, eigen parameters zoals MQTT, een resetknop, softAP en AP+STA-webbediening.
ESP32 WiFiManager is een bibliotheek waarmee je je ESP32 vanaf je telefoon met een netwerk verbindt, zonder de wifinaam en het wachtwoord in de code te schrijven. Als het board geen verbinding kan maken met een opgeslagen netwerk, opent het een eigen wifinetwerk. Zodra je daar met je telefoon verbinding mee maakt, verschijnt er een instellingenpagina. Je kiest je netwerk uit de lijst, typt het wachtwoord, en de ESP32 slaat deze gegevens op in het permanente geheugen en maakt verbinding. Zo kun je dezelfde firmware thuis, op school of bij een vriend gebruiken zonder opnieuw te uploaden. Slimme stekkers en commerciële IoT-apparaten die je de eerste keer vanaf je telefoon instelt, werken precies zo.
In deze gids leer je eerst de wifimodi van de ESP32: station (STA), access point (AP) en AP+STA, waarbij beide samen draaien. Daarna installeren we de WiFiManager-bibliotheek, schrijven we een eerste sketch zonder wachtwoord, voegen we een knop toe die de instellingen wist of het portaal opnieuw opent, en verzamelen we eigen parameters zoals een MQTT-server, poort en apparaatnaam op dezelfde pagina en slaan we die permanent op. In de laatste onderdelen bouwt de ESP32 met softAP een eigen netwerk, zonder router, zodat je een LED vanaf je telefoon kunt bedienen. We proberen de AP+STA-modus en zetten een access point op met de Raspberry Pi Pico W en MicroPython.

Wat is ESP32 WiFiManager en hoe werkt het?
In een gewone ESP32-sketch staan de netwerknaam en het wachtwoord vast in de regel WiFi.begin("HomeNet", "password"). Als je van router wisselt, het wachtwoord aanpast of het apparaat naar een ander huis meeneemt, moet je de code openen en opnieuw uploaden. WiFiManager verplaatst deze taak naar een webpagina. Bij het opstarten controleert het of er een netwerk is opgeslagen in het permanente geheugen (NVS) van de ESP32 en probeert dan daarmee te verbinden. Lukt dat, dan gaat je code gewoon verder zonder iets te tonen. Is er geen opgeslagen netwerk of mislukt de verbinding, dan opent de ESP32 een eigen access point, start een DNS-server en toont een instellingenpagina op 192.168.4.1. Omdat de DNS-server elk domein dat de telefoon opvraagt met dit adres beantwoordt, opent de telefoon het venster "Inloggen op netwerk" vanzelf zodra hij verbinding maakt. Het is hetzelfde idee als de inlogpagina's in hotels en cafés, en het heet een captive portal. Als je op de pagina je netwerk kiest en het wachtwoord opslaat, maakt de ESP32 verbinding met het nieuwe netwerk, sluit het access point en bewaart de gegevens voor de volgende start. Dit alles is gebouwd op de wifimodi die de ESP32 ondersteunt:
| Modus | Wat het doet | Wanneer gebruiken |
|---|---|---|
| WIFI_STA (station) | Maakt als client verbinding met een router en krijgt daar een IP-adres van | Projecten die online gaan en bereikbaar zijn vanaf elk apparaat op het thuisnetwerk |
| WIFI_AP (access point) | Zendt een eigen netwerk uit en deelt 192.168.4.x-adressen uit aan clients | Plekken zonder router, instellingspagina's, bediening met de telefoon in het veld |
| WIFI_AP_STA | Doet beide tegelijk, met twee aparte IP-adressen | WiFiManager-portaal, op het thuisnetwerk blijven terwijl een servicenetwerk openstaat |
| WIFI_OFF | Schakelt de radio volledig uit | Batterij besparen, momenten waarop wifi niet nodig is |
De WiFiManager-bibliotheek installeren
- Controleer of het ESP32-boardpakket is geïnstalleerd in de Arduino IDE. Zo niet, volg dan de stappen in Wat is de ESP32?.
- Open Tools > Manage Libraries en typ WiFiManager in het zoekvak.
- Zoek de WiFiManager-bibliotheek van tzapu en installeer de nieuwste versie (2.0.17 of nieuwer).
- Kies onder Tools > Board je board (ESP32 Dev Module voor de meeste DevKits) en stel de poort in.
- De bibliotheek heeft geen extra pakketten nodig: WebServer, DNSServer en Preferences zitten al in de ESP32-core.
Eerste voorbeeld: verbinden met wifi zonder wachtwoord in de code
De onderstaande sketch is de eenvoudigste manier om WiFiManager te gebruiken. Er staan geen netwerknaam of wachtwoord in de code. Als het board binnen 20 seconden geen verbinding kan maken met het opgeslagen netwerk, opent het een netwerk met de naam BlueGrays-Kurulum. Het portaalwachtwoord is ingesteld op kurulum123; je zou het portaal ook zonder wachtwoord kunnen openen, maar dan kan iedereen in de buurt netwerkgegevens in je apparaat invoeren. Als het portaal 180 seconden niet wordt gebruikt, herstart het board en probeert het opnieuw het opgeslagen netwerk. Dit detail is belangrijk: als de router na een stroomstoring langzamer opstart dan de ESP32, blijft het board niet in het portaal hangen en keert het binnen enkele minuten uit zichzelf terug naar je netwerk.
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}Open na het uploaden de Serial Monitor op 115200 baud. Omdat het board voor het eerst draait, heeft het geen opgeslagen netwerk, en je ziet in de regels van WiFiManager die beginnen met *wm: dat het access point is geopend. Pak nu je telefoon en volg deze stappen:
- Zoek het netwerk BlueGrays-Kurulum in de wifilijst van je telefoon en maak verbinding met het wachtwoord kurulum123.
- Binnen een paar seconden opent de inlogpagina vanzelf. Gebeurt dat niet, typ dan 192.168.4.1 in de browser.
- Tik op Configure WiFi. De netwerken die de ESP32 kan zien, worden getoond met hun signaalsterkte.
- Kies je netwerk, typ het wachtwoord en druk op Save.
- De ESP32 maakt verbinding met het nieuwe netwerk, sluit het access point en toont het gekregen IP-adres in de Serial Monitor. Ook je telefoon keert terug naar zijn eigen netwerk.
- Reset het board: nu opent het portaal niet en maakt de ESP32 binnen een paar seconden uit zichzelf verbinding met het opgeslagen netwerk.
Het onderdeel Info van het portaal toont het MAC-adres van het board, chipgegevens en de geheugenstatus; met Exit sluit je het portaal zonder op te slaan. Dit zijn de belangrijkste WiFiManager-functies die je in dit artikel gebruikt:
| Functie | Wat het doet |
|---|---|
| autoConnect(name, password) | Probeert het opgeslagen netwerk; lukt dat niet, dan opent het het portaal. Geeft true terug zodra er verbinding is |
| startConfigPortal(name, password) | Opent het portaal direct zonder het opgeslagen netwerk te controleren |
| setConfigPortalTimeout(s) | Sluit het portaal en geeft false terug als het zoveel seconden niet wordt gebruikt |
| setConnectTimeout(s) | Hoe lang er wordt geprobeerd verbinding te maken met het opgeslagen netwerk |
| resetSettings() | Wist de opgeslagen wifinaam en het wachtwoord |
| addParameter(¶meter) | Voegt een eigen invoerveld toe aan de portaalpagina |
| setSaveParamsCallback(function) | Roept je functie aan wanneer de eigen parameters worden opgeslagen |
| setConfigPortalBlocking(false) en process() | Houdt loop() draaiend terwijl het portaal openstaat |
| setHostname("name") | Stelt de naam van het board op het netwerk in, zichtbaar in de apparatenlijst van de router |
Resetknop en portaal op aanvraag
Zodra het apparaat in zijn behuizing zit, moet je misschien de wifigegevens wijzigen. De makkelijkste manier om dat te doen zonder nieuwe code te uploaden, is een knop. In het onderstaande voorbeeld gebruiken we de BOOT-knop op ESP32 DevKit-boards; die zit op GPIO 0 en omdat er een pull-upweerstand op het board zit, geeft hij LOW als hij is ingedrukt. Een korte druk opent het portaal zonder het opgeslagen netwerk te wissen, zodat je een nieuw netwerk kunt invoeren of alleen je eigen instellingen wijzigt. 3 seconden ingedrukt houden wist het opgeslagen netwerk helemaal en herstart het board. Heb je liever een aparte knop, sluit er dan een aan op een vrije pin zoals GPIO 4; de details staan in Hoe sluit je een knop aan. De ingebouwde led op GPIO 2 toont de verbindingsstatus.
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}Eigen parameters: MQTT-server, poort en apparaatnaam
Een van de nuttigste functies van WiFiManager is dat je eigen invoervelden aan de portaalpagina kunt toevoegen. Als je een sensorboard via MQTT met Home Assistant verbindt, wil je ook het serveradres, het poortnummer en de apparaatnaam niet vastleggen in de code. Daarvoor maak je WiFiManagerParameter-objecten en voeg je ze met addParameter() toe aan het portaal. Let op één ding: WiFiManager slaat de wifinaam en het wachtwoord zelf op, maar slaat eigen parameters niet op. De waarden die de gebruiker typt opslaan is jouw taak. We gebruiken de Preferences-bibliotheek die bij de ESP32-core zit; Preferences schrijft sleutel-waardeparen naar de NVS-partitie in het flashgeheugen en die blijven behouden bij stroomuitval. Ben je benieuwd naar het Arduino-equivalent, lees dan het 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}Als je de pagina Configure WiFi in het portaal opent, zie je onder de netwerklijst drie nieuwe velden. Ze zijn vooraf ingevuld met de waarden die in NVS zijn opgeslagen, of met de standaardwaarden uit de code als er nog niets is opgeslagen. Als je op Save drukt, roept WiFiManager eerst je functie parametreleriKaydet() aan en maakt daarna verbinding met wifi. Hier is een overzicht van de parameters en functies:
| Onderdeel | Doel | Opmerking |
|---|---|---|
| WiFiManagerParameter(id, label, default, length) | Voegt een invoerveld toe aan het portaal | De id moet uniek zijn, zonder spaties of speciale tekens |
| getValue() | Geeft de tekst terug die de gebruiker heeft getypt | Het is altijd tekst; gebruik atoi() of atof() voor getallen |
| setValue(value, length) | Vult het veld in | Gebruikt om de opgeslagen waarde in het formulier te tonen |
| setSaveParamsCallback() | Roept je functie aan op het moment van opslaan | Schrijf hier naar NVS |
| setParamsPage(true) | Verplaatst de parameters naar een aparte Setup-pagina | Alleen voor het bijwerken van instellingen, zonder de wifi te wijzigen |
Let op de lengtewaarde: de grootte van de array en de parameterlengte moeten overeenkomen, anders kan een lange invoer het geheugen laten overlopen of worden afgekapt. Daarom kopieert de sketch de waarden met strlcpy(); deze functie gaat nooit voorbij de grootte van de doelarray. Het is ook een goede gewoonte om te controleren of numerieke waarden zoals het poortnummer binnen een zinnig bereik liggen voordat je ze gebruikt.
Het eigen netwerk van de ESP32: webbediening vanaf je telefoon met softAP
Het portaal van WiFiManager is eigenlijk een kant-en-klaar gebruik van de access-pointfunctie van de ESP32, en die functie kun je zelf gebruiken. Wanneer WiFi.softAP() wordt aangeroepen, gedraagt de ESP32 zich als een router: hij zendt een eigen netwerk uit, geeft de telefoon die verbinding maakt een adres zoals 192.168.4.2 en zit zelf op 192.168.4.1. Het is ideaal voor bediening met de telefoon in een tuin zonder router, op een wetenschapsbeurs op school of bij een robotwedstrijd. De functie neemt de netwerknaam, het wachtwoord, het kanaal, een optie voor een verborgen netwerk en het maximale aantal verbindingen. Het wachtwoord moet minstens 8 tekens hebben; geef je een kortere op, dan geeft softAP() false terug en komt het netwerk nooit op. Het standaardmaximum aan verbindingen is 4 en op de ESP32 kan het worden verhoogd tot 10. De onderstaande sketch toont een webpagina die de LED op GPIO 2 vanaf je telefoon aan- en uitzet:
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}Upload de code, maak met je telefoon verbinding met het netwerk BlueGrays-LED en open 192.168.4.1 in de browser. De LED gaat aan en uit terwijl je op de knoppen drukt, en de pagina toont hoeveel apparaten er verbonden zijn. Hier is geen captive portal, dus je moet het adres zelf typen. Laadt de pagina niet, bedenk dan dat de telefoon naar mobiele data kan zijn overgeschakeld omdat er geen internet is. Wil je een bedieningspaneel dat direct bijwerkt zonder de pagina te herladen, dan kun je de methode uit het artikel ESP32-webserver en WebSocket gebruiken op hetzelfde softAP-netwerk.
AP+STA samen: een eigen netwerk uitzenden terwijl je op het thuisnetwerk zit
In de modus WIFI_AP_STA maakt de ESP32 verbinding met de router en zendt tegelijk een eigen netwerk uit. Het board heeft dan twee aparte IP-adressen: WiFi.localIP() geeft het adres op het thuisnetwerk en WiFi.softAPIP() geeft 192.168.4.1 op het eigen netwerk. Het WiFiManager-portaal draait ook in deze modus, zodat het naar netwerken kan zoeken terwijl het een pagina aan je telefoon toont. In je eigen projecten kies je misschien AP+STA om een servicenetwerk achter te laten waarmee je altijd vanaf je telefoon kunt verbinden, ook als de router uit staat, of om ESP-NOW en wifi samen te gebruiken. De onderstaande sketch toont dezelfde pagina op beide interfaces:
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}De AP+STA-modus heeft een belangrijke beperking die je moet kennen: de ESP32 heeft één radio, dus beide netwerken moeten op hetzelfde kanaal draaien. Een netwerk dat je met softAP() op kanaal 1 opent, verschuift naar kanaal 11 op het moment dat de ESP32 verbinding maakt met een router op kanaal 11. Tijdens die overschakeling kan de telefoon die met het servicenetwerk is verbonden enkele seconden de verbinding verliezen. Omdat de radio over twee netwerken wordt gedeeld, daalt de doorvoer en trekt het board iets meer stroom. Heb je het servicenetwerk na de installatie niet meer nodig, dan kun je het access point uitschakelen met WiFi.softAPdisconnect(true) en het board terugzetten in de modus alleen-station.
Access point met de Raspberry Pi Pico W en MicroPython
Op de Raspberry Pi Pico W bestaat geen exact equivalent van de Arduino-WiFiManager, maar een access point opzetten kost in MicroPython maar een paar regels. network.WLAN(network.AP_IF) geeft je de access-pointinterface; met config() stel je de netwerknaam en het wachtwoord in en met active(True) zet je hem aan. De Pico W deelt ook 192.168.4.x-adressen uit aan clients en zit zelf op 192.168.4.1. De onderstaande code is een kleine webserver die de ingebouwde led van de Pico W vanaf je telefoon aan- en uitzet:
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 requestAls je de code met Thonny als main.py op de Pico W opslaat, zet het board bij elke start automatisch zijn netwerk op. Maak gewoon met je telefoon verbinding met het netwerk BlueGrays-Pico en open 192.168.4.1. Wil je een captive portal op de Pico W, dan levert de bibliotheek phew van Pimoroni een access point en een DNS-server die elk domein opvangt; het idee is hetzelfde als bij WiFiManager. Om de Pico W met je thuisnetwerk te verbinden en een webserver in stationmodus te draaien, lees je het artikel Pico W wifi-webserver, en ben je nieuw met MicroPython, kijk dan eens naar de gids MicroPython-basis.
Projectideeën met WiFiManager
- Een temperatuurdisplay om weg te geven: Laat degene die een sensorboard krijgt dat zijn metingen op een webpagina toont, het vanaf de eigen telefoon met het eigen wifi verbinden.
- Slimme-huissensor: Verbind een board dat zijn MQTT-server uit het portaal haalt met Home Assistant; niet opnieuw uploaden als het serveradres verandert.
- Alarm dat je telefoon waarschuwt: Bouw een ESP32 Telegram-bot die de bottoken als eigen parameter neemt.
- Draadloze updates voor een ingebouwd apparaat: Stuur nieuwe code met een OTA-update naar een board dat via WiFiManager met het netwerk is verbonden.
- Internetklok: Bouw een NTP-klok waarvan de tijdzone in het portaal wordt gekozen.
- Bediening in het veld zonder router: Zet met softAP een tuinbewateringspomp vanaf je telefoon aan en uit; gebruik ESP-NOW voor communicatie tussen meerdere boards.
Veelgemaakte fouten en oplossingen
| Symptoom | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| Het portaalnetwerk verschijnt niet op de telefoon | Het board heeft verbinding gemaakt met het opgeslagen netwerk, dus het portaal is niet geopend | Controleer de Serial Monitor; voer ter test één keer resetSettings() uit of open het portaal met de knop |
| Ik maak verbinding met het netwerk, maar de pagina opent niet | De telefoon is overgeschakeld op mobiele data omdat er geen internet is | Zet mobiele data uit en typ 192.168.4.1 in de browser |
| Het portaal opent niet en de Serial Monitor toont een wachtwoordwaarschuwing | Het portaalwachtwoord is korter dan 8 tekens | Gebruik een wachtwoord van minstens 8 tekens of laat de wachtwoordparameter weg |
| wm.process() of setParamsPage wordt niet herkend | Verkeerde of zeer oude WiFiManager-bibliotheek | Installeer de actuele WiFiManager van tzapu en verwijder bibliotheken met vergelijkbare namen |
| Na Save opent het board het portaal opnieuw | Verkeerd wachtwoord ingevoerd of het netwerk is 5 GHz | Controleer het wachtwoord en kies het 2,4 GHz-netwerk; zie de gids over wifi die geen verbinding maakt voor details |
| Eigen parameters gaan verloren na een herstart | De waarden zijn niet naar NVS geschreven | Sla ze op met Preferences in setSaveParamsCallback, lees ze bij het opstarten uit en zet ze met setValue() in het formulier |
| Het board gaat steeds in uploadmodus | De knop zit op GPIO 0 en wordt ingedrukt bij het opstarten | Druk op de knop nadat het board is gestart of gebruik een pin die geen strapping-pin is |
| De telefoon verliest de verbinding in AP+STA-modus | Het access point is naar het kanaal van de router verschoven | Dit is normaal; maak na een paar seconden opnieuw verbinding of gebruik softAPdisconnect(true) als je klaar bent |
WiFiManager is de makkelijkste stap om een ESP32-project van een experiment op je bureau te veranderen in een apparaat dat anderen kunnen gebruiken: het wachtwoord verdwijnt uit de code, de instellingen voer je in vanaf een telefoon en één knop zet alles terug. Nu je ook softAP en AP+STA kent, kun je in elke situatie, met of zonder router, projecten bouwen die je met je telefoon bedient. In de BlueGrays-app ontdek je ESP32-projecten zoals wifiverbinding, een asynchrone webserver, mDNS, WebSocket, OTA-updates en een Telegram-alarm, elk met stapsgewijze schakelschema's en kant-en-klare code.
Veelgestelde vragen
Wat doet ESP32 WiFiManager?
Hiermee verbind je een ESP32 vanaf je telefoon met een netwerk zonder de wifinaam en het wachtwoord in de code te schrijven. Als het board geen verbinding kan maken met een opgeslagen netwerk, opent het een eigen access point en toont het een instellingenpagina op 192.168.4.1. Het netwerk en wachtwoord dat je daar kiest, worden in permanent geheugen opgeslagen en bij de volgende start automatisch gebruikt.
Waar slaat WiFiManager het opgeslagen wifiwachtwoord op?
Op de ESP32 worden de wifinaam en het wachtwoord als eigen instellingen van het wifistuurprogramma bewaard in de NVS-partitie van het flashgeheugen. Ze worden niet gewist als je nieuwe code uploadt. Om ze te wissen, roep je resetSettings() aan of wis je het flashgeheugen volledig.
Hoe reset ik de WiFiManager-instellingen?
Roep wm.resetSettings() aan in je code en herstart het board. In de praktijk koppel je dit het best aan een knop: voeg bijvoorbeeld een controle toe die de instellingen wist als de BOOT-knop 3 seconden wordt ingedrukt. Wil je alleen het portaal openen zonder het opgeslagen netwerk te wissen, gebruik dan startConfigPortal().
Waarom opent de captive-portalpagina van de ESP32 niet?
De meest voorkomende reden is dat de telefoon ziet dat het portaalnetwerk geen internet heeft en overschakelt naar mobiele data; zet mobiele data uit en typ 192.168.4.1 in de browser. Als het board al verbinding heeft gemaakt met een opgeslagen netwerk, opent het portaal helemaal niet. Zorg er ook voor dat het portaalwachtwoord minstens 8 tekens lang is.
Kan de ESP32 tegelijk access point en station zijn?
Ja. In de modus WIFI_AP_STA zendt de ESP32 zijn eigen netwerk uit terwijl hij met de router is verbonden, en gebruikt hij twee aparte IP-adressen. Omdat er maar één radio is, moeten beide netwerken hetzelfde kanaal gebruiken; als het board met de router verbindt, schakelt het access point over naar het kanaal van de router.
Hoeveel apparaten kunnen verbinding maken met een ESP32-softAP?
In de Arduino-core staat softAP() standaard maximaal 4 apparaten toe. Op de ESP32 kun je dit met de vijfde parameter van softAP() verhogen tot 10. Het aantal verbonden apparaten lees je uit met WiFi.softAPgetStationNum().
Projecten om hierna te bouwen
Alle projecten bekijken
ESP32 Wi-Fi-verbinding in STA-modus (met lcd-scherm)
In dit project verbinden we de ESP32 in Station-modus (STA) veilig en foutbestendig met het wifinetwerk thuis. We zetten de SSID en het wachtwoord in een apart bestand secrets.h zodat ze niet in Git lekken, bouwen een automatisch herverbindingsmechanisme en tonen het RSSI-signaalniveau en het IP-adres op een I2C-lcd-scherm. De ingebouwde led werkt als statusindicator. Het is een verbindingsmanager van productieniveau.

ESP32 asynchrone webserver (met IP-weergave op lcd)
In dit project maken we van de ESP32 een asynchrone webserver die je met je telefoon of computer op hetzelfde wifinetwerk kunt bedienen. Dankzij de ESPAsyncWebServer-bibliotheek kan de server meerdere verzoeken tegelijk verwerken (anders dan de klassieke WebServer.h, die bij één verzoek blokkeert). Je opent het IP-adres van de ESP32 in een browser en klikt op de knoppen ON/OFF (de routes /on en /off) om de led op GPIO 5 aan en uit te zetten.

ESP32 mDNS: het apparaat bereiken via bluegrays-esp.local (met lcd-scherm)
In dit project voegen we een mDNS-service (Multicast DNS) toe aan de ESP32, zodat je het apparaat bereikt met een leesbare hostnaam zoals bluegrays-esp.local in plaats van een IP-adres. Ook als het IP-adres dat DHCP uitdeelt verandert, reageert het apparaat altijd op dezelfde naam. Met een kleine webserver op het board bedien je de LED vanuit je browser op http://bluegrays-esp.local/.

ESP32 WebSocket-teller (2 knoppen + lcd + realtime web)
In dit project verandert een teller met twee knoppen op de ESP32 (GPIO 5 telt op, GPIO 4 telt af). De waarde wordt direct bijgewerkt op een 16x2 I2C-lcd en, via de WebSocket-ondersteuning van ESPAsyncWebServer, in elke verbonden browser zonder de pagina te herladen. In plaats van HTTP-polling wordt één blijvende verbinding gebruikt en de ESP32 stuurt de nieuwe waarde met ws.textAll() naar iedereen.

ESP32 OTA-update: firmware draadloos installeren (met lcd-scherm)
In dit project leer je nieuwe firmware naar de ESP32 te uploaden via wifi, zonder USB-kabel. Met de ArduinoOTA-bibliotheek wordt de ESP32 zichtbaar op het netwerk en verschijnt hij automatisch als bluegrays-ota onder "Network port" in de Arduino IDE. De eerste upload gaat via USB; daarna zijn alle updates draadloos, een belangrijke functie voor apparaten die op afstand hangen.

Echte tijd van internet met ESP32 en NTP
De ESP32 verbindt met Wi-Fi en haalt met milliseconde-precisie de echte tijd op bij NTP-servers (Network Time Protocol). configTzTime() past de Turkse tijdzone (TRT, UTC+3) automatisch toe, en in landen met zomertijd wordt de overgang naar zomertijd (DST) geregeld met een POSIX TZ-string. De tijd wordt zowel naar de Serial Monitor als naar een optioneel I2C-lcd gestuurd.

ESP32 HTTPClient + weer-API (met lcd-scherm)
In dit project doet de ESP32 via internet een REST API-aanroep naar een weer-API (wttr.in) met HTTPClient.h. Het JSON-antwoord wordt verwerkt met ArduinoJson v7 en stad, temperatuur, luchtvochtigheid, weer en wind verschijnen op een I2C-LCD. wttr.in vraagt geen API-sleutel; typ gewoon de naam van een willekeurige stad.

ESP32-bewegingsalarm (PIR + buzzer + LED + Telegram)
Een slim beveiligingsalarm: als de PIR-sensor beweging detecteert, gaat de buzzer af, licht de LED op en krijgt de eigenaar direct een Telegram-melding. Een afkoeltijd van 30 seconden beperkt hoe vaak het alarm zich herhaalt; valse detecties van de PIR-sensor filtert dit niet weg. Gebruik het thuis, in een garage, een berging of een studeerkamer.
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

