Blynk com ESP32: controle LEDs, relés e sensores pelo celular

O Blynk e o ESP32 formam o caminho mais rápido para controlar uma placa de qualquer lugar do mundo sem escrever o seu próprio app de celular. O Blynk IoT oferece um servidor na nuvem ao qual o ESP32 se conecta (Blynk.Cloud), um app para celular em que você monta um painel arrastando e soltando e um painel web. Quando você toca em um interruptor no celular, o comando vai primeiro para a nuvem e de lá para o ESP32; a temperatura que o ESP32 mede faz o mesmo caminho de volta e aparece no celular como número e como gráfico. O celular e a placa não precisam estar na mesma casa: funciona até quando o celular está nos dados móveis.

Neste guia você vai montar um projeto funcional do zero: vai abrir uma conta no Blynk.Cloud, definir um template e datastreams (V0, V1, V2, V3), pegar o auth token do dispositivo, instalar a biblioteca, controlar um LED e um relé pelo celular, mostrar em gráfico os dados do sensor DHT11 e receber uma notificação no celular quando a temperatura subir. Você também vai entender por que não deve usar delay() e o que o BlynkTimer faz no lugar dele, como calcular o limite de mensagens do plano grátis, por que códigos que sobraram do Blynk antigo não compilam e como resolver os erros de conexão mais comuns.

O que é o Blynk IoT e como ele funciona?

No Blynk, o ESP32 e o celular nunca se conectam diretamente um ao outro; os dois se conectam ao Blynk.Cloud e o servidor leva as mensagens. Quando o ESP32 liga, ele entra no Wi-Fi, depois se conecta ao servidor do Blynk e se identifica com o seu auth token. Os dados passam pelos pinos virtuais (V0–V255): um pino virtual não é uma perna real do ESP32, e sim um canal de dados numerado entre o seu código e o app. O interruptor no app escreve 1 em V1, a função BLYNK_WRITE(V1) do seu código recebe esse valor e aciona o relé; quando o seu código executa Blynk.virtualWrite(V2, 24.5), o medidor no celular é atualizado. Estes são os blocos que formam essa estrutura:

Diferenças entre o Blynk antigo e o novo Blynk IoT

A maioria dos vídeos e sketches de Blynk na internet foi feita para a versão antiga (Blynk Legacy), que não funciona mais. A nova plataforma foi lançada em maio de 2021; o app antigo saiu das lojas em junho de 2022 e os servidores antigos na nuvem foram desligados de vez em 31 de dezembro de 2022. Ou seja, um token de um projeto antigo, energy points comprados no passado ou o endereço blynk-cloud.com não servem para nada hoje; você precisa refazer o projeto na nova plataforma. A boa notícia: a maior parte do código do ESP32 (BLYNK_WRITE, virtualWrite, BlynkTimer) continua igual.

Lista de materiais e ligações

Neste projeto você vai usar uma placa de desenvolvimento ESP32, um módulo relé de 5 V, um sensor de temperatura e umidade DHT11, um LED opcional com um resistor de 220 Ω, uma protoboard e jumpers. Para o LED, o LED azul integrado da placa no GPIO 2 já basta; se você adicionar um LED externo, pode encontrar o valor do resistor com a calculadora de resistor para LED. Confira também a disposição dos pinos da sua placa na ferramenta Pinagem; em algumas placas o pino de 5 V está marcado como VIN, em outras como 5V.

Passo 1: crie uma conta no Blynk.Cloud e um template

1. No computador, acesse blynk.cloud, crie uma conta grátis com o seu endereço de e-mail e defina a sua senha pelo link do e-mail que você receber.
2. No menu à esquerda, vá em Developer Zone > My Templates e clique em + New Template.
3. Dê um nome ao template (por exemplo ESP32 Casa), escolha ESP32 como hardware e WiFi como tipo de conexão e crie o template.
4. Os valores BLYNK_TEMPLATE_ID e BLYNK_TEMPLATE_NAME exibidos na página do template vão para o seu código; por enquanto, só observe onde eles ficam.
5. Se um assistente de Quickstart aparecer quando você criar a conta, pode pulá-lo; neste guia vamos fazer cada passo à mão para você ver para que serve cada configuração.

Passo 2: defina os datastreams (V0, V1, V2, V3)

Um datastream é a carteira de identidade de um pino virtual: ele define qual é o pino, o tipo de dado (Integer para números inteiros, Double para decimais, String para texto), o valor mínimo e o máximo, a unidade e quantas casas decimais são exibidas. Abra o template no modo de edição, vá na aba Datastreams, escolha + New Datastream > Virtual Pin e crie estes quatro canais:

Passo 3: crie um dispositivo e pegue o auth token

O template é a receita; o dispositivo é a placa real feita a partir dela. No menu à esquerda, abra Devices, clique em + New Device, escolha o template ESP32 Casa com From template e dê um nome ao dispositivo. Assim que o dispositivo é criado, aparece uma configuração de três linhas: BLYNK_TEMPLATE_ID, BLYNK_TEMPLATE_NAME e BLYNK_AUTH_TOKEN. Copie essas linhas; você também pode encontrá-las depois na seção Device Info da página do dispositivo (chamada Developer Tools em algumas versões da interface).

Passo 4: instale a biblioteca Blynk no Arduino IDE

1. Se o pacote de placas ESP32 ainda não estiver instalado no Arduino IDE, instale-o primeiro; os passos estão em O que é o ESP32?
2. Abra o Gerenciador de Bibliotecas, digite Blynk na caixa de busca e instale a biblioteca oficial Blynk, de Volodymyr Shymanskyy. Se ele perguntar sobre dependências, escolha Instalar tudo.
3. Para o sensor, instale pelo mesmo lugar a DHT sensor library da Adafruit e a biblioteca Adafruit Unified Sensor, que ela exige. Se tiver problemas, veja o guia Como adicionar uma biblioteca no Arduino.
4. Selecione ESP32 Dev Module em Ferramentas > Placa, conecte a placa com um cabo USB que transmita dados e escolha a porta certa.
5. A biblioteca vem com exemplos prontos: Arquivo > Exemplos > Blynk > Boards_WiFi > ESP32_WiFi é a forma mais simples do primeiro sketch abaixo.

Primeiro sketch: acenda e apague um LED pelo celular (V0)

No código abaixo, troque as três primeiras linhas pelas que você copiou da página do seu dispositivo, e o nome e a senha do Wi-Fi pelos seus. Essas três linhas #define precisam vir antes das linhas #include; a biblioteca procura esses valores durante a compilação e dá erro de compilação se não os encontrar.

1// Bu üç satırı Blynk.Console'daki cihaz sayfasından kopyala / copy these three lines from the device page in Blynk.Console
2#define BLYNK_TEMPLATE_ID   "TMPLxxxxxxxx"
3#define BLYNK_TEMPLATE_NAME "ESP32 Ev"
4#define BLYNK_AUTH_TOKEN    "CihazTokeniniBurayaYapistir"
5
6#define BLYNK_PRINT Serial          // bağlantı günlüğünü Seri Monitör'e yaz / print the connection log to the Serial Monitor
7
8#include <WiFi.h>
9#include <WiFiClient.h>
10#include <BlynkSimpleEsp32.h>
11
12char ssid[] = "AgAdi";              // Wi-Fi adın (yalnız 2,4 GHz) / your Wi-Fi name (2.4 GHz only)
13char pass[] = "Sifre123";           // Wi-Fi şifren / your Wi-Fi password
14
15const int LED_PIN = 2;              // çoğu DevKit'te dahili LED / onboard LED on most DevKits
16
17// Uygulama V0'a her değer yazdığında çalışır / runs every time the app writes a value to V0
18BLYNK_WRITE(V0) {
19  int deger = param.asInt();        // anahtar: 0 ya da 1 / switch: 0 or 1
20  digitalWrite(LED_PIN, deger);
21  Serial.print("V0 = ");
22  Serial.println(deger);
23}
24
25// Buluta her bağlanışta son V0 değerini iste / ask for the last V0 value on every connection
26BLYNK_CONNECTED() {
27  Blynk.syncVirtual(V0);
28}
29
30void setup() {
31  Serial.begin(115200);
32  pinMode(LED_PIN, OUTPUT);
33  Blynk.begin(BLYNK_AUTH_TOKEN, ssid, pass);   // Wi-Fi'ye ve Blynk.Cloud'a bağlan / connect to Wi-Fi and Blynk.Cloud
34}
35
36void loop() {
37  Blynk.run();                      // gelen komutları işler, bağlantıyı canlı tutar / handles commands, keeps the link alive
38}

Depois de carregar o código e abrir o Monitor Serial em 115200 baud, você deve ver, nesta ordem, linhas como “Connecting to AgAdi”, “Connected to WiFi”, o endereço IP, “Connecting to blynk.cloud:80” e, por fim, “Ready (ping: 45ms).”. Quando a linha Ready aparece, o dispositivo fica Online no Blynk.Console. Na primeira conexão você também pode ver uma linha começando com “Redirecting to”; a biblioteca passa sozinha para o servidor regional em que a sua conta está, e isso é normal.

Montando os painéis do celular e da web

O código está pronto, então vamos posicionar os botões. No Blynk, o painel do celular e o painel web são montados separadamente; como os dois usam os mesmos datastreams, uma mudança feita em um aparece na hora no outro.

1. Instale no celular o app Blynk IoT (não o Blynk antigo nem o Blynk Legacy) e entre com a mesma conta.
2. Ative o Developer Mode na página do seu perfil e depois toque no template ESP32 Casa, na Developer Zone.
3. Toque na área vazia para adicionar widgets: um Button ou Switch para V0 e outro para V1, um Gauge ou Labeled Value para V2 e V3 e um SuperChart para o histórico.
4. Toque em cada widget e selecione o datastream correspondente nas configurações dele; você pode adicionar V2 e V3 juntos ao SuperChart. As alterações são salvas automaticamente.
5. Para o painel web, edite o template no Blynk.Console, arraste e solte widgets na aba Web Dashboard, escolha o datastream pelo ícone de engrenagem de cada widget e clique em Save.
6. No app, toque no nome do seu dispositivo e teste o interruptor: o LED do GPIO 2 deve acender na hora e o Monitor Serial deve mostrar “V0 = 1”.

Relé e sensor: leitura sem delay() com o BlynkTimer

A regra de ouro do Blynk é: o loop() deve conter apenas Blynk.run() e timer.run(). Se você colocar delay(2000) no loop, o ESP32 não enxerga os comandos do celular durante esse tempo e o interruptor responde com atraso; esperas muito longas fazem o servidor considerar o dispositivo offline. Pior ainda: se você colocar Blynk.virtualWrite() direto no loop, o ESP32 tenta enviar centenas de mensagens por segundo; o servidor limita o dispositivo e a sua cota mensal de mensagens acaba rápido. A solução é o BlynkTimer, que funciona pelo princípio do millis(): ele chama a função que você escolher no intervalo que você escolher, e o loop fica livre entre uma chamada e outra. Explicamos essa ideia em detalhes em millis() vs delay() no Arduino.

O código abaixo controla o relé por V1, envia a temperatura lida do DHT11 para V2 e a umidade para V3 a cada 60 segundos e dispara um evento de notificação quando a temperatura passa de 30 °C. Para entender como o sensor funciona, veja Sensor de temperatura e umidade DHT11.

1#define BLYNK_TEMPLATE_ID   "TMPLxxxxxxxx"
2#define BLYNK_TEMPLATE_NAME "ESP32 Ev"
3#define BLYNK_AUTH_TOKEN    "CihazTokeniniBurayaYapistir"
4#define BLYNK_PRINT Serial
5
6#include <WiFi.h>
7#include <WiFiClient.h>
8#include <BlynkSimpleEsp32.h>
9#include <DHT.h>
10
11char ssid[] = "AgAdi";
12char pass[] = "Sifre123";
13
14const int ROLE_PIN = 26;            // röle modülünün IN pini / relay module IN pin
15const int DHT_PIN  = 4;             // DHT11 veri pini / DHT11 data pin
16const bool ROLE_AKTIF_LOW = true;   // çoğu modül LOW'da çeker / most modules switch on with LOW
17
18DHT dht(DHT_PIN, DHT11);            // DHT22 kullanıyorsan DHT22 yaz / write DHT22 if you use a DHT22
19BlynkTimer timer;                   // delay() yerine zamanlayıcı / a timer instead of delay()
20bool alarmGitti = false;            // aynı bildirimin tekrarını önler / stops the same alert repeating
21
22void roleYaz(bool acik) {
23  if (ROLE_AKTIF_LOW) digitalWrite(ROLE_PIN, acik ? LOW : HIGH);
24  else                digitalWrite(ROLE_PIN, acik ? HIGH : LOW);
25}
26
27// V1: uygulamadaki röle anahtarı / relay switch in the app
28BLYNK_WRITE(V1) {
29  roleYaz(param.asInt() == 1);
30}
31
32// Elektrik gidip gelince rölenin son durumunu geri al / restore the relay state after a power cut
33BLYNK_CONNECTED() {
34  Blynk.syncVirtual(V1);
35}
36
37// Zamanlayıcının çağırdığı fonksiyon / the function called by the timer
38void sensorGonder() {
39  float sicaklik = dht.readTemperature();
40  float nem = dht.readHumidity();
41  if (isnan(sicaklik) || isnan(nem)) {
42    Serial.println("DHT okunamadi / DHT read failed");
43    return;
44  }
45  Blynk.virtualWrite(V2, sicaklik);   // V2: sıcaklık (°C) / temperature (°C)
46  Blynk.virtualWrite(V3, nem);        // V3: nem (%) / humidity (%)
47
48  // 30 °C'yi geçince tek bildirim, 28 °C'nin altında yeniden kur / one alert above 30 °C, re-arm below 28 °C
49  if (sicaklik > 30.0 && !alarmGitti) {
50    Blynk.logEvent("yuksek_sicaklik", String("Sicaklik / Temp: ") + sicaklik + " C");
51    alarmGitti = true;
52  } else if (sicaklik < 28.0) {
53    alarmGitti = false;
54  }
55}
56
57void setup() {
58  Serial.begin(115200);
59  pinMode(ROLE_PIN, OUTPUT);
60  roleYaz(false);                   // açılışta röle kapalı / relay off at boot
61  dht.begin();
62  Blynk.begin(BLYNK_AUTH_TOKEN, ssid, pass);
63  timer.setInterval(60000L, sensorGonder);   // 60 saniyede bir ölç ve gönder / measure and send every 60 seconds
64}
65
66void loop() {
67  Blynk.run();
68  timer.run();                      // loop'ta delay() ya da virtualWrite olmasın / no delay() or virtualWrite in loop
69}

A linha timer.setInterval(60000L, sensorGonder) chama a função a cada 60.000 milissegundos; o L no final indica que o número é do tipo long. Para tarefas de uma vez só, use timer.setTimeout(), por exemplo para ligar o relé e desligá-lo 5 segundos depois. Um objeto BlynkTimer guarda até 16 temporizadores, o que é mais do que suficiente para a maioria dos projetos. A verificação isnan() impede que um valor NaN sem sentido chegue à nuvem quando não é possível ler o sensor. A flag alarmGitti e a diferença entre os limites de 30 e 28 °C (histerese) evitam uma nova notificação a cada leitura enquanto a temperatura oscila perto de 30 °C.

Mostrando os dados do sensor em um gráfico

Para o gráfico se encher, duas coisas são necessárias: o ESP32 precisa enviar dados com virtualWrite e o datastream precisa guardar histórico. Se Last Value estiver selecionado para o histórico nas configurações do datastream, o servidor guarda só o último valor e nenhum gráfico é desenhado; a opção de média por minuto (1 Minute AVG) basta para gráficos. No plano grátis o histórico fica guardado por 1 semana, e o armazenamento de dados brutos (RAW) é exclusivo dos planos pagos. No SuperChart você pode alternar entre intervalos de tempo como horas, dias e semanas e ver temperatura e umidade em duas cores no mesmo gráfico. Como os dados chegam a cada 60 segundos, os primeiros pontos levam alguns minutos para aparecer; não perca a paciência baixando o intervalo para 1 segundo, você vai ver por quê na seção do plano grátis.

Enviando notificações: eventos e Blynk.logEvent()

No novo Blynk, as notificações funcionam por meio de eventos. Primeiro você define o evento no template e depois o dispara no código com Blynk.logEvent(); o Blynk registra o evento na linha do tempo (Timeline) do dispositivo e, conforme as configurações, envia uma notificação push ou um e-mail para o seu celular. A descrição de um evento pode ter até 300 caracteres, mas como o buffer de envio da biblioteca é pequeno, o melhor é mantê-la curta.

1. Abra o template no modo de edição e vá para a aba Events & Notifications.
2. Clique em + Create Event, dê ao evento um nome como “Temperatura alta” e defina o código do evento (event code) como yuksek_sicaklik. O código só pode ter letras, números e sublinhados e precisa ser exatamente igual ao texto do seu sketch.
3. Escolha Warning como tipo de evento; Info, Warning e Critical definem a gravidade do alerta. Confira se a opção de linha do tempo (Timeline) está ativada para o evento aparecer no app.
4. Na aba Notifications, ative as notificações, escolha a sua própria conta como destinatário e push e e-mail como canais; se quiser, limite as notificações a uma por hora.
5. Clique em Save no template e confirme a atualização do dispositivo. Não se esqueça de permitir as notificações do app Blynk IoT no celular.

Limites do plano grátis: como fazer a conta das mensagens

O plano grátis do Blynk basta para aprender e para projetos pequenos, mas um projeto montado sem conhecer os limites pode ficar mudo no meio do mês. Em outubro de 2026, a página de preços do Blynk lista estes valores para o plano grátis: 5 dispositivos, 1 usuário, 100.000 mensagens de dispositivo por mês, 1 semana de histórico de dados, 10 templates, 5 eventos por template, 1 webhook e 5 automações. Esses limites mudaram várias vezes nos últimos anos; antes de montar um projeto de longo prazo, confira os valores atuais na página de preços do Blynk ou nas configurações de plano da sua conta. O que mais conta para a cota são os comandos virtualWrite, syncVirtual e logEvent que o seu dispositivo envia, e cada virtualWrite sozinho é uma mensagem. Um mês tem cerca de 2.592.000 segundos, então a conta é simples:

Uma conexão que não trava sem Wi-Fi

O Blynk.begin() é fácil, mas tem um ponto fraco: se a conexão com o Wi-Fi ou com o Blynk não for estabelecida, ele espera para sempre dentro do setup() e o resto da placa nunca roda. Em projetos que precisam continuar funcionando quando a internet cai, como um termostato ou um sistema de irrigação, você deve gerenciar a conexão por conta própria. O esqueleto abaixo inicia o Wi-Fi sem esperar, só aplica as configurações com Blynk.config() e verifica a conexão a cada 10 segundos; enquanto isso, as tarefas locais que você adicionar ao timer continuam rodando, com ou sem internet.

1#define BLYNK_TEMPLATE_ID   "TMPLxxxxxxxx"
2#define BLYNK_TEMPLATE_NAME "ESP32 Ev"
3#define BLYNK_AUTH_TOKEN    "CihazTokeniniBurayaYapistir"
4#define BLYNK_PRINT Serial
5
6#include <WiFi.h>
7#include <WiFiClient.h>
8#include <BlynkSimpleEsp32.h>
9
10char ssid[] = "AgAdi";
11char pass[] = "Sifre123";
12
13BlynkTimer timer;
14
15// Wi-Fi varsa ama Blynk bağlı değilse yeniden dene / retry Blynk when Wi-Fi is up but Blynk is not
16void baglantiKontrol() {
17  if (WiFi.status() == WL_CONNECTED && !Blynk.connected()) {
18    Serial.println("Blynk'e yeniden baglaniliyor / reconnecting to Blynk");
19    Blynk.connect(3000);            // en fazla 3 saniye bekle / wait at most 3 seconds
20  }
21}
22
23void setup() {
24  Serial.begin(115200);
25  WiFi.mode(WIFI_STA);
26  WiFi.begin(ssid, pass);           // beklemeden başlat / start without waiting
27  Blynk.config(BLYNK_AUTH_TOKEN);   // yalnız ayarla, bağlanmayı bekleme / configure only, don't block
28  timer.setInterval(10000L, baglantiKontrol);   // 10 saniyede bir kontrol / check every 10 seconds
29}
30
31void loop() {
32  if (Blynk.connected()) {
33    Blynk.run();
34  }
35  timer.run();                      // yerel işler internet yokken de çalışır / local tasks keep running offline
36}

O ESP32 tenta se reconectar ao Wi-Fi sozinho quando a conexão cai; o código só se reconecta ao Blynk quando o Wi-Fi volta. Se quiser os seus dados criptografados, basta incluir BlynkSimpleEsp32_SSL.h no lugar de BlynkSimpleEsp32.h; a conexão passa a usar TLS na porta 443 em vez da 80 e também escapa do bloqueio de portas em algumas redes de escolas ou empresas. Se não quiser deixar os dados do Wi-Fi fixos no código, o exemplo Blynk.Edgent > Edgent_ESP32 da biblioteca permite digitar o nome da rede e a senha pelo app Blynk IoT no celular; com esse método, o auth token é atribuído automaticamente quando o dispositivo é adicionado e o código pode ser atualizado sem fio (OTA). O mesmo código também roda em placas ESP8266: para uma NodeMCU, basta usar ESP8266WiFi.h e BlynkSimpleEsp8266.h.

Blynk com Raspberry Pi Pico W e MicroPython

O Blynk não é só para o ESP32. Se você usa MicroPython em um Raspberry Pi Pico W, basta copiar para o Pico com o Thonny o arquivo único BlynkLib.py da biblioteca Python do Blynk. Saiba que essa biblioteca não é mais desenvolvida ativamente e que o Blynk recomenda a sua API MQTT para projetos novos; mesmo assim, ela dá conta do recado para aprender e para projetos simples. O código abaixo controla o LED integrado do Pico W por V0 e envia a leitura do sensor de temperatura interno do chip para V2 uma vez por minuto. Crie um dispositivo separado para o Pico W no Blynk.Console e use o token dele. Se você está começando com MicroPython, Fundamentos de MicroPython é um bom ponto de partida.

1import network, time
2from machine import Pin, ADC
3import BlynkLib                      # BlynkLib.py Pico'da olmalı / BlynkLib.py must be on the Pico
4
5WIFI_SSID = "AgAdi"
6WIFI_PASS = "Sifre123"
7BLYNK_AUTH = "PicoTokeniniBurayaYapistir"
8
9led = Pin("LED", Pin.OUT)            # Pico W dahili LED / Pico W onboard LED
10sensor = ADC(4)                      # yongadaki sıcaklık sensörü / on-chip temperature sensor
11
12wlan = network.WLAN(network.STA_IF)
13wlan.active(True)
14wlan.connect(WIFI_SSID, WIFI_PASS)
15while not wlan.isconnected():
16    time.sleep(0.5)
17print("IP:", wlan.ifconfig()[0])
18
19blynk = BlynkLib.Blynk(BLYNK_AUTH, insecure=True)   # 80 portu, TLS'siz / port 80, no TLS
20
21@blynk.on("V0")
22def v0_yazildi(value):               # uygulamadaki anahtar / switch in the app
23    led.value(int(value[0]))
24
25@blynk.on("connected")
26def baglandi(ping):
27    print("Blynk hazir / ready, ping:", ping, "ms")
28    blynk.sync_virtual(0)            # son V0 değerini iste / ask for the last V0 value
29
30son = time.ticks_ms()
31while True:
32    blynk.run()
33    if time.ticks_diff(time.ticks_ms(), son) >= 60000:   # 60 saniyede bir / every 60 seconds
34        son = time.ticks_ms()
35        volt = sensor.read_u16() * 3.3 / 65535
36        sicaklik = 27 - (volt - 0.706) / 0.001721
37        blynk.virtual_write(2, round(sicaklik, 1))      # V2: sıcaklık / temperature

Neste exemplo, a conexão é feita sem criptografia na porta 80 com insecure=True; essa é a opção que gasta menos memória e equivale ao BlynkSimpleEsp32.h no ESP32. Se você remover esse parâmetro, a biblioteca tenta usar TLS na porta 443. O motivo de medirmos o tempo com ticks_ms no laço em vez de usar time.sleep() é o mesmo do lado do Arduino: se blynk.run() não for chamado com frequência, os comandos atrasam e a conexão cai. O sensor de temperatura interno do chip pode ficar alguns graus longe da temperatura ambiente; para medições reais, ligue um DHT11 ou um DS18B20.

Ideias de projetos com Blynk

• Tomada inteligente: ligue e desligue um abajur ou uma ventoinha de qualquer lugar do mundo com um relé; para as ligações do relé, veja O que é um módulo relé?
• Irrigação de plantas a distância: acione a bomba quando o sensor de umidade do solo indicar solo seco e acompanhe o nível de umidade em um gráfico.
• Estufa inteligente: ligue uma ventoinha quando a temperatura e a umidade subirem e receba uma notificação quando os valores passarem de um limite; detalhes em Projeto de estufa inteligente.
• Alarme antifurto: envie uma notificação crítica para o celular com logEvent quando o sensor de movimento PIR detectar alguém.
• Alerta de vazamento de gás: quando o sensor de gás MQ-2 passar do limite, faça um buzzer tocar e o celular vibrar também.
• Estação meteorológica: compare temperatura, umidade e pressão de um BME280 em um gráfico semanal.
• Monitor de portas e janelas: veja no app se uma porta ficou aberta com um reed switch.

Erros comuns e soluções

Blynk, servidor web próprio ou MQTT?

Resumindo: o Blynk é o caminho mais fácil para ter resultado rápido com um painel pronto e bonito e para acessar o seu projeto de fora de casa. Se você quer um sistema ilimitado e totalmente local, leia Servidor web e WebSocket no ESP32 ou ESP32 com MQTT e Home Assistant; se só quer mandar alertas para o celular, confira o guia Bot do Telegram com ESP32.

Um caminho mais fácil: BlueGrays IoT

O Blynk é uma plataforma flexível e poderosa. Mas, se você só quer ligar e desligar um relé ou acompanhar um sensor pelo celular, talvez não queira configurar à mão o template, os datastreams, os widgets e o auth token. O BlueGrays IoT faz isso com modelos prontos: você escolhe um em Oficina › Meus dispositivos › Adicionar novo dispositivo, o Ohmi prepara o código com a chave do seu dispositivo e você o carrega uma vez pela Arduino IDE com a biblioteca BlueGraysIoT. Ele funciona com o ESP32 e o Raspberry Pi Pico W em Wi-Fi de 2,4 GHz, e seu primeiro dispositivo é grátis. Para mais detalhes, confira o guia para controlar um ESP32 pelo celular.

Depois de entender o trio template, datastream e auth token, ligar um novo projeto com ESP32 ao celular pelo Blynk leva só alguns minutos. Junte os exemplos de LED, relé e sensor deste guia e você tem o começo do seu próprio sistema de casa inteligente. No app BlueGrays você também encontra projetos com ESP32, como piscar um LED, conectar ao Wi-Fi, medir temperatura com um DHT22, iluminação inteligente, irrigação de plantas e alarme de movimento com Telegram, cada um com esquema do circuito e código passo a passo.