Blynk ESP32 : contrôler LED, relais et capteurs à distance

Blynk et l'ESP32 forment le moyen le plus rapide de piloter une carte depuis n'importe où dans le monde sans écrire ta propre application mobile. Blynk IoT te fournit un serveur cloud auquel l'ESP32 se connecte (Blynk.Cloud), une application mobile où tu crées un tableau de bord par glisser-déposer, et un tableau de bord web. Quand tu touches un interrupteur sur ton téléphone, la commande part d'abord vers le cloud, puis vers l'ESP32 ; la température mesurée par l'ESP32 revient par le même chemin et s'affiche sur ton téléphone sous forme de valeur et de graphique. Le téléphone et la carte n'ont pas besoin d'être dans la même maison : cela fonctionne même en données mobiles.

Dans ce guide, tu vas construire un projet complet à partir de zéro : tu ouvriras un compte Blynk.Cloud, tu définiras un modèle (template) et des datastreams (V0, V1, V2, V3), tu récupéreras l'Auth Token de l'appareil, tu installeras la bibliothèque, tu piloteras une LED et un relais depuis ton téléphone, tu afficheras les données d'un DHT11 sur un graphique et tu recevras une notification quand la température monte. Tu verras aussi pourquoi il ne faut pas utiliser delay() et ce que fait BlynkTimer à la place, comment calculer la limite de messages du forfait gratuit, pourquoi le code de l'ancien Blynk ne compile plus et comment corriger les erreurs de connexion les plus courantes.

Qu'est-ce que Blynk IoT et comment ça marche ?

Avec Blynk, l'ESP32 et le téléphone ne se connectent jamais directement l'un à l'autre ; tous deux se connectent à Blynk.Cloud et c'est le serveur qui transporte les messages. Au démarrage, l'ESP32 se connecte d'abord au Wi-Fi, puis au serveur Blynk, et s'identifie avec son Auth Token. Les données circulent par des broches virtuelles (Virtual Pin, V0–V255) : une broche virtuelle n'est pas une vraie patte de l'ESP32, mais un canal de données numéroté entre ton code et l'application. L'interrupteur de l'application écrit 1 sur V1, la fonction BLYNK_WRITE(V1) de ton code le récupère et enclenche le relais ; quand ton code exécute Blynk.virtualWrite(V2, 24.5), la jauge du téléphone se met à jour. Voici les notions de base :

Différences entre l'ancien Blynk et le nouveau Blynk IoT

La plupart des vidéos et des codes Blynk qu'on trouve sur internet ont été faits pour l'ancienne version (Blynk Legacy), qui ne fonctionne plus. La nouvelle plateforme est sortie en mai 2021 ; l'ancienne application a été retirée des stores en juin 2022 et les anciens serveurs cloud ont été définitivement arrêtés le 31 décembre 2022. Un token d'un ancien projet, les points d'énergie achetés ou l'adresse blynk-cloud.com ne servent donc plus à rien ; il faut recréer le projet sur la nouvelle plateforme. Bonne nouvelle : l'essentiel du code de l'ESP32 (BLYNK_WRITE, virtualWrite, BlynkTimer) est resté le même.

Matériel et câblage

Pour ce projet, il te faut une carte de développement ESP32, un module relais 5 V, un capteur de température et d'humidité DHT11, éventuellement une LED avec une résistance de 220 Ω, une breadboard et des câbles Dupont. Pour la LED, la LED bleue intégrée sur le GPIO 2 suffit ; si tu ajoutes une LED externe, calcule la résistance avec le calculateur de résistance de LED. Vérifie aussi le brochage de ta carte avec l'outil Pinout ; selon les cartes, la broche 5 V s'appelle VIN ou 5V.

Étape 1 : créer le compte Blynk.Cloud et le modèle

1. Sur ton ordinateur, va sur blynk.cloud, crée un compte gratuit avec ton adresse e-mail et définis ton mot de passe grâce au lien reçu par e-mail.
2. Dans le menu de gauche, va dans Developer Zone > My Templates et clique sur + New Template.
3. Donne un nom au modèle (par exemple ESP32 Maison), choisis ESP32 comme matériel et WiFi comme type de connexion, puis crée le modèle.
4. Les valeurs BLYNK_TEMPLATE_ID et BLYNK_TEMPLATE_NAME affichées sur la page du modèle iront dans ton code ; pour l'instant, repère simplement où elles se trouvent.
5. Si un assistant Quickstart s'ouvre à l'inscription, tu peux le passer ; dans ce guide, on fait chaque étape à la main pour que tu comprennes à quoi sert chaque réglage.

Étape 2 : définir les datastreams (V0, V1, V2, V3)

Un datastream est la carte d'identité d'une broche virtuelle : il précise de quelle broche il s'agit, le type de donnée (Integer pour les entiers, Double pour les décimaux, String pour le texte), la valeur minimale et maximale, l'unité et le nombre de décimales affichées. Ouvre le modèle en mode édition, va dans l'onglet Datastreams, choisis + New Datastream > Virtual Pin et crée ces quatre canaux :

Étape 3 : créer l'appareil et récupérer l'Auth Token

Le modèle est une recette, l'appareil est la vraie carte fabriquée selon cette recette. Dans le menu de gauche, ouvre Devices, clique sur + New Device, choisis le modèle ESP32 Maison avec From template et donne un nom à l'appareil. Une fois l'appareil créé, une configuration de trois lignes s'affiche : BLYNK_TEMPLATE_ID, BLYNK_TEMPLATE_NAME et BLYNK_AUTH_TOKEN. Copie ces lignes ; tu les retrouveras aussi plus tard dans la section Device Info de la page de l'appareil (appelée Developer Tools dans certaines versions de l'interface).

Étape 4 : installer la bibliothèque Blynk dans l'Arduino IDE

1. Si le paquet de cartes ESP32 n'est pas encore installé dans l'Arduino IDE, installe-le d'abord ; les étapes sont dans Qu'est-ce que l'ESP32 ?
2. Ouvre le gestionnaire de bibliothèques, tape Blynk dans la recherche et installe la bibliothèque officielle Blynk de Volodymyr Shymanskyy. Si on te parle de dépendances, choisis Install all.
3. Pour le capteur, installe au même endroit la DHT sensor library d'Adafruit et la bibliothèque Adafruit Unified Sensor qu'elle demande. En cas de souci, consulte le guide Ajouter une bibliothèque Arduino.
4. Choisis ESP32 Dev Module dans Outils > Type de carte, branche la carte avec un câble USB qui transmet les données et sélectionne le bon port.
5. La bibliothèque est livrée avec des exemples : Fichier > Exemples > Blynk > Boards_WiFi > ESP32_WiFi est la version la plus simple du premier sketch ci-dessous.

Premier sketch : allumer et éteindre une LED depuis ton téléphone (V0)

Dans le code ci-dessous, remplace les trois premières lignes par celles copiées depuis la page de ton appareil, et le nom et le mot de passe du Wi-Fi par les tiens. Ces trois lignes #define doivent impérativement précéder les lignes #include ; la bibliothèque cherche ces valeurs à la compilation et renvoie une erreur si elle ne les trouve pas.

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}

Après le téléversement, ouvre le moniteur série à 115200 bauds : tu dois voir dans l'ordre des lignes comme "Connecting to AgAdi", "Connected to WiFi", l'adresse IP, "Connecting to blynk.cloud:80" et enfin "Ready (ping: 45ms).". Dès que la ligne Ready apparaît, l'appareil s'affiche Online dans Blynk.Console. Lors de la première connexion, tu verras peut-être aussi une ligne commençant par "Redirecting to" ; la bibliothèque bascule toute seule sur le serveur régional de ton compte, c'est normal.

Préparer les tableaux de bord mobile et web

Le code est prêt, plaçons maintenant les boutons. Dans Blynk, le tableau de bord mobile et le tableau de bord web se conçoivent séparément ; comme ils utilisent les mêmes datastreams, une modification faite sur l'un apparaît aussitôt sur l'autre.

1. Installe l'application Blynk IoT sur ton téléphone (pas l'ancien Blynk ni Blynk Legacy) et connecte-toi avec le même compte.
2. Active Developer Mode sur ta page de profil, puis touche le modèle ESP32 Maison dans la Developer Zone.
3. Touche l'espace vide pour ajouter des widgets : un Button ou Switch pour V0 et un pour V1, une Gauge ou un Labeled Value pour V2 et V3, et un SuperChart pour l'historique.
4. Touche chaque widget et choisis le datastream correspondant dans ses réglages ; tu peux ajouter V2 et V3 ensemble au SuperChart. Les modifications sont enregistrées automatiquement.
5. Pour le tableau de bord web, modifie le modèle dans Blynk.Console, glisse les widgets dans l'onglet Web Dashboard, choisis le datastream via l'icône d'engrenage de chacun et enregistre avec Save.
6. Dans l'application, touche le nom de ton appareil et essaie l'interrupteur : la LED du GPIO 2 doit s'allumer aussitôt et le moniteur série doit afficher "V0 = 1".

Relais et capteur : lecture sans delay() avec BlynkTimer

La règle d'or de Blynk : loop() ne doit contenir que Blynk.run() et timer.run(). Si tu mets delay(2000) dans loop, l'ESP32 ne voit pas les commandes du téléphone pendant ce temps et l'interrupteur réagit en retard ; de très longues attentes font que le serveur considère l'appareil comme hors ligne. Pire encore, si tu écris Blynk.virtualWrite() directement dans loop, l'ESP32 essaie d'envoyer des centaines de messages par seconde ; le serveur le bride et ton quota mensuel de messages s'épuise très vite. La solution est BlynkTimer, qui fonctionne sur le principe de millis() : il appelle la fonction de ton choix à l'intervalle de ton choix, et loop reste libre entre deux appels. On détaille ce principe dans Arduino millis() et delay().

Le code suivant commande le relais avec V1, envoie toutes les 60 secondes la température lue sur le DHT11 vers V2 et l'humidité vers V3, et déclenche un événement de notification quand la température dépasse 30 °C. Pour le fonctionnement du capteur, vois Capteur de température et d'humidité 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 ligne timer.setInterval(60000L, sensorGonder) appelle la fonction toutes les 60 000 millisecondes ; le L final indique que le nombre est de type long. Pour une action unique, on utilise timer.setTimeout(), par exemple pour enclencher le relais puis le couper 5 secondes plus tard. Un objet BlynkTimer gère jusqu'à 16 minuteries, ce qui suffit largement pour la plupart des projets. Le test isnan() évite d'envoyer au cloud une valeur NaN absurde quand le capteur ne répond pas. Le drapeau alarmGitti et l'écart entre les seuils de 30 et 28 °C (hystérésis) empêchent une nouvelle notification à chaque mesure quand la température oscille autour de 30 °C.

Afficher les données du capteur sur un graphique

Pour que le graphique se remplisse, il faut deux choses : que l'ESP32 envoie des données avec virtualWrite et que le datastream conserve un historique. Si l'historique (history) est réglé sur Last Value dans les paramètres du datastream, le serveur ne garde que la dernière valeur et aucun graphique ne s'affiche ; la moyenne par minute (1 Minute AVG) suffit pour les graphiques. Avec le forfait gratuit, l'historique est conservé 1 semaine, et le stockage des données brutes (RAW) est réservé aux forfaits payants. Dans SuperChart, tu passes d'une plage horaire à l'autre (heures, jours, semaines) et tu vois la température et l'humidité en deux couleurs sur le même graphique. Comme les données arrivent toutes les 60 secondes, les premiers points mettent quelques minutes à apparaître ; ne baisse pas l'intervalle à 1 seconde par impatience, tu verras pourquoi dans la partie sur le forfait gratuit.

Envoyer des notifications : événements et Blynk.logEvent()

Dans le nouveau Blynk, les notifications passent par des événements (events). Tu définis d'abord l'événement dans le modèle, puis tu le déclenches dans le code avec Blynk.logEvent() ; Blynk inscrit l'événement dans la chronologie (Timeline) de l'appareil et, selon ses réglages, envoie une notification push ou un e-mail sur ton téléphone. La description d'un événement peut faire jusqu'à 300 caractères, mais comme le tampon d'envoi de la bibliothèque est petit, mieux vaut la garder courte.

1. Ouvre le modèle en mode édition et va dans l'onglet Events & Notifications.
2. Clique sur + Create Event, donne à l'événement un nom comme "Température élevée" et choisis yuksek_sicaklik comme code d'événement (event code). Le code ne peut contenir que des lettres, des chiffres et des tirets bas, et doit correspondre exactement au texte du sketch.
3. Choisis Warning comme type d'événement ; Info, Warning et Critical indiquent la gravité de l'alerte. Vérifie que l'option de chronologie est activée pour que l'événement apparaisse dans l'application.
4. Dans l'onglet Notifications, active les notifications, choisis ton propre compte comme destinataire et le push et l'e-mail comme canaux ; si tu veux, limite-les à une par heure.
5. Enregistre le modèle avec Save et confirme la mise à jour de l'appareil. N'oublie pas d'autoriser les notifications de l'application Blynk IoT sur ton téléphone.

Limites du forfait gratuit : comment calculer les messages

Le forfait gratuit de Blynk suffit pour apprendre et pour de petits projets, mais un projet monté sans connaître ses limites peut se taire en milieu de mois. En octobre 2026, la page des tarifs de Blynk indique pour le forfait gratuit : 5 appareils, 1 utilisateur, 100 000 messages d'appareil par mois, 1 semaine d'historique, 10 modèles, 5 événements par modèle, 1 webhook et 5 automatisations. Ces limites ont changé plusieurs fois ces dernières années ; avant de lancer un projet sur la durée, vérifie les valeurs actuelles sur la page des tarifs de Blynk ou dans les paramètres de forfait de ton compte. Ce qui compte le plus, ce sont les commandes virtualWrite, syncVirtual et logEvent envoyées par ton appareil, et chaque virtualWrite représente un message. Un mois compte environ 2 592 000 secondes, le calcul est donc simple :

Une connexion qui ne bloque pas sans Wi-Fi

Blynk.begin() est pratique mais a un défaut : si la connexion Wi-Fi ou Blynk échoue, il attend indéfiniment dans setup() et le reste du programme ne s'exécute jamais. Pour les projets qui doivent continuer à fonctionner sans internet, comme un thermostat ou un arrosage, mieux vaut gérer la connexion toi-même. Le squelette ci-dessous démarre le Wi-Fi sans attendre, applique seulement les réglages avec Blynk.config() et vérifie la connexion toutes les 10 secondes ; pendant ce temps, les tâches locales que tu ajoutes à la minuterie continuent de tourner, avec ou sans 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}

L'ESP32 tente de lui-même de se reconnecter au Wi-Fi en cas de coupure ; le code ne se reconnecte à Blynk qu'une fois le Wi-Fi revenu. Pour chiffrer tes données, il suffit d'inclure BlynkSimpleEsp32_SSL.h au lieu de BlynkSimpleEsp32.h ; la connexion passe alors en TLS sur le port 443 au lieu du 80 et contourne aussi les blocages de ports de certains réseaux d'école ou d'entreprise. Si tu ne veux pas écrire les identifiants Wi-Fi en dur dans le code, l'exemple Blynk.Edgent > Edgent_ESP32 de la bibliothèque te permet de saisir le nom du réseau et le mot de passe depuis l'application Blynk IoT ; avec cette méthode, l'Auth Token est attribué automatiquement à l'ajout de l'appareil et le code peut être mis à jour sans fil (OTA). Le même code fonctionne aussi sur les cartes ESP8266 : pour un NodeMCU, utilise simplement ESP8266WiFi.h et BlynkSimpleEsp8266.h.

Blynk avec le Raspberry Pi Pico W et MicroPython

Blynk n'est pas réservé à l'ESP32. Si tu utilises MicroPython sur un Raspberry Pi Pico W, il suffit de copier sur le Pico, avec Thonny, le fichier unique BlynkLib.py de la bibliothèque Python de Blynk. Sache que cette bibliothèque n'est plus activement développée et que Blynk recommande son API MQTT pour les nouveaux projets ; elle reste tout à fait utilisable pour apprendre et pour des projets simples. Le code ci-dessous commande la LED intégrée du Pico W avec V0 et envoie une fois par minute la valeur du capteur de température interne de la puce vers V2. Crée un appareil distinct pour le Pico W dans Blynk.Console et utilise son token. Si tu débutes en MicroPython, Les bases de MicroPython est un bon point de départ.

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

Dans cet exemple, la connexion se fait en clair sur le port 80 avec insecure=True ; c'est l'option la plus économe en mémoire, au même niveau que BlynkSimpleEsp32.h sur l'ESP32. Si tu retires ce paramètre, la bibliothèque tente d'utiliser TLS sur le port 443. On mesure le temps avec ticks_ms dans la boucle plutôt qu'avec time.sleep() pour la même raison que côté Arduino : si blynk.run() n'est pas appelée souvent, les commandes arrivent en retard et la connexion tombe. Le capteur de température interne peut s'écarter de quelques degrés de la température ambiante ; pour de vraies mesures, branche un DHT11 ou un DS18B20.

Idées de projets avec Blynk

• Prise connectée : allume et éteins une lampe de bureau ou un ventilateur depuis n'importe où avec un relais ; pour le câblage, vois Qu'est-ce qu'un module relais ?
• Arrosage à distance : lance la pompe quand le capteur d'humidité du sol signale une terre sèche et suis l'humidité sur un graphique.
• Serre connectée : démarre un ventilateur quand la température et l'humidité montent et reçois une alerte en cas de dépassement de seuil ; détails dans Projet de serre connectée.
• Alarme anti-intrusion : envoie avec logEvent une notification critique sur ton téléphone quand le détecteur de mouvement PIR repère quelqu'un.
• Alerte fuite de gaz : quand le capteur de gaz MQ-2 dépasse son seuil, un buzzer sonne et ton téléphone vibre.
• Station météo : compare la température, l'humidité et la pression d'un BME280 sur un graphique hebdomadaire.
• Surveillance portes et fenêtres : vois dans l'application si une porte est restée ouverte grâce à un interrupteur reed.

Erreurs fréquentes et solutions

Blynk, ton propre serveur web ou MQTT ?

En résumé, Blynk est le moyen le plus simple d'obtenir vite un résultat avec un tableau de bord prêt et soigné, et d'accéder à ton projet hors de chez toi. Si tu veux un système illimité et entièrement local, lis Serveur web et WebSocket avec l'ESP32 ou ESP32 avec MQTT et Home Assistant ; si tu veux seulement envoyer des alertes sur ton téléphone, jette un œil au guide Bot Telegram avec l'ESP32.

Une fois le trio modèle, datastream et Auth Token compris, relier un nouveau projet ESP32 à ton téléphone avec Blynk ne prend que quelques minutes. Combine les exemples de LED, de relais et de capteur de ce guide et tu poses les bases de ta propre maison connectée. Dans l'application BlueGrays, tu trouveras aussi des projets ESP32 comme allumer une LED, se connecter au Wi-Fi, mesurer la température avec un DHT22, l'éclairage intelligent, l'arrosage de plantes et une alarme de mouvement avec Telegram, chacun avec son schéma et son code pas à pas.