Guias · 15 min de leitura

API de clima com ESP32: buscar dados, interpretar JSON e mostrar no OLED

Guia de API de clima com ESP32: requisições HTTPClient ao Open-Meteo e OpenWeatherMap, interpretação com ArduinoJson, exibição em OLED/LCD, certificados HTTPS e erros 401, 404 e -1.

Projetos de clima com ESP32 se resumem a conectar a placa ao Wi-Fi, fazer uma pergunta a um serviço de clima on-line e mostrar a resposta em um display. Sem nenhum sensor, você pode obter a temperatura, a umidade, o vento e a previsão para amanhã na sua cidade, porque uma API (interface de programação de aplicações) alimentada por estações meteorológicas e modelos de previsão já fez as medições para você. O ESP32 envia uma requisição HTTP GET a esse serviço, assim como um navegador, recebe texto simples no formato JSON e usa a biblioteca ArduinoJson para extrair os números.

Neste guia, você primeiro enviará uma requisição ao Open-Meteo, que não exige chave, e depois passará ao OpenWeatherMap, que aceita nomes de cidades. Você verá como interpretar JSON, transformar códigos meteorológicos WMO em palavras, mostrar o resultado em um OLED de 0,96 polegada e em um LCD I2C 16x2, configurar HTTPS e certificados, respeitar os limites de requisições e entender o significado de códigos de erro como 401, 404 e -1. No final, há um exemplo que busca taxas de câmbio da mesma forma, além de código MicroPython para o Raspberry Pi Pico W.

Placa de desenvolvimento ESP32
ESP32: graças ao Wi-Fi integrado, pode buscar dados meteorológicos na internet sem nenhum módulo extra.

Como o ESP32 obtém dados da internet? API, HTTP e JSON

Quando você digita um endereço no navegador, ele envia uma requisição HTTP àquele servidor, e o servidor retorna uma página da web. Uma API funciona da mesma forma; a única diferença é que a resposta não é uma página formatada para pessoas, mas um texto estruturado que os programas conseguem ler facilmente. No ESP32, essa tarefa é feita pela biblioteca HTTPClient, que vem com o core: você informa o endereço, ela envia a requisição GET e entrega o código de status do servidor e o corpo da resposta. A resposta geralmente é JSON, composto por pares "key": value entre chaves, que podem conter objetos ou arrays aninhados.

TermoSignificadoExemplo de clima
APIA porta que os programas usam para trocar dadosServiço de previsão Open-Meteo
EndpointO endereço da API que executa uma tarefa específica/v1/forecast
Parâmetro de consultaConfigurações após o ? no endereçolatitude=41.01¤t=temperature_2m
Requisição GETSolicitação de dados ao servidorhttp.GET()
Código de statusUm número que descreve o resultado da requisição200 sucesso, 404 não encontrado
JSONUm formato de texto composto por chaves e valores{"temperature_2m":17.3}
Chave de APIUm ID secreto que identifica vocêO valor appid do OpenWeatherMap

Qual serviço escolher: Open-Meteo ou OpenWeatherMap?

Muitos serviços de clima têm um plano gratuito, mas dois se destacam para começar. O Open-Meteo não exige cadastro nem chave: você informa a localização por latitude e longitude, escolhe apenas os campos desejados e a resposta fica curta e leve para o ESP32. O OpenWeatherMap exige uma conta gratuita e uma chave de API, mas, em troca, oferece consultas pelo nome da cidade, uma descrição pronta (“chuva leve”, por exemplo) e um código de ícone. Os planos gratuitos de ambos são voltados a projetos pessoais e educacionais; se você estiver criando um produto comercial, leia os termos de uso de cada serviço.

CaracterísticaOpen-MeteoOpenWeatherMap (gratuito)
Cadastro e chaveNão são necessáriosConta e chave de API obrigatórias
LocalizaçãoLatitude e longitudeNome da cidade, latitude e longitude ou ID da cidade
Limite gratuito10.000 chamadas por dia, 5.000 por hora, 600 por minuto60 chamadas por minuto, 1.000.000 por mês
Atualização dos dadosDados atuais a cada 15 minutosAproximadamente a cada 10 minutos
Condição do tempoCódigo numérico WMO (0, 3, 61...)Texto descritivo e código de ícone
Unidades°C e km/h (alteráveis por parâmetros)°C e m/s com units=metric
Tamanho da respostaSomente os campos escolhidos, cerca de 400 bytesCerca de 500 bytes
Se você só quer mostrar a temperatura e as condições do tempo, comece com o Open-Meteo: terá um resultado já no primeiro minuto, sem esperar por uma chave. Você pode encontrar a latitude e a longitude da sua localização clicando com o botão direito na sua cidade em um app de mapas (ou mantendo o dedo pressionado no celular). Para Londres, 51,51, -0,13; para Nova York, 40,71, -74,01; e para Istambul, 41,01, 28,98 são aproximações suficientes.

O que você precisa e como configurar

  1. Instale o pacote de placas ESP32 no Arduino IDE (Ferramentas > Placa > Gerenciador de Placas, esp32 da Espressif). A configuração é explicada em detalhes no guia O que é ESP32.
  2. No Gerenciador de Bibliotecas, busque ArduinoJson (Benoit Blanchon) e instale a versão 7.x. As bibliotecas HTTPClient, WiFi e WiFiClientSecure vêm com o pacote ESP32 e não precisam ser instaladas separadamente.
  3. Para a versão com display, instale as bibliotecas Adafruit SSD1306 e Adafruit GFX, ou LiquidCrystal I2C se estiver usando um LCD.
  4. Substitua AgAdi e Sifre123 no código pelo nome e pela senha da sua rede Wi-Fi, selecione ESP32 Dev Module como placa e configure o Monitor Serial para 115.200 baud.
O ESP32 só se conecta a redes Wi-Fi de 2,4 GHz. Se o código continuar imprimindo pontos na linha do Wi-Fi, o problema está na conexão, não na API: confira o nome da rede, a senha e se o roteador transmite em 2,4 GHz. Há uma lista detalhada de soluções no guia ESP32 não conecta ao Wi-Fi.

Passo a passo: sua primeira requisição GET com HTTPClient

O primeiro sketch tem uma única tarefa: conectar ao Wi-Fi, solicitar ao Open-Meteo o tempo atual em Istambul e imprimir a resposta no Monitor Serial sem alterações. O parâmetro current= no endereço indica quais campos você deseja; separados por vírgulas, escolhemos temperatura, umidade, código meteorológico e velocidade do vento. timezone=auto converte os horários para a hora local da localização.

C++ (Arduino IDE)
1#include <WiFi.h>
2#include <HTTPClient.h>
3
4const char* WIFI_SSID = "AgAdi";        // Wi-Fi adı / Wi-Fi name
5const char* WIFI_PASS = "Sifre123";     // Wi-Fi şifresi / Wi-Fi password
6
7// İstanbul'un anlık hava durumu (anahtar gerekmez) / current weather for Istanbul (no key needed)
8const char* URL = "http://api.open-meteo.com/v1/forecast?latitude=41.01&longitude=28.98"
9                  "&current=temperature_2m,relative_humidity_2m,weather_code,wind_speed_10m"
10                  "&timezone=auto";
11
12void setup() {
13  Serial.begin(115200);
14  WiFi.mode(WIFI_STA);
15  WiFi.begin(WIFI_SSID, WIFI_PASS);
16  Serial.print("Wi-Fi");
17  while (WiFi.status() != WL_CONNECTED) {   // bağlanana kadar bekle / wait until connected
18    delay(500);
19    Serial.print(".");
20  }
21  Serial.println(" OK");
22
23  HTTPClient http;
24  http.begin(URL);                          // isteği hazırla / prepare the request
25  int code = http.GET();                    // GET isteğini gönder / send the GET request
26  Serial.printf("HTTP kodu / code: %d\n", code);
27
28  if (code > 0) {                           // sunucu yanıt verdi / the server answered
29    Serial.println(http.getString());       // yanıtın gövdesi (JSON) / response body (JSON)
30  } else {                                  // eksi kod: bağlantı sorunu / negative: connection problem
31    Serial.println(http.errorToString(code));
32  }
33  http.end();                               // bağlantıyı kapat, belleği boşalt / close and free memory
34}
35
36void loop() {
37}

Após carregar o código, você deve ver “HTTP kodu / code: 200” no Monitor Serial, seguido de uma única linha de JSON. A parte útil da resposta é assim: "current":{"time":"2026-11-17T14:15","interval":900,"temperature_2m":17.3,"relative_humidity_2m":63,"weather_code":3,"wind_speed_10m":12.4}. O valor 900 de interval informa que os dados são atualizados a cada 900 segundos, ou seja, a cada 15 minutos; você precisará disso mais adiante para decidir a frequência de envio das requisições.

FunçãoO que faz?
http.begin(url) (define o endereço da conexão)Analisa o endereço e prepara a conexão
http.GET()Envia a requisição; retorna o código de status HTTP ou um código de erro negativo
http.getString()Lê o corpo da resposta como uma String
http.getStream()Entrega o corpo como um fluxo sem armazená-lo em buffer (para respostas grandes)
http.errorToString(code)Transforma um código de erro negativo em texto legível
http.setTimeout(ms)Quanto tempo esperar por uma resposta (5.000 ms por padrão)
http.end()Fecha a conexão e libera a memória

Como interpretar JSON com ArduinoJson

Mostrar JSON bruto em um display não é útil; você precisa extrair o número 17,3 e colocá-lo em uma variável float. O ArduinoJson transforma o texto em uma árvore na memória, e você percorre seus ramos usando os nomes das chaves: doc["current"]["temperature_2m"] primeiro acessa o objeto current e depois a temperatura dentro dele. A biblioteca converte o valor para o tipo da variável à qual você o atribui. Se você solicitar uma chave que não existe, o programa não trava; você recebe 0 para um número e um ponteiro nulo para texto.

C++ (Arduino IDE)
1#include <WiFi.h>
2#include <HTTPClient.h>
3#include <ArduinoJson.h>
4
5const char* WIFI_SSID = "AgAdi";
6const char* WIFI_PASS = "Sifre123";
7const char* URL = "http://api.open-meteo.com/v1/forecast?latitude=41.01&longitude=28.98"
8                  "&current=temperature_2m,relative_humidity_2m,weather_code,wind_speed_10m"
9                  "&timezone=auto";
10
11bool fetchWeather() {
12  HTTPClient http;
13  http.begin(URL);
14  int code = http.GET();
15  if (code != HTTP_CODE_OK) {               // 200 değilse vazgeç / give up if not 200
16    Serial.printf("Hata / error: %d %s\n", code, http.errorToString(code).c_str());
17    http.end();
18    return false;
19  }
20
21  JsonDocument doc;                         // ArduinoJson 7: boyut otomatik / size is automatic
22  DeserializationError err = deserializeJson(doc, http.getString());
23  http.end();
24  if (err) {                                // JSON bozuk ya da eksik / JSON broken or truncated
25    Serial.print("JSON hatasi / error: ");
26    Serial.println(err.c_str());
27    return false;
28  }
29
30  JsonObject now = doc["current"];          // "current" nesnesi / the "current" object
31  float temp     = now["temperature_2m"];   // °C
32  int humidity   = now["relative_humidity_2m"];
33  int wmo        = now["weather_code"];     // WMO hava kodu / WMO weather code
34  float wind     = now["wind_speed_10m"];   // km/sa / km/h
35  const char* t  = now["time"];             // ölçüm zamanı / observation time
36
37  Serial.printf("%s  %.1f C  %%%d nem/hum  kod/code %d  ruzgar/wind %.1f km/h\n",
38                t, temp, humidity, wmo, wind);
39  return true;
40}
41
42void setup() {
43  Serial.begin(115200);
44  WiFi.begin(WIFI_SSID, WIFI_PASS);
45  while (WiFi.status() != WL_CONNECTED) delay(500);
46  fetchWeather();
47}
48
49void loop() {
50}

Este código é para o ArduinoJson 7. As linhas StaticJsonDocument e DynamicJsonDocument doc(1024) que você verá em exemplos antigos pertencem à versão 6.x; na 7.x, basta escrever JsonDocument doc;, e a memória é alocada automaticamente conforme necessário. Se receber o aviso “StaticJsonDocument is deprecated” ao compilar código antigo, esse é o motivo: o código geralmente continua funcionando, mas adotar o novo estilo deixa tudo mais claro. A leitura, com a sintaxe doc["key"], é igual nas duas versões.

Se deserializeJson() retornar um erro, err.c_str() informa o motivo: IncompleteInput significa que a resposta foi interrompida, InvalidInput significa que o texto não é JSON (geralmente uma página de erro HTML) e NoMemory significa que não havia memória suficiente. A forma mais rápida de resolver é primeiro imprimir a resposta com Serial.println() e examiná-la.

Códigos meteorológicos WMO: transformar números em palavras

O Open-Meteo não descreve o tempo com uma palavra como “nublado”, mas com um número definido pela Organização Meteorológica Mundial (WMO). Isso torna a resposta independente do idioma, e você decide qual idioma usar no display. Estes são os códigos que você verá com mais frequência:

Código WMOSignificado
0Céu limpo
1, 2, 3Predominantemente limpo, parcialmente nublado, encoberto
45, 48Nevoeiro, nevoeiro com deposição de gelo
51, 53, 55Garoa leve, moderada, intensa
56, 57Garoa congelante
61, 63, 65Chuva leve, moderada, forte
66, 67Chuva congelante
71, 73, 75Queda de neve leve, moderada, forte
77Grãos de neve
80, 81, 82Pancadas de chuva leves, moderadas, violentas
85, 86Pancadas de neve leves e fortes
95Tempestade com trovoadas
96, 99Tempestade com trovoadas e granizo

A função wmoText() no sketch do OLED abaixo transforma esta tabela em rótulos curtos. Os rótulos no código estão escritos em turco sem caracteres especiais; se quiser, mude-os para inglês (“Clear”, “Rain”, “Snow”). Se quiser desenhar seus próprios ícones, use as mesmas faixas para escolher bitmaps de sol, nuvem ou gotas de chuva; por exemplo, um único ícone de chuva é suficiente para 61 a 67 e 80 a 82.

Tempo pelo nome da cidade com OpenWeatherMap

Depois de criar uma conta gratuita no OpenWeatherMap, você encontrará uma chave de 32 caracteres na seção API keys da sua conta. Uma chave nova pode levar de alguns minutos a algumas horas para ser ativada; até lá, toda requisição retorna 401, e você pode achar que seu código está errado. Na consulta, q=Ankara,TR define o nome da cidade e o código do país, units=metric define Celsius e m/s, e lang define o idioma da descrição.

C++ (Arduino IDE)
1#include <WiFi.h>
2#include <HTTPClient.h>
3#include <ArduinoJson.h>
4
5const char* WIFI_SSID = "AgAdi";
6const char* WIFI_PASS = "Sifre123";
7const char* API_KEY   = "BURAYA_API_ANAHTARIN";   // OpenWeatherMap hesabındaki anahtar / key from your account
8const char* CITY      = "Ankara,TR";              // şehir,ülke kodu / city,country code
9
10void fetchCity() {
11  String url = String("http://api.openweathermap.org/data/2.5/weather?q=") + CITY +
12               "&appid=" + API_KEY + "&units=metric&lang=en";   // metric = °C ve m/s / °C and m/s
13  HTTPClient http;
14  http.begin(url);
15  int code = http.GET();
16  String body = (code > 0) ? http.getString() : "";
17  http.end();
18
19  if (code == 401) { Serial.println("401: anahtar gecersiz ya da henuz aktif degil / invalid or inactive key"); return; }
20  if (code == 404) { Serial.println("404: sehir bulunamadi / city not found"); return; }
21  if (code == 429) { Serial.println("429: istek siniri asildi / rate limit exceeded"); return; }
22  if (code != 200) { Serial.printf("Hata / error %d: %s\n", code, HTTPClient::errorToString(code).c_str()); return; }
23
24  JsonDocument doc;
25  if (deserializeJson(doc, body)) { Serial.println("JSON hatasi / error"); return; }
26
27  const char* name = doc["name"];                        // şehir adı / city name
28  float temp       = doc["main"]["temp"];                // sıcaklık / temperature
29  float feels      = doc["main"]["feels_like"];          // hissedilen / feels like
30  int humidity     = doc["main"]["humidity"];            // nem % / humidity %
31  int pressure     = doc["main"]["pressure"];            // hPa
32  const char* desc = doc["weather"][0]["description"];   // dizi: [0] ilk eleman / array: [0] first item
33  float wind       = doc["wind"]["speed"];               // m/s
34
35  Serial.printf("%s: %.1f C (hissedilen/feels %.1f), %%%d, %d hPa, %s, %.1f m/s\n",
36                name, temp, feels, humidity, pressure, desc, wind);
37}
38
39void setup() {
40  Serial.begin(115200);
41  WiFi.begin(WIFI_SSID, WIFI_PASS);
42  while (WiFi.status() != WL_CONNECTED) delay(500);
43  fetchCity();
44}
45
46void loop() {
47}

Dois detalhes dessa resposta exigem atenção. Primeiro, o campo weather não é um objeto, mas um array, então você acessa a descrição pelo primeiro elemento: doc["weather"][0]["description"]. Segundo, com units=metric, a velocidade do vento vem em m/s; multiplique por 3,6 para obter km/h. Outros valores de lang fornecem descrições no idioma correspondente, mas as fontes padrão da Adafruit GFX e dos LCDs HD44780 só incluem ASCII básico, então letras acentuadas como é, ü ou ñ aparecem corrompidas. Usar lang=en com seus próprios rótulos curtos é a opção mais segura para displays pequenos.

HTTPS e certificados: setInsecure ou setCACert?

A maioria dos serviços de clima agora usa HTTPS, e alguns nem aceitam HTTP simples. Com HTTPS, o tráfego entre o ESP32 e o servidor é criptografado; para ter certeza de que está realmente falando com aquele servidor, o ESP32 também precisa verificar a cadeia de certificados com base em um certificado raiz. Para isso, você usa WiFiClientSecure em vez do WiFiClient comum, e há duas opções.

setInsecure() criptografa a conexão, mas não verifica o certificado. É uma opção prática e comum para dados públicos e não sigilosos, como o clima, mas alguém no meio da conexão poderia enviar dados falsos. setCACert() verifica a cadeia com o certificado raiz que você fornece. O certificado do Open-Meteo é emitido pela Let's Encrypt e sua cadeia chega à raiz ISRG Root X1, válida até 2035. O certificado do próprio servidor é renovado a cada poucos meses, portanto nunca o coloque no código; use sempre a raiz no topo da cadeia.

C++ (Arduino IDE)
1#include <WiFi.h>
2#include <WiFiClientSecure.h>
3#include <HTTPClient.h>
4
5const char* WIFI_SSID = "AgAdi";
6const char* WIFI_PASS = "Sifre123";
7
8// ISRG Root X1: Let's Encrypt kök sertifikası, 2035'e kadar geçerli
9// ISRG Root X1: Let's Encrypt root certificate, valid until 2035
10const char* ROOT_CA = R"EOF(
11-----BEGIN CERTIFICATE-----
12MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
13TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
14cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
15WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
16ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
17MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
18h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
190TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
20A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
21T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
22B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
23B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
24KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
25OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
26jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
27qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
28rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
29HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
30hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
31ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
323BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
33NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
34ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
35TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
36jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
37oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
384RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
39mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
40emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
41-----END CERTIFICATE-----
42)EOF";
43
44void setup() {
45  Serial.begin(115200);
46  WiFi.begin(WIFI_SSID, WIFI_PASS);
47  while (WiFi.status() != WL_CONNECTED) delay(500);
48
49  WiFiClientSecure client;
50  client.setCACert(ROOT_CA);       // sunucuyu doğrula / verify the server
51  // client.setInsecure();         // yalnız deneme için: şifreler ama doğrulamaz / testing only: encrypts, no verification
52
53  HTTPClient http;
54  http.begin(client, "https://api.open-meteo.com/v1/forecast?latitude=39.93&longitude=32.86&current=temperature_2m");
55  int code = http.GET();
56  Serial.printf("HTTPS kodu / code: %d\n", code);
57  if (code > 0) Serial.println(http.getString());
58  else Serial.println(HTTPClient::errorToString(code));
59  http.end();
60}
61
62void loop() {
63}
Antes de usar um certificado raiz para outro serviço, verifique a qual raiz a cadeia daquele site chega: o OpenWeatherMap usa a cadeia Sectigo e USERTrust, e o Frankfurter usa Google Trust Services. Se você fornecer a raiz errada, GET() retorna -1, e o Monitor Serial não mostra nenhuma outra pista. Se enviar algo sigiloso, como sua chave de API, use sempre setCACert() em vez de setInsecure().

Como mostrar o tempo da sua cidade em um display OLED

Display OLED I2C de 0,96 polegada
OLED SSD1306 de 0,96 polegada: conecta-se ao ESP32 com apenas quatro fios e mostra o tempo em dígitos grandes.

Agora vamos deixar o Monitor Serial de lado e montar uma estação meteorológica de mesa de verdade. O OLED SSD1306 de 0,96 polegada se conecta aos pinos I2C do ESP32. Para conhecer o básico do display e os detalhes das bibliotecas, veja o guia do display OLED SSD1306.

Pino do OLEDESP32
GNDGND
VCC3V3
SCLGPIO 22
SDAGPIO 21
C++ (Arduino IDE)
1#include <WiFi.h>
2#include <WiFiClientSecure.h>
3#include <HTTPClient.h>
4#include <ArduinoJson.h>
5#include <Wire.h>
6#include <Adafruit_GFX.h>
7#include <Adafruit_SSD1306.h>
8
9const char* WIFI_SSID = "AgAdi";
10const char* WIFI_PASS = "Sifre123";
11const char* CITY_NAME = "Izmir";                   // ekranda görünecek ad / name shown on screen
12const char* URL = "https://api.open-meteo.com/v1/forecast?latitude=38.42&longitude=27.14"
13                  "&current=temperature_2m,relative_humidity_2m,weather_code,wind_speed_10m"
14                  "&timezone=auto";
15const unsigned long PERIOD = 10UL * 60UL * 1000UL; // 10 dakikada bir / every 10 minutes
16
17Adafruit_SSD1306 display(128, 64, &Wire, -1);
18unsigned long lastFetch = 0;
19bool firstRun = true;
20
21// WMO kodunu kısa metne çevir / turn a WMO code into a short label
22const char* wmoText(int c) {
23  if (c == 0) return "Acik";                       // açık / clear
24  if (c <= 2) return "Az bulutlu";                 // az bulutlu / partly cloudy
25  if (c == 3) return "Kapali";                     // kapalı / overcast
26  if (c == 45 || c == 48) return "Sis";            // sis / fog
27  if (c >= 51 && c <= 57) return "Ciseleme";       // çiseleme / drizzle
28  if (c >= 61 && c <= 67) return "Yagmur";         // yağmur / rain
29  if (c >= 71 && c <= 77) return "Kar";            // kar / snow
30  if (c >= 80 && c <= 82) return "Saganak";        // sağanak / showers
31  if (c == 85 || c == 86) return "Kar saganagi";   // kar sağanağı / snow showers
32  if (c >= 95) return "Firtina";                   // gök gürültülü fırtına / thunderstorm
33  return "?";
34}
35
36void showMessage(const char* line1, const char* line2) {
37  display.clearDisplay();
38  display.setTextSize(1);
39  display.setCursor(0, 0);
40  display.println(line1);
41  display.println(line2);
42  display.display();
43}
44
45void fetchAndShow() {
46  if (WiFi.status() != WL_CONNECTED) {             // Wi-Fi koptuysa yeniden bağlan / reconnect if Wi-Fi dropped
47    showMessage("Wi-Fi yok", "yeniden baglaniyor");
48    WiFi.reconnect();
49    return;
50  }
51
52  WiFiClientSecure client;
53  client.setInsecure();                            // şifreli, sertifika doğrulamasız / encrypted, no cert check
54  HTTPClient http;
55  http.setTimeout(8000);                           // yavaş ağlar için 8 sn / 8 s for slow networks
56  http.begin(client, URL);
57  int code = http.GET();
58  if (code != HTTP_CODE_OK) {
59    char buf[24];
60    snprintf(buf, sizeof(buf), "HTTP hata %d", code);
61    showMessage(buf, "10 dk sonra tekrar");
62    http.end();
63    return;
64  }
65
66  JsonDocument doc;
67  DeserializationError err = deserializeJson(doc, http.getString());
68  http.end();
69  if (err) { showMessage("JSON hatasi", err.c_str()); return; }
70
71  float temp   = doc["current"]["temperature_2m"];
72  int humidity = doc["current"]["relative_humidity_2m"];
73  int wmo      = doc["current"]["weather_code"];
74  float wind   = doc["current"]["wind_speed_10m"];
75  const char* t = doc["current"]["time"];          // "2026-11-17T14:15"
76
77  display.clearDisplay();
78  display.setTextSize(1);
79  display.setCursor(0, 0);
80  display.print(CITY_NAME);
81  display.setCursor(98, 0);
82  if (t && strlen(t) >= 16) display.print(t + 11); // "T"den sonrası: "14:15" / the part after "T"
83  display.drawLine(0, 10, 127, 10, SSD1306_WHITE);
84
85  display.setTextSize(3);                          // büyük sıcaklık / big temperature
86  display.setCursor(0, 16);
87  display.print(temp, 1);
88  display.setTextSize(1);
89  display.print((char)247);                        // derece işareti / degree sign
90  display.print("C");
91
92  display.setCursor(0, 44);
93  display.print(wmoText(wmo));
94  display.setCursor(0, 55);
95  display.printf("Nem %%%d  Ruzgar %.0f", humidity, wind);
96  display.display();
97}
98
99void setup() {
100  Serial.begin(115200);
101  Wire.begin(21, 22);                              // SDA, SCL
102  if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
103    Serial.println("OLED bulunamadi / not found");
104    for (;;);
105  }
106  display.setTextColor(SSD1306_WHITE);
107  display.cp437(true);                             // (char)247 derece olsun / so 247 is the degree sign
108  showMessage("Wi-Fi'ye", "baglaniyor...");
109  WiFi.mode(WIFI_STA);
110  WiFi.begin(WIFI_SSID, WIFI_PASS);
111  while (WiFi.status() != WL_CONNECTED) delay(500);
112}
113
114void loop() {
115  if (firstRun || millis() - lastFetch >= PERIOD) { // delay yerine millis / millis instead of delay
116    firstRun = false;
117    lastFetch = millis();
118    fetchAndShow();
119  }
120}

Ao iniciar, o sketch se conecta ao Wi-Fi, busca os primeiros dados imediatamente e depois os atualiza a cada 10 minutos. Usamos millis() em vez de delay() para a espera, então você pode acrescentar a leitura de botões ou uma animação enquanto loop() executa livremente. Se a conexão cair, o código mostra um aviso e tenta reconectar; se uma requisição falhar, mostra o código de erro. O horário no canto superior direito é a parte após a letra T na string “2026-11-17T14:15” da resposta, então você vê quando a última observação foi feita sem configurar um relógio. Se quiser um relógio que avance a cada segundo, adicione a este sketch o método do guia de hora NTP com ESP32.

Como mostrar os dados em um LCD I2C 16x2

Se você tiver um LCD de caracteres 16x2 em vez de um OLED, poderá acomodar os mesmos dados em duas linhas. Alimentar o módulo LCD pelo pino VIN do ESP32, que fornece 5 V, melhora o contraste; conecte SDA a GPIO 21 e SCL a GPIO 22. Como o módulo puxa as linhas I2C para 5 V, a opção mais segura é colocar um conversor de nível lógico entre eles. Basta substituir as linhas de desenho do sketch do OLED por uma função como a que aparece abaixo; há mais detalhes no guia do display LCD I2C.

C++ (Arduino IDE)
1#include <LiquidCrystal_I2C.h>
2
3LiquidCrystal_I2C lcd(0x27, 16, 2);                // adres 0x27 ya da 0x3F / address 0x27 or 0x3F
4
5// OLED kodundaki ekran kısmının yerine / replaces the OLED drawing part
6void showOnLcd(float temp, int humidity, const char* label) {
7  lcd.clear();
8  lcd.setCursor(0, 0);
9  lcd.print("Izmir ");
10  lcd.print(temp, 1);
11  lcd.print((char)223);                            // LCD'de derece işareti / degree sign on HD44780
12  lcd.print("C");
13  lcd.setCursor(0, 1);
14  lcd.print(label);                                // ör. "Yagmur" / e.g. "Yagmur"
15  lcd.print(" %");
16  lcd.print(humidity);
17}
18
19void setup() {
20  lcd.init();                                      // ESP32'de Wire.begin(21, 22) varsayılan / default pins
21  lcd.backlight();
22  showOnLcd(18.4, 62, "Az bulutlu");
23}
24
25void loop() {
26}

Frequência das requisições e limites gratuitos

O erro mais comum é colocar delay(1000) em loop() e enviar uma requisição a cada segundo. Além de inútil, isso faz você atingir os limites rapidamente: os dados atuais do Open-Meteo só são atualizados a cada 15 minutos, então consultar a cada segundo traz a mesma resposta 900 vezes. Uma requisição por segundo soma 86.400 por dia e esgota o limite diário de 10.000 do Open-Meteo em menos de três horas. A conta é simples: o número de requisições por dia é igual a 1.440 dividido pelo intervalo em minutos.

IntervaloRequisições por diaAvaliação
1 segundo86.400Acima do limite; seu endereço IP pode ser bloqueado temporariamente
1 minuto1.440Dentro do limite, mas é desperdício, pois os dados não mudam
10 minutos144Ideal para uma estação meteorológica de mesa
15 minutos96Corresponde à frequência de atualização do Open-Meteo
1 hora24Suficiente para dispositivos alimentados por bateria e previsões diárias
Em uma estação meteorológica alimentada por bateria, o Wi-Fi é o que mais consome corrente. Se você colocar o ESP32 em deep sleep por 15 minutos após buscar os dados, a corrente média cai para menos de 1 mA em um módulo sem placa de desenvolvimento e para alguns miliampères em uma placa de desenvolvimento típica, e uma única célula 18650 dura semanas. Os detalhes estão no guia de deep sleep do ESP32.

Códigos de erro: 401, 404, 429 e -1

http.GET() retorna dois tipos de números. Números positivos são códigos de status HTTP do servidor: a conexão foi estabelecida e o servidor recebeu a solicitação, mas não aceitou algo na requisição. Números negativos são os códigos de erro do próprio ESP32 e indicam que a requisição nunca chegou ao servidor ou que a resposta foi interrompida.

CódigoSignificadoO que fazer
200SucessoLeia e interprete o corpo da resposta
400Requisição inválidaVerifique os nomes dos parâmetros e as vírgulas no endereço
401Não autorizado: chave de API ausente, incorreta ou ainda não ativadaCopie a chave novamente; se for nova, aguarde um pouco
404Não encontrado: nome da cidade ou endereço incorretoEscreva a cidade com letras simples do alfabeto inglês (Istanbul,TR) e confira o endereço
429Requisições demaisAumente o intervalo
500-503Problema no servidorTente novamente em alguns minutos
-1Sem conexão: falta de internet, domínio não resolvido, endereço incorreto ou falha na negociação HTTPSVerifique o Wi-Fi, o endereço e o certificado
-5Conexão perdida no meio da transferênciaMelhore o sinal do Wi-Fi e repita a requisição
-11Tempo limite de leitura excedidoAumente o tempo de espera com http.setTimeout()

O OpenWeatherMap também retorna JSON em caso de erro: com uma chave incorreta, você recebe {"cod":401, "message":"Invalid API key..."}, e, para uma cidade desconhecida, {"cod":"404","message":"city not found"}. No primeiro caso, cod é um número; no segundo, uma string entre aspas. Se você basear seu código no número retornado por http.GET(), em vez do campo cod, essa inconsistência não afetará você.

Respostas grandes: filtros, getStream e useHTTP10

Quando você solicita uma previsão por hora ou para 7 dias, a resposta pode crescer de alguns quilobytes para dezenas. getString() coloca a resposta inteira primeiro em uma String e depois na árvore do ArduinoJson, então a memória é usada duas vezes. Como alternativa, você pode interpretar a resposta à medida que ela chega com http.getStream() e manter apenas os campos necessários com um filtro. Há uma armadilha: se o servidor enviar a resposta em blocos (chunked encoding), os tamanhos dos blocos se misturam ao fluxo e invalidam o JSON. O Open-Meteo envia respostas em blocos; http.useHTTP10(true) faz a requisição por HTTP/1.0 e força o servidor a enviar uma resposta simples.

C++ (Arduino IDE)
1#include <WiFi.h>
2#include <WiFiClientSecure.h>
3#include <HTTPClient.h>
4#include <ArduinoJson.h>
5
6const char* WIFI_SSID = "AgAdi";
7const char* WIFI_PASS = "Sifre123";
8const char* URL = "https://api.open-meteo.com/v1/forecast?latitude=41.01&longitude=28.98"
9                  "&daily=temperature_2m_max,temperature_2m_min,weather_code"
10                  "&forecast_days=3&timezone=auto";
11
12void setup() {
13  Serial.begin(115200);
14  WiFi.begin(WIFI_SSID, WIFI_PASS);
15  while (WiFi.status() != WL_CONNECTED) delay(500);
16
17  WiFiClientSecure client;
18  client.setInsecure();
19  HTTPClient http;
20  http.useHTTP10(true);                      // parçalı (chunked) yanıtı kapat / disable chunked replies
21  http.begin(client, URL);
22  if (http.GET() != HTTP_CODE_OK) { http.end(); return; }
23
24  JsonDocument filter;                       // yalnız gereken alanları tut / keep only what we need
25  filter["daily"]["time"] = true;
26  filter["daily"]["temperature_2m_max"] = true;
27  filter["daily"]["temperature_2m_min"] = true;
28  filter["daily"]["weather_code"] = true;
29
30  JsonDocument doc;
31  DeserializationError err = deserializeJson(doc, http.getStream(),   // String yerine akış / stream instead of String
32                                             DeserializationOption::Filter(filter));
33  http.end();
34  if (err) { Serial.println(err.c_str()); return; }
35
36  JsonArray days = doc["daily"]["time"];
37  for (size_t i = 0; i < days.size(); i++) {  // 3 gün / 3 days
38    const char* day = days[i];
39    float tmax = doc["daily"]["temperature_2m_max"][i];
40    float tmin = doc["daily"]["temperature_2m_min"][i];
41    int wmo    = doc["daily"]["weather_code"][i];
42    Serial.printf("%s  en dusuk/min %.0f  en yuksek/max %.0f  kod/code %d\n", day, tmin, tmax, wmo);
43  }
44}
45
46void loop() {
47}

Da mesma forma, você pode solicitar hourly=temperature_2m e desenhar um gráfico de temperatura de 24 horas, ou usar daily=precipitation_probability_max para acender um LED quando houver alta probabilidade de chuva amanhã. No Open-Meteo, forecast_days pode ser no máximo 16; entre 3 e 7 dias é uma faixa confortável para o ESP32.

Outras APIs, mesmo método: um exemplo de câmbio

O que você aprendeu aqui não se limita ao clima: as etapas de endereço, GET, JSON e interpretação são as mesmas para qualquer API REST. Por exemplo, o serviço Frankfurter, que publica as taxas de referência diárias do Banco Central Europeu, não exige chave e retorna moedas como dólar, euro e lira turca em uma única requisição.

C++ (Arduino IDE)
1#include <WiFi.h>
2#include <WiFiClientSecure.h>
3#include <HTTPClient.h>
4#include <ArduinoJson.h>
5
6const char* WIFI_SSID = "AgAdi";
7const char* WIFI_PASS = "Sifre123";
8// Avrupa Merkez Bankası kurları, anahtar gerekmez / European Central Bank rates, no key needed
9const char* URL = "https://api.frankfurter.dev/v1/latest?from=USD&to=TRY,EUR";
10
11void setup() {
12  Serial.begin(115200);
13  WiFi.begin(WIFI_SSID, WIFI_PASS);
14  while (WiFi.status() != WL_CONNECTED) delay(500);
15
16  WiFiClientSecure client;
17  client.setInsecure();
18  HTTPClient http;
19  http.begin(client, URL);
20  int code = http.GET();
21  if (code == HTTP_CODE_OK) {
22    JsonDocument doc;
23    if (!deserializeJson(doc, http.getString())) {
24      const char* date = doc["date"];          // kurun tarihi / rate date
25      float usdTry = doc["rates"]["TRY"];      // 1 USD kaç TL / how many TRY per USD
26      float usdEur = doc["rates"]["EUR"];
27      Serial.printf("%s  1 USD = %.2f TRY = %.4f EUR\n", date, usdTry, usdEur);
28      Serial.printf("1 EUR = %.2f TRY\n", usdTry / usdEur);   // çapraz kur / cross rate
29    }
30  } else {
31    Serial.printf("Hata / error: %d\n", code);
32  }
33  http.end();
34}
35
36void loop() {
37}

As taxas do banco central são atualizadas uma vez por dia nos dias úteis, por volta das 16:00 no horário da Europa Central, então até uma requisição por hora é mais que suficiente. Com a mesma estrutura, você pode buscar dados de terremotos, horários de oração, preços de criptomoedas ou um valor do seu próprio servidor. As únicas coisas que mudam são o endereço e os nomes das chaves no JSON, e você os descobre abrindo o endereço no navegador e examinando a resposta.

Clima com o Raspberry Pi Pico W (MicroPython)

Nos modelos com Wi-Fi da família Raspberry Pi Pico, o Pico W e o Pico 2 W, a mesma tarefa é feita pelo módulo urequests do MicroPython, e você não precisa de uma biblioteca JSON separada: r.json() converte a resposta diretamente em um dicionário Python. Grave a versão mais recente do MicroPython com o Thonny e salve o código como main.py. Os detalhes da conexão Wi-Fi estão no guia de servidor web Wi-Fi com Pico W.

Python
1import network
2import time
3import urequests
4
5SSID = "AgAdi"
6PASS = "Sifre123"
7URL = ("https://api.open-meteo.com/v1/forecast?latitude=41.01&longitude=28.98"
8       "&current=temperature_2m,relative_humidity_2m,weather_code&timezone=auto")
9
10wlan = network.WLAN(network.STA_IF)
11wlan.active(True)
12wlan.connect(SSID, PASS)
13while not wlan.isconnected():          # bağlanana kadar bekle / wait until connected
14    time.sleep(0.5)
15print("IP:", wlan.ifconfig()[0])
16
17while True:
18    try:
19        r = urequests.get(URL)
20        if r.status_code == 200:
21            now = r.json()["current"]  # JSON -> sözlük / JSON -> dict
22            print(now["time"], now["temperature_2m"], "C",
23                  "%", now["relative_humidity_2m"], "kod/code", now["weather_code"])
24        else:
25            print("HTTP hata / error:", r.status_code)
26        r.close()                      # soketi kapat, belleği boşalt / close socket, free memory
27    except OSError as e:               # ağ hatası / network error
28        print("Baglanti hatasi / connection error:", e)
29    time.sleep(600)                    # 10 dakika bekle / wait 10 minutes

O urequests do MicroPython criptografa conexões HTTPS, mas não verifica o certificado do servidor; o nível de segurança é o mesmo de setInsecure() no ESP32. Chamar r.close() após cada requisição é importante: se você esquecer, os sockets e a memória do Pico se esgotam após algumas requisições, e o código para com um OSError.

Ideias de projetos de clima com ESP32

  • Estação meteorológica de mesa: Mostre os dados do Open-Meteo em um OLED e acrescente a temperatura e a pressão do ambiente com um BME280, para ver as condições internas e externas lado a lado.
  • Lembrete de guarda-chuva: Um ESP32 ao lado da porta de entrada acende um LED WS2812B vermelho quando a probabilidade de chuva do dia passa de 60%.
  • Irrigação inteligente: Pule a rega se houver previsão de chuva para amanhã; em conjunto com um sensor de umidade do solo, você evita desperdiçar água.
  • Notificação matinal: Envie a previsão do dia ao celular às 07:00 de cada manhã com um bot do Telegram.
  • Automação residencial: Envie a temperatura externa ao Home Assistant por MQTT e use-a nas decisões de aquecimento.
  • Painel de clima e câmbio: Mostre a temperatura, uma previsão de 3 dias e as taxas de câmbio do dia em cartões coloridos em um display TFT ILI9341.

Erros comuns e soluções

SintomaCausa provávelSolução
Pontos sem parar no Monitor SerialNão consegue conectar ao Wi-FiRede de 2,4 GHz, senha correta, maior proximidade do roteador
Código HTTP -1Problema de internet, domínio ou HTTPSTeste o endereço em um navegador e verifique WiFiClientSecure e o certificado
401 Invalid API key (chave de API inválida)Chave incorreta ou ainda não ativadaCopie a chave novamente; em uma conta nova, aguarde um pouco
Erro JSON InvalidInputA resposta não é JSON (uma página de erro HTML)Primeiro imprima a resposta com getString()
Erro JSON IncompleteInputResposta interrompida ou fluxo em blocosUse getString() ou adicione useHTTP10(true)
Temperatura sempre em 0.00Nome da chave escrito incorretamenteCopie o nome exatamente como aparece no JSON (temperature_2m)
Caracteres estranhos no displayLetras acentuadas ou o símbolo ° ausentes na fonteUse lang=en e imprima o símbolo de grau com (char)247
Trava após algumas horasConexões não fechadas, fragmentação da memóriaChame http.end() após cada requisição e aumente o intervalo
A forma mais fácil de isolar um problema é primeiro colar o endereço no navegador do computador. Se você vir um JSON correto no navegador, o problema está no ESP32 (Wi-Fi, certificado ou interpretação); se o navegador também mostrar um erro, você precisa corrigir o endereço ou a chave de API.

Um projeto de clima com ESP32 ensina a sequência básica de qualquer dispositivo conectado: conectar, solicitar, interpretar, exibir e repetir em intervalos razoáveis. Depois de dominar essa sequência, o mesmo código pode buscar dados de centenas de APIs diferentes. No app BlueGrays, você encontra projetos que mostram uma API de clima em um LCD e em um OLED SSD1306 usando HTTPClient no ESP32, junto com projetos de conexão Wi-Fi e relógio NTP, cada um com esquema do circuito e código passo a passo.

Perguntas frequentes

Como obter dados meteorológicos com um ESP32?

Conecte o ESP32 ao Wi-Fi e envie uma requisição GET a um serviço como Open-Meteo ou OpenWeatherMap com a biblioteca HTTPClient. Depois, leia a temperatura, a umidade e o código meteorológico da resposta JSON com a biblioteca ArduinoJson. O Open-Meteo não exige chave de API, o que o torna a opção mais fácil para um primeiro teste.

A API do Open-Meteo é gratuita?

O Open-Meteo é gratuito para uso não comercial e não exige cadastro nem chave de API. O plano gratuito tem limite de 10.000 chamadas por dia, 5.000 por hora e 600 por minuto. Para um produto comercial, você precisa de um plano pago.

Por que minha chave de API do OpenWeatherMap retorna o erro 401?

O código 401 significa que a chave está incorreta, ausente ou ainda não foi ativada. Chaves recém-criadas levam de alguns minutos a algumas horas para ficar ativas. Confira se você copiou a chave sem espaços e a incluiu no endereço com o parâmetro appid=.

O que significa o erro HTTP GET -1 no ESP32?

-1 é HTTPC_ERROR_CONNECTION_REFUSED e significa que nenhuma conexão pôde ser estabelecida. Geralmente é causado por falta de acesso à internet, um nome de domínio que não pode ser resolvido, um endereço digitado incorretamente ou uma conexão a um servidor HTTPS com o certificado errado. Imprima http.errorToString(code) no Monitor Serial para ver a descrição.

Com que frequência um ESP32 deve atualizar o tempo?

A cada 10 a 15 minutos é suficiente, pois os serviços atualizam os dados aproximadamente nessa frequência. Isso representa de 96 a 144 requisições por dia, muito abaixo dos limites gratuitos. Fazer requisições a cada segundo desperdiça energia e pode causar seu bloqueio.

Qual é a diferença entre ArduinoJson 6 e 7?

O ArduinoJson 7 substitui StaticJsonDocument e DynamicJsonDocument por uma única classe JsonDocument, que gerencia a memória automaticamente. O código antigo continua compilando com um aviso, mas, em projetos novos, basta usar JsonDocument doc;. A chamada de interpretação e a sintaxe de leitura doc["key"] são iguais nas duas versões.

Ver todos os projetos
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
ESP32 HTTPClient + API de clima (com display OLED SSD1306)
ES-32Avançado
Premium

ESP32 HTTPClient + API de clima (com display OLED SSD1306)

Neste projeto, usamos o ESP32 para fazer uma chamada REST à API de clima wttr.in pela internet com HTTPClient.h. Diferentemente da versão anterior com LCD I2C, aqui usamos um display OLED SSD1306 (128×64), que permite usar fontes grandes, ícones vetoriais e uma apresentação visual rica em uma única tela. Sete ícones vetoriais de condições do tempo (ensolarado, parcialmente nublado, nublado, chuvoso, com neve, com tempestade e com neblina) são desenhados durante a execução, sem arquivos bitmap.

4.3(10)
22
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
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
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
Display LCD I2C com ESP32 (16x2)
ES-17Intermediário
Premium

Display LCD I2C com ESP32 (16x2)

Neste projeto, exibimos texto conectando um display LCD de 16x2 caracteres ao ESP32 pelo protocolo I2C. Com o I2C, controlamos o display usando apenas dois pinos de dados (SDA e SCL), dispensando o uso de seis ou mais pinos da conexão paralela tradicional. O código mostra uma mensagem fixa na primeira linha e um contador que aumenta a cada segundo na segunda linha. Na inicialização, também executamos um scanner I2C para mostrar o endereço do display no Monitor Serial (geralmente 0x27 ou 0x3F).

4.9(23)
40
ESP32 em sono profundo — Economia de bateria (OLED + contador na RAM RTC)
ES-33Avançado
Premium

ESP32 em sono profundo — Economia de bateria (OLED + contador na RAM RTC)

O modo de sono profundo do ESP32 reduz o consumo de corrente para ~10 µA ao desligar a CPU e a maioria dos periféricos, sendo essencial para dispositivos IoT alimentados por bateria. Neste projeto, usamos três fontes de despertar: um temporizador (15 segundos), um pino externo (EXT0 — botão no GPIO 33) e toque (T0/GPIO 4). As variáveis marcadas com RTC_DATA_ATTR são preservadas durante o sono profundo, mantendo os contadores de inicializações e de despertares por temporizador e botão.

4.3(10)
16
Registrador de temperatura com ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Avançado
Premium

Registrador de temperatura com ESP32 (DHT22 + DS1307 RTC + microSD + OLED)

Monte um registrador de temperatura com data e hora usando ESP32. O DHT22 mede a temperatura e a umidade a cada minuto, o DS1307 RTC fornece a hora real e cada leitura é gravada em CSV no cartão microSD. O OLED mostra em letras grandes a temperatura atual, além da umidade, da data e hora e do total de registros. Abra o arquivo /temp_log.csv no Excel, no Google Sheets ou com pandas para acompanhar uma estufa ou a temperatura de casa.

4.7(7)
12