Blynk ESP32: controla LED, relé y sensores desde el móvil

Blynk con ESP32 es la forma más rápida de controlar una placa desde cualquier parte del mundo sin programar tu propia app para el móvil. Blynk IoT te ofrece un servidor en la nube al que se conecta el ESP32 (Blynk.Cloud), una app móvil en la que montas un panel arrastrando y soltando, y un panel web. Cuando tocas un interruptor en el móvil, la orden va primero a la nube y de ahí al ESP32; la temperatura que mide el ESP32 vuelve por el mismo camino y aparece en tu móvil como número y como gráfica. El móvil y la placa no tienen que estar en la misma casa: funciona incluso con el móvil en datos móviles.

En esta guía vas a montar desde cero un proyecto que funciona: abrirás una cuenta en Blynk.Cloud, definirás una plantilla (template) y varios datastreams (V0, V1, V2, V3), obtendrás el Auth Token del dispositivo, instalarás la librería, controlarás un LED y un relé desde el móvil, verás los datos de un DHT11 en una gráfica y recibirás una notificación cuando suba la temperatura. Además aprenderás por qué no debes usar delay() y qué hace BlynkTimer en su lugar, cómo calcular el límite de mensajes del plan gratuito, por qué el código del Blynk antiguo ya no compila y cómo resolver los errores de conexión más frecuentes.

¿Qué es Blynk IoT y cómo funciona?

Con Blynk, el ESP32 y el móvil nunca se conectan entre sí directamente; ambos se conectan a Blynk.Cloud y el servidor lleva los mensajes. Al arrancar, el ESP32 se conecta primero al Wi-Fi, después al servidor de Blynk y se identifica con su Auth Token. Los datos viajan por pines virtuales (Virtual Pin, V0–V255): un pin virtual no es una patilla real del ESP32, sino un canal de datos numerado entre tu código y la app. El interruptor de la app escribe un 1 en V1, la función BLYNK_WRITE(V1) de tu código lo recoge y activa el relé; cuando tu código ejecuta Blynk.virtualWrite(V2, 24.5), se actualiza el indicador del móvil. Estos son los conceptos básicos:

Diferencias entre el Blynk antiguo y el nuevo Blynk IoT

La mayoría de vídeos y códigos de Blynk que circulan por internet se hicieron para la versión antigua (Blynk Legacy), que ya no funciona. La nueva plataforma salió en mayo de 2021; la app antigua se retiró de las tiendas en junio de 2022 y los antiguos servidores en la nube se apagaron definitivamente el 31 de diciembre de 2022. Así que el token de un proyecto antiguo, los puntos de energía que compraste o la dirección blynk-cloud.com ya no sirven de nada; tienes que crear el proyecto de nuevo en la plataforma actual. La buena noticia: la mayor parte del código del ESP32 (BLYNK_WRITE, virtualWrite, BlynkTimer) sigue igual.

Materiales y conexiones

Para este proyecto usarás una placa de desarrollo ESP32, un módulo de relé de 5 V, un sensor de temperatura y humedad DHT11, opcionalmente un LED con una resistencia de 220 Ω, una protoboard y cables jumper. Como LED basta con el LED azul integrado en el GPIO 2; si pones un LED externo, calcula la resistencia con la calculadora de resistencia para LED. Comprueba también el pinout de tu placa en la herramienta Pinout; en algunas placas el pin de 5 V se llama VIN y en otras 5V.

Paso 1: crear la cuenta de Blynk.Cloud y la plantilla

1. En el ordenador entra en blynk.cloud, crea una cuenta gratuita con tu correo y define tu contraseña con el enlace del correo que recibirás.
2. En el menú de la izquierda ve a Developer Zone > My Templates y pulsa + New Template.
3. Ponle un nombre a la plantilla (por ejemplo ESP32 Casa), elige ESP32 como hardware y WiFi como tipo de conexión, y crea la plantilla.
4. Los valores BLYNK_TEMPLATE_ID y BLYNK_TEMPLATE_NAME que aparecen en la página de la plantilla irán en tu código; por ahora solo fíjate en dónde están.
5. Si al registrarte aparece un asistente Quickstart, puedes saltarlo; en esta guía haremos cada paso a mano para que veas para qué sirve cada ajuste.

Paso 2: definir los datastreams (V0, V1, V2, V3)

Un datastream es la ficha de identidad de un pin virtual: indica qué pin es, el tipo de dato (Integer para enteros, Double para decimales, String para texto), el valor mínimo y máximo, la unidad y cuántos decimales se muestran. Abre la plantilla en modo edición, ve a la pestaña Datastreams, elige + New Datastream > Virtual Pin y crea estos cuatro canales:

Paso 3: crear el dispositivo y obtener el Auth Token

La plantilla es una receta y el dispositivo es la placa real hecha con esa receta. En el menú de la izquierda abre Devices, pulsa + New Device, elige la plantilla ESP32 Casa con From template y ponle un nombre al dispositivo. Al crearlo aparece una configuración de tres líneas: BLYNK_TEMPLATE_ID, BLYNK_TEMPLATE_NAME y BLYNK_AUTH_TOKEN. Copia esas líneas; más adelante también las encontrarás en la sección Device Info de la página del dispositivo (en algunas versiones de la interfaz se llama Developer Tools).

Paso 4: instalar la librería Blynk en el Arduino IDE

1. Si todavía no tienes el paquete de placas ESP32 en el Arduino IDE, instálalo primero; los pasos están en ¿Qué es el ESP32?
2. Abre el Gestor de Librerías, escribe Blynk en el buscador e instala la librería oficial Blynk de Volodymyr Shymanskyy. Si te pregunta por las dependencias, elige Install all.
3. Para el sensor, instala desde el mismo sitio la DHT sensor library de Adafruit y la Adafruit Unified Sensor que necesita. Si tienes problemas, consulta la guía Cómo añadir una librería en Arduino.
4. Elige ESP32 Dev Module en Herramientas > Placa, conecta la placa con un cable USB de datos y selecciona el puerto correcto.
5. La librería incluye ejemplos listos: Archivo > Ejemplos > Blynk > Boards_WiFi > ESP32_WiFi es la versión más sencilla del primer sketch de abajo.

Primer sketch: encender y apagar un LED desde el móvil (V0)

En el código de abajo, sustituye las tres primeras líneas por las que copiaste de la página de tu dispositivo, y el nombre y la contraseña del Wi-Fi por los tuyos. Esas tres líneas #define deben ir siempre antes de las líneas #include; la librería busca esos valores al compilar y da un error si no los encuentra.

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}

Al subir el código y abrir el Monitor Serie a 115200 baudios deberías ver, por este orden, líneas como "Connecting to AgAdi", "Connected to WiFi", la dirección IP, "Connecting to blynk.cloud:80" y al final "Ready (ping: 45ms).". Cuando aparece la línea Ready, el dispositivo se ve Online en Blynk.Console. En la primera conexión puede que veas también una línea que empieza por "Redirecting to"; la librería pasa sola al servidor regional de tu cuenta, es normal.

Preparar el panel del móvil y el panel web

El código está listo, ahora coloquemos los botones. En Blynk el panel móvil y el panel web se diseñan por separado; como ambos usan los mismos datastreams, lo que cambies en uno se ve al instante en el otro.

1. Instala en el móvil la app Blynk IoT (no el Blynk antiguo ni Blynk Legacy) e inicia sesión con la misma cuenta.
2. Activa Developer Mode en la página de tu perfil y luego toca la plantilla ESP32 Casa en la Developer Zone.
3. Toca el espacio vacío para añadir widgets: un Button o Switch para V0 y otro para V1, un Gauge o Labeled Value para V2 y V3, y un SuperChart para el historial.
4. Toca cada widget y elige su datastream en los ajustes; al SuperChart puedes añadirle V2 y V3 juntos. Los cambios se guardan solos.
5. Para el panel web, edita la plantilla en Blynk.Console, arrastra los widgets en la pestaña Web Dashboard, elige el datastream desde el icono del engranaje de cada uno y guarda con Save.
6. En la app, toca el nombre de tu dispositivo y prueba el interruptor: el LED del GPIO 2 debe encenderse al momento y el Monitor Serie debe mostrar "V0 = 1".

Relé y sensor: lectura sin delay() con BlynkTimer

La regla de oro de Blynk es: en loop() solo deben estar Blynk.run() y timer.run(). Si pones delay(2000) en loop, durante ese tiempo el ESP32 no ve las órdenes del móvil y el interruptor responde con retraso; las esperas muy largas hacen que el servidor considere el dispositivo desconectado. Peor aún, si escribes Blynk.virtualWrite() directamente en loop, el ESP32 intenta enviar cientos de mensajes por segundo; el servidor lo limita y tu cuota mensual de mensajes se agota enseguida. La solución es BlynkTimer, que funciona con la lógica de millis(): llama a la función que elijas cada cierto intervalo y deja loop libre entre medias. Explicamos esta idea en detalle en Arduino millis() y delay().

El siguiente código controla el relé con V1, envía cada 60 segundos la temperatura del DHT11 a V2 y la humedad a V3, y dispara un evento de notificación cuando la temperatura supera los 30 °C. Para saber cómo funciona el sensor, mira Sensor de temperatura y humedad 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}

La línea timer.setInterval(60000L, sensorGonder) llama a la función cada 60.000 milisegundos; la L final indica que el número es de tipo long. Para tareas de una sola vez se usa timer.setTimeout(), por ejemplo para encender el relé y apagarlo 5 segundos después. Un objeto BlynkTimer admite hasta 16 temporizadores, más que suficiente para la mayoría de proyectos. La comprobación con isnan() evita que llegue a la nube un valor NaN sin sentido cuando no se puede leer el sensor. La variable alarmGitti y la diferencia entre los umbrales de 30 y 28 °C (histéresis) evitan una notificación nueva en cada lectura mientras la temperatura oscila alrededor de 30 °C.

Mostrar los datos del sensor en una gráfica

Para que la gráfica se llene hacen falta dos cosas: que el ESP32 envíe datos con virtualWrite y que el datastream guarde historial. Si en los ajustes del datastream el historial (history) está en Last Value, el servidor guarda solo el último valor y no se dibuja ninguna gráfica; la media por minuto (1 Minute AVG) es suficiente para las gráficas. En el plan gratuito el historial se guarda 1 semana, y el almacenamiento de datos en bruto (RAW) es exclusivo de los planes de pago. En SuperChart puedes cambiar entre rangos de horas, días y semanas y ver temperatura y humedad en dos colores en la misma gráfica. Como los datos llegan cada 60 segundos, los primeros puntos tardan unos minutos en aparecer; no te impacientes bajando el intervalo a 1 segundo, verás por qué en la sección del plan gratuito.

Enviar notificaciones: eventos y Blynk.logEvent()

En el nuevo Blynk las notificaciones funcionan mediante eventos. Primero defines el evento en la plantilla y luego lo disparas en el código con Blynk.logEvent(); Blynk anota el evento en la línea de tiempo (Timeline) del dispositivo y, según su configuración, envía una notificación push o un correo a tu móvil. La descripción de un evento puede tener hasta 300 caracteres, pero como el búfer de envío de la librería es pequeño, es mejor que sea corta.

1. Abre la plantilla en modo edición y ve a la pestaña Events & Notifications.
2. Pulsa + Create Event, ponle al evento un nombre como "Temperatura alta" y usa yuksek_sicaklik como código del evento (event code). El código solo puede tener letras, números y guiones bajos y debe coincidir exactamente con el texto del sketch.
3. Elige Warning como tipo de evento; Info, Warning y Critical indican la gravedad del aviso. Comprueba que la opción de línea de tiempo esté activada para que el evento aparezca en la app.
4. En la pestaña Notifications activa las notificaciones, elige tu propia cuenta como destinatario y push y correo como canales; si quieres, limítalas a una por hora.
5. Guarda la plantilla con Save y confirma la actualización del dispositivo. No olvides permitir las notificaciones de la app Blynk IoT en el móvil.

Límites del plan gratuito: cómo calcular los mensajes

El plan gratuito de Blynk es suficiente para aprender y para proyectos pequeños, pero un proyecto montado sin conocer sus límites puede quedarse mudo a mitad de mes. A octubre de 2026, la página de precios de Blynk indica estos valores para el plan gratuito: 5 dispositivos, 1 usuario, 100.000 mensajes de dispositivo al mes, 1 semana de historial, 10 plantillas, 5 eventos por plantilla, 1 webhook y 5 automatizaciones. Estos límites han cambiado varias veces en los últimos años; antes de montar un proyecto de larga duración, comprueba los valores actuales en la página de precios de Blynk o en los ajustes del plan de tu cuenta. Lo que más cuenta son los comandos virtualWrite, syncVirtual y logEvent que envía tu dispositivo, y cada virtualWrite es un mensaje. Un mes tiene unos 2.592.000 segundos, así que la cuenta es sencilla:

Una conexión que no se bloquea sin Wi-Fi

Blynk.begin() es cómodo pero tiene un inconveniente: si no consigue conectar al Wi-Fi o a Blynk, se queda esperando para siempre dentro de setup() y el resto de la placa nunca se ejecuta. En proyectos que deben seguir funcionando aunque se caiga internet, como un termostato o un riego, conviene que gestiones tú la conexión. El esqueleto de abajo inicia el Wi-Fi sin esperar, con Blynk.config() solo aplica los ajustes y comprueba la conexión cada 10 segundos; mientras tanto, las tareas locales que añadas al temporizador siguen funcionando con o sin 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}

El ESP32 intenta reconectarse al Wi-Fi por su cuenta cuando se corta; el código solo vuelve a conectar con Blynk cuando el Wi-Fi ha vuelto. Si quieres que tus datos viajen cifrados, basta con incluir BlynkSimpleEsp32_SSL.h en lugar de BlynkSimpleEsp32.h; la conexión usa entonces TLS por el puerto 443 en vez del 80 y además esquiva los bloqueos de puertos de algunas redes de colegios o empresas. Si no quieres escribir los datos del Wi-Fi en el código, el ejemplo Blynk.Edgent > Edgent_ESP32 de la librería te permite introducir el nombre de la red y la contraseña desde la app Blynk IoT; con este método el Auth Token se asigna solo al añadir el dispositivo y el código se puede actualizar de forma inalámbrica (OTA). El mismo código funciona también en placas ESP8266: para un NodeMCU basta con usar ESP8266WiFi.h y BlynkSimpleEsp8266.h.

Blynk con la Raspberry Pi Pico W y MicroPython

Blynk no es solo cosa del ESP32. Si usas MicroPython en una Raspberry Pi Pico W, solo tienes que copiar a la Pico con Thonny el archivo único BlynkLib.py de la librería de Python de Blynk. Ten en cuenta que esta librería ya no se desarrolla activamente y que Blynk recomienda su API MQTT para proyectos nuevos; aun así, sirve para aprender y para proyectos sencillos. El código de abajo controla con V0 el LED integrado de la Pico W y envía una vez por minuto a V2 el valor del sensor de temperatura del chip. Crea un dispositivo aparte para la Pico W en Blynk.Console y usa su token. Si eres nuevo en MicroPython, Fundamentos de MicroPython es un buen punto 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

En el ejemplo la conexión se hace sin cifrar por el puerto 80 con insecure=True; es la opción que menos memoria gasta y está al mismo nivel que BlynkSimpleEsp32.h en el ESP32. Si quitas este parámetro, la librería intenta usar TLS por el puerto 443. Medimos el tiempo con ticks_ms en el bucle en lugar de time.sleep() por la misma razón que en Arduino: si blynk.run() no se llama a menudo, las órdenes llegan tarde y la conexión se cae. El sensor de temperatura del chip puede desviarse unos grados de la temperatura ambiente; para medidas reales conecta un DHT11 o un DS18B20.

Ideas de proyectos con Blynk

• Enchufe inteligente: enciende y apaga una lámpara o un ventilador desde cualquier parte del mundo con un relé; para conectarlo mira ¿Qué es un módulo de relé?
• Riego de plantas a distancia: activa la bomba cuando el sensor de humedad del suelo detecte tierra seca y sigue la humedad en una gráfica.
• Invernadero inteligente: enciende un ventilador cuando suban la temperatura y la humedad y recibe un aviso si se pasa un umbral; detalles en Proyecto de invernadero inteligente.
• Alarma antirrobo: envía con logEvent una notificación crítica al móvil cuando el sensor de movimiento PIR detecte a alguien.
• Aviso de fuga de gas: cuando el sensor de gas MQ-2 supere su umbral, que suene un zumbador y vibre tu móvil.
• Estación meteorológica: compara en una gráfica semanal la temperatura, la humedad y la presión de un BME280.
• Control de puertas y ventanas: mira en la app si una puerta se ha quedado abierta con un interruptor reed.

Errores comunes y soluciones

¿Blynk, tu propio servidor web o MQTT?

En resumen, Blynk es la forma más fácil de conseguir resultados rápidos con un panel listo y bonito y de acceder a tu proyecto desde fuera de casa. Si quieres un sistema ilimitado y totalmente local, lee Servidor web y WebSocket con ESP32 o ESP32 con MQTT y Home Assistant; si solo quieres enviar avisos al móvil, echa un vistazo a la guía Bot de Telegram con ESP32.

Cuando entiendes el trío plantilla, datastream y Auth Token, conectar un nuevo proyecto con ESP32 al móvil mediante Blynk te lleva solo unos minutos. Combina los ejemplos de LED, relé y sensor de esta guía y tendrás el punto de partida de tu propia casa inteligente. En la app BlueGrays también encontrarás proyectos con ESP32 como encender un LED, conectarse al Wi-Fi, medir la temperatura con un DHT22, iluminación inteligente, riego de plantas y una alarma de movimiento con Telegram, cada uno con su esquema y su código paso a paso.