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.

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.
| Termo | Significado | Exemplo de clima |
|---|---|---|
| API | A porta que os programas usam para trocar dados | Serviço de previsão Open-Meteo |
| Endpoint | O endereço da API que executa uma tarefa específica | /v1/forecast |
| Parâmetro de consulta | Configurações após o ? no endereço | latitude=41.01¤t=temperature_2m |
| Requisição GET | Solicitação de dados ao servidor | http.GET() |
| Código de status | Um número que descreve o resultado da requisição | 200 sucesso, 404 não encontrado |
| JSON | Um formato de texto composto por chaves e valores | {"temperature_2m":17.3} |
| Chave de API | Um 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ística | Open-Meteo | OpenWeatherMap (gratuito) |
|---|---|---|
| Cadastro e chave | Não são necessários | Conta e chave de API obrigatórias |
| Localização | Latitude e longitude | Nome da cidade, latitude e longitude ou ID da cidade |
| Limite gratuito | 10.000 chamadas por dia, 5.000 por hora, 600 por minuto | 60 chamadas por minuto, 1.000.000 por mês |
| Atualização dos dados | Dados atuais a cada 15 minutos | Aproximadamente a cada 10 minutos |
| Condição do tempo | Có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 resposta | Somente os campos escolhidos, cerca de 400 bytes | Cerca de 500 bytes |
O que você precisa e como configurar
- 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.
- 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.
- Para a versão com display, instale as bibliotecas Adafruit SSD1306 e Adafruit GFX, ou LiquidCrystal I2C se estiver usando um LCD.
- 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.
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.
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 "¤t=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ção | O 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.
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 "¤t=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.
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 WMO | Significado |
|---|---|
| 0 | Céu limpo |
| 1, 2, 3 | Predominantemente limpo, parcialmente nublado, encoberto |
| 45, 48 | Nevoeiro, nevoeiro com deposição de gelo |
| 51, 53, 55 | Garoa leve, moderada, intensa |
| 56, 57 | Garoa congelante |
| 61, 63, 65 | Chuva leve, moderada, forte |
| 66, 67 | Chuva congelante |
| 71, 73, 75 | Queda de neve leve, moderada, forte |
| 77 | Grãos de neve |
| 80, 81, 82 | Pancadas de chuva leves, moderadas, violentas |
| 85, 86 | Pancadas de neve leves e fortes |
| 95 | Tempestade com trovoadas |
| 96, 99 | Tempestade 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.
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.
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¤t=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}Como mostrar o tempo da sua cidade em um display OLED

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 OLED | ESP32 |
|---|---|
| GND | GND |
| VCC | 3V3 |
| SCL | GPIO 22 |
| SDA | GPIO 21 |
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 "¤t=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.
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.
| Intervalo | Requisições por dia | Avaliação |
|---|---|---|
| 1 segundo | 86.400 | Acima do limite; seu endereço IP pode ser bloqueado temporariamente |
| 1 minuto | 1.440 | Dentro do limite, mas é desperdício, pois os dados não mudam |
| 10 minutos | 144 | Ideal para uma estação meteorológica de mesa |
| 15 minutos | 96 | Corresponde à frequência de atualização do Open-Meteo |
| 1 hora | 24 | Suficiente para dispositivos alimentados por bateria e previsões diárias |
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ódigo | Significado | O que fazer |
|---|---|---|
| 200 | Sucesso | Leia e interprete o corpo da resposta |
| 400 | Requisição inválida | Verifique os nomes dos parâmetros e as vírgulas no endereço |
| 401 | Não autorizado: chave de API ausente, incorreta ou ainda não ativada | Copie a chave novamente; se for nova, aguarde um pouco |
| 404 | Não encontrado: nome da cidade ou endereço incorreto | Escreva a cidade com letras simples do alfabeto inglês (Istanbul,TR) e confira o endereço |
| 429 | Requisições demais | Aumente o intervalo |
| 500-503 | Problema no servidor | Tente novamente em alguns minutos |
| -1 | Sem conexão: falta de internet, domínio não resolvido, endereço incorreto ou falha na negociação HTTPS | Verifique o Wi-Fi, o endereço e o certificado |
| -5 | Conexão perdida no meio da transferência | Melhore o sinal do Wi-Fi e repita a requisição |
| -11 | Tempo limite de leitura excedido | Aumente 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.
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.
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.
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 "¤t=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 minutesO 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
| Sintoma | Causa provável | Solução |
|---|---|---|
| Pontos sem parar no Monitor Serial | Não consegue conectar ao Wi-Fi | Rede de 2,4 GHz, senha correta, maior proximidade do roteador |
| Código HTTP -1 | Problema de internet, domínio ou HTTPS | Teste 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 ativada | Copie a chave novamente; em uma conta nova, aguarde um pouco |
| Erro JSON InvalidInput | A resposta não é JSON (uma página de erro HTML) | Primeiro imprima a resposta com getString() |
| Erro JSON IncompleteInput | Resposta interrompida ou fluxo em blocos | Use getString() ou adicione useHTTP10(true) |
| Temperatura sempre em 0.00 | Nome da chave escrito incorretamente | Copie o nome exatamente como aparece no JSON (temperature_2m) |
| Caracteres estranhos no display | Letras acentuadas ou o símbolo ° ausentes na fonte | Use lang=en e imprima o símbolo de grau com (char)247 |
| Trava após algumas horas | Conexões não fechadas, fragmentação da memória | Chame http.end() após cada requisição e aumente o intervalo |
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.
Projetos para montar depois desta leitura
Ver todos os projetos
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.

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.

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.

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.

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.

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).

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.

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.
Mais artigos
- O que é ESP32? Características, configuração na Arduino IDE e seu primeiro projeto com Wi-Fi
- Como usar um display OLED (SSD1306): texto, formas e gráficos com Arduino
- Hora NTP no ESP32: relógio pela internet com fuso horário, OLED e RTC de reserva
- ESP32 não conecta ao Wi-Fi? Códigos do WiFi.status() e soluções reais
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

