Monitorando e Mantendo a Conexão Wi-Fi no ESP32

Introdução🔗

Imagine que você está desenvolvendo um sistema de automação residencial usando o ESP32. Tudo funciona perfeitamente enquanto você está por perto, mas em algum momento, a conexão Wi-Fi cai e seu sistema para de funcionar. Sem uma estratégia para detectar e reconectar automaticamente, seu projeto pode falhar nos momentos mais críticos.

Para evitar esse tipo de problema, é essencial entender como o ESP32 gerencia a conexão Wi-Fi e como podemos implementar mecanismos para monitorar e manter essa conexão ativa.

Entendendo o Gerenciamento de Wi-Fi no ESP32🔗

O ESP32 possui uma pilha de protocolos Wi-Fi integrada que lida com a maioria das tarefas de conexão. No entanto, situações como sinal fraco, queda da rede ou problemas no roteador podem desconectar o dispositivo. Por isso, precisamos implementar soluções no código para lidar com essas eventualidades.

Modos de Operação

O ESP32 pode operar em três modos principais:

• Station Mode (STA): Conecta-se a um ponto de acesso (AP) existente, como um roteador doméstico.
• Access Point Mode (AP): Atua como um ponto de acesso, permitindo que outros dispositivos se conectem a ele.
• Dual Mode (AP+STA): Opera simultaneamente nos modos STA e AP.

Neste artigo, focaremos no Station Mode, já que o objetivo é manter o ESP32 conectado a uma rede Wi-Fi existente.

Implementando Monitoramento de Conexão🔗

Para monitorar a conexão Wi-Fi, precisamos utilizar funções que nos informem o estado atual da conexão. A biblioteca WiFi do ESP32 nos fornece ferramentas para isso.

Passo 1: Incluindo as Bibliotecas Necessárias

Primeiro, devemos incluir as bibliotecas essenciais no nosso código:

#include <WiFi.h>

Passo 2: Configurando as Credenciais da Rede

Defina o nome da rede (SSID) e a senha (PASSWORD):

const char* ssid = "SEU_SSID";
const char* password = "SUA_SENHA";

Passo 3: Conectando ao Wi-Fi

No setup(), iniciamos a conexão:

void setup() {
  Serial.begin(115200);
  WiFi.begin(ssid, password);
  Serial.print("Conectando-se ao Wi-Fi");
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("\nConectado com sucesso!");
  Serial.print("Endereço IP: ");
  Serial.println(WiFi.localIP());
}

Passo 4: Monitorando o Status da Conexão no Loop

Para monitorar continuamente a conexão, utilizamos o loop():

void loop() {
  if (WiFi.status() != WL_CONNECTED) {
    Serial.println("Conexão perdida. Tentando reconectar...");
    reconnectWiFi();
  } else {
    // Código da sua aplicação
  }
  delay(1000);
}

Passo 5: Implementando a Função de Reconexão

Criamos uma função para reconectar ao Wi-Fi:

void reconnectWiFi() {
  WiFi.disconnect();
  WiFi.begin(ssid, password);
  int tentativas = 0;
  while (WiFi.status() != WL_CONNECTED && tentativas < 10) {
    delay(1000);
    Serial.print(".");
    tentativas++;
  }
  if (WiFi.status() == WL_CONNECTED) {
    Serial.println("\nReconectado com sucesso!");
    Serial.print("Endereço IP: ");
    Serial.println(WiFi.localIP());
  } else {
    Serial.println("\nNão foi possível reconectar ao Wi-Fi.");
  }
}

Lidando com Eventos Wi-Fi🔗

O ESP32 permite registrar eventos relacionados ao Wi-Fi, o que nos dá mais controle sobre a conexão.

Passo 1: Registrando um Manipulador de Eventos

No setup(), registramos o manipulador:

WiFi.onEvent(WiFiEvent);

Passo 2: Definindo o Manipulador de Eventos

Implementamos a função WiFiEvent para lidar com diferentes eventos:

void WiFiEvent(WiFiEvent_t event) {
  switch (event) {
    case SYSTEM_EVENT_STA_GOT_IP:
      Serial.println("Obtido endereço IP:");
      Serial.println(WiFi.localIP());
      break;
    case SYSTEM_EVENT_STA_DISCONNECTED:
      Serial.println("Conexão Wi-Fi perdida. Tentando reconectar...");
      WiFi.reconnect();
      break;
    default:
      break;
  }
}

Implementando um Watchdog de Conexão🔗

Um watchdog é um mecanismo que monitora o sistema e toma ações corretivas caso algo dê errado.

Passo 1: Configurando uma Tarefa de Monitoramento

Utilizamos o FreeRTOS, que é o sistema operacional em tempo real do ESP32, para criar uma tarefa que monitora a conexão:

void monitorWiFi(void * parameter) {
  for (;;) {
    if (WiFi.status() != WL_CONNECTED) {
      Serial.println("Wi-Fi desconectado. Reiniciando...");
      ESP.restart();
    }
    vTaskDelay(10000 / portTICK_PERIOD_MS); // Verifica a cada 10 segundos
  }
}

Passo 2: Iniciando a Tarefa no Setup

No setup(), iniciamos a tarefa:

xTaskCreate(
  monitorWiFi,    // Função da tarefa
  "MonitorWiFi",  // Nome da tarefa
  10000,          // Tamanho da pilha
  NULL,           // Parâmetro
  1,              // Prioridade
  NULL            // Handle da tarefa
);

Melhorando a Estabilidade da Conexão🔗

Além de monitorar e reconectar, podemos implementar técnicas para melhorar a estabilidade.

Utilizando IP Estático

Atribuir um IP estático pode reduzir o tempo de reconexão:

IPAddress local_IP(192, 168, 1, 184);
IPAddress gateway(192, 168, 1, 1);
IPAddress subnet(255, 255, 0, 0);
if (!WiFi.config(local_IP, gateway, subnet)) {
  Serial.println("Configuração de IP estático falhou.");
}

Ajustando Parâmetros Wi-Fi

Podemos ajustar parâmetros como potência do sinal e intervalo de beacon:

WiFi.setTxPower(WIFI_POWER_11dBm); // Ajusta a potência de transmissão
WiFi.setSleep(false); // Desativa o modo sleep do Wi-Fi

Exemplo Completo🔗

Integrando tudo, temos um código completo para monitorar e manter a conexão Wi-Fi:

#include <WiFi.h>
const char* ssid = "SEU_SSID";
const char* password = "SUA_SENHA";
void setup() {
  Serial.begin(115200);
  WiFi.onEvent(WiFiEvent);
  WiFi.begin(ssid, password);
  Serial.print("Conectando-se ao Wi-Fi");
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("\nConectado com sucesso!");
  Serial.print("Endereço IP: ");
  Serial.println(WiFi.localIP());
  xTaskCreate(
    monitorWiFi,
    "MonitorWiFi",
    10000,
    NULL,
    1,
    NULL
  );
}
void loop() {
  // Código principal da aplicação
}
void WiFiEvent(WiFiEvent_t event) {
  switch (event) {
    case SYSTEM_EVENT_STA_GOT_IP:
      Serial.println("Obtido endereço IP:");
      Serial.println(WiFi.localIP());
      break;
    case SYSTEM_EVENT_STA_DISCONNECTED:
      Serial.println("Conexão Wi-Fi perdida. Tentando reconectar...");
      WiFi.reconnect();
      break;
    default:
      break;
  }
}
void monitorWiFi(void * parameter) {
  for (;;) {
    if (WiFi.status() != WL_CONNECTED) {
      Serial.println("Wi-Fi desconectado. Reiniciando...");
      ESP.restart();
    }
    vTaskDelay(10000 / portTICK_PERIOD_MS);
  }
}

Testando o Código🔗

Para testar se o monitoramento está funcionando:

1. Desligue o roteador: O ESP32 deve detectar a perda de conexão e tentar reconectar.

2. Desative a rede Wi-Fi: Use as configurações do roteador para desativar temporariamente o Wi-Fi.

3. Altere as credenciais: Modifique o SSID ou a senha para valores incorretos e observe como o ESP32 reage.

Boas Práticas🔗

• Reconexões Exponenciais: Em vez de tentar reconectar continuamente, implemente um algoritmo de reconexão exponencial para evitar sobrecarregar a rede.
• Logs Detalhados: Mantenha registros das tentativas de reconexão, permitindo uma análise posterior.
• Timeouts: Defina limites para as tentativas de reconexão, evitando loops infinitos.

Considerações Finais🔗

Manter o ESP32 conectado ao Wi-Fi de forma confiável é fundamental para aplicações de IoT. Com as técnicas apresentadas, você pode garantir que seu dispositivo seja capaz de detectar problemas de conexão e tomar medidas para restabelecê-la automaticamente.

Lembre-se de que, em ambientes reais, diversos fatores podem afetar a conectividade. Portanto, é importante testar sua aplicação em diferentes cenários e implementar soluções que atendam às necessidades específicas do seu projeto.

Próximos Passos🔗

Agora que você sabe como monitorar e manter a conexão Wi-Fi no ESP32, pode avançar para implementar funcionalidades mais complexas, confiando na estabilidade da sua conexão de rede. Essa base sólida permitirá integrar serviços online, comunicar-se com servidores remotos e criar aplicações robustas de IoT.

Resumo🔗

Neste artigo, abordamos:

• Monitoramento da Conexão Wi-Fi: Como verificar o estado da conexão e reagir a alterações.
• Reconexão Automática: Implementação de mecanismos para reconectar automaticamente ao Wi-Fi.
• Eventos Wi-Fi: Uso de manipuladores de eventos para respostas imediatas a mudanças na conexão.
• Melhoria da Estabilidade: Técnicas para otimizar a conexão, como uso de IP estático e ajustes de parâmetros.
• Exemplo Prático: Código completo integrando todas as técnicas apresentadas.

Com essas ferramentas, você está preparado para desenvolver aplicações Wi-Fi com o ESP32 que sejam resilientes e confiáveis, mesmo diante de desafios no ambiente de rede.

Referências🔗

• Arduino IDE Official Website arduino.cc
• Documentação da Espressif docs.espressif.com
• Documentação do ESP32 Arduino Core docs.espressif.com/projects/arduino-esp32