Blynk ESP32: controllare LED, relè e sensori dallo smartphone

Blynk con l'ESP32 è il modo più rapido per controllare una scheda da qualsiasi parte del mondo senza scrivere una tua app per smartphone. Blynk IoT ti offre un server cloud a cui si collega l'ESP32 (Blynk.Cloud), un'app mobile in cui costruisci una dashboard con il trascinamento, e una dashboard web. Quando tocchi un interruttore sul telefono, il comando va prima nel cloud e da lì all'ESP32; la temperatura misurata dall'ESP32 fa lo stesso percorso al contrario e compare sul telefono come numero e come grafico. Telefono e scheda non devono stare nella stessa casa: funziona anche quando il telefono è sotto rete dati.

In questa guida costruirai da zero un progetto funzionante: aprirai un account Blynk.Cloud, definirai un template e dei datastream (V0, V1, V2, V3), otterrai l'Auth Token del dispositivo, installerai la libreria, controllerai un LED e un relè dal telefono, mostrerai i dati di un DHT11 su un grafico e riceverai una notifica quando la temperatura sale. Vedrai anche perché non devi usare delay() e cosa fa BlynkTimer al suo posto, come calcolare il limite di messaggi del piano gratuito, perché il codice del vecchio Blynk non si compila più e come risolvere gli errori di connessione più frequenti.

Cos'è Blynk IoT e come funziona?

Con Blynk, l'ESP32 e il telefono non si collegano mai direttamente tra loro; entrambi si collegano a Blynk.Cloud ed è il server a trasportare i messaggi. All'avvio l'ESP32 si connette prima al Wi-Fi, poi al server Blynk, e si identifica con il suo Auth Token. I dati passano attraverso i pin virtuali (Virtual Pin, V0–V255): un pin virtuale non è un vero piedino dell'ESP32, ma un canale di dati numerato tra il tuo codice e l'app. L'interruttore dell'app scrive 1 su V1, la funzione BLYNK_WRITE(V1) del tuo codice lo intercetta ed eccita il relè; quando il codice esegue Blynk.virtualWrite(V2, 24.5), l'indicatore sul telefono si aggiorna. Ecco i concetti di base:

Differenze tra il vecchio Blynk e il nuovo Blynk IoT

La maggior parte dei video e dei codici Blynk che trovi online è stata fatta per la vecchia versione (Blynk Legacy), che non funziona più. La nuova piattaforma è uscita a maggio 2021; la vecchia app è stata rimossa dagli store a giugno 2022 e i vecchi server cloud sono stati spenti definitivamente il 31 dicembre 2022. Quindi il token di un vecchio progetto, i punti energia acquistati o l'indirizzo blynk-cloud.com oggi non servono a nulla; devi ricreare il progetto sulla nuova piattaforma. La buona notizia: gran parte del codice dell'ESP32 (BLYNK_WRITE, virtualWrite, BlynkTimer) è rimasta uguale.

Materiale e collegamenti

Per questo progetto ti servono una scheda di sviluppo ESP32, un modulo relè da 5 V, un sensore di temperatura e umidità DHT11, facoltativamente un LED con una resistenza da 220 Ω, una breadboard e dei cavetti jumper. Come LED basta quello blu integrato sul GPIO 2; se aggiungi un LED esterno, calcola la resistenza con il calcolatore della resistenza per LED. Controlla anche la piedinatura della tua scheda con lo strumento Pinout; su alcune schede il pin a 5 V si chiama VIN, su altre 5V.

Passo 1: creare l'account Blynk.Cloud e il template

1. Dal computer vai su blynk.cloud, crea un account gratuito con il tuo indirizzo e-mail e imposta la password con il link dell'e-mail che ricevi.
2. Nel menu a sinistra vai in Developer Zone > My Templates e clicca su + New Template.
3. Dai un nome al template (per esempio ESP32 Casa), scegli ESP32 come hardware e WiFi come tipo di connessione, poi crea il template.
4. I valori BLYNK_TEMPLATE_ID e BLYNK_TEMPLATE_NAME mostrati nella pagina del template andranno nel codice; per ora limitati a notare dove si trovano.
5. Se in fase di registrazione compare una procedura guidata Quickstart, puoi saltarla; in questa guida faremo ogni passo a mano, così vedrai a cosa serve ogni impostazione.

Passo 2: definire i datastream (V0, V1, V2, V3)

Un datastream è la carta d'identità di un pin virtuale: stabilisce di quale pin si tratta, il tipo di dato (Integer per i numeri interi, Double per i decimali, String per il testo), il valore minimo e massimo, l'unità e quanti decimali mostrare. Apri il template in modalità modifica, vai nella scheda Datastreams, scegli + New Datastream > Virtual Pin e crea questi quattro canali:

Passo 3: creare il dispositivo e ottenere l'Auth Token

Il template è una ricetta, il dispositivo è la scheda reale preparata con quella ricetta. Nel menu a sinistra apri Devices, clicca su + New Device, scegli il template ESP32 Casa con From template e dai un nome al dispositivo. Appena creato, compare una configurazione di tre righe: BLYNK_TEMPLATE_ID, BLYNK_TEMPLATE_NAME e BLYNK_AUTH_TOKEN. Copia queste righe; le ritroverai anche in seguito nella sezione Device Info della pagina del dispositivo (in alcune versioni dell'interfaccia si chiama Developer Tools).

Passo 4: installare la libreria Blynk nell'Arduino IDE

1. Se nell'Arduino IDE non hai ancora il pacchetto delle schede ESP32, installalo prima; trovi i passaggi in Cos'è l'ESP32?
2. Apri il Gestore librerie, scrivi Blynk nella ricerca e installa la libreria ufficiale Blynk di Volodymyr Shymanskyy. Se ti chiede delle dipendenze, scegli Install all.
3. Per il sensore installa dallo stesso posto la DHT sensor library di Adafruit e la Adafruit Unified Sensor che richiede. Se hai problemi, consulta la guida Come aggiungere una libreria Arduino.
4. Scegli ESP32 Dev Module in Strumenti > Scheda, collega la scheda con un cavo USB che trasmette dati e seleziona la porta corretta.
5. La libreria include esempi pronti: File > Esempi > Blynk > Boards_WiFi > ESP32_WiFi è la versione più semplice del primo sketch qui sotto.

Primo sketch: accendere e spegnere un LED dallo smartphone (V0)

Nel codice qui sotto sostituisci le prime tre righe con quelle copiate dalla pagina del tuo dispositivo, e nome e password del Wi-Fi con i tuoi dati. Queste tre righe #define devono stare per forza prima delle righe #include; la libreria cerca questi valori durante la compilazione e dà errore se non li trova.

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}

Dopo il caricamento, apri il Monitor seriale a 115200 baud: dovresti vedere in ordine righe come "Connecting to AgAdi", "Connected to WiFi", l'indirizzo IP, "Connecting to blynk.cloud:80" e alla fine "Ready (ping: 45ms).". Quando compare la riga Ready, il dispositivo risulta Online in Blynk.Console. Alla prima connessione potresti vedere anche una riga che inizia con "Redirecting to"; la libreria passa da sola al server regionale del tuo account, è normale.

Preparare la dashboard sul telefono e sul web

Il codice è pronto, ora sistemiamo i pulsanti. In Blynk la dashboard mobile e quella web si progettano separatamente; dato che entrambe usano gli stessi datastream, una modifica fatta da una compare subito anche sull'altra.

1. Installa sul telefono l'app Blynk IoT (non il vecchio Blynk né Blynk Legacy) e accedi con lo stesso account.
2. Attiva Developer Mode nella pagina del profilo, poi tocca il template ESP32 Casa nella Developer Zone.
3. Tocca lo spazio vuoto per aggiungere i widget: un Button o Switch per V0 e uno per V1, un Gauge o un Labeled Value per V2 e V3, e un SuperChart per lo storico.
4. Tocca ogni widget e scegli il datastream corrispondente nelle impostazioni; al SuperChart puoi aggiungere V2 e V3 insieme. Le modifiche si salvano da sole.
5. Per la dashboard web modifica il template in Blynk.Console, trascina i widget nella scheda Web Dashboard, scegli il datastream dall'icona a ingranaggio di ciascuno e salva con Save.
6. Nell'app tocca il nome del dispositivo e prova l'interruttore: il LED sul GPIO 2 deve accendersi subito e il Monitor seriale deve mostrare "V0 = 1".

Relè e sensore: letture senza delay() con BlynkTimer

La regola d'oro di Blynk è: in loop() devono esserci solo Blynk.run() e timer.run(). Se metti delay(2000) in loop, per tutto quel tempo l'ESP32 non vede i comandi del telefono e l'interruttore risponde in ritardo; attese molto lunghe fanno sì che il server consideri il dispositivo offline. Ancora peggio, se scrivi Blynk.virtualWrite() direttamente in loop, l'ESP32 cerca di inviare centinaia di messaggi al secondo; il server lo limita e la tua quota mensile di messaggi finisce in fretta. La soluzione è BlynkTimer, che funziona con la logica di millis(): chiama la funzione che scegli all'intervallo che scegli, e nel frattempo loop resta libero. Spieghiamo questo concetto nel dettaglio in Arduino millis() e delay().

Il codice seguente comanda il relè con V1, invia ogni 60 secondi la temperatura letta dal DHT11 a V2 e l'umidità a V3, e attiva un evento di notifica quando la temperatura supera i 30 °C. Per capire come funziona il sensore, leggi Sensore di temperatura e umidità 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 riga timer.setInterval(60000L, sensorGonder) chiama la funzione ogni 60.000 millisecondi; la L finale indica che il numero è di tipo long. Per le azioni da eseguire una sola volta c'è timer.setTimeout(), per esempio per accendere il relè e spegnerlo 5 secondi dopo. Un oggetto BlynkTimer gestisce fino a 16 timer, più che sufficienti per la maggior parte dei progetti. Il controllo con isnan() evita di mandare al cloud un valore NaN senza senso quando il sensore non risponde. Il flag alarmGitti e la differenza tra le soglie di 30 e 28 °C (isteresi) impediscono una nuova notifica a ogni lettura mentre la temperatura oscilla intorno ai 30 °C.

Mostrare i dati del sensore su un grafico

Perché il grafico si riempia servono due cose: l'ESP32 deve inviare dati con virtualWrite e il datastream deve conservare lo storico. Se nelle impostazioni del datastream lo storico (history) è su Last Value, il server salva solo l'ultimo valore e il grafico non viene disegnato; la media al minuto (1 Minute AVG) è sufficiente per i grafici. Nel piano gratuito lo storico resta disponibile per 1 settimana, mentre il salvataggio dei dati grezzi (RAW) è riservato ai piani a pagamento. In SuperChart puoi passare da un intervallo all'altro (ore, giorni, settimane) e vedere temperatura e umidità in due colori sullo stesso grafico. Visto che i dati arrivano ogni 60 secondi, i primi punti compaiono dopo qualche minuto; non abbassare l'intervallo a 1 secondo per impazienza, vedrai perché nella sezione sul piano gratuito.

Inviare notifiche: eventi e Blynk.logEvent()

Nel nuovo Blynk le notifiche passano dagli eventi (event). Prima definisci l'evento nel template, poi lo attivi nel codice con Blynk.logEvent(); Blynk registra l'evento nella timeline del dispositivo e, in base alle impostazioni, invia una notifica push o un'e-mail al tuo telefono. La descrizione di un evento può arrivare a 300 caratteri, ma dato che il buffer di invio della libreria è piccolo, conviene tenerla breve.

1. Apri il template in modalità modifica e passa alla scheda Events & Notifications.
2. Clicca su + Create Event, dai all'evento un nome come "Temperatura alta" e imposta il codice dell'evento (event code) su yuksek_sicaklik. Il codice può contenere solo lettere, cifre e trattini bassi e deve coincidere esattamente con il testo dello sketch.
3. Scegli Warning come tipo di evento; Info, Warning e Critical indicano la gravità dell'avviso. Assicurati che l'opzione della timeline sia attiva, così l'evento compare nell'app.
4. Nella scheda Notifications attiva le notifiche, scegli il tuo account come destinatario e push ed e-mail come canali; se vuoi, limitale a una all'ora.
5. Salva il template con Save e conferma l'aggiornamento del dispositivo. Non dimenticare di consentire le notifiche dell'app Blynk IoT sul telefono.

Limiti del piano gratuito: come calcolare i messaggi

Il piano gratuito di Blynk basta per imparare e per piccoli progetti, ma un progetto costruito senza conoscerne i limiti può ammutolire a metà mese. A ottobre 2026 la pagina dei prezzi di Blynk riporta per il piano gratuito questi valori: 5 dispositivi, 1 utente, 100.000 messaggi del dispositivo al mese, 1 settimana di storico, 10 template, 5 eventi per template, 1 webhook e 5 automazioni. Questi limiti sono cambiati più volte negli ultimi anni; prima di avviare un progetto di lunga durata, verifica i valori aggiornati sulla pagina dei prezzi di Blynk o nelle impostazioni del piano del tuo account. A pesare di più sono i comandi virtualWrite, syncVirtual e logEvent inviati dal dispositivo, e ogni singolo virtualWrite vale un messaggio. Un mese ha circa 2.592.000 secondi, quindi il calcolo è semplice:

Una connessione che non si blocca senza Wi-Fi

Blynk.begin() è comodo ma ha un difetto: se la connessione al Wi-Fi o a Blynk non riesce, resta in attesa per sempre dentro setup() e il resto del programma non parte mai. Nei progetti che devono continuare a funzionare anche se cade internet, come un termostato o un impianto di irrigazione, conviene gestire la connessione da te. Lo scheletro qui sotto avvia il Wi-Fi senza aspettare, con Blynk.config() applica solo le impostazioni e controlla la connessione ogni 10 secondi; nel frattempo le attività locali che aggiungi al timer continuano a girare indipendentemente da 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}

Quando la connessione cade, l'ESP32 prova da solo a ricollegarsi al Wi-Fi; il codice si ricollega a Blynk solo quando il Wi-Fi è tornato. Se vuoi che i dati viaggino cifrati, basta includere BlynkSimpleEsp32_SSL.h al posto di BlynkSimpleEsp32.h; la connessione usa allora TLS sulla porta 443 invece della 80 e supera anche i blocchi di porta di alcune reti scolastiche o aziendali. Se non vuoi scrivere i dati del Wi-Fi nel codice, l'esempio Blynk.Edgent > Edgent_ESP32 della libreria ti permette di inserire nome della rete e password dall'app Blynk IoT; con questo metodo l'Auth Token viene assegnato in automatico quando aggiungi il dispositivo e il codice si può aggiornare via wireless (OTA). Lo stesso codice funziona anche sulle schede ESP8266: per un NodeMCU basta usare ESP8266WiFi.h e BlynkSimpleEsp8266.h.

Blynk con il Raspberry Pi Pico W e MicroPython

Blynk non è solo per l'ESP32. Se usi MicroPython su un Raspberry Pi Pico W, ti basta copiare sul Pico con Thonny il singolo file BlynkLib.py della libreria Python di Blynk. Tieni presente che questa libreria non è più sviluppata attivamente e che Blynk consiglia la sua API MQTT per i nuovi progetti; per imparare e per progetti semplici, però, fa il suo lavoro. Il codice qui sotto comanda con V0 il LED integrato del Pico W e invia una volta al minuto a V2 il valore del sensore di temperatura interno al chip. Crea un dispositivo separato per il Pico W in Blynk.Console e usa il suo token. Se sei alle prime armi con MicroPython, Le basi di MicroPython è un buon punto di partenza.

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

Nell'esempio la connessione avviene in chiaro sulla porta 80 con insecure=True; è l'opzione che consuma meno memoria ed è allo stesso livello di BlynkSimpleEsp32.h sull'ESP32. Se togli questo parametro, la libreria prova a usare TLS sulla porta 443. Misuriamo il tempo con ticks_ms nel ciclo invece di usare time.sleep() per lo stesso motivo visto con Arduino: se blynk.run() non viene chiamata spesso, i comandi arrivano in ritardo e la connessione cade. Il sensore di temperatura interno può scostarsi di qualche grado dalla temperatura ambiente; per misure vere collega un DHT11 o un DS18B20.

Idee di progetti con Blynk

• Presa smart: accendi e spegni una lampada da scrivania o un ventilatore da qualsiasi parte del mondo con un relè; per i collegamenti vedi Cos'è un modulo relè?
• Irrigazione a distanza: avvia la pompa quando il sensore di umidità del terreno segnala terreno secco e segui l'umidità su un grafico.
• Serra smart: accendi una ventola quando temperatura e umidità salgono e ricevi un avviso quando si supera una soglia; dettagli in Progetto serra smart.
• Antifurto: invia con logEvent una notifica critica al telefono quando il sensore di movimento PIR rileva qualcuno.
• Allarme fuga di gas: quando il sensore di gas MQ-2 supera la soglia, suona un buzzer e vibra anche il telefono.
• Stazione meteo: confronta temperatura, umidità e pressione di un BME280 su un grafico settimanale.
• Controllo di porte e finestre: verifica dall'app se una porta è rimasta aperta con un interruttore reed.

Errori comuni e soluzioni

Blynk, un tuo web server o MQTT?

In breve, Blynk è il modo più semplice per ottenere risultati in fretta con una dashboard pronta e curata e per raggiungere il progetto da fuori casa. Se vuoi un sistema illimitato e completamente locale, leggi Web server e WebSocket con l'ESP32 o ESP32 con MQTT e Home Assistant; se ti basta inviare avvisi al telefono, dai un'occhiata alla guida Bot Telegram con l'ESP32.

Una volta capito il trio template, datastream e Auth Token, collegare al telefono un nuovo progetto ESP32 con Blynk richiede pochi minuti. Combina gli esempi di LED, relè e sensore di questa guida e avrai la base della tua casa smart. Nell'app BlueGrays trovi anche progetti con l'ESP32 come accendere un LED, collegarsi al Wi-Fi, misurare la temperatura con un DHT22, illuminazione smart, irrigazione delle piante e un allarme di movimento con Telegram, ognuno con schema e codice passo passo.