ESP32 Google Sheets : enregistrer des données de capteurs
Tuto ESP32 Google Sheets : application Web Apps Script, ajout de lignes avec doPost, requête HTTPS, horodatage, DHT22 + LDR, graphique, quotas et jeton secret.
Relier un ESP32 à Google Sheets est le moyen le plus simple de stocker des données de capteurs dans un tableur gratuit accessible de partout, sans installer ton propre serveur. Chaque minute, l'ESP32 lit la température, l'humidité et la luminosité, les envoie à Google en Wi-Fi, et une nouvelle ligne apparaît dans Google Sheets. En ouvrant la feuille sur ton téléphone, tu vois la dernière mesure, son horodatage et un graphique qui se met à jour tout seul. Le pont qui rend cela possible est une petite application Web écrite avec Apps Script, le service gratuit de Google.
Dans ce guide, tu vas préparer la feuille, écrire le code Apps Script qui vérifie les données reçues et ajoute une ligne, le publier comme application Web et envoyer les données depuis l'ESP32 en HTTPS. Ensuite, on verra l'horodatage, plusieurs capteurs et appareils, le graphique, les quotas de Google, les codes d'erreur et comment garder secrète l'URL de l'application Web. La dernière partie compare la méthode avec des alternatives comme ThingSpeak. Si tu débutes avec l'ESP32, lis d'abord Qu'est-ce que l'ESP32 ? ; tu peux aussi voir comment l'ESP32 envoie des requêtes HTTP dans l'exemple de l'API météo.

Comment l'ESP32 écrit-il dans Google Sheets ?
L'ESP32 ne peut pas écrire directement dans la feuille : l'API Sheets de Google exige une authentification OAuth, compliquée pour un petit microcontrôleur. À la place, tu écris un projet Apps Script lié à la feuille et tu le publies comme application Web. Google te donne une adresse de la forme script.google.com/macros/s/.../exec. Quand l'ESP32 envoie des données à cette adresse, voici ce qui se passe :
- L'ESP32 lit les capteurs et transforme les valeurs en un court texte JSON.
- Le JSON est envoyé en HTTPS par une requête POST à l'adresse /exec de l'application Web.
- Google transmet la requête à la fonction doPost(e), exécutée avec ton compte ; la fonction vérifie le jeton secret et ajoute une ligne avec appendRow().
- Google ne répond pas tout de suite mais renvoie une redirection 302 ; l'ESP32 demande cette nouvelle adresse en GET pour obtenir la réponse produite par ta fonction.
- Si l'ESP32 voit "ok":true dans la réponse, le travail est fait ; sinon il attend un peu et réessaie.
Étape 1 : préparer le fichier Google Sheets
- Crée une nouvelle feuille de calcul dans Google Drive et nomme-la par exemple "Journal ESP32".
- Renomme l'onglet du bas en Veri ; le nom doit correspondre exactement à SHEET_NAME dans le code, majuscules comprises (ou change les deux).
- Écris les en-têtes sur la première ligne : Heure, Appareil, Température, Humidité, Lumière. Tu peux figer la ligne d'en-tête avec Affichage > Figer.
- Sélectionne les colonnes inutilisées de F à Z et supprime-les. Tu verras pourquoi dans la partie sur les quotas.
- Dans Fichier > Paramètres, règle le fuseau horaire sur ta région ; les horodatages sont écrits dans ce fuseau.
Étape 2 : écrire doPost et doGet dans Apps Script
Feuille ouverte, choisis Extensions > Apps Script ; un projet lié à la feuille s'ouvre. Efface tout le contenu de Code.gs, colle le code ci-dessous et enregistre. Ouvre ensuite les Paramètres du projet via l'icône d'engrenage à gauche, ajoute tout en bas, dans Propriétés du script, une propriété nommée TOKEN et donne-lui une longue valeur que personne ne peut deviner. Garder la clé dans les propriétés plutôt que dans le code évite qu'elle fuite quand tu partages le code.
1// Google Apps Script - ESP32 veri alıcı / ESP32 data receiver
2const SHEET_NAME = 'Veri'; // sayfa (sekme) adı / sheet (tab) name
3
4function doPost(e) {
5 try {
6 const data = JSON.parse(e.postData.contents); // ESP32'nin gönderdiği JSON / JSON sent by the ESP32
7 return addRow(data);
8 } catch (err) {
9 return reply({ ok: false, error: 'json: ' + err });
10 }
11}
12
13function doGet(e) {
14 // Tarayıcı testi / browser test: .../exec?token=...&device=test&temp=21.5&hum=40&light=1200
15 return addRow(e.parameter);
16}
17
18function addRow(data) {
19 const token = PropertiesService.getScriptProperties().getProperty('TOKEN');
20 if (!token || data.token !== token) {
21 return reply({ ok: false, error: 'yetkisiz / unauthorized' });
22 }
23 const lock = LockService.getScriptLock(); // aynı anda gelen istekleri sıraya koy / queue simultaneous requests
24 lock.waitLock(10000);
25 try {
26 const sheet = SpreadsheetApp.getActiveSpreadsheet().getSheetByName(SHEET_NAME);
27 sheet.appendRow([
28 new Date(), // zaman damgası / timestamp
29 String(data.device || ''),
30 num(data.temp),
31 num(data.hum),
32 num(data.light)
33 ]);
34 return reply({ ok: true, row: sheet.getLastRow() });
35 } catch (err) {
36 return reply({ ok: false, error: String(err) });
37 } finally {
38 lock.releaseLock();
39 }
40}
41
42function num(v) {
43 const n = Number(v); // metni sayıya çevir / turn text into a number
44 return isFinite(n) ? n : '';
45}
46
47function reply(obj) {
48 return ContentService.createTextOutput(JSON.stringify(obj))
49 .setMimeType(ContentService.MimeType.JSON);
50}| Élément | Rôle |
|---|---|
| doPost(e) | Reçoit la requête POST de l'ESP32 ; le corps se trouve dans e.postData.contents |
| doGet(e) | Permet de tester depuis un navigateur ou par une simple requête GET ; les valeurs sont dans e.parameter |
| PropertiesService | Conserve le TOKEN hors du code, dans les paramètres du projet |
| LockService | Empêche les lignes de s'écraser quand deux appareils envoient en même temps |
| appendRow([...]) | Ajoute une nouvelle ligne sous la dernière ligne remplie |
| ContentService | Renvoie à l'ESP32 une petite réponse JSON comme {"ok":true} |
Étape 3 : déployer en application Web
- Clique sur Déployer > Nouveau déploiement en haut à droite et choisis Application Web comme type.
- Règle "Exécuter en tant que" sur Moi et "Qui a accès" sur Tout le monde ; c'est indispensable car l'ESP32 ne peut pas se connecter avec un compte Google.
- Clique sur Déployer ; Google demande l'autorisation d'accéder à la feuille. Choisis ton compte, ouvre le projet via le lien "Paramètres avancés" et autorise l'accès.
- Copie l'URL de l'application Web qui se termine par /exec ; tu la colleras dans la variable SCRIPT_URL du code ESP32.
Étape 4 : câbler le DHT22 et la LDR

| Composant | Connexion | Broche ESP32 |
|---|---|---|
| DHT22 | VCC | 3V3 |
| DHT22 | DATA (pull-up de 10 kΩ vers 3V3 sur un capteur nu) | GPIO 4 |
| DHT22 | GND | GND |
| LDR | Une patte sur 3V3, l'autre sur GPIO 34 | 3V3 / GPIO 34 |
| Résistance de 10 kΩ | Entre GPIO 34 et GND | GPIO 34 / GND |
La LDR et la résistance de 10 kΩ forment un diviseur de tension : plus il y a de lumière, plus la résistance de la LDR baisse et plus la tension sur GPIO 34 monte. GPIO 34 n'a pas été choisi au hasard : sur l'ESP32, les broches ADC2 (GPIO 0, 2, 4, 12-15, 25-27) ne peuvent pas faire de mesure analogique quand le Wi-Fi est actif, branche donc toujours les capteurs analogiques sur les broches ADC1, GPIO 32 à 39. Le DHT22 est un capteur numérique et fonctionne sans souci sur GPIO 4. Pour en savoir plus sur la famille DHT, consulte le guide DHT11 et DHT22.
Étape 5 : envoyer la requête HTTPS depuis l'ESP32
Dans l'Arduino IDE, installe la bibliothèque DHT sensor library (Adafruit) depuis le gestionnaire de bibliothèques et accepte sa dépendance Adafruit Unified Sensor si on te la propose. Les bibliothèques WiFi, WiFiClientSecure et HTTPClient sont fournies avec le paquet ESP32. Remplace les identifiants Wi-Fi, l'URL de l'application Web copiée et la valeur TOKEN par les tiennes, téléverse le croquis et ouvre le moniteur série à 115200 bauds.
1// ESP32 -> Google E-Tablolar veri kaydı / ESP32 -> Google Sheets data logger
2#include <WiFi.h>
3#include <WiFiClientSecure.h>
4#include <HTTPClient.h>
5#include <DHT.h> // "DHT sensor library" (Adafruit)
6
7const char* WIFI_SSID = "AgAdi"; // Wi-Fi adın / your Wi-Fi name
8const char* WIFI_PASS = "Sifre123"; // Wi-Fi şifren / your Wi-Fi password
9const char* SCRIPT_URL = "https://script.google.com/macros/s/BURAYA_DAGITIM_ID/exec"; // web uygulaması / web app
10const char* TOKEN = "gizli-anahtar-123"; // Komut dosyası özelliğiyle aynı / same as the script property
11const char* DEVICE = "salon"; // cihaz adı / device name
12
13const int DHT_PIN = 4; // DHT22 veri / data
14const int LDR_PIN = 34; // LDR bölücü, ADC1 / LDR divider, ADC1
15const unsigned long INTERVAL_MS = 60000; // dakikada bir satır / one row per minute
16
17DHT dht(DHT_PIN, DHT22);
18unsigned long lastSend = 0;
19bool firstRun = true;
20
21void connectWiFi() {
22 if (WiFi.status() == WL_CONNECTED) return;
23 WiFi.mode(WIFI_STA);
24 WiFi.begin(WIFI_SSID, WIFI_PASS);
25 Serial.print("Wi-Fi");
26 for (int i = 0; i < 40 && WiFi.status() != WL_CONNECTED; i++) { // en fazla 20 sn / 20 s max
27 delay(500);
28 Serial.print(".");
29 }
30 Serial.println(WiFi.status() == WL_CONNECTED ? " OK" : " HATA / FAIL");
31}
32
33bool sendRow(float temp, float hum, int light) {
34 WiFiClientSecure client;
35 client.setInsecure(); // sertifika denetimi yok, yazıdaki nota bak / no cert check, see note
36 HTTPClient http;
37 http.setFollowRedirects(HTTPC_STRICT_FOLLOW_REDIRECTS); // 302 yönlendirmesini GET ile izle / follow 302 with GET
38 http.setTimeout(15000); // Apps Script yavaş olabilir / Apps Script can be slow
39 if (!http.begin(client, SCRIPT_URL)) return false;
40 http.addHeader("Content-Type", "application/json");
41
42 char body[160];
43 snprintf(body, sizeof(body),
44 "{\"token\":\"%s\",\"device\":\"%s\",\"temp\":%.1f,\"hum\":%.1f,\"light\":%d}",
45 TOKEN, DEVICE, temp, hum, light);
46
47 int code = http.POST(body); // negatif = bağlantı hatası / negative = connection error
48 String reply = http.getString();
49 http.end();
50 Serial.printf("HTTP %d: %s\n", code, reply.c_str());
51 return code == 200 && reply.indexOf("\"ok\":true") >= 0;
52}
53
54void setup() {
55 Serial.begin(115200);
56 dht.begin();
57 connectWiFi();
58}
59
60void loop() {
61 if (!firstRun && millis() - lastSend < INTERVAL_MS) return;
62 firstRun = false;
63 lastSend = millis();
64
65 float t = dht.readTemperature(); // °C
66 float h = dht.readHumidity(); // %
67 int light = analogRead(LDR_PIN); // 0-4095
68 if (isnan(t) || isnan(h)) {
69 Serial.println("DHT22 okunamadı / read failed");
70 return;
71 }
72
73 connectWiFi();
74 for (int attempt = 1; attempt <= 3; attempt++) { // 3 deneme / 3 attempts
75 if (sendRow(t, h, light)) break;
76 delay(2000 * attempt); // giderek uzayan bekleme / growing back-off
77 }
78}- Sans setFollowRedirects(HTTPC_STRICT_FOLLOW_REDIRECTS), l'ESP32 s'arrête sur la réponse 302 de Google et ne voit jamais la vraie réponse ; la ligne est quand même ajoutée, mais tu ne peux pas confirmer le succès.
- client.setInsecure() chiffre la connexion mais ne vérifie pas le certificat du serveur. Pour un projet maison, c'est suffisant ; pour plus de sécurité, ajoute le certificat racine de Google avec setCACert().
- setTimeout(15000) compte : Apps Script met parfois 2 à 5 secondes à répondre et le délai par défaut peut être trop court.
- En cas d'échec, le code réessaie trois fois en attendant 2, 4 puis 6 secondes ; cela limite les pertes de données lors d'une coupure réseau passagère.
- Le minutage repose sur millis(), donc la boucle ne bloque jamais ; tu peux y ajouter la mise à jour d'un écran ou la lecture de boutons.
Horodatage, plusieurs capteurs et appareils
Écrire l'horodatage dans Apps Script avec new Date() est le plus pratique : l'ESP32 n'a pas besoin de connaître l'heure et tous les appareils partagent la même source de temps. Le seul inconvénient est que l'horodatage indique l'arrivée chez Google et non l'instant de la mesure ; l'écart est en général de quelques secondes. Si tu accumules des mesures pour les envoyer par lots, récupère l'heure sur l'ESP32 via NTP et ajoute-la au JSON sous forme de champ ts. Pour ajouter un capteur, il suffit de modifier trois endroits : le champ dans le texte JSON de l'ESP32, une ligne num(data.nouveau) dans le tableau appendRow d'Apps Script et l'en-tête dans la feuille. Plusieurs ESP32 peuvent écrire dans la même feuille ; donne un nom DEVICE différent à chaque carte et tu pourras filtrer les lignes sur cette colonne ou ouvrir un onglet par appareil.
Créer un graphique en direct dans Google Sheets
- Sélectionne les colonnes A à D en entier en cliquant sur les lettres de colonne, pas sur les en-têtes (A:D) ; les nouvelles lignes rejoindront ainsi le graphique automatiquement.
- Ouvre Insertion > Graphique et choisis le type Graphique en courbes dans l'éditeur.
- Garde la colonne Heure en axe X et Température et Humidité comme séries ; retire la colonne Appareil des séries.
- Comme la lumière va de 0 à 4095, elle écrase les autres courbes ; affiche-la dans un graphique séparé ou sur l'axe de droite via Personnaliser > Séries.
- Avec Publier le graphique dans les trois points en haut à droite du graphique, tu obtiens un lien qui l'affiche sans ouvrir la feuille.
Quotas et limites : à quelle fréquence envoyer ?
| Limite | Valeur | En pratique |
|---|---|---|
| Nombre de cellules | 10 millions de cellules par feuille de calcul | Les colonnes vides comptent aussi ; supprime celles que tu n'utilises pas |
| Exécutions simultanées | Environ 30 par utilisateur | Beaucoup d'appareils qui envoient dans la même seconde peuvent provoquer des erreurs |
| Durée d'exécution | 6 minutes par appel | Aucun souci pour appendRow |
| Temps de réponse | En général 1 à 5 secondes | Inadapté à plusieurs mesures par seconde |
| Intervalle conseillé | 1 minute ou plus | Largement suffisant pour surveiller une maison ou une serre |
Rendons la limite de cellules concrète. Une ligne par minute donne 1 440 lignes par jour. Si tu ne gardes que 5 colonnes, tu consommes 7 200 cellules par jour et les 10 millions de cellules durent environ 3,8 ans. Si tu ne supprimes pas les 26 colonnes par défaut d'une nouvelle feuille, chaque ligne compte pour 26 cellules et la même limite est atteinte en environ 9 mois. Pour un enregistrement de longue durée, ouvrir un nouvel onglet chaque année ou déplacer les anciennes données dans un autre fichier garde aussi la feuille rapide ; une feuille de plusieurs centaines de milliers de lignes s'ouvre lentement sur un téléphone.
Gestion des erreurs : que signifient les codes HTTP ?
| Dans le moniteur série | Signification | Que faire ? |
|---|---|---|
| HTTP 200 + "ok":true | Ligne ajoutée | Tout va bien |
| HTTP 200 + unauthorized | Le TOKEN ne correspond pas ou la propriété manque | Compare le code et les propriétés du script |
| HTTP 302 | La redirection n'a pas été suivie | Ajoute la ligne setFollowRedirects |
| HTTP 401 / 403 ou page de connexion HTML | L'accès n'est pas sur "Tout le monde" | Modifie le déploiement et règle l'accès |
| HTTP 404 | URL erronée ou déploiement archivé | Copie l'URL actuelle qui finit par /exec |
| Code négatif (-1, -11) | Pas de connexion ou délai dépassé | Vérifie le signal Wi-Fi et la valeur de setTimeout |
Sur un appareil qui tourne longtemps, les coupures réseau sont inévitables. Pour les coupures brèves, la boucle à trois tentatives du code suffit. Si tu ne veux pas perdre de données lors de coupures de plusieurs heures, accumule les mesures dans un tableau ou un fichier en flash sur l'ESP32 et envoie-les dans l'ordre au retour de la connexion. Si tu n'arrives pas du tout à te connecter au Wi-Fi, les étapes de l'article l'ESP32 ne se connecte pas au Wi-Fi t'aideront à trouver la cause.
Garder secrète l'URL de l'application Web
- Comme l'accès est réglé sur "Tout le monde", quiconque connaît l'URL peut ajouter des lignes ; retire toujours l'URL et la clé avant de partager ton code en ligne.
- Ne mets jamais en service sans la vérification du TOKEN ; les requêtes sans clé sont rejetées sans toucher à la feuille.
- Si tu places le mot de passe Wi-Fi, l'URL et la clé dans un fichier séparé secrets.h inclus par #include, il est facile de l'exclure au moment de partager le code.
- Si l'URL a fuité, archive l'ancien déploiement dans Gérer les déploiements, crée-en un nouveau et change le TOKEN.
- Inutile de partager la feuille avec "toute personne disposant du lien" ; l'application Web s'exécute avec ton compte, la feuille peut donc rester privée.
ThingSpeak et autres alternatives
| Méthode | Point fort | Point faible |
|---|---|---|
| Google Sheets | Gratuit, interface familière, formules et partage faciles | Réponses lentes, inadapté à plus d'une mesure par minute |
| ThingSpeak | Graphiques prêts, analyse MATLAB, API HTTP simple | Au moins 15 s entre deux envois en offre gratuite, 8 champs par canal |
| MQTT + Home Assistant | Instantané, bidirectionnel, s'intègre à la domotique | Demande un serveur allumé en permanence à la maison |
| Blynk | Interface mobile prête, notifications | L'offre gratuite limite appareils et données |
| Carte SD | Pas besoin d'Internet, enregistrement très rapide | Pas d'accès aux données à distance |
Lequel choisir ? Si tu veux modifier les données dans un tableur, les traiter avec des formules ou les partager, Google Sheets est imbattable. Si tu veux seulement regarder des graphiques, les tableaux de bord prêts à l'emploi de ThingSpeak demandent moins d'efforts. Si tu as déjà une installation domotique, MQTT avec Home Assistant est l'option la plus souple. Si tu préfères Excel sur ordinateur, regarde la méthode par port série dans envoyer les données Arduino vers Excel, et pour les lieux sans Internet, l'enregistrement sur carte SD.
Idées de projets ESP32 et Google Sheets
- Journal de serre : écris la température, l'humidité de l'air et du sol toutes les 10 minutes et décide de l'arrosage d'après l'historique.
- Station extérieure sur batterie : réveille l'ESP32 de son sommeil profond toutes les 15 minutes, envoie la mesure puis rendors-le.
- Compteur de porte et de mouvement : enregistre chaque ouverture de porte ou détection PIR avec son horodatage et trace les totaux quotidiens.
- Suivi de consommation électrique : envoie la mesure d'un capteur de courant en moyenne par minute et calcule les kWh avec une formule dans la feuille.
- Expérience en classe : plusieurs cartes d'élèves écrivent dans la même feuille avec des noms DEVICE différents, puis vous comparez les résultats ensemble.
Dès que tu sais écrire dans Google Sheets, chaque projet ESP32 devient un petit objet connecté avec un historique de mesures et un graphique. Dans l'application BlueGrays, tu trouveras des projets ESP32 comme la connexion Wi-Fi, la température et l'humidité avec un DHT22, l'heure NTP, la météo avec HTTPClient et le sommeil profond, chacun avec schéma et code pas à pas, pour y ajouter l'enregistrement Google Sheets de cet article.
Questions fréquentes
Comment envoyer des données d'un ESP32 vers Google Sheets ?
Tu écris une fonction doPost dans un projet Google Apps Script lié à la feuille et tu le publies comme application Web. L'ESP32 utilise WiFiClientSecure et HTTPClient pour envoyer une requête HTTPS POST contenant du JSON vers l'URL /exec de l'application, et la fonction ajoute une ligne avec appendRow.
Faut-il une clé API Google Sheets ?
Avec la méthode de l'application Web Apps Script, aucune clé API ni configuration OAuth n'est nécessaire. Le script s'exécute avec ton compte et écrit lui-même dans la feuille. Pour la sécurité, il suffit de vérifier une clé secrète (TOKEN) que tu choisis.
Pourquoi l'ESP32 reçoit-il une erreur 302 de Google Sheets ?
L'application Web Apps Script répond d'abord à une requête POST par une redirection 302. Sur l'ESP32, HTTPClient ne suit pas les redirections par défaut, d'où le code 302. En ajoutant http.setFollowRedirects(HTTPC_STRICT_FOLLOW_REDIRECTS), tu reçois la vraie réponse.
À quelle fréquence puis-je envoyer des données à Google Sheets ?
Chaque requête prend 1 à 5 secondes et les exécutions simultanées sont limitées, il est donc conseillé d'envoyer une fois par minute ou moins. Une feuille accepte jusqu'à 10 millions de cellules ; une ligne de 5 colonnes par minute tient environ 3,8 ans. Pour plusieurs mesures par seconde, fais la moyenne sur l'ESP32 et envoie par lots.
J'ai modifié le code Apps Script mais l'ESP32 reçoit l'ancien résultat. Pourquoi ?
Une application Web exécute la version publiée ; enregistrer le code ne suffit pas. Dans Déployer > Gérer les déploiements, modifie le déploiement existant et choisis Nouvelle version. Si tu crées un nouveau déploiement, l'URL change et tu dois aussi la mettre à jour dans l'ESP32.
ThingSpeak ou Google Sheets, lequel est le mieux ?
Pour des graphiques prêts et un tableau de bord IoT simple, ThingSpeak se configure plus vite, mais l'offre gratuite impose au moins 15 secondes entre deux envois et 8 champs par canal. Pour traiter, modifier et partager les données avec des formules, Google Sheets est plus souple.
Projets à réaliser après cet article
Voir tous les projets
Connexion Wi-Fi STA ESP32 (avec écran LCD)
Dans ce projet, nous connectons l'ESP32 au réseau Wi-Fi domestique en mode Station (STA) de manière sécurisée et tolérante aux pannes. Nous isolons SSID/mot de passe dans un fichier secrets.h pour empêcher leur fuite sur Git, mettons en place une reconnexion automatique, et affichons le niveau RSSI et l'adresse IP sur un écran LCD I2C. La LED intégrée sert d'indicateur d'état.

ESP32 HTTPClient + API météo (avec écran LCD)
L'ESP32 appelle par Internet une API météo (wttr.in) en REST avec HTTPClient.h. La réponse JSON est analysée avec ArduinoJson v7, puis la ville, la température, l'humidité, la météo et le vent s'affichent sur un LCD I2C. wttr.in ne demande aucune clé d'API : il suffit de taper le nom de n'importe quelle ville.

ESP32 DHT22 Température et humidité (avec écran LCD)
Il s'agit d'un projet permettant de mesurer la température ambiante et le taux d'humidité à l'aide d'un capteur DHT22 et d'afficher ces données en temps réel sur un écran LCD I2C 16x2. Les données du capteur sont lues à l'aide du protocole one-wire grâce à la bibliothèque Adafruit DHT. Ce projet constitue la base des stations météo IoT, de la domotique ou des systèmes de surveillance de l'environnement dans les serres.

Enregistreur de Température ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
Construis avec l'ESP32 un enregistreur de température et d'humidité horodaté ! Un capteur DHT22 mesure la température et l'humidité une fois par minute, et chaque mesure est enregistrée sur une carte microSD au format CSV avec l'heure réelle du module RTC DS1307. L'écran OLED affiche en direct, en grands caractères, la dernière température, l'humidité, l'horodatage et le nombre d'enregistrements.

ESP32 : heure réelle depuis Internet via NTP
L'ESP32 se connecte au Wi-Fi et récupère l'heure exacte auprès de serveurs NTP (Network Time Protocol) à la milliseconde près. Avec configTzTime(), le fuseau horaire de la Turquie (TRT, UTC+3) s'applique automatiquement, et dans les pays à heure d'été, le changement (DST) est géré tout seul par une chaîne POSIX TZ. L'heure s'affiche dans le Serial Monitor et sur un LCD I2C en option.

Mode veille profonde de l'ESP32 — Économie de batterie (OLED + compteur RAM RTC)
Le mode Deep Sleep de l'ESP32 coupe le CPU et la plupart des périphériques et réduit la consommation à environ 10µA, un point clé pour les objets IoT sur batterie. Ce projet utilise trois sources de réveil : un minuteur (15 s), une broche externe (EXT0, le bouton sur GPIO 33) et une broche tactile (T0/GPIO 4). Les compteurs marqués RTC_DATA_ATTR sont conservés pendant le deep sleep.

Mesure de l'intensité lumineuse avec le module LDR ESP32
Suivi en temps réel sur le moniteur série de la valeur brute de l'ADC du module LDR et du pourcentage relatif de luminosité calculé à partir de références dans l'obscurité et à la lumière. Ce pourcentage n'est pas une mesure en lux. Permet de comprendre le principe de calibrage du module. Il est préférable de réaliser cet exercice avant le projet 10, car il sert à déterminer la valeur seuil.
Autres articles
Application BlueGrays
Réalise ce montage pas à pas sur ton téléphone
Schéma, code et liste des composants sur un seul écran. Plus de 500 projets Arduino, ESP32 et Pico à réaliser.
Scanne avec ton téléphone
Pointe l’appareil photo vers le code : la boutique d’applications de ton téléphone s’ouvre.
ou ouvre la boutique

