Guías · 13 min de lectura

ESP32 WiFiManager: configurar el WiFi desde el móvil sin código

ESP32 WiFiManager: introduce la clave WiFi desde el móvil. Portal cautivo, parámetros propios como MQTT, botón de reinicio, softAP y AP+STA con control web.

ESP32 WiFiManager es una librería que te permite conectar tu ESP32 a la red desde el móvil sin escribir el nombre del WiFi ni la contraseña en el código. Si la placa no puede conectarse a una red guardada, abre su propia red WiFi; cuando te conectas a ella con el móvil aparece una página de configuración, eliges tu red de la lista, escribes la contraseña y el ESP32 guarda estos datos en su memoria permanente y se conecta. Así puedes usar el mismo programa en casa, en el instituto o en casa de un amigo sin volver a cargarlo. Los enchufes inteligentes y los dispositivos IoT comerciales que configuras desde el móvil la primera vez funcionan exactamente así.

En esta guía primero conocerás los modos WiFi del ESP32: estación (STA), punto de acceso (AP) y AP+STA, en el que ambos funcionan a la vez. Después instalaremos la librería WiFiManager, escribiremos un primer programa sin contraseña, añadiremos un botón que borra la configuración o vuelve a abrir el portal, y pediremos parámetros propios como el servidor MQTT, el puerto y el nombre del dispositivo en la misma página, guardándolos de forma permanente. En las últimas secciones el ESP32 creará su propia red con softAP, sin ningún router, para controlar un LED desde el móvil; probaremos el modo AP+STA y montaremos un punto de acceso en la Raspberry Pi Pico W con MicroPython.

Placa de desarrollo ESP32
Placa ESP32 DevKit: su WiFi puede funcionar como estación y como punto de acceso al mismo tiempo.

¿Qué es ESP32 WiFiManager y cómo funciona?

En un programa normal del ESP32, el nombre de la red y la contraseña van fijos en la línea WiFi.begin("MiRed", "contraseña"). Cuando cambias de router, actualizas la contraseña o llevas el dispositivo a otra casa, tienes que abrir el código y cargarlo de nuevo. WiFiManager traslada este trabajo a una página web. Al arrancar, comprueba si hay una red guardada en la memoria permanente del ESP32 (NVS) y, si la hay, intenta conectarse. Si lo consigue, tu código continúa sin mostrar nada. Si no hay red guardada o la conexión falla, el ESP32 abre su propio punto de acceso, arranca un servidor DNS y sirve una página de configuración en 192.168.4.1. Como el servidor DNS responde con esa dirección a cualquier dominio que pregunte el móvil, el teléfono abre solo la ventana de "iniciar sesión en la red" en cuanto se conecta. Es la misma idea que las páginas de acceso de hoteles y cafeterías y se llama portal cautivo. Cuando eliges tu red en la página y guardas la contraseña, el ESP32 se conecta a la nueva red, cierra el punto de acceso y guarda los datos para el siguiente arranque. Todo esto se basa en los modos WiFi que admite el ESP32:

ModoQué haceCuándo usarlo
WIFI_STA (estación)Se une a un router como cliente y recibe una IP de élProyectos que salen a internet y son accesibles desde cualquier dispositivo de la red de casa
WIFI_AP (punto de acceso)Emite su propia red y reparte direcciones 192.168.4.x a los clientesLugares sin router, páginas de configuración, control desde el móvil en el campo
WIFI_AP_STAHace las dos cosas a la vez, con dos direcciones IP distintasPortal de WiFiManager, seguir en la red de casa con una red de servicio abierta
WIFI_OFFApaga la radio por completoAhorrar batería, momentos en los que no hace falta WiFi

Instalar la librería WiFiManager

  1. Asegúrate de que el paquete de placas ESP32 está instalado en el Arduino IDE. Si no lo está, sigue los pasos del artículo ¿Qué es el ESP32?.
  2. Abre Herramientas > Administrar bibliotecas y escribe WiFiManager en el buscador.
  3. Busca la librería WiFiManager cuyo autor es tzapu e instala la versión más reciente (2.0.17 o superior).
  4. Elige tu placa en Herramientas > Placa (ESP32 Dev Module para la mayoría de DevKits) y selecciona el puerto.
  5. La librería no necesita paquetes extra: WebServer, DNSServer y Preferences ya vienen con el núcleo del ESP32.
En el gestor de bibliotecas hay varias librerías con nombres parecidos a WiFiManager. Los programas de este artículo están escritos para la librería de tzapu; si instalas ESPAsyncWiFiManager u otro WiFiManager, los nombres de las funciones no coincidirán y el código no compilará. Si usas la versión 3.x del núcleo ESP32, instala también la versión más reciente de la librería; las versiones antiguas pueden dar errores de compilación con el núcleo nuevo.

Primer ejemplo: conectarse al WiFi sin contraseña en el código

El programa de abajo es la forma más sencilla de usar WiFiManager. En el código no hay ni nombre de red ni contraseña. Si la placa no logra conectarse a la red guardada en 20 segundos, abre una red llamada BlueGrays-Kurulum. La contraseña del portal es kurulum123; también podrías abrir el portal sin contraseña, pero entonces cualquiera que esté cerca podría meter datos de red en tu dispositivo. Si el portal no se usa durante 180 segundos, la placa se reinicia y vuelve a probar la red guardada. Este detalle es importante: si tras un corte de luz el router arranca más despacio que el ESP32, la placa no se queda atascada en el portal y vuelve sola a tu red en unos minutos.

C++ (Arduino IDE)
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}

Después de cargar el código, abre el Monitor Serie a 115200 baudios. Como la placa arranca por primera vez, no tiene ninguna red guardada, y en las líneas de WiFiManager que empiezan por *wm: verás que se ha abierto el punto de acceso. Ahora coge el móvil y sigue estos pasos:

  1. Busca la red BlueGrays-Kurulum en la lista WiFi del móvil y conéctate con la contraseña kurulum123.
  2. En pocos segundos la página de acceso se abre sola. Si no, escribe 192.168.4.1 en el navegador.
  3. Pulsa Configure WiFi. Aparecen las redes que ve el ESP32 junto con la intensidad de su señal.
  4. Elige tu red, escribe la contraseña y pulsa Save.
  5. El ESP32 se une a la nueva red, cierra el punto de acceso y escribe en el Monitor Serie la IP que ha recibido. El móvil también vuelve a su red.
  6. Reinicia la placa: esta vez no se abre el portal y el ESP32 se conecta solo a la red guardada en pocos segundos.

La sección Info del portal muestra la dirección MAC de la placa, los datos del chip y el estado de la memoria; Exit cierra el portal sin guardar. Estas son las funciones principales de WiFiManager que usarás en este artículo:

FunciónQué hace
autoConnect(nombre, contraseña)Prueba la red guardada; si falla, abre el portal. Devuelve true al conectarse
startConfigPortal(nombre, contraseña)Abre el portal enseguida, sin mirar la red guardada
setConfigPortalTimeout(s)Cierra el portal y devuelve false si no se usa durante esos segundos
setConnectTimeout(s)Tiempo del intento de conexión a la red guardada
resetSettings()Borra el nombre y la contraseña WiFi guardados
addParameter(&parámetro)Añade un campo de entrada propio a la página del portal
setSaveParamsCallback(función)Llama a tu función cuando se guardan los parámetros propios
setConfigPortalBlocking(false) y process()Mantiene loop() en marcha mientras el portal está abierto
setHostname("nombre")Define el nombre de la placa en la red, el que aparece en la lista de dispositivos del router
Cuando el móvil se conecta a la red del portal puede avisar de que "esta red no tiene acceso a internet" y, al cabo de un rato, intentar pasarse a los datos móviles o a otra red WiFi. Si sale el aviso, elige mantener la conexión; si la página no se abre, desactiva los datos móviles temporalmente. En el iPhone, si se cierra la ventana de acceso, puedes volver a abrir la página tocando el icono de información junto a la red BlueGrays-Kurulum en los ajustes WiFi.

Botón de reinicio y portal bajo demanda

Cuando el dispositivo ya está metido en su caja, puede que tengas que cambiar los datos del WiFi. La forma más fácil de hacerlo sin cargar código nuevo es un botón. En el ejemplo usamos el botón BOOT de las placas ESP32 DevKit; está conectado al GPIO 0 y, como la placa lleva una resistencia pull-up, lee LOW al pulsarlo. Una pulsación corta abre el portal sin borrar la red guardada, así que puedes poner una red nueva o cambiar solo tus ajustes propios. Si lo mantienes 3 segundos, la red guardada se borra por completo y la placa se reinicia. Si prefieres un botón aparte, conéctalo a un pin libre como el GPIO 4; tienes los detalles en Cómo conectar un botón. El LED integrado del GPIO 2 indica el estado de la conexión.

C++ (Arduino IDE)
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}
El GPIO 0 es un pin de arranque (strapping): si está en LOW cuando la placa se enciende o se reinicia, el ESP32 no ejecuta tu código y entra en modo de carga. Por eso pulsa el botón BOOT solo cuando la placa ya haya arrancado. Si conectas el botón a otro pin en vez del GPIO 0, evita los pines de arranque como GPIO 0, 2, 5, 12 y 15; puedes ver los pines seguros en la herramienta Pinout.

Parámetros propios: servidor MQTT, puerto y nombre del dispositivo

Una de las funciones más útiles de WiFiManager es que puedes añadir tus propios campos a la página del portal. Si conectas una placa de sensores a Home Assistant por MQTT, tampoco querrás dejar fijos en el código la dirección del servidor, el puerto y el nombre del dispositivo. Para ello creas objetos WiFiManagerParameter y los añades al portal con addParameter(). Solo hay un detalle a tener en cuenta: WiFiManager guarda él mismo el nombre y la contraseña del WiFi, pero no guarda los parámetros propios. Guardar los valores que escribe el usuario es tarea tuya. Usaremos la librería Preferences que viene con el núcleo del ESP32; Preferences escribe pares clave-valor en la partición NVS de la memoria flash y no se pierden aunque se corte la luz. Si te interesa el equivalente en Arduino, mira el artículo EEPROM de Arduino.

C++ (Arduino IDE)
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}

Cuando abras la página Configure WiFi del portal verás tres campos nuevos bajo la lista de redes. Aparecen rellenos con los valores guardados en NVS, o con los valores por defecto del código si aún no hay nada guardado. Al pulsar Save, WiFiManager primero llama a tu función parametreleriKaydet() y luego se conecta al WiFi. Este es el resumen de los parámetros y funciones:

ElementoPara qué sirveNota
WiFiManagerParameter(id, etiqueta, por defecto, longitud)Añade un campo de entrada al portalEl id debe ser único, sin espacios ni caracteres especiales
getValue()Devuelve el texto que escribió el usuarioSiempre es texto; para números usa atoi() o atof()
setValue(valor, longitud)Rellena el campoPara mostrar el valor guardado en el formulario
setSaveParamsCallback()Llama a tu función en el momento de guardarEscribe en NVS aquí
setParamsPage(true)Lleva los parámetros a una página Setup apartePara cambiar solo ajustes sin tocar el WiFi

Ojo con el valor de longitud: el tamaño del array y la longitud del parámetro deben coincidir; si no, una entrada larga podría desbordar la memoria o quedar cortada. Por eso el programa copia los valores con strlcpy(), que nunca pasa del tamaño del array de destino. También es buena costumbre comprobar que los valores numéricos, como el puerto, están en un rango lógico antes de usarlos.

La red propia del ESP32: control web desde el móvil con softAP

El portal de WiFiManager es en realidad un uso ya preparado de la función de punto de acceso del ESP32, y tú también puedes usarla. Al llamar a WiFi.softAP(), el ESP32 se comporta como un router: emite su propia red, da al móvil que se conecta una dirección como 192.168.4.2 y él mismo queda en 192.168.4.1. Es ideal para controlar algo desde el móvil en un jardín sin router, en una feria de ciencias del instituto o en una competición de robots. La función recibe el nombre de la red, la contraseña, el canal, una opción de red oculta y el número máximo de conexiones. La contraseña debe tener al menos 8 caracteres; si pasas una más corta, softAP() devuelve false y la red no llega a abrirse. Por defecto se permiten 4 conexiones como máximo, y en el ESP32 se puede subir hasta 10. El programa de abajo sirve una página web que enciende y apaga el LED del GPIO 2 desde el móvil:

C++ (Arduino IDE)
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}

Carga el código, conecta el móvil a la red BlueGrays-LED y abre 192.168.4.1 en el navegador. El LED se enciende y se apaga al pulsar los botones y la página muestra cuántos dispositivos hay conectados. Aquí no hay portal cautivo, así que tienes que escribir la dirección tú. Si la página no carga, recuerda que el móvil puede haber pasado a datos móviles por no tener internet. Si quieres un panel de control que se actualice al instante sin recargar la página, puedes usar el método del artículo servidor web ESP32 y WebSocket sobre la misma red softAP.

AP+STA a la vez: emitir tu propia red sin salir de la red de casa

En el modo WIFI_AP_STA el ESP32 se conecta al router y a la vez emite su propia red. La placa tiene entonces dos direcciones IP distintas: WiFi.localIP() da la dirección en la red de casa y WiFi.softAPIP() da la 192.168.4.1 de su propia red. El portal de WiFiManager también funciona en este modo, para poder buscar redes mientras sirve una página al móvil. En tus proyectos puedes elegir AP+STA para dejar una red de servicio a la que conectarte siempre desde el móvil, incluso con el router apagado, o para usar ESP-NOW y WiFi juntos. El programa de abajo sirve la misma página en las dos interfaces:

C++ (Arduino IDE)
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}

El modo AP+STA tiene un límite importante que debes conocer: el ESP32 tiene una sola radio, así que las dos redes deben funcionar en el mismo canal. Una red que abres en el canal 1 con softAP() pasa al canal 11 en el momento en que el ESP32 se conecta a un router en el canal 11. Durante ese cambio, el móvil conectado a la red de servicio puede perder la conexión unos segundos. Como la radio se reparte entre dos redes, la velocidad baja y la placa consume algo más de corriente. Si ya no necesitas la red de servicio una vez terminada la configuración, puedes apagar el punto de acceso con WiFi.softAPdisconnect(true) y dejar la placa solo en modo estación.

Punto de acceso con la Raspberry Pi Pico W y MicroPython

En la Raspberry Pi Pico W no existe un equivalente exacto del WiFiManager de Arduino, pero montar un punto de acceso en MicroPython lleva solo unas líneas. network.WLAN(network.AP_IF) te da la interfaz de punto de acceso; defines el nombre de la red y la contraseña con config() y la activas con active(True). La Pico W también reparte direcciones 192.168.4.x a los clientes y ella queda en 192.168.4.1. El código de abajo es un pequeño servidor web que enciende y apaga el LED integrado de la Pico W desde el móvil:

MicroPython
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 request

Si guardas el código en la Pico W como main.py con Thonny, la placa crea su red automáticamente en cada arranque. Solo tienes que conectar el móvil a la red BlueGrays-Pico y abrir 192.168.4.1. Si quieres un portal cautivo en la Pico W, la librería phew de Pimoroni ofrece un punto de acceso y un servidor DNS que captura todos los dominios; la idea es la misma que la de WiFiManager. Para conectar la Pico W a la red de casa y montar un servidor web en modo estación, consulta el artículo servidor web WiFi con Pico W, y si eres nuevo en MicroPython, echa un vistazo a fundamentos de MicroPython.

Ideas de proyectos con WiFiManager

  • Indicador de temperatura para regalar: Quien reciba una placa de sensores que muestra sus lecturas en una página web podrá conectarla a su propio WiFi desde el móvil.
  • Sensor domótico: Conecta a Home Assistant una placa que toma su servidor MQTT del portal; si cambia la dirección del servidor, no hace falta recargar el código.
  • Alarma con aviso al móvil: Crea un bot de Telegram con ESP32 que pida el token del bot como parámetro propio.
  • Actualizaciones inalámbricas en la caja: Envía código nuevo con una actualización OTA a una placa que se unió a la red con WiFiManager.
  • Reloj por internet: Monta un reloj NTP cuya zona horaria se elija en el portal.
  • Control sin router: Enciende y apaga desde el móvil la bomba de riego del jardín con softAP; para comunicar varias placas entre sí usa ESP-NOW.

Errores frecuentes y soluciones

SíntomaCausa probableSolución
La red del portal no aparece en el móvilLa placa se conectó a la red guardada y no abrió el portalMira el Monitor Serie; para probar, ejecuta resetSettings() una vez o abre el portal con el botón
Me conecto a la red pero la página no se abreEl móvil pasó a datos móviles al no haber internetDesactiva los datos móviles y escribe 192.168.4.1 en el navegador
El portal no se abre y el Monitor Serie avisa de la contraseñaLa contraseña del portal tiene menos de 8 caracteresUsa una contraseña de 8 caracteres o más, o no pases el parámetro de contraseña
No se reconoce wm.process() o setParamsPageLibrería WiFiManager equivocada o muy antiguaInstala la versión actual del WiFiManager de tzapu y quita las librerías de nombre parecido
Tras Save la placa vuelve a abrir el portalContraseña mal escrita o red de 5 GHzRevisa la contraseña y elige la red de 2,4 GHz; más detalles en la guía de WiFi que no conecta
Los parámetros propios se pierden al reiniciarLos valores no se escribieron en NVSGuárdalos con Preferences en setSaveParamsCallback, léelos al arrancar y ponlos en el formulario con setValue()
La placa entra una y otra vez en modo de cargaEl botón está en el GPIO 0 y pulsado al encenderPulsa el botón después de arrancar o usa un pin que no sea de arranque
En modo AP+STA el móvil pierde la conexiónEl punto de acceso se movió al canal del routerEs normal; vuelve a conectarte en unos segundos o usa softAPdisconnect(true) al terminar
Ante problemas de conexión, lee primero las líneas *wm: del Monitor Serie; WiFiManager indica con claridad qué red probó, el resultado de la conexión y por qué se cerró el portal. Si la placa sigue sin conectarse después de cerrar el portal, lo más probable es que el problema esté en el router o en la alimentación; explicamos paso a paso cómo leer los códigos de estado y de motivo en ESP32 no se conecta al WiFi.

WiFiManager es el paso más sencillo para convertir un proyecto con ESP32 de un experimento en tu mesa en un dispositivo que otros pueden usar: la contraseña sale del código, los ajustes se introducen desde el móvil y un solo botón lo reinicia todo. Ahora que también conoces softAP y AP+STA, puedes crear proyectos controlados desde el móvil en cualquier lugar, con router o sin él. En la app BlueGrays puedes explorar proyectos con ESP32 como conexión WiFi, servidor web asíncrono, mDNS, WebSocket, actualización OTA y alarma por Telegram, con esquemas paso a paso y código listo para usar.

Preguntas frecuentes

¿Para qué sirve ESP32 WiFiManager?

Sirve para conectar un ESP32 a la red desde el móvil sin escribir el nombre del WiFi ni la contraseña en el código. Si la placa no puede conectarse a una red guardada, abre su propio punto de acceso y muestra una página de configuración en 192.168.4.1. La red y la contraseña que elijas ahí se guardan en la memoria permanente y se usan solas en el siguiente arranque.

¿Dónde guarda WiFiManager la contraseña del WiFi?

En el ESP32, el nombre y la contraseña del WiFi se guardan en la partición NVS de la memoria flash, como ajustes propios del controlador WiFi. No se borran al cargar un código nuevo. Para borrarlos, llama a resetSettings() o borra la flash por completo.

¿Cómo se reinicia la configuración de WiFiManager?

Basta con llamar a wm.resetSettings() en el código y reiniciar la placa. En la práctica lo mejor es asociarlo a un botón: por ejemplo, una comprobación que borre los ajustes cuando el botón BOOT se mantiene pulsado 3 segundos. Si solo quieres abrir el portal sin borrar la red guardada, usa startConfigPortal().

¿Por qué no se abre el portal cautivo del ESP32?

Lo más habitual es que el móvil vea que no hay internet en la red del portal y se pase a los datos móviles; desactívalos y escribe 192.168.4.1 en el navegador. Si la placa ya se ha conectado a una red guardada, el portal no se abre. Comprueba también que la contraseña del portal tenga al menos 8 caracteres.

¿Puede el ESP32 ser punto de acceso y estación a la vez?

Sí. En el modo WIFI_AP_STA el ESP32 emite su propia red mientras está conectado al router y usa dos direcciones IP distintas. Como solo tiene una radio, las dos redes deben usar el mismo canal; cuando la placa se une al router, el punto de acceso pasa al canal del router.

¿Cuántos dispositivos se pueden conectar a un softAP del ESP32?

En el núcleo de Arduino, softAP() admite por defecto hasta 4 dispositivos. En el ESP32 puedes subirlo hasta 10 con el quinto parámetro de softAP(). El número de dispositivos conectados se lee con WiFi.softAPgetStationNum().

Ver todos los proyectos
Conexión Wi-Fi STA con ESP32 (con pantalla LCD)
ES-25Avanzado

Conexión Wi-Fi STA con ESP32 (con pantalla LCD)

En este proyecto, conectamos el ESP32 a la red Wi-Fi doméstica en modo Station (STA) de forma segura y tolerante a fallos. Separamos el SSID y la contraseña en el archivo secrets.h para evitar que se filtren a Git, configuramos un mecanismo de reconexión automática y mostramos el nivel de señal RSSI y la dirección IP en una pantalla LCD I2C. El LED interno actúa como indicador de estado.

4.4(21)
38
Servidor web asíncrono ESP32 (con indicación de IP en la pantalla LCD)
ES-27Avanzado

Servidor web asíncrono ESP32 (con indicación de IP en la pantalla LCD)

En este proyecto, convertimos el ESP32 en un servidor web asíncrono que puedes controlar desde tu teléfono o tu ordenador, siempre que estén conectados a la misma red Wi-Fi. Gracias a la biblioteca ESPAsyncWebServer, el servidor puede procesar varias solicitudes al mismo tiempo (a diferencia del clásico WebServer.h, que se bloquea con una sola solicitud).

4.8(16)
26
ESP32 mDNS: Acceso al dispositivo mediante bluegrays-esp.local (con pantalla LCD)
ES-29Avanzado
Premium

ESP32 mDNS: Acceso al dispositivo mediante bluegrays-esp.local (con pantalla LCD)

Añadimos un servicio mDNS (Multicast DNS) al ESP32 para que accedas a él con un nombre de host legible como bluegrays-esp.local en lugar de una dirección IP. Aunque cambie la IP que asigna el DHCP, el dispositivo siempre responde al mismo nombre. Un pequeño servidor web en la placa te permite controlar el LED desde el navegador en http://bluegrays-esp.local/.

4.8(14)
23
Contador ESP32 WebSocket (2 botones + pantalla LCD + web en tiempo real)
ES-28Avanzado
Premium

Contador ESP32 WebSocket (2 botones + pantalla LCD + web en tiempo real)

En este proyecto, dos botones conectados al ESP32 (GPIO 5 suma, GPIO 4 resta) cambian un contador. El valor se actualiza al instante en una pantalla LCD I2C de 16x2 y, gracias al soporte WebSocket de ESPAsyncWebServer, en todos los navegadores conectados sin recargar la página. En lugar del sondeo HTTP se usa una única conexión persistente y el ESP32 envía el nuevo valor a todos con ws.textAll().

4.5(14)
23
Actualización OTA del ESP32 — Instalación inalámbrica del firmware (con pantalla LCD)
ES-30Avanzado
Premium

Actualización OTA del ESP32 — Instalación inalámbrica del firmware (con pantalla LCD)

Aprenderás a cargar un firmware nuevo en el ESP32 por Wi-Fi, sin cable USB. Con la biblioteca ArduinoOTA, el ESP32 se hace visible en la red y aparece automáticamente como bluegrays-ota en la pestaña "Network port" del Arduino IDE. La primera carga se hace por USB; después, todas las actualizaciones son inalámbricas, algo clave para los dispositivos instalados sobre el terreno.

4.6(14)
22
ESP32: hora real desde Internet con NTP
ES-26Avanzado
Premium

ESP32: hora real desde Internet con NTP

El ESP32 se conecta al Wi-Fi y obtiene la hora real de servidores NTP (Network Time Protocol) con precisión de milisegundos. Gracias a configTzTime(), se aplica automáticamente la zona horaria de Turquía (TRT, UTC+3), y en los países con horario de verano el cambio (DST) se gestiona solo mediante una cadena POSIX TZ. La hora se muestra en el Serial Monitor y en una LCD I2C opcional.

4.5(13)
22
ESP32 HTTPClient + API del tiempo (con pantalla LCD)
ES-31Avanzado
Premium

ESP32 HTTPClient + API del tiempo (con pantalla LCD)

El ESP32 hace una llamada REST por internet a una API del tiempo (wttr.in) con HTTPClient.h. La respuesta JSON se analiza con ArduinoJson v7, y la ciudad, la temperatura, la humedad, el estado del tiempo y el viento aparecen en una LCD I2C. wttr.in no pide clave de API: basta con escribir el nombre de cualquier ciudad.

4.7(13)
20
Sistema de Alarma de Movimiento ESP32 (PIR + Buzzer + LED + Telegram)
ES-41Avanzado
Premium

Sistema de Alarma de Movimiento ESP32 (PIR + Buzzer + LED + Telegram)

Una alarma de seguridad inteligente: cuando el sensor PIR detecta movimiento, suena el zumbador, se enciende el LED y el dueño recibe al instante una notificación por Telegram. Una espera de 30 segundos (cooldown) limita cada cuánto se repite la alarma; no elimina las falsas detecciones del sensor PIR. Sirve para casa, garaje, almacén o estudio.

9