Como ver a intensidade do sinal Wi-Fi no ESP32 com display OLED SSD1306 mostrando RSSI em dBm

Exemplo prático de como medir a intensidade do sinal Wi-Fi (RSSI) no ESP32 usando display OLED SSD1306, exibindo o IP e a qualidade do sinal em dBm em tempo real.

Qual o Alcance do Wi-Fi no ESP32? + Qual a Intensidade Ideal do Sinal (dBm) Explicado

Projeto com ESP32 que mostra como visualizar a intensidade do sinal Wi-Fi (RSSI) em dBm diretamente em um display OLED SSD1306, incluindo IP da rede e indicador de qualidade do sinal em tempo real.

Se você quer deixar seus projetos com ESP32 mais profissionais e independentes do Monitor Serial, este projeto é perfeito!

Neste tutorial, você vai aprender a:

✅ Exibir o IP do ESP32 no display OLED
✅ Mostrar a força do Wi-Fi (RSSI)
✅ Criar um ícone de Wi-Fi animado
✅ Entender a diferença entre as bibliotecas U8g2lib e Adafruit SSD1306

🔧 Componentes Utilizados

ESP32
Display OLED SSD1306 (I2C)
Jumpers

Ligação do Display OLED no ESP32

ligacao-display-oled-esp32-i2c-endereco-ip

Exemplo de ligação do display OLED I2C no ESP32 exibindo o endereço IP .

Código Completo (IP - RSSI - dBm)



/*
***************************************************************
=========================================================
 PROJETO: Monitor Wi-Fi com ESP32 + OLED SSD1306
=========================================================

Descrição:
Este projeto exibe no display OLED SSD1306:

- Endereço IP do ESP32
- Intensidade do sinal Wi-Fi (RSSI em dBm)
- Barras visuais estilo Wi-Fi (qualidade do sinal)

Ideal para:
- Projetos IoT
- Monitoramento de rede Wi-Fi
- Interfaces sem Monitor Serial

---------------------------------------------------------
Bibliotecas utilizadas:

- WiFi.h
- U8g2lib.h
---------------------------------------------------------
Autor: RodRobot
=========================================================
***************************************************************
*/


// Inclui a biblioteca para usar Wi-Fi no ESP32
#include <WiFi.h>

// Inclui a biblioteca do display OLED (U8g2)
#include <U8g2lib.h>

// Cria o objeto do display OLED via I2C
// 128x64 pixels, sem nome específico, buffer completo (_F_)
U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0);

// Nome da rede Wi-Fi (SSID)
const char* ssid = "SEU_WIFI";

// Senha da rede Wi-Fi
const char* password = "SUA_SENHA";


// =========================================================
// FUNÇÃO SETUP (executa uma vez)
// =========================================================
void setup() {

  // Inicializa o display OLED
  u8g2.begin();

  // Inicia a conexão Wi-Fi
  WiFi.begin(ssid, password);

  // Limpa o buffer do display (memória interna)
  u8g2.clearBuffer();

  // Define uma fonte para o texto
  u8g2.setFont(u8g2_font_ncenB08_tr);

  // Escreve mensagem na tela
  u8g2.drawStr(10, 30, "Conectando...");

  // Envia o conteúdo do buffer para o display
  u8g2.sendBuffer();

  // Aguarda até conectar no Wi-Fi
  while (WiFi.status() != WL_CONNECTED) {
    delay(500); // pequena pausa
  }
}


// =========================================================
// FUNÇÃO PARA DESENHAR AS BARRAS DE SINAL
// =========================================================
void drawSignalBars(int rssi) {

  int bars = 0; // variável que define quantas barras acender

  // Define quantidade de barras baseado no RSSI (força do sinal)
  if (rssi > -60) bars = 4;        // sinal excelente
  else if (rssi > -70) bars = 3;   // bom
  else if (rssi > -80) bars = 2;   // médio
  else if (rssi > -90) bars = 1;   // fraco
  else bars = 0;                   // muito fraco

  int x = 0;   // posição horizontal inicial
  int y = 64;  // posição vertical (parte inferior do display)

  // Loop para desenhar 4 barras
  for (int i = 0; i < 4; i++) {

    // Altura da barra (cada barra é maior que a anterior)
    int height = (i + 1) * 4;

    // Se estiver dentro da quantidade de barras -> preenchida
    if (i < bars) {
      u8g2.drawBox(x + (i * 8), y - height, 6, height);
    } 
    // Caso contrário -> só contorno
    else {
      u8g2.drawFrame(x + (i * 8), y - height, 6, height);
    }
  }
}


// =========================================================
// LOOP PRINCIPAL (executa continuamente)
// =========================================================
void loop() {

  // Limpa o buffer do display antes de redesenhar
  u8g2.clearBuffer();

  // Obtém o IP do ESP32 como texto
  String ip = WiFi.localIP().toString();

  // Obtém a intensidade do sinal Wi-Fi (RSSI)
  int rssi = WiFi.RSSI();

  // Define fonte maior para destacar o IP
  u8g2.setFont(u8g2_font_logisoso16_tr);

  // Mostra o IP na tela (posição X=0, Y=20)
  u8g2.drawStr(0, 20, ip.c_str());

  // Define fonte menor para o RSSI
  u8g2.setFont(u8g2_font_6x10_tr);

  // Cria string formatada com o valor do RSSI
  char rssiStr[20];
  sprintf(rssiStr, "RSSI: %d dBm", rssi);

  // Mostra o RSSI na tela
  u8g2.drawStr(0, 38, rssiStr);

  // Desenha as barras de sinal
  drawSignalBars(rssi);

  // Envia tudo para o display OLED
  u8g2.sendBuffer();

  // Atualiza a cada 1 segundo
  delay(1000);
}



Código Completo (Barras animadas estilo celular - dBm)

/*
***************************************************************
=====================================================
 PROJETO: Monitor de Sinal Wi-Fi com ESP32 + OLED
=====================================================

 DESCRIÇÃO:
Este projeto utiliza um ESP32 com display OLED SSD1306
para mostrar em tempo real a qualidade do sinal Wi-Fi.

O que é exibido:
- Nome "WiFi"
- Nível do sinal (FORTE, BOM, MÉDIO, FRACO)
- Barras animadas estilo celular 
- Valor do RSSI em dBm

HARDWARE:
- ESP32
- Display OLED SSD1306 (I2C)

 BIBLIOTECAS NECESSÁRIAS:
- WiFi.h
- U8g2lib.h
=====================================================
***************************************************************
*/

#include <WiFi.h>        // Biblioteca Wi-Fi do ESP32
#include <U8g2lib.h>     // Biblioteca do display OLED

// =====================================================
// CONFIGURAÇÃO DO DISPLAY OLED (I2C)
U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0);

// =====================================================
// DADOS DA REDE WI-FI
const char* ssid = "SEU_WIFI";
const char* password = "SUA_SENHA";

// =====================================================
// VARIÁVEIS DE ANIMAÇÃO
int anim = 0;      // controla altura das barras
bool sobe = true;  // controla direção da animação

// =====================================================
// FUNÇÃO: CLASSIFICA O SINAL Wi-Fi
// Recebe o RSSI e retorna um texto amigável
String getSignalLevel(int rssi) {

  if (rssi > -60) return "FORTE";   // sinal excelente
  else if (rssi > -70) return "BOM"; // bom
  else if (rssi > -80) return "MEDIO"; // médio
  else return "FRACO"; // sinal ruim
}

// =====================================================
// FUNÇÃO: DESENHA BARRAS DE SINAL (COM ANIMAÇÃO)
void drawAnimatedBars(int rssi) {

  int bars = 0;

  // Define quantas barras devem aparecer
  if (rssi > -60) bars = 4;
  else if (rssi > -70) bars = 3;
  else if (rssi > -80) bars = 2;
  else if (rssi > -90) bars = 1;
  else bars = 0;

  int x = 20; // posição horizontal inicial
  int y = 46; // base das barras

  // Loop para desenhar as 4 barras
  for (int i = 0; i < 4; i++) {

    // Altura da barra aumenta com animação
    int height = ((i + 1) * 8) + anim;

    if (i < bars) {
      // Barra preenchida (sinal ativo)
      u8g2.drawBox(x + (i * 18), y - height, 12, height);
    } else {
      // Barra vazia (sem sinal)
      u8g2.drawFrame(x + (i * 18), y - height, 12, height);
    }
  }
}

/*
// =====================================================
// EFEITO EXTRA (OPCIONAL) - LINHA ESCANEANDO
void drawScanningEffect() {

  int y = 63;

  for (int i = 0; i < 5; i++) {
    int pos = (i * 25 + anim * 5) % 128;
    u8g2.drawPixel(pos, y);
  }
}
*/

// =====================================================
// SETUP (RODA UMA VEZ)
void setup() {

  u8g2.begin(); // inicia display

  WiFi.begin(ssid, password); // conecta no Wi-Fi

  // Tela inicial
  u8g2.clearBuffer();
  u8g2.setFont(u8g2_font_ncenB08_tr);
  u8g2.drawStr(10, 30, "Conectando...");
  u8g2.sendBuffer();

  // Aguarda conexão
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
  }
}

// =====================================================
// LOOP PRINCIPAL
void loop() {

  u8g2.clearBuffer(); // limpa tela

  int rssi = WiFi.RSSI(); // lê força do sinal

  //  Título
  u8g2.setFont(u8g2_font_6x12_tr);
  u8g2.drawStr(0, 12, "WiFi");

  //  Nível do sinal (FORTE, BOM...)
  String nivel = getSignalLevel(rssi);
  u8g2.drawStr(30, 12, nivel.c_str());

  // Barras animadas
  drawAnimatedBars(rssi);

  //  Exibe valor numérico do RSSI
  char rssiStr[20];
  sprintf(rssiStr, "%d dBm", rssi);

  u8g2.drawStr(20, 62, rssiStr);

  //  Efeito opcional (descomentando ativa)
  //drawScanningEffect();

  u8g2.sendBuffer(); // envia para o display

  // =====================================================
  //  CONTROLE DA ANIMAÇÃO (sobe e desce)
  if (sobe) {
    anim++;
    if (anim > 3) sobe = false;
  } else {
    anim--;
    if (anim < 0) sobe = true;
  }

  delay(150); // velocidade da animação
}

O que é RSSI?

RSSI (Received Signal Strength Indicator) é um indicador que mostra a força do sinal Wi-Fi que o seu dispositivo está recebendo.

Em projetos com ESP32, ele é usado para saber se a conexão está boa ou ruim — algo essencial para evitar falhas.

Como o RSSI funciona?

O RSSI é medido em dBm (decibéis miliwatt).

👉 Importante:

Os valores são negativos
Quanto mais próximo de 0, melhor o sinal

Exemplos práticos

RSSI (dBm)	Qualidade
-30	🟢 Excelente
-50	🟢 Ótimo
-60	🟢 Bom
-70	🟡 Médio
-80	🔴 Fraco
-90	🔴 Muito fraco

Entendendo na prática

Se o seu ESP32 mostrar:

-55 dBm → conexão forte, ideal para projetos
-68 dBm → funciona bem, mas pode variar
-82 dBm → sinal fraco, pode cair

Por que o RSSI é importante?

✔ Ajuda a posicionar melhor o ESP32
✔ Evita desconexões
✔ Melhora estabilidade de projetos IoT
✔ Permite monitoramento em tempo real

Dica prática

Se o RSSI estiver baixo:

Aproxime do roteador
Evite paredes e obstáculos
Use repetidor Wi-Fi
Evite interferência (micro-ondas, etc.)

Resumo rápido

👉 RSSI = força do sinal Wi-Fi
👉 Quanto mais próximo de 0 → melhor
👉 Ideal para ESP32 → entre -50 e -60 dBm

U8g2 vs Adafruit SSD1306: Qual usar?

📚 Bibliotecas comparadas

🔹 U8g2lib.h

🔹 Adafruit_SSD1306 + Adafruit_GFX

Comparação direta

Característica	U8g2lib	Adafruit SSD1306
Facilidade	Média	Fácil
Qualidade de fontes	⭐⭐⭐⭐⭐	⭐⭐
Consumo de memória	Maior	Menor
Velocidade	Média	Rápida
Recursos gráficos	Avançados	Básicos
Suporte a vários displays	Excelente	Limitado

Vantagens da U8g2lib

✔ Muitas fontes profissionais
✔ Melhor qualidade visual
✔ Suporte a vários displays
✔ Funções gráficas avançadas
✔ Ideal para interfaces mais bonitas

Desvantagens da U8g2lib

❌ Usa mais memória
❌ Código um pouco mais complexo
❌ Pode ser mais lenta

Vantagens da Adafruit SSD1306

✔ Muito fácil de usar
✔ Mais leve (menos memória)
✔ Mais rápida para projetos simples
✔ Excelente para iniciantes

Desvantagens da Adafruit

❌ Poucas fontes
❌ Visual mais simples
❌ Menos recursos gráficos

Entendendo melhor a U8g2lib

A biblioteca U8g2lib é uma das mais completas para displays monocromáticos.

Principais recursos:

Mais de 100 fontes diferentes
Suporte a I2C, SPI e paralelos
Controle total de buffer
Desenho de:
- Linhas
- Círculos
- Ícones
- Bitmaps

Modos de funcionamento

A U8g2 tem 3 modos principais:

1. Full Buffer (F)

Usa mais RAM
Melhor qualidade
Mais fácil de usar

2. Page Buffer (_1 ou 2)

Usa menos memória
Mais rápido em alguns casos

Dica importante

Se seu projeto tiver muitos recursos (Wi-Fi, sensores, etc.), use:

👉 Adafruit SSD1306

Se quiser interface bonita e profissional:

👉 U8g2lib

Como instalar a U8g2lib no Arduino IDE (ESP32)

A biblioteca U8g2lib é usada para controlar displays OLED como o SSD1306 com muito mais recursos visuais.

PASSO 1 — Abrir o Arduino IDE

Abra o Arduino IDE no seu computador.

PASSO 2 — Ir até o Gerenciador de Bibliotecas

Acessando o Gerenciador de Bibliotecas na Arduino IDE para instalar a biblioteca U8g2 no ESP32 com display OLED

Clique no ícone do Gerenciador de Bibliotecas na Arduino IDE para buscar e instalar a biblioteca U8g2 usada com display OLED SSD1306 no ESP32

PASSO 3 — Procurar pela biblioteca

Na barra de busca, digite:


👉 U8g2
Procure por:
👉 U8g2 by oliver
Passo a passo para instalar a biblioteca U8g2 na Arduino IDE e utilizar displays OLED SSD1306 com ESP32 de forma simples e rápida.

PASSO 4 — Instalar a biblioteca correta

Clique em:

👉 Instalar

Aguarde terminar.

PASSO 5 — Verificar instalação

Após instalar, você já pode usar no seu código:


#include <U8g2lib.h>

Se não der erro → está tudo certo 🎉

⚠️ Dica importante

A U8g2lib já inclui suporte ao SSD1306, então:

👉 Você NÃO precisa instalar outra biblioteca para o display.

Conclusão

Este projeto mostra como transformar um simples ESP32 em algo muito mais profissional:

Sem depender do Monitor Serial
Interface visual direta no display
Informações úteis como IP e sinal Wi-Fi

Além disso, você aprendeu quando usar cada biblioteca — algo essencial para projetos mais avançados.

🔧 Acompanhe o RodRobot

Projetos maker com ESP32, Arduino, eletrônica e programação.

📖 Blog RodRobot 💻 GitHub ▶ YouTube Shorts 🎵 TikTok 📸 Instagram

RodRobot – Projetos maker, eletrônica e programação na prática.

1. Como Medir a Intensidade do Sinal Wi-Fi no ESP32 (RSSI em dBm) (Código e Projeto) - com Display OLED SSD1306