ESP32 Firebase : écrire des capteurs et piloter une LED
ESP32 et Firebase Realtime Database : crée le projet, authentifie-toi par e-mail, envoie les mesures d'un DHT22, pilote une LED en stream et utilise un Pico W.
Le duo ESP32 Firebase est l'un des moyens les plus rapides de mettre les données de tes capteurs sur Internet et de piloter ta carte de n'importe où. La Realtime Database de Google Firebase est une base de données cloud qui stocke les données sous forme d'arbre JSON et transmet chaque modification à tous les clients connectés, souvent en moins d'une seconde. L'ESP32 y écrit la température et l'humidité ; une page web ou une appli sur ton téléphone voit les mêmes données instantanément. L'inverse marche aussi : quand tu passes la valeur led à true dans la base, la LED reliée à l'ESP32 s'allume aussitôt.
Dans ce guide, tu vas créer un projet Firebase de zéro, activer l'authentification par e-mail et mot de passe, écrire des règles de sécurité correctes et installer la bibliothèque Firebase ESP Client dans l'IDE Arduino. Ensuite, nous verrons pas à pas un code qui écrit les mesures du DHT22 toutes les 30 secondes, puis un second qui écoute la base en stream pour allumer la LED instantanément. Dans les dernières parties, tu feras la même chose avec un Raspberry Pi Pico W en MicroPython via l'API REST, tu compareras Firebase à Google Sheets et tu trouveras les solutions aux messages d'erreur les plus fréquents. Si l'ESP32 est nouveau pour toi, lis d'abord Qu'est-ce que l'ESP32 ?.

Qu'est-ce que Firebase Realtime Database et comment ça marche ?
Contrairement aux bases SQL classiques à tables, Realtime Database garde les données dans un seul grand arbre JSON. Chaque donnée est adressée par un chemin (path) ; par exemple, /cihazlar/UID/son/sicaklik peut contenir un nombre et /cihazlar/UID/led peut contenir true ou false. L'ESP32 lit et écrit sur ces chemins via une connexion HTTPS chiffrée. Sa vraie force est le stream (écoute) : l'appareil s'abonne à un chemin, la connexion reste ouverte et, dès que la valeur change, le serveur envoie la nouvelle donnée de lui-même. Plus besoin d'une boucle qui interroge chaque seconde : la latence et le trafic baissent.
| Caractéristique | Valeur / Explication |
|---|---|
| Modèle de données | Arbre JSON (NoSQL), accès par chemin |
| Connexion | HTTPS (TLS) ; connexion HTTP maintenue ouverte pour le stream |
| Offre gratuite Spark | 1 Go de stockage, 10 Go de téléchargement par mois, 100 connexions simultanées |
| Latence | Une modification arrive généralement en moins d'une seconde |
| Authentification | E-mail/mot de passe, connexion anonyme, compte Google et autres |
| Sécurité | Règles de sécurité JSON exécutées côté serveur |
| Cartes prises en charge | ESP32 et ESP8266 (avec la bibliothèque) ; Pico W (via l'API REST) |
Créer un projet Firebase pas à pas
- Connecte-toi à la console Firebase avec ton compte Google et clique sur Create a project. Donne-lui un nom comme esp32-serre ; Google Analytics n'est pas nécessaire pour ce projet, tu peux le désactiver.
- Dans le menu de gauche, va dans Build > Realtime Database et clique sur Create Database.
- Choisis l'emplacement de la base. Si tu es en Europe, europe-west1 (Belgique) offre une latence plus faible ; l'adresse prend alors la forme https://nom-du-projet-default-rtdb.europe-west1.firebasedatabase.app. Pour un emplacement aux États-Unis, l'adresse se termine par -default-rtdb.firebaseio.com.
- Choisis Locked mode comme mode de sécurité ; tu écriras les règles toi-même dans un instant. Copie l'adresse en haut de la page : c'est ta valeur DATABASE_URL.
- Va dans Build > Authentication, clique sur Get started et active le fournisseur Email/Password dans l'onglet Sign-in method.
- Dans l'onglet Users, crée un utilisateur pour l'ESP32 avec Add user (par exemple [email protected] et un mot de passe d'au moins 6 caractères). Note la valeur User UID de la ligne créée.
- Avec l'icône d'engrenage en haut à gauche, ouvre Project settings > General et copie la Web API Key ; c'est ta valeur API_KEY.
Authentification et règles de sécurité
La clé Web API n'est pas un mot de passe secret à elle seule ; elle indique seulement à quel projet Firebase appartient la requête. La vraie protection, ce sont les règles de sécurité exécutées sur le serveur Firebase. Quand l'ESP32 se connecte avec e-mail et mot de passe, Firebase lui donne un ID token valable une heure ; la bibliothèque le renouvelle toute seule avant l'expiration. Dans les règles, l'expression auth.uid donne l'identité de l'utilisateur qui envoie la requête. Le tableau ci-dessous montre trois règles que tu peux mettre dans l'onglet Realtime Database > Rules. La structure recommandée est la troisième : chaque appareil n'accède qu'à la branche de son propre UID, donc même si le mot de passe d'un appareil est volé, les données des autres restent protégées.
| Règle (onglet Rules) | Signification |
|---|---|
| {"rules": {".read": true, ".write": true}} | Tout le monde lit et écrit. Seulement pour quelques minutes de test ; ne la laisse jamais active. |
| {"rules": {".read": "auth != null", ".write": "auth != null"}} | Tout utilisateur connecté accède à toute la base. Suffisant pour un petit projet à une seule personne. |
| {"rules": {"cihazlar": {"$uid": {".read": "$uid === auth.uid", ".write": "$uid === auth.uid"}}}} | Chaque utilisateur ne peut lire et écrire que sa branche /cihazlar/son-UID. Les codes de cet article sont prévus pour cette structure. |
Installation de la bibliothèque et réglages
- Vérifie que le paquet de cartes ESP32 est installé dans l'IDE Arduino (Outils > Type de carte > esp32). Les codes de cet article fonctionnent avec les versions 2.x comme 3.x du core.
- Dans le gestionnaire de bibliothèques, cherche Firebase ESP Client et installe la bibliothèque Firebase Arduino Client Library for ESP8266 and ESP32 de Mobizt. Les codes utilisent l'interface Firebase_ESP_Client.h de cette bibliothèque ; la nouvelle bibliothèque FirebaseClient du même développeur a une interface différente, ne les mélange pas.
- Depuis le même gestionnaire, installe la bibliothèque DHT sensor library d'Adafruit ; si elle demande Adafruit Unified Sensor comme dépendance, ajoute-la aussi.
- Remplace par tes propres valeurs les six réglages au début du code (nom et mot de passe Wi-Fi, clé API, adresse de la base, e-mail et mot de passe de l'utilisateur).
| Réglage | Où le trouver ? | Exemple |
|---|---|---|
| API_KEY | Project settings > General > Web API Key | Chaîne de 39 caractères commençant par AIza |
| DATABASE_URL | Haut de la page Realtime Database | https://nom-du-projet-default-rtdb.europe-west1.firebasedatabase.app |
| USER_EMAIL | Authentication > Users | [email protected] |
| USER_PASSWORD | Le mot de passe donné à la création de l'utilisateur | Au moins 6 caractères |
| WIFI_SSID / WIFI_PASSWORD | Réglages de ta box | Réseau 2,4 GHz uniquement (l'ESP32 ne gère pas le 5 GHz) |
Montage : DHT22 et LED
| Connexion | ESP32 | Raspberry Pi Pico W |
|---|---|---|
| DHT22 VCC | 3V3 | 3V3(OUT) |
| DHT22 DATA | GPIO 4 | GP15 |
| DHT22 GND | GND | GND |
| Anode de la LED (via résistance de 220 Ω) | GPIO 26 | GP14 |
| Cathode de la LED | GND | GND |
Écrire les données du capteur dans Firebase
Le code ci-dessous se connecte au Wi-Fi, s'authentifie auprès de Firebase avec e-mail et mot de passe, et écrit la mesure du DHT22 toutes les 30 secondes à deux endroits : le nœud /cihazlar/UID/son garde la dernière mesure, écrasée à chaque fois, et le nœud /cihazlar/UID/kayit conserve l'historique ajouté avec push. L'UID est récupéré automatiquement de la bibliothèque après la connexion, tu n'as pas à l'écrire à la main.
1#include <WiFi.h>
2#include <Firebase_ESP_Client.h>
3#include "addons/TokenHelper.h" // token durumunu Seri Monitör'e yazar / prints token status to Serial
4#include <DHT.h>
5
6// Kendi bilgilerinle değiştir / Replace with your own values
7#define WIFI_SSID "WIFI_ADIN"
8#define WIFI_PASSWORD "WIFI_SIFREN"
9#define API_KEY "WEB_API_KEY"
10#define DATABASE_URL "https://proje-adin-default-rtdb.europe-west1.firebasedatabase.app"
11#define USER_EMAIL "[email protected]"
12#define USER_PASSWORD "sifre123"
13
14#define DHT_PIN 4
15
16DHT dht(DHT_PIN, DHT22);
17FirebaseData fbdo; // istek nesnesi / request object
18FirebaseAuth auth; // kullanıcı bilgisi / user credentials
19FirebaseConfig config; // proje ayarları / project settings
20
21unsigned long sonGonderim = 0;
22const unsigned long ARALIK = 30000; // 30 saniye / 30 seconds
23
24void setup() {
25 Serial.begin(115200);
26 dht.begin();
27
28 WiFi.mode(WIFI_STA);
29 WiFi.setAutoReconnect(true); // kopunca yeniden bağlan / reconnect on drop
30 WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
31 Serial.print("Wi-Fi baglaniyor");
32 while (WiFi.status() != WL_CONNECTED) {
33 delay(300);
34 Serial.print(".");
35 }
36 Serial.println();
37 Serial.print("IP: ");
38 Serial.println(WiFi.localIP());
39
40 config.api_key = API_KEY;
41 config.database_url = DATABASE_URL;
42 auth.user.email = USER_EMAIL;
43 auth.user.password = USER_PASSWORD;
44 config.token_status_callback = tokenStatusCallback; // giriş durumunu izle / watch sign-in status
45
46 Firebase.begin(&config, &auth); // arka planda giriş yapar / signs in in the background
47}
48
49void loop() {
50 if (!Firebase.ready()) return; // token hazır değil / token not ready
51 if (millis() - sonGonderim < ARALIK) return;
52 sonGonderim = millis();
53
54 float t = dht.readTemperature();
55 float h = dht.readHumidity();
56 if (isnan(t) || isnan(h)) {
57 Serial.println("DHT22 okunamadi / read failed");
58 return;
59 }
60
61 FirebaseJson json;
62 json.set("sicaklik", t);
63 json.set("nem", h);
64 json.set("zaman/.sv", "timestamp"); // sunucu saati / server timestamp
65
66 String kok = String("/cihazlar/") + auth.token.uid.c_str();
67 String yolSon = kok + "/son";
68 String yolKayit = kok + "/kayit";
69
70 if (Firebase.RTDB.setJSON(&fbdo, yolSon.c_str(), &json)) { // son ölçümü güncelle / update latest
71 Serial.printf("Yazildi: %.1f C, %.0f %%\n", t, h);
72 } else {
73 Serial.println(fbdo.errorReason());
74 }
75
76 if (!Firebase.RTDB.pushJSON(&fbdo, yolKayit.c_str(), &json)) { // geçmişe ekle / append to history
77 Serial.println(fbdo.errorReason());
78 }
79}| Ligne / fonction | Rôle |
|---|---|
| Firebase.begin(&config, &auth) | Charge les réglages, se connecte en arrière-plan et obtient le token. |
| Firebase.ready() | Renvoie true si le token est prêt et valide ; le renouvelle s'il est sur le point d'expirer. À appeler avant chaque requête. |
| Firebase.RTDB.setJSON() | Remplace complètement le contenu du chemin donné par le nouveau JSON. |
| Firebase.RTDB.pushJSON() | Ajoute sous le chemin un nouvel enregistrement à clé unique, trié dans le temps. |
| json.set("zaman/.sv", "timestamp") | Écrit l'horloge du serveur (temps Unix en millisecondes) ; aucun réglage d'heure n'est nécessaire sur l'ESP32. |
| fbdo.errorReason() | Donne la cause de l'échec de la requête sous forme de texte. |
Chaque enregistrement, avec sa clé, occupe environ 100 octets. Un enregistrement toutes les 30 secondes, cela fait 2880 enregistrements par jour et environ 0,3 Mo ; avec ce rythme, le 1 Go gratuit ne se remplit pas avant des années. Si tu descends l'intervalle à 1 seconde, tu obtiens 86 400 enregistrements par jour et environ 8,6 Mo ; en plus, chaque client qui lit ces données consomme ton quota mensuel de 10 Go de téléchargement. C'est pourquoi, pour les affichages en direct, mieux vaut ne lire que le nœud son et ne récupérer l'historique que pour tracer un graphique.
Commander une LED depuis la base : réaction instantanée avec le stream
Il y a deux façons de commander une LED à distance. La première consiste à interroger la valeur toutes les quelques secondes dans loop ; c'est simple, mais chaque interrogation est une nouvelle requête HTTPS et la réaction a un retard égal à l'intervalle. La seconde est le stream : l'ESP32 s'abonne une fois au chemin /cihazlar/UID/led, la connexion reste ouverte et, dès que tu changes la valeur dans la console, la nouvelle valeur arrive à l'ESP32. Le code ci-dessous utilise cette méthode. Sur l'ESP32, la fonction de rappel du stream s'exécute dans une tâche séparée ; c'est pourquoi on ne modifie pas la LED directement là, mais dans loop via un drapeau, ce qui évite aussi qu'une opération longue ne bloque le stream.
1#include <WiFi.h>
2#include <Firebase_ESP_Client.h>
3#include "addons/TokenHelper.h"
4
5// Kendi bilgilerinle değiştir / Replace with your own values
6#define WIFI_SSID "WIFI_ADIN"
7#define WIFI_PASSWORD "WIFI_SIFREN"
8#define API_KEY "WEB_API_KEY"
9#define DATABASE_URL "https://proje-adin-default-rtdb.europe-west1.firebasedatabase.app"
10#define USER_EMAIL "[email protected]"
11#define USER_PASSWORD "sifre123"
12
13#define LED_PIN 26
14
15FirebaseData stream; // yalnızca dinleme için / for listening only
16FirebaseAuth auth;
17FirebaseConfig config;
18
19volatile bool yeniVeri = false;
20volatile bool ledDurum = false;
21bool streamAcik = false;
22
23// Değer değişince çağrılır / Called when the value changes
24void streamCallback(FirebaseStream data) {
25 if (data.dataType() == "boolean") {
26 ledDurum = data.boolData();
27 yeniVeri = true;
28 } else if (data.dataType() == "int") {
29 ledDurum = (data.intData() != 0); // 1 ve 0 da kabul / 1 and 0 also accepted
30 yeniVeri = true;
31 }
32}
33
34// Bağlantı zaman aşımında çağrılır / Called on stream timeout
35void streamTimeoutCallback(bool timeout) {
36 if (timeout) Serial.println("Stream zaman asimi, devam ediliyor / timeout, resuming");
37 if (!stream.httpConnected()) Serial.println(stream.errorReason());
38}
39
40void setup() {
41 Serial.begin(115200);
42 pinMode(LED_PIN, OUTPUT);
43 digitalWrite(LED_PIN, LOW);
44
45 WiFi.mode(WIFI_STA);
46 WiFi.setAutoReconnect(true);
47 WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
48 while (WiFi.status() != WL_CONNECTED) {
49 delay(300);
50 Serial.print(".");
51 }
52 Serial.println();
53
54 config.api_key = API_KEY;
55 config.database_url = DATABASE_URL;
56 auth.user.email = USER_EMAIL;
57 auth.user.password = USER_PASSWORD;
58 config.token_status_callback = tokenStatusCallback;
59 Firebase.begin(&config, &auth);
60}
61
62void loop() {
63 // Giriş tamamlanınca stream'i bir kez başlat / Start the stream once after sign-in
64 if (Firebase.ready() && !streamAcik) {
65 String yol = String("/cihazlar/") + auth.token.uid.c_str() + "/led";
66 if (Firebase.RTDB.beginStream(&stream, yol.c_str())) {
67 Firebase.RTDB.setStreamCallback(&stream, streamCallback, streamTimeoutCallback);
68 streamAcik = true;
69 Serial.println("Dinleniyor / Listening: " + yol);
70 } else {
71 Serial.println(stream.errorReason());
72 delay(2000);
73 }
74 }
75
76 // Yeni değer geldiyse LED'i güncelle / Update the LED when new data arrives
77 if (yeniVeri) {
78 yeniVeri = false;
79 digitalWrite(LED_PIN, ledDurum ? HIGH : LOW);
80 Serial.println(ledDurum ? "LED ACIK / ON" : "LED KAPALI / OFF");
81 }
82}Après avoir téléversé le code, ouvre la page Realtime Database dans la console Firebase, ajoute dans ton propre UID, sous le nœud cihazlar, une clé nommée led, choisis le type boolean et mets true. À l'ouverture du stream, Firebase envoie d'abord la valeur actuelle du chemin, puis chaque modification ; ainsi, même si l'ESP32 redémarre, la LED revient à son dernier état enregistré. Si tu appliques la même structure à un module relais, tu peux allumer et éteindre une lampe, un ventilateur ou une pompe à eau via Internet.
Firebase avec le Raspberry Pi Pico W (MicroPython)
Pour le Pico W, il n'existe pas de bibliothèque Firebase répandue comme sur l'ESP32, mais ce n'est pas nécessaire : Realtime Database expose aussi chaque chemin comme une adresse REST. Tu ajoutes .json à la fin du chemin, puis tu écris avec PUT et tu lis avec GET. Pour l'authentification, tu envoies d'abord l'e-mail et le mot de passe au service de connexion de Firebase pour obtenir un idToken et le localId (l'identifiant utilisateur), puis tu ajoutes le token à chaque requête avec le paramètre ?auth=. Comme le token est valable une heure, le code se reconnecte toutes les 50 minutes. Cette méthode n'est pas aussi rapide que le stream ; l'état de la LED est interrogé à chaque boucle de 10 secondes. Pour la configuration Wi-Fi du Pico W, consulte l'article Serveur web Wi-Fi avec le Pico W.
1import network, time, urequests, dht
2from machine import Pin
3
4# Kendi bilgilerinle değiştir / Replace with your own values
5SSID = "WIFI_ADIN"
6SIFRE_WIFI = "WIFI_SIFREN"
7API_KEY = "WEB_API_KEY"
8DB_URL = "https://proje-adin-default-rtdb.europe-west1.firebasedatabase.app"
9EMAIL = "[email protected]"
10SIFRE = "sifre123"
11
12sensor = dht.DHT22(Pin(15))
13led = Pin(14, Pin.OUT)
14
15wlan = network.WLAN(network.STA_IF)
16wlan.active(True)
17wlan.connect(SSID, SIFRE_WIFI)
18while not wlan.isconnected(): # bağlantıyı bekle / wait for connection
19 time.sleep(0.5)
20print("IP:", wlan.ifconfig()[0])
21
22def giris():
23 # E-posta/şifre ile token al / Get a token with email/password
24 url = "https://identitytoolkit.googleapis.com/v1/accounts:signInWithPassword?key=" + API_KEY
25 r = urequests.post(url, json={"email": EMAIL, "password": SIFRE, "returnSecureToken": True})
26 cevap = r.json()
27 r.close()
28 return cevap["idToken"], cevap["localId"] # token ve UID / token and UID
29
30token, uid = giris()
31giris_zamani = time.time()
32
33while True:
34 try:
35 if time.time() - giris_zamani > 3000: # 50 dakikada bir yenile / refresh every 50 min
36 token, uid = giris()
37 giris_zamani = time.time()
38 kok = DB_URL + "/cihazlar/" + uid
39 sensor.measure()
40 veri = {"sicaklik": sensor.temperature(), "nem": sensor.humidity(),
41 "zaman": {".sv": "timestamp"}} # sunucu saati / server timestamp
42 r = urequests.put(kok + "/son.json?auth=" + token, json=veri)
43 r.close()
44 r = urequests.get(kok + "/led.json?auth=" + token)
45 durum = r.json() # true, false ya da None / true, false or None
46 r.close()
47 led.value(1 if durum else 0)
48 print(veri["sicaklik"], veri["nem"], "LED:", durum)
49 except Exception as e:
50 print("Hata / Error:", e)
51 time.sleep(10)Firebase ou Google Sheets ?
| Critère | Firebase Realtime Database | Google Sheets (Apps Script) |
|---|---|---|
| Sens des données | Bidirectionnel : écriture, lecture et écoute instantanée | Généralement à sens unique : de l'appareil vers le tableau |
| Latence | Modifications généralement en moins d'une seconde | Chaque requête peut prendre quelques secondes |
| Commande d'appareils | LED, relais, servo instantanément avec le stream | Inadapté ; interrogation continue nécessaire |
| Graphiques et analyse | Tu dois écrire ta propre page web ou appli | Graphiques tout faits, formules, export vers Excel |
| Sécurité | Règles détaillées par utilisateur | Quiconque connaît l'adresse du script publié publiquement peut écrire |
| Limites | Spark : 1 Go de stockage, 10 Go de téléchargement par mois | Maximum 10 millions de cellules par fichier, quotas Apps Script |
| Mise en place | Moyenne : projet, authentification, règles | Facile : un tableau et un court script |
En résumé, si ton but est seulement d'enregistrer des mesures et de tracer un graphique hebdomadaire, la méthode ESP32 avec Google Sheets se met en place plus vite et tu vois tes données directement dans le tableau. Si tu veux commander l'appareil à distance, surveiller plusieurs appareils à la fois ou créer un affichage en direct avec une appli mobile, Firebase est le meilleur choix. Tu peux aussi combiner les deux : l'état instantané dans Firebase, le résumé quotidien dans Sheets. Si tu veux l'intégrer à un système domotique, MQTT et Home Assistant sont aussi une alternative solide.
Idées de projets ESP32 Firebase
- Suivi de serre à distance : écris la température, l'humidité et l'humidité du sol dans Firebase, et déclenche la pompe d'arrosage avec un interrupteur dans la base.
- Prise connectée : commande le relais avec le stream et enregistre la durée d'allumage dans la base ; pour les détails, lis l'article Prise connectée ESP32.
- Journal de mouvements : à chaque déclenchement du capteur PIR, ajoute avec push un enregistrement horodaté et consulte l'historique depuis ton téléphone.
- Station météo multi-pièces : place un ESP32 dans chaque pièce, chacun écrivant sous son propre UID ; suis-les tous en direct sur une seule page web.
- Thermostat réglable à distance : lis la température cible dans la base et pilote le chauffage en conséquence ; pour la logique, l'article Thermostat Arduino est un bon début.
- Capteur sur batterie : après avoir écrit la mesure, passe en mode deep sleep et réveille-toi toutes les quelques minutes pour envoyer la nouvelle valeur.
Erreurs fréquentes et solutions
| Erreur / symptôme | Cause probable | Solution |
|---|---|---|
| Permission denied | Les règles n'autorisent pas la requête ou le mode test a expiré | Vérifie l'onglet Rules ; assure-toi que le chemin commence par /cihazlar/UID |
| EMAIL_NOT_FOUND, INVALID_PASSWORD ou INVALID_LOGIN_CREDENTIALS | L'utilisateur n'existe pas ou le mot de passe est faux | Vérifie l'e-mail et le mot de passe dans la liste Authentication > Users |
| OPERATION_NOT_ALLOWED | Le fournisseur Email/Password n'est pas activé | Active-le dans l'onglet Sign-in method |
| API key not valid | Clé API manquante ou mal copiée | Recopie la clé depuis la page Project settings |
| token is not ready | Requête envoyée avant la fin de la connexion | Vérifie Firebase.ready() avant chaque requête ; contrôle la connexion Wi-Fi |
| connection refused, send request failed | DATABASE_URL incorrecte, signal faible ou réseau 5 GHz | Copie l'adresse telle quelle depuis la console ; connecte-toi à un réseau 2,4 GHz |
| L'ESP32 redémarre sans cesse | Pic de courant pendant le Wi-Fi et le TLS (brownout) | Utilise un bon câble USB et une alimentation solide |
| Firebase_ESP_Client.h introuvable | Mauvaise bibliothèque installée (par exemple FirebaseClient) | Installe la bibliothèque Firebase Arduino Client Library for ESP8266 and ESP32 de Mobizt |
Une voie plus simple : BlueGrays IoT
Firebase te donne un contrôle total sur la structure de ta base de données et les règles de sécurité. Mais si tu veux seulement commander un relais ou surveiller un capteur depuis ton téléphone, tu n'as pas besoin de créer un projet, d'écrire les règles de la Realtime Database, d'ajouter un utilisateur Authentication ni de copier à la main la clé API et la DATABASE_URL dans ton code. BlueGrays IoT, dans l'application BlueGrays, part de modèles prêts dans Atelier › Mes appareils › Ajouter un appareil : Ohmi prépare le code avec la clé de ton appareil, tu le téléverses une seule fois depuis l'Arduino IDE avec la bibliothèque BlueGraysIoT, puis tu obtiens interrupteurs, valeurs en direct et graphiques sur ton téléphone. Cela fonctionne avec l'ESP32 et la Raspberry Pi Pico W en Wi-Fi 2,4 GHz, et ton premier appareil est gratuit ; pour les détails, consulte le guide pour contrôler un ESP32 depuis ton téléphone.
Avec Firebase, ton ESP32 ne se contente plus de mesurer : il parle sur Internet et reçoit des ordres. Lance d'abord l'exemple d'écriture du capteur, ajoute ensuite la commande de LED par stream et lie impérativement les règles à l'authentification. Dans l'application BlueGrays, tu retrouves pas à pas, avec schémas et codes, les projets ESP32 de connexion Wi-Fi, d'horloge NTP, de serveur web, de WebSocket et d'enregistreur de température DHT22, pour y ajouter facilement la couche Firebase de cet article.
Questions fréquentes
Utiliser Firebase avec l'ESP32 est-il gratuit ?
Oui, l'offre gratuite Spark de Firebase propose pour Realtime Database 1 Go de stockage, 10 Go de téléchargement par mois et 100 connexions simultanées. Des projets de loisir où quelques ESP32 écrivent toutes les 30 secondes restent très en dessous de ces limites. Tu peux aussi créer un projet sans enregistrer de carte bancaire.
Quelle différence entre Firebase Realtime Database et Firestore ?
Realtime Database garde les données dans un seul arbre JSON, se met en place simplement et l'écoute instantanée par stream est bien rodée dans les bibliothèques ESP32. Firestore utilise des collections et des documents, est plus puissant pour les requêtes complexes, mais le nombre de lectures et d'écritures quotidiennes est limité dans l'offre gratuite. Pour les données de capteurs et la commande d'appareils, Realtime Database est généralement plus pratique.
Pourquoi mon ESP32 ne se connecte pas à Firebase ?
Les causes les plus fréquentes sont une adresse de base mal copiée, une connexion Email/Password non activée, une clé API erronée et un réseau Wi-Fi 5 GHz. Si tu obtiens Permission denied, tes règles de sécurité n'autorisent pas la requête. Lire la sortie de tokenStatusCallback dans le moniteur série te montre à quelle étape se trouve le problème.
Est-il sûr de garder la clé API Firebase dans le code ?
La clé Web API identifie seulement le projet et ne donne pas à elle seule le droit d'accéder à la base. La vraie sécurité vient de l'authentification et des règles ; si tes règles contiennent auth != null ou un contrôle d'UID, quelqu'un qui connaît la clé ne peut pas lire de données sans se connecter. Pense tout de même à retirer les mots de passe Wi-Fi et utilisateur quand tu partages ton code publiquement.
À quelle fréquence l'ESP32 peut-il envoyer des données à Firebase ?
Comme chaque requête HTTPS prend quelques centaines de millisecondes selon la connexion, écrire une fois par seconde est techniquement possible. Mais pour des données qui varient lentement comme la température, un intervalle de 10 secondes à quelques minutes protège à la fois le quota et l'énergie. Pour les commandes qui demandent une réaction immédiate, mieux vaut utiliser le stream plutôt que l'interrogation.
Le même code fonctionne-t-il avec l'ESP8266 (NodeMCU) ?
La bibliothèque Firebase ESP Client prend aussi en charge l'ESP8266 ; il suffit d'inclure ESP8266WiFi.h au lieu de WiFi.h. Comme l'ESP8266 a moins de RAM, les connexions TLS peuvent saturer la mémoire ; il faut donc n'utiliser qu'un seul objet FirebaseData à la fois et combiner avec soin stream et écriture. Si tu démarres un nouveau projet, l'ESP32 est un choix plus confortable.
Projets à réaliser après cet article
Voir tous les projets
Clignotement LED avec ESP32
Enseigne l'utilisation de base des sorties GPIO avec l'ESP32. Nous obtenons un effet de clignotement en allumant et éteignant une LED à partir de la broche numérique. Version ESP32 du projet blink classique sur Arduino UNO ; les commandes de base de blink dans l'environnement Arduino restent les mêmes, mais le brochage et les niveaux GPIO de 3,3 V de l'ESP32 diffèrent de ceux de l'Arduino UNO.

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.

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 : 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.

Serveur Web asynchrone ESP32 (avec affichage de l'adresse IP sur l'écran LCD)
On transforme l'ESP32 en serveur web asynchrone que tu pilotes depuis ton téléphone ou ton ordinateur sur le même réseau Wi-Fi. Grâce à la bibliothèque ESPAsyncWebServer, le serveur traite plusieurs requêtes à la fois (il ne bloque pas sur une seule requête comme le WebServer.h classique). Ouvre l'adresse IP de l'ESP32 dans le navigateur et allume ou éteins la LED sur GPIO 5 avec les boutons ON/OFF (adresses /on et /off).

Compteur ESP32 WebSocket (2 boutons + écran LCD + affichage Web en temps réel)
Dans ce projet, deux boutons reliés à l'ESP32 (GPIO 5 incrémente, GPIO 4 décrémente) modifient un compteur. La valeur se met à jour instantanément sur un écran LCD I2C 16x2 et, grâce au support WebSocket d'ESPAsyncWebServer, dans tous les navigateurs connectés sans recharger la page. Au lieu du polling HTTP, une seule connexion persistante est utilisée et l'ESP32 envoie la nouvelle valeur à tous avec ws.textAll().

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.

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.
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

