Guias · 13 min de leitura

ESP32 WiFiManager: configure o Wi-Fi pelo celular (captive portal)

O ESP32 WiFiManager permite inserir a senha do Wi-Fi pelo celular: captive portal, parâmetros personalizados como MQTT, botão de redefinição, softAP e controle web com AP+STA.

ESP32 WiFiManager é uma biblioteca que permite conectar seu ESP32 a uma rede pelo celular sem escrever o nome e a senha do Wi-Fi no código. Se a placa não conseguir se conectar a uma rede salva, ela cria sua própria rede Wi-Fi; quando você se conecta a ela pelo celular, aparece uma página de configuração, você escolhe sua rede na lista, digita a senha, e o ESP32 armazena esses dados na memória permanente e se conecta. Assim, você pode usar o mesmo firmware em casa, na escola ou na casa de um amigo sem carregá-lo novamente. Tomadas inteligentes e dispositivos IoT comerciais que você configura pelo celular no primeiro uso funcionam exatamente dessa forma.

Neste guia, você vai conhecer primeiro os modos Wi-Fi do ESP32: estação (STA), ponto de acesso (AP) e AP+STA, em que ambos funcionam juntos. Depois, vamos instalar a biblioteca WiFiManager, escrever um primeiro sketch sem senha, adicionar um botão que apaga as configurações ou reabre o portal e coletar parâmetros personalizados, como servidor MQTT, porta e nome do dispositivo, na mesma página, armazenando-os permanentemente. Nas últimas seções, o ESP32 criará sua própria rede com softAP, sem roteador, para você controlar um LED pelo celular; vamos experimentar o modo AP+STA e configurar um ponto de acesso no Raspberry Pi Pico W com MicroPython.

Placa de desenvolvimento ESP32
Placa ESP32 DevKit: seu Wi-Fi pode funcionar como estação e ponto de acesso ao mesmo tempo.

O que é o ESP32 WiFiManager e como ele funciona?

Em um sketch comum para ESP32, o nome e a senha da rede ficam fixos na linha WiFi.begin("HomeNet", "password"). Quando você troca o roteador, atualiza a senha ou leva o dispositivo para outra casa, precisa abrir o código e carregá-lo novamente. O WiFiManager transfere esse trabalho para uma página web. Na inicialização, ele verifica se há uma rede salva na memória permanente (NVS) do ESP32 e, se houver, tenta se conectar a ela. Se a conexão funcionar, seu código continua sem mostrar nada. Se não houver rede salva ou a conexão falhar, o ESP32 cria seu próprio ponto de acesso, inicia um servidor DNS e disponibiliza uma página de configuração em 192.168.4.1. Como o servidor DNS responde com esse endereço a todos os domínios solicitados pelo celular, o celular abre sozinho a janela “fazer login na rede” assim que se conecta. É a mesma ideia das páginas de login de hotéis e cafés, chamada de captive portal. Quando você escolhe sua rede na página e salva a senha, o ESP32 se conecta à nova rede, fecha o ponto de acesso e guarda os dados para a próxima inicialização. Tudo isso usa os modos Wi-Fi compatíveis com o ESP32:

ModoO que fazQuando usar
WIFI_STA (estação)Conecta-se a um roteador como cliente e recebe um IP deleProjetos que acessam a internet e podem ser acessados por qualquer dispositivo da rede doméstica
WIFI_AP (ponto de acesso)Disponibiliza sua própria rede e distribui endereços 192.168.4.x aos clientesLocais sem roteador, páginas de configuração, controle pelo celular em campo
WIFI_AP_STAFaz as duas coisas ao mesmo tempo, com dois endereços IP separadosPortal do WiFiManager, permanecer na rede doméstica enquanto uma rede de serviço está aberta
WIFI_OFFDesliga o rádio completamenteEconomizar bateria, momentos em que o Wi-Fi não é necessário

Instalação da biblioteca WiFiManager

  1. Verifique se o pacote de placas ESP32 está instalado no Arduino IDE. Se não estiver, siga os passos em O que é o ESP32?.
  2. Abra Ferramentas > Gerenciar Bibliotecas e digite WiFiManager no campo de busca.
  3. Encontre a biblioteca WiFiManager cujo autor é tzapu e instale a versão mais recente (2.0.17 ou posterior).
  4. Selecione sua placa em Ferramentas > Placa (ESP32 Dev Module para a maioria dos DevKits) e defina a porta.
  5. A biblioteca não precisa de pacotes extras: WebServer, DNSServer e Preferences já vêm com o core do ESP32.
O Gerenciador de Bibliotecas lista várias bibliotecas com nomes parecidos com WiFiManager. Os sketches deste artigo foram escritos para a biblioteca de tzapu; se você instalar ESPAsyncWiFiManager ou outra WiFiManager, os nomes das funções não corresponderão e o código não compilará. Se você usa a versão 3.x do core do ESP32, instale também a versão mais recente da biblioteca; versões antigas podem não compilar no novo core.

Primeiro exemplo: conectar ao Wi-Fi sem senha no código

O sketch abaixo é a maneira mais simples de usar o WiFiManager. Não há nome nem senha de rede no código. Se a placa não conseguir se conectar à rede salva em 20 segundos, ela cria uma rede chamada BlueGrays-Kurulum. A senha do portal é kurulum123; você também poderia abrir o portal sem senha, mas qualquer pessoa por perto poderia inserir dados de rede no seu dispositivo. Se o portal ficar sem uso por 180 segundos, a placa reinicia e tenta a rede salva novamente. Esse detalhe importa: se o roteador demorar mais para iniciar do que o ESP32 após uma queda de energia, a placa não ficará presa no portal e voltará sozinha à sua rede em poucos 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}

Após carregar o código, abra o Monitor Serial em 115200 baud. Como a placa está funcionando pela primeira vez, ela não tem uma rede salva, e você verá nas linhas do WiFiManager que começam com *wm: que o ponto de acesso foi aberto. Agora pegue o celular e siga estes passos:

  1. Encontre a rede BlueGrays-Kurulum na lista de Wi-Fi do celular e conecte-se com a senha kurulum123.
  2. Em poucos segundos, a página de login abre sozinha. Se isso não acontecer, digite 192.168.4.1 no navegador.
  3. Toque em Configure WiFi (Configurar Wi-Fi). As redes detectadas pelo ESP32 aparecem junto com a intensidade do sinal.
  4. Selecione sua rede, digite a senha e pressione Save (Salvar).
  5. O ESP32 se conecta à nova rede, fecha o ponto de acesso e imprime no Monitor Serial o endereço IP recebido. Seu celular também volta à sua própria rede.
  6. Reinicie a placa: desta vez, o portal não abre e o ESP32 se conecta sozinho à rede salva em poucos segundos.

A seção Info (Informações) do portal mostra o endereço MAC da placa, detalhes do chip e o estado da memória; Exit (Sair) fecha o portal sem salvar. Estas são as principais funções do WiFiManager que você usará neste artigo:

FunçãoO que faz
autoConnect(name, password)Tenta a rede salva; se falhar, abre o portal. Retorna true após conectar
startConfigPortal(name, password)Abre o portal imediatamente, sem verificar a rede salva
setConfigPortalTimeout(s)Fecha o portal e retorna false se ficar sem uso por essa quantidade de segundos
setConnectTimeout(s)Por quanto tempo tentar se conectar à rede salva
resetSettings()Apaga o nome e a senha do Wi-Fi salvos
addParameter(¶meter)Adiciona um campo de entrada personalizado à página do portal
setSaveParamsCallback(function)Chama sua função quando os parâmetros personalizados são salvos
setConfigPortalBlocking(false) e process()Mantém loop() em execução enquanto o portal está aberto
setHostname("name")Define o nome da placa na rede, exibido na lista de dispositivos do roteador
Quando o celular se conecta à rede do portal, ele pode avisar que “esta rede não tem acesso à internet” e, depois de um tempo, tentar mudar para os dados móveis ou outra rede Wi-Fi. Se o aviso aparecer, escolha permanecer conectado; se a página não abrir, desative os dados móveis temporariamente. No iPhone, se a janela de login fechar, você pode reabrir a página tocando no ícone de informações ao lado da rede BlueGrays-Kurulum nos ajustes de Wi-Fi.

Botão de redefinição e portal sob demanda

Depois de fechar o dispositivo na caixa, você pode precisar alterar os dados do Wi-Fi. A maneira mais fácil de fazer isso sem carregar um novo código é usar um botão. No exemplo abaixo, usamos o botão BOOT das placas ESP32 DevKit; ele está conectado ao GPIO 0 e, como há um resistor de pull-up na placa, a leitura é LOW quando pressionado. Um toque curto abre o portal sem apagar a rede salva, para você inserir uma nova rede ou apenas alterar as configurações personalizadas. Manter pressionado por 3 segundos apaga completamente a rede salva e reinicia a placa. Se preferir um botão separado, conecte um a um pino livre, como GPIO 4; os detalhes estão em Como ligar um botão. O LED integrado no GPIO 2 mostra o estado da conexão.

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}
GPIO 0 é um pino de strapping: se estiver em LOW quando a placa ligar ou reiniciar, o ESP32 não executará seu código e entrará no modo de carregamento. Por isso, pressione o botão BOOT somente depois que a placa iniciar. Se você conectar o botão a outro pino em vez do GPIO 0, evite pinos de strapping como GPIO 0, 2, 5, 12 e 15; você pode ver os pinos seguros na ferramenta Pinagem.

Parâmetros personalizados: servidor MQTT, porta e nome do dispositivo

Um dos recursos mais úteis do WiFiManager é a possibilidade de adicionar seus próprios campos de entrada à página do portal. Se você está conectando uma placa com sensor ao Home Assistant por MQTT, também não vai querer fixar no código o endereço do servidor, o número da porta e o nome do dispositivo. Para isso, crie objetos WiFiManagerParameter e adicione-os ao portal com addParameter(). Só há um detalhe que exige atenção: o WiFiManager armazena o nome e a senha do Wi-Fi por conta própria, mas não armazena os parâmetros personalizados. Salvar os valores digitados pelo usuário é sua responsabilidade. Vamos usar a biblioteca Preferences, que acompanha o core do ESP32; ela grava pares de chave e valor na partição NVS da memória flash, preservando-os mesmo após quedas de energia. Se você tem curiosidade sobre o equivalente no Arduino, confira o artigo EEPROM do 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}

Quando você abrir a página Configure WiFi (Configurar Wi-Fi) no portal, verá três novos campos abaixo da lista de redes. Eles vêm preenchidos com os valores salvos na NVS ou com os valores padrão do código, se ainda não houver nada salvo. Quando você pressiona Save (Salvar), o WiFiManager primeiro chama sua função parametreleriKaydet() e depois se conecta ao Wi-Fi. Veja um resumo dos parâmetros e das funções:

ItemFinalidadeObservação
WiFiManagerParameter(id, label, default, length) (construtor que adiciona um campo de entrada ao portal)Adiciona um campo de entrada ao portalO id deve ser único, sem espaços nem caracteres especiais
getValue()Retorna o texto digitado pelo usuárioÉ sempre texto; use atoi() ou atof() para números
setValue(value, length)Preenche o campoUsado para mostrar o valor salvo no formulário
setSaveParamsCallback()Chama sua função no momento de salvarFaça a gravação na NVS aqui
setParamsPage(true)Move os parâmetros para uma página Setup (Configuração) separadaPara atualizar somente as configurações, sem alterar o Wi-Fi

Preste atenção ao valor do comprimento: o tamanho do array e o comprimento do parâmetro devem corresponder, caso contrário, uma entrada longa pode ultrapassar o espaço de memória ou ser cortada. Por isso, o sketch copia os valores com strlcpy(); essa função nunca ultrapassa o tamanho do array de destino. Também é um bom hábito verificar se valores numéricos, como o número da porta, estão em um intervalo adequado antes de usá-los.

Rede própria do ESP32: controle web pelo celular com softAP

O portal do WiFiManager é, na verdade, uma aplicação pronta do recurso de ponto de acesso do ESP32, que você também pode usar por conta própria. Quando WiFi.softAP() é chamada, o ESP32 se comporta como um roteador: disponibiliza sua própria rede, atribui ao celular conectado um endereço como 192.168.4.2 e usa 192.168.4.1 como seu próprio endereço. É ideal para controle pelo celular em um jardim sem roteador, em uma feira de ciências escolar ou em uma competição de robôs. A função recebe o nome da rede, a senha, o canal, uma opção de rede oculta e o número máximo de conexões. A senha deve ter pelo menos 8 caracteres; se você passar uma menor, softAP() retorna false e a rede não é criada. O número máximo padrão de conexões é 4 e, no ESP32, pode ser aumentado para 10. O sketch abaixo disponibiliza uma página web que liga e desliga o LED do GPIO 2 pelo celular:

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}

Carregue o código, conecte o celular à rede BlueGrays-LED e abra 192.168.4.1 no navegador. O LED liga e desliga conforme você pressiona os botões, e a página mostra quantos dispositivos estão conectados. Aqui não há captive portal, então você precisa digitar o endereço. Se a página não carregar, lembre-se de que o celular pode ter mudado para os dados móveis por não haver internet. Se quiser um painel de controle que atualize instantaneamente sem recarregar a página, você pode usar o método do artigo Servidor web e WebSocket no ESP32 na mesma rede softAP.

AP+STA juntos: disponibilizar sua própria rede enquanto está na rede doméstica

No modo WIFI_AP_STA, o ESP32 se conecta ao roteador e disponibiliza sua própria rede ao mesmo tempo. A placa passa a ter dois endereços IP separados: WiFi.localIP() fornece o endereço na rede doméstica e WiFi.softAPIP() fornece 192.168.4.1 na rede própria. O portal do WiFiManager também funciona nesse modo, podendo buscar redes enquanto disponibiliza uma página para seu celular. Nos seus projetos, você pode escolher AP+STA para manter uma rede de serviço à qual sempre possa se conectar pelo celular, mesmo quando o roteador estiver desligado, ou para usar ESP-NOW e Wi-Fi juntos. O sketch abaixo disponibiliza a mesma página nas duas 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}

O modo AP+STA tem uma limitação importante que você precisa conhecer: o ESP32 tem um único rádio, então as duas redes precisam funcionar no mesmo canal. Uma rede que você cria no canal 1 com softAP() muda para o canal 11 no instante em que o ESP32 se conecta a um roteador no canal 11. Durante essa troca, o celular conectado à rede de serviço pode perder a conexão por alguns segundos. Como o rádio é compartilhado entre duas redes, a taxa de transferência diminui e a placa consome um pouco mais de corrente. Se você não precisar mais da rede de serviço após a configuração, pode desligar o ponto de acesso com WiFi.softAPdisconnect(true) e colocar a placa novamente no modo somente estação.

Ponto de acesso com Raspberry Pi Pico W e MicroPython

Não há um equivalente exato do WiFiManager do Arduino no Raspberry Pi Pico W, mas configurar um ponto de acesso exige apenas algumas linhas no MicroPython. network.WLAN(network.AP_IF) fornece a interface de ponto de acesso; você define o nome e a senha da rede com config() e a ativa com active(True). O Pico W também distribui endereços 192.168.4.x aos clientes e usa 192.168.4.1 como seu próprio endereço. O código abaixo é um pequeno servidor web que liga e desliga o LED integrado do Pico W pelo celular:

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

Se você salvar o código no Pico W como main.py usando o Thonny, a placa criará sua rede automaticamente a cada inicialização. Basta conectar o celular à rede BlueGrays-Pico e abrir 192.168.4.1. Se quiser um captive portal no Pico W, a biblioteca phew da Pimoroni oferece um ponto de acesso e um servidor DNS que intercepta todos os domínios; a ideia é a mesma do WiFiManager. Para conectar o Pico W à rede doméstica e executar um servidor web no modo estação, confira o artigo Servidor web Wi-Fi com Pico W e, se você está começando com MicroPython, veja o guia Fundamentos de MicroPython.

Ideias de projetos com WiFiManager

  • Indicador de temperatura para presentear: Permita que quem receber uma placa com sensor que mostra as leituras em uma página web a conecte ao próprio Wi-Fi pelo celular.
  • Sensor para casa inteligente: Conecte ao Home Assistant uma placa que recebe o servidor MQTT pelo portal; sem precisar carregar o código novamente quando o endereço do servidor mudar.
  • Alarme que notifica seu celular: Crie um bot do Telegram com ESP32 que recebe o token do bot como parâmetro personalizado.
  • Atualizações sem fio para um dispositivo na caixa: Envie um novo código com uma atualização OTA para uma placa que se conectou à rede pelo WiFiManager.
  • Relógio pela internet: Monte um relógio NTP cujo fuso horário seja escolhido no portal.
  • Controle em campo sem roteador: Ligue e desligue uma bomba de irrigação do jardim pelo celular com softAP; use ESP-NOW para a comunicação entre várias placas.

Erros comuns e soluções

SintomaCausa provávelSolução
A rede do portal não aparece no celularA placa se conectou à rede salva, por isso o portal não abriuConfira o Monitor Serial; execute resetSettings() uma vez para testar ou abra o portal pelo botão
Eu me conecto à rede, mas a página não abreO celular mudou para os dados móveis porque não há internetDesative os dados móveis e digite 192.168.4.1 no navegador
O portal não abre e o Monitor Serial mostra um aviso sobre a senhaA senha do portal tem menos de 8 caracteresUse uma senha com pelo menos 8 caracteres ou omita o parâmetro de senha
wm.process() ou setParamsPage não é reconhecidaBiblioteca WiFiManager incorreta ou muito antigaInstale a versão atual do WiFiManager de tzapu e remova bibliotecas com nomes parecidos
Depois de Save (Salvar), a placa abre o portal novamenteA senha digitada está errada ou a rede é de 5 GHzConfira a senha e escolha a rede de 2,4 GHz; veja os detalhes no guia sobre Wi-Fi que não conecta
Os parâmetros personalizados se perdem após reiniciarOs valores não foram gravados na NVSSalve-os com Preferences em setSaveParamsCallback, leia-os na inicialização e coloque-os no formulário com setValue()
A placa continua entrando no modo de carregamentoO botão está no GPIO 0 e fica pressionado ao ligarPressione o botão depois que a placa iniciar ou use um pino que não seja de strapping
O celular perde a conexão no modo AP+STAO ponto de acesso mudou para o canal do roteadorIsso é normal; reconecte após alguns segundos ou use softAPdisconnect(true) ao terminar
Em caso de problemas de conexão, leia primeiro as linhas *wm: no Monitor Serial; o WiFiManager informa claramente qual rede tentou, o resultado da conexão e por que o portal fechou. Se a placa ainda não conseguir se conectar à rede depois de fechar o portal, o problema provavelmente está no roteador ou na fonte de alimentação; explicamos passo a passo como ler os códigos de estado e reason em ESP32 não conecta ao WiFi.

O WiFiManager é o passo mais fácil para transformar um projeto ESP32 de um experimento na sua mesa em um dispositivo que outras pessoas podem usar: a senha sai do código, as configurações são inseridas pelo celular e um único botão redefine tudo. Agora que você também conhece softAP e AP+STA, pode criar projetos controlados pelo celular em qualquer ambiente, com ou sem roteador. No app BlueGrays, você pode explorar projetos com ESP32, como conexão Wi-Fi, servidor web assíncrono, mDNS, WebSocket, atualizações OTA e alarme pelo Telegram, todos com esquemas do circuito passo a passo e códigos prontos para usar.

Perguntas frequentes

Para que serve o ESP32 WiFiManager?

Ele permite conectar um ESP32 a uma rede pelo celular sem escrever o nome e a senha do Wi-Fi no código. Se a placa não conseguir se conectar a uma rede salva, ela abre seu próprio ponto de acesso e disponibiliza uma página de configuração em 192.168.4.1. A rede e a senha escolhidas nessa página são armazenadas na memória permanente e usadas automaticamente na próxima inicialização.

Onde o WiFiManager armazena a senha salva do Wi-Fi?

No ESP32, o nome e a senha do Wi-Fi ficam na partição NVS da memória flash como configurações do próprio driver de Wi-Fi. Esses dados não são apagados quando você carrega um novo código. Para apagá-los, chame resetSettings() ou apague completamente a memória flash.

Como redefinir as configurações do WiFiManager?

Chame wm.resetSettings() no código e reinicie a placa. Na prática, o melhor é associar isso a um botão: por exemplo, adicione uma verificação que apague as configurações quando o botão BOOT for mantido pressionado por 3 segundos. Se você quiser apenas abrir o portal sem apagar a rede salva, use startConfigPortal().

Por que a página do captive portal do ESP32 não abre?

O motivo mais comum é que o celular percebe que não há internet na rede do portal e muda para os dados móveis; desative os dados móveis e digite 192.168.4.1 no navegador. Se a placa já estiver conectada a uma rede salva, o portal nem chega a abrir. Verifique também se a senha do portal tem pelo menos 8 caracteres.

O ESP32 pode ser ponto de acesso e estação ao mesmo tempo?

Sim. No modo WIFI_AP_STA, o ESP32 disponibiliza sua própria rede enquanto está conectado ao roteador e usa dois endereços IP separados. Como há apenas um rádio, as duas redes precisam usar o mesmo canal; quando a placa se conecta ao roteador, o ponto de acesso muda para o canal do roteador.

Quantos dispositivos podem se conectar a um softAP do ESP32?

No core do Arduino, softAP() permite até 4 dispositivos por padrão. No ESP32, você pode aumentar esse número para 10 com o quinto parâmetro de softAP(). Você pode ler a quantidade de dispositivos conectados com WiFi.softAPgetStationNum().

Ver todos os projetos
Conexão Wi-Fi STA com ESP32 e display LCD
ES-25Avançado

Conexão Wi-Fi STA com ESP32 e display LCD

Neste projeto, conectamos o ESP32 à rede Wi-Fi de casa no modo estação (STA), de forma segura e tolerante a falhas. Guardamos o SSID e a senha em um arquivo secrets.h separado para evitar que sejam expostos no Git, configuramos um mecanismo de reconexão automática e exibimos o nível de sinal RSSI e o endereço IP em um display LCD I2C. O LED integrado funciona como indicador de status. É um gerenciador de conexão pronto para uso em produção.

4.4(21)
38
Servidor web assíncrono com ESP32 (IP no LCD)
ES-27Avançado

Servidor web assíncrono com ESP32 (IP no LCD)

Neste projeto, transformamos o ESP32 em um servidor web assíncrono que você pode controlar pelo celular ou computador na mesma rede Wi-Fi. Com a biblioteca ESPAsyncWebServer, o servidor processa várias requisições ao mesmo tempo (ao contrário do WebServer.h tradicional, que bloqueia a execução ao processar uma requisição). Você poderá abrir o endereço IP do ESP32 no navegador e clicar nos botões ON/OFF (as rotas /on e /off) para ligar e desligar o LED conectado ao GPIO 5.

4.8(16)
26
ESP32 mDNS: acesso via bluegrays-esp.local (com display LCD)
ES-29Avançado
Premium

ESP32 mDNS: acesso via bluegrays-esp.local (com display LCD)

Neste projeto, adicionamos o serviço mDNS (Multicast DNS) ao ESP32 para acessar o dispositivo por um nome de host fácil de ler, como bluegrays-esp.local, em vez de um endereço IP. Mesmo que o IP atribuído pelo DHCP mude, você pode acessar o dispositivo pelo mesmo nome. Também executamos um pequeno servidor web no dispositivo para enviar comandos de controle do LED pelo navegador no endereço http://bluegrays-esp.local/.

4.8(14)
23
Contador WebSocket com ESP32 (2 botões + LCD + web em tempo real)
ES-28Avançado
Premium

Contador WebSocket com ESP32 (2 botões + LCD + web em tempo real)

Neste projeto, dois botões conectados ao ESP32 (GPIO 5 aumenta, GPIO 4 diminui) alteram um contador. O valor é atualizado instantaneamente no LCD I2C 16x2 e, com o suporte a WebSocket do ESPAsyncWebServer, em todos os navegadores conectados, sem recarregar a página. Em vez de consultas periódicas por HTTP, usamos uma única conexão persistente, e o ESP32 envia o novo valor a todos com ws.textAll().

4.5(14)
23
Atualização OTA no ESP32 — firmware sem fio (com display LCD)
ES-30Avançado
Premium

Atualização OTA no ESP32 — firmware sem fio (com display LCD)

Neste projeto, você aprende a carregar um novo firmware no ESP32 por Wi-Fi, sem cabo USB. Com a biblioteca ArduinoOTA, o ESP32 fica visível na rede e aparece automaticamente como bluegrays-ota na aba "Porta de rede" do Arduino IDE. A primeira carga é feita por USB, e todas as atualizações seguintes são sem fio — um recurso essencial para dispositivos em campo. O LCD I2C mostra o estado do Wi-Fi, o IP, o nome do host, a porcentagem de envio por OTA e as mensagens de erro em turco e inglês.

4.6(14)
22
Hora exata pela internet com ESP32 e NTP
ES-26Avançado
Premium

Hora exata pela internet com ESP32 e NTP

O ESP32 se conecta ao Wi-Fi e obtém a hora exata com precisão de milissegundos de servidores NTP (Network Time Protocol). Com a função configTzTime(), o fuso horário configurado (TRT, UTC+3 neste exemplo) é aplicado automaticamente, e as mudanças nos países que adotam horário de verão são gerenciadas automaticamente por uma string POSIX TZ. A hora é exibida tanto no Monitor Serial quanto em um LCD I2C opcional.

4.5(13)
22
ESP32 HTTPClient + API de clima (com display LCD)
ES-31Avançado
Premium

ESP32 HTTPClient + API de clima (com display LCD)

Neste projeto, usamos o ESP32 para fazer uma chamada REST à API de clima wttr.in pela internet com HTTPClient.h. Interpretamos a resposta JSON com ArduinoJson v7 e mostramos cidade, temperatura, umidade, condições do tempo e vento em um display LCD I2C, em turco e inglês. O wttr.in é grátis e não exige chave de API — basta informar o nome de uma cidade para consultar o clima atual. Os dados se atualizam sozinhos a cada 30 minutos, e o LED dá um retorno visual diferente para cada tela.

4.7(13)
20
Alarme de movimento com ESP32 (PIR + buzzer + LED + Telegram)
ES-41Avançado
Premium

Alarme de movimento com ESP32 (PIR + buzzer + LED + Telegram)

Um sistema de alarme de segurança inteligente que aciona o buzzer e o LED quando o sensor PIR detecta movimento e, ao mesmo tempo, envia uma notificação instantânea ao proprietário pelo Telegram. Inclui um intervalo de espera de 30 segundos para limitar a frequência dos alarmes repetidos; esse mecanismo não valida as detecções do PIR nem elimina disparos falsos. Pode ser usado na segurança de casas, no monitoramento de garagens, depósitos ou salas de trabalho.

9