Guide · 10 min di lettura

ESP32 Firebase Realtime Database: Guida a Sensori e LED

Guida ESP32 Firebase Realtime Database passo passo: progetto, login con email, scrittura dati DHT22, controllo LED con stream ed esempio REST su Pico W.

ESP32 e Firebase sono uno dei modi più rapidi per portare i dati dei sensori su internet e controllare la tua scheda da qualsiasi parte del mondo. Realtime Database, sulla piattaforma Firebase di Google, è un database cloud che salva i dati come albero JSON e li inoltra a tutti i client connessi, di solito in meno di un secondo. L'ESP32 scrive qui temperatura e umidità, e una pagina web o un'app sul tuo telefono vede lo stesso dato all'istante. Vale anche il contrario: quando imposti il valore led su true nel database, il LED collegato all'ESP32 si accende subito.

In questa guida creerai il progetto Firebase da zero, attiverai l'autenticazione con email e password, scriverai correttamente le regole di sicurezza e installerai la libreria Firebase ESP Client nell'Arduino IDE. Poi vedremo passo passo il codice che scrive nel database i dati del sensore DHT22 ogni 30 secondi e, nel secondo esempio, quello che ascolta le modifiche del database con uno stream e accende il LED all'istante. Nelle ultime sezioni faremo lo stesso con Raspberry Pi Pico W in MicroPython tramite l'API REST, confronteremo Firebase con Google Sheets e raccoglieremo le soluzioni ai messaggi d'errore più comuni. Se sei nuovo dell'ESP32, dai prima un'occhiata a Cos'è l'ESP32.

Scheda di sviluppo ESP32 per un progetto Firebase
Scheda di sviluppo ESP32: grazie al Wi-Fi integrato si collega a Firebase Realtime Database senza moduli aggiuntivi.

Cos'è Firebase Realtime Database e come funziona?

A differenza dei classici database a tabelle (SQL), Realtime Database conserva i dati in un unico grande albero JSON. Ogni dato è indirizzato da un percorso (path): per esempio /cihazlar/UID/son/sicaklik può contenere un numero, mentre /cihazlar/UID/led può contenere true o false. L'ESP32 scrive e legge questi percorsi tramite una connessione HTTPS cifrata. Il vero punto di forza è lo stream (ascolto): il dispositivo si iscrive a un percorso, la connessione resta aperta e, nel momento in cui il valore cambia, il server invia da solo il nuovo dato. Non serve più un ciclo che interroga ogni secondo, quindi si riducono sia la latenza sia il traffico dati.

CaratteristicaValore / Descrizione
Modello datiAlbero JSON (NoSQL), accesso basato sui percorsi
ConnessioneHTTPS (TLS); per lo stream una connessione HTTP che resta aperta
Piano gratuito Spark1 GB di archiviazione, 10 GB di download al mese, 100 connessioni simultanee
LatenzaLe modifiche arrivano di solito in meno di 1 secondo
AutenticazioneEmail/password, accesso anonimo, account Google e altri
SicurezzaRegole di sicurezza JSON eseguite lato server
Schede supportateESP32 ed ESP8266 (con la libreria); Pico W (con l'API REST)

Creare il progetto Firebase passo passo

  1. Accedi alla console di Firebase con il tuo account Google e clicca su Create a project (Crea un progetto). Dai al progetto un nome, per esempio esp32-serra; Google Analytics non serve per questo progetto, puoi disattivarlo.
  2. Dal menu a sinistra vai su Build > Realtime Database e premi Create Database.
  3. Scegli la posizione del database. Se sei in Europa, europe-west1 (Belgio) offre una latenza più bassa; in questo caso l'indirizzo avrà la forma https://nome-progetto-default-rtdb.europe-west1.firebasedatabase.app. Con la posizione USA l'indirizzo termina invece con -default-rtdb.firebaseio.com.
  4. Come modalità di sicurezza scegli Locked mode: le regole le scriverai tu tra poco. Copia l'indirizzo in alto nella pagina che si apre: è il tuo DATABASE_URL.
  5. Vai su Build > Authentication, clicca Get started e nella scheda Sign-in method abilita il provider Email/Password.
  6. Nella scheda Users crea un utente per l'ESP32 con Add user (per esempio [email protected] e una password di almeno 6 caratteri). Annota il valore User UID della riga creata.
  7. Dall'icona a forma di ingranaggio in alto a sinistra apri Project settings > General e copia il Web API Key: è il tuo API_KEY.
Se apri il database in Test mode, per 30 giorni le regole permettono a chiunque di leggere e scrivere; alla scadenza tutte le richieste vengono rifiutate con l'errore Permission denied e il progetto smette di funzionare da un giorno all'altro. Peggio ancora, in quei 30 giorni chiunque conosca l'indirizzo del database può leggere o cancellare i tuoi dati. Partire con Locked mode e legare le regole all'autenticazione è la soluzione sicura e duratura.

Autenticazione e regole di sicurezza

La Web API key da sola non è una password segreta: dice soltanto a quale progetto Firebase appartiene la richiesta. La vera protezione sono le regole di sicurezza eseguite sul server Firebase. Quando l'ESP32 accede con email e password, Firebase gli consegna un ID token valido per un'ora; la libreria lo rinnova da sola prima della scadenza. Nelle regole, l'espressione auth.uid restituisce l'identità dell'utente che invia la richiesta. Nella tabella qui sotto trovi tre regole che puoi scrivere nella scheda Realtime Database > Rules, con il loro significato. La struttura consigliata è la terza: ogni dispositivo accede solo al ramo sotto il proprio UID, così anche se la password di un dispositivo venisse rubata, i dati degli altri resterebbero al sicuro.

Regola (scheda Rules)Significato
{"rules": {".read": true, ".write": true}}Tutti leggono e scrivono. Solo per qualche minuto di prova; non lasciarla mai attiva.
{"rules": {".read": "auth != null", ".write": "auth != null"}}Ogni utente autenticato accede a tutto il database. Basta per piccoli progetti personali.
{"rules": {"cihazlar": {"$uid": {".read": "$uid === auth.uid", ".write": "$uid === auth.uid"}}}}Ogni utente può leggere e scrivere solo il ramo /cihazlar/il-proprio-UID. Il codice di questo articolo è pensato per questa struttura.

Installazione delle librerie e impostazioni

  1. Assicurati che nell'Arduino IDE sia installato il pacchetto schede ESP32 (Strumenti > Scheda > esp32). Il codice di questo articolo funziona sia con il core 2.x sia con il 3.x.
  2. Nel Gestore librerie cerca Firebase ESP Client e installa la libreria di Mobizt Firebase Arduino Client Library for ESP8266 and ESP32. Il codice usa l'interfaccia Firebase_ESP_Client.h di questa libreria; la nuova libreria dello stesso autore, FirebaseClient, ha un'interfaccia diversa: non confonderle.
  3. Dallo stesso gestore installa la DHT sensor library di Adafruit; se come dipendenza ti viene chiesta Adafruit Unified Sensor, aggiungi anche quella.
  4. Sostituisci con i tuoi valori le sei impostazioni all'inizio del codice (nome e password del Wi-Fi, chiave API, indirizzo del database, email e password dell'utente).
ImpostazioneDove trovarlaEsempio
API_KEYProject settings > General > Web API KeyStringa di 39 caratteri che inizia con AIza
DATABASE_URLParte alta della pagina Realtime Databasehttps://nome-progetto-default-rtdb.europe-west1.firebasedatabase.app
USER_EMAILAuthentication > Users[email protected]
USER_PASSWORDLa password inserita quando hai aggiunto l'utenteAlmeno 6 caratteri
WIFI_SSID / WIFI_PASSWORDImpostazioni del tuo routerSolo rete a 2,4 GHz (l'ESP32 non supporta i 5 GHz)

Circuito: collegamento di DHT22 e LED

CollegamentoESP32Raspberry Pi Pico W
DHT22 VCC3V33V3(OUT)
DHT22 DATAGPIO 4GP15
DHT22 GNDGNDGND
Anodo LED (tramite resistenza da 220 Ω)GPIO 26GP14
Catodo LEDGNDGND
Se usi un sensore DHT22 nudo, devi aggiungere una resistenza pull-up da 10 kΩ tra DATA e 3V3; nelle versioni a modulo questa resistenza è già sulla scheda. Con un'uscita a 3,3 V, una resistenza da 220 Ω per un LED rosso dà circa 6 mA; per altri colori puoi verificare il valore con il calcolatore di resistenza per LED. Se aggiungerai un sensore analogico, ricorda che i pin ADC2 dell'ESP32 (GPIO 0, 2, 4, 12–15, 25–27) non si possono usare con analogRead mentre il Wi-Fi è attivo; per gli ingressi analogici scegli i pin ADC1 (GPIO 32–39).

Scrivere i dati del sensore su Firebase

Il codice seguente si connette al Wi-Fi, accede a Firebase con email e password e scrive la misura del DHT22 ogni 30 secondi in due posti: il nodo /cihazlar/UID/son contiene l'ultima misura, sovrascritta ogni volta, mentre il nodo /cihazlar/UID/kayit contiene lo storico aggiunto con push. Il valore dell'UID viene ottenuto automaticamente dalla libreria dopo l'accesso, non devi scriverlo a mano.

C++ (Arduino IDE)
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}
Riga / funzioneCosa fa
Firebase.begin(&config, &auth)Carica le impostazioni, accede in background e ottiene il token.
Firebase.ready()Restituisce true se il token è pronto e valido; lo rinnova se sta per scadere. Va chiamata prima di ogni richiesta.
Firebase.RTDB.setJSON()Sostituisce completamente il contenuto del percorso indicato con il nuovo JSON.
Firebase.RTDB.pushJSON()Aggiunge sotto il percorso un nuovo record con chiave univoca, ordinato nel tempo.
json.set("zaman/.sv", "timestamp")Scrive l'orario del server (tempo Unix in millisecondi); sull'ESP32 non serve impostare l'orologio.
fbdo.errorReason()Se la richiesta fallisce, restituisce la causa dell'errore come testo.

Ogni record, con la sua chiave, occupa circa 100 byte. Un record ogni 30 secondi significa 2880 record al giorno e circa 0,3 MB; con questo ritmo 1 GB di archiviazione del piano gratuito non si riempie per anni. Se porti l'intervallo a 1 secondo ottieni 86.400 record al giorno e circa 8,6 MB; inoltre ogni client che legge questi dati consuma la tua quota di download da 10 GB al mese. Per questo, negli indicatori in tempo reale è buona abitudine leggere solo il nodo son e scaricare lo storico soltanto quando disegni un grafico.

Controllare un LED dal database: reazione immediata con lo stream

Ci sono due modi per controllare un LED da remoto. Il primo è interrogare il valore ogni pochi secondi nel loop: è semplice, ma ogni interrogazione è una nuova richiesta HTTPS e il tempo di reazione ritarda quanto l'intervallo. Il secondo è lo stream: l'ESP32 si iscrive una volta al percorso /cihazlar/UID/led, la connessione resta aperta e nel momento in cui cambi il valore nella console il nuovo valore arriva all'ESP32. Il codice seguente usa questo metodo. Poiché sull'ESP32 la funzione di callback dello stream gira in un task separato, non cambiamo il LED direttamente lì ma tramite un flag nel loop; così evitiamo anche che operazioni lunghe blocchino lo stream.

C++ (Arduino IDE)
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}

Dopo aver caricato il codice, apri la pagina Realtime Database nella console di Firebase, aggiungi una chiave chiamata led dentro il tuo UID sotto il nodo cihazlar, scegli boolean come tipo di valore e scrivi true. Quando lo stream si apre, Firebase invia prima il valore attuale del percorso e poi ogni modifica; per questo, anche se l'ESP32 si riavvia, il LED torna all'ultimo stato salvato. Se applichi la stessa struttura a un modulo relè, puoi accendere e spegnere una lampada, una ventola o una pompa dell'acqua via internet.

Quando scrivi il valore nella console, fai attenzione al tipo: se scrivi "true" tra virgolette diventa una stringa e il codice non la riconosce come booleano. Il codice accetta anche numeri interi come 1 e 0. Se vuoi unire scrittura dei sensori e ascolto del LED sulla stessa scheda, usa due oggetti FirebaseData separati: uno solo per lo stream, l'altro per le richieste di scrittura. Ogni connessione TLS usa decine di KB di RAM; per l'ESP32 non è un problema, ma non aumentare il numero di oggetti senza motivo.

Firebase con Raspberry Pi Pico W (MicroPython)

Per il Pico W non esiste una libreria Firebase diffusa come quella dell'ESP32, ma non serve: Realtime Database espone ogni percorso anche come indirizzo REST. Aggiungi .json alla fine del percorso, scrivi con PUT e leggi con GET. Per l'autenticazione invii prima email e password al servizio di accesso di Firebase e ottieni l'idToken e il localId (l'identificativo utente), poi aggiungi il token a ogni richiesta con il parametro ?auth=. Poiché il token vale un'ora, il codice rifà l'accesso ogni 50 minuti. Questo metodo non è veloce come lo stream: lo stato del LED viene letto a ogni ciclo di 10 secondi. Per la configurazione del Wi-Fi del Pico W puoi guardare l'articolo sul server web Wi-Fi con Pico W.

MicroPython
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 o Google Sheets?

CriterioFirebase Realtime DatabaseGoogle Sheets (Apps Script)
Direzione dei datiBidirezionale: scrittura, lettura e ascolto immediatoDi solito a senso unico: dal dispositivo al foglio
LatenzaLe modifiche arrivano di solito in meno di 1 secondoOgni richiesta può richiedere alcuni secondi
Controllo dei dispositiviLED, relè, servo all'istante con lo streamNon adatto; serve un'interrogazione continua
Grafici e analisiDevi scrivere tu la pagina web o l'appGrafici pronti, formule, esportazione in Excel
SicurezzaRegole dettagliate per utenteChiunque conosca l'indirizzo dello script pubblicato può scrivere
LimitiSpark: 1 GB di archiviazione, 10 GB di download al meseAl massimo 10 milioni di celle per file, quote di Apps Script
ConfigurazioneMedia: progetto, autenticazione, regoleFacile: un foglio e un breve script

In breve, se vuoi solo registrare le misure e disegnare un grafico settimanale, il metodo ESP32 con Google Sheets si configura più in fretta e vedi i dati direttamente nel foglio. Se vuoi controllare il dispositivo da remoto, monitorare più dispositivi insieme o creare un indicatore in tempo reale con un'app mobile, Firebase è la scelta più giusta. Si possono anche usare insieme: lo stato istantaneo su Firebase, il riepilogo giornaliero su Sheets. Se devi collegarti a un sistema di domotica, anche MQTT e Home Assistant sono un'alternativa valida.

Idee di progetto ESP32 con Firebase

  • Monitoraggio remoto di una serra: scrivi su Firebase temperatura, umidità e umidità del terreno e aziona la pompa di irrigazione con un interruttore nel database.
  • Presa intelligente: controlla il relè con lo stream e salva nel database il tempo in cui resta accesa; per i dettagli guarda l'articolo sulla presa intelligente ESP32.
  • Registro dei movimenti: a ogni attivazione del sensore PIR aggiungi con push un record con data e ora e consulta lo storico dal telefono.
  • Stazione meteo multi-stanza: metti un ESP32 in ogni stanza, ciascuno scrive sotto il proprio UID; guardali tutti in diretta su un'unica pagina web.
  • Termostato regolabile da remoto: leggi la temperatura obiettivo dal database e gestisci il riscaldamento di conseguenza; per la logica, l'articolo sul termostato Arduino è un buon punto di partenza.
  • Sensore a batteria: dopo aver scritto la misura passa alla modalità deep sleep, svegliati ogni pochi minuti e invia il nuovo valore.

Errori comuni e soluzioni

Errore / sintomoCausa probabileSoluzione
Permission deniedLe regole non permettono la richiesta o la modalità test è scadutaControlla la scheda Rules; assicurati che il percorso inizi con /cihazlar/UID
EMAIL_NOT_FOUND, INVALID_PASSWORD o INVALID_LOGIN_CREDENTIALSL'utente non esiste o la password è errataVerifica email e password nell'elenco Authentication > Users
OPERATION_NOT_ALLOWEDIl provider Email/Password non è attivoAttivalo dalla scheda Sign-in method
API key not validChiave API mancante o copiata maleCopia di nuovo la chiave dalla pagina Project settings
token is not readyRichiesta inviata prima del completamento dell'accessoControlla Firebase.ready() prima di ogni richiesta; verifica la connessione Wi-Fi
connection refused, send request failedDATABASE_URL errato, segnale debole o rete a 5 GHzCopia l'indirizzo esattamente dalla console; collegati a una rete a 2,4 GHz
L'ESP32 si riavvia di continuoPicco di corrente durante Wi-Fi e TLS (brownout)Usa un buon cavo USB e un'alimentazione robusta
Firebase_ESP_Client.h non trovatoInstallata la libreria sbagliata (per esempio FirebaseClient)Installa la libreria Firebase Arduino Client Library for ESP8266 and ESP32 di Mobizt
Per cercare il problema apri il Monitor seriale a 115200 baud: la funzione tokenStatusCallback stampa passo passo il processo di accesso e i codici d'errore. Se la scheda non riesce proprio a connettersi al Wi-Fi, segui i passaggi di ESP32 non si connette al Wi-Fi; se si resetta da sola, quelli di brownout e Guru Meditation.

Una strada più semplice: BlueGrays IoT

Firebase ti dà il pieno controllo sulla struttura del database e sulle regole di sicurezza. Ma se vuoi solo accendere e spegnere un relè o tenere d'occhio un sensore dal telefono, non devi creare a mano un progetto, scrivere le regole del Realtime Database, aggiungere un utente in Authentication e copiare nel codice la chiave API e il DATABASE_URL. BlueGrays IoT nell'app BlueGrays parte da modelli pronti in La Mia Officina › I miei dispositivi › Aggiungi nuovo dispositivo: Ohmi prepara il codice con la chiave del tuo dispositivo, tu lo carichi una sola volta dall'Arduino IDE con la libreria BlueGraysIoT e poi hai interruttori, valori in tempo reale e grafici sul telefono. Funziona con ESP32 e Raspberry Pi Pico W su Wi-Fi a 2,4 GHz e il tuo primo dispositivo è gratuito; per i dettagli leggi la guida per controllare un ESP32 dal telefono.

Con Firebase il tuo ESP32 non si limita più a misurare: parla su internet e riceve comandi. Prima esegui l'esempio di scrittura dei sensori, poi aggiungi il controllo del LED con lo stream e ricordati di legare sempre le regole all'autenticazione. Nell'app BlueGrays trovi i progetti ESP32 su connessione Wi-Fi, orologio NTP, server web, WebSocket e registratore di temperatura DHT22, con schemi e codice passo passo, e potrai aggiungere facilmente il livello Firebase di questo articolo.

Domande frequenti

Usare Firebase con l'ESP32 è gratuito?

Sì, il piano gratuito Spark di Firebase offre per Realtime Database 1 GB di archiviazione, 10 GB di download al mese e 100 connessioni simultanee. I progetti hobbistici in cui qualche ESP32 scrive dati ogni 30 secondi restano ben al di sotto di questi limiti. Puoi anche creare il progetto senza inserire una carta di credito.

Qual è la differenza tra Firebase Realtime Database e Firestore?

Realtime Database conserva i dati in un unico albero JSON, è semplice da configurare e lo stream per l'ascolto immediato è maturo nelle librerie per ESP32. Firestore usa collezioni e documenti, è più potente per le query complesse, ma nel piano gratuito ha un limite giornaliero di letture e scritture. Per dati dei sensori e controllo dei dispositivi Realtime Database è di solito più pratico.

Perché l'ESP32 non si connette a Firebase?

Le cause più frequenti sono un indirizzo del database copiato male, l'accesso Email/Password non attivato, una chiave API errata e una rete Wi-Fi a 5 GHz. Se ricevi l'errore Permission denied, le tue regole di sicurezza non permettono la richiesta. Leggere l'output di tokenStatusCallback nel Monitor seriale ti mostra in quale passaggio si trova il problema.

È sicuro tenere la chiave API di Firebase nel codice?

La Web API key identifica soltanto il progetto e da sola non dà accesso al database. La vera sicurezza è data da autenticazione e regole di sicurezza; se le tue regole contengono auth != null o il controllo dell'UID, chi conosce la chiave non può leggere dati senza accedere. Quando condividi il codice pubblicamente, ricordati comunque di rimuovere le password del Wi-Fi e dell'utente.

Con quale frequenza l'ESP32 può inviare dati a Firebase?

Ogni richiesta HTTPS richiede alcune centinaia di millisecondi a seconda della connessione, quindi tecnicamente scrivere una volta al secondo è possibile. Per dati che cambiano lentamente, come la temperatura, un intervallo tra 10 secondi e qualche minuto protegge sia la quota sia l'energia. Per i controlli che richiedono una reazione immediata è più efficiente usare lo stream al posto dell'interrogazione.

Lo stesso codice funziona con ESP8266 (NodeMCU)?

La libreria Firebase ESP Client supporta anche l'ESP8266; devi solo includere ESP8266WiFi.h al posto di WiFi.h. Poiché l'ESP8266 ha meno RAM, le connessioni TLS possono mettere sotto pressione la memoria, quindi conviene usare un solo oggetto FirebaseData alla volta e combinare con cautela stream e scrittura. Se inizi un nuovo progetto, l'ESP32 è una scelta più comoda.

Vedi tutti i progetti
LED Lampeggiante con ESP32
ES-1Principiante

LED Lampeggiante con ESP32

Insegna l'uso di base delle uscite GPIO con l'ESP32. Otteniamo un effetto lampeggiante accendendo e spegnendo un LED dal pin digitale. Versione ESP32 del classico progetto blink su Arduino UNO; i comandi di base di blink nell'ambiente Arduino sono gli stessi, ma la disposizione dei pin e i livelli GPIO a 3,3 V dell'ESP32 sono diversi da quelli di Arduino UNO.

4.7(37)
108
ESP32 DHT22 Temperatura e umidità (con display LCD)
ES-15Intermedio

ESP32 DHT22 Temperatura e umidità (con display LCD)

Si tratta di un progetto che misura la temperatura e l'umidità dell'ambiente tramite il sensore DHT22 e le visualizza in tempo reale su un display LCD I2C 16x2. I dati vengono letti dal sensore utilizzando il protocollo one-wire tramite la libreria Adafruit DHT. Questo progetto costituisce la base per stazioni meteorologiche IoT, sistemi di automazione domestica intelligente o sistemi di monitoraggio ambientale nelle serre. La comunicazione con il DHT22 avviene tramite il pin GPIO 4 dell'ESP32.

4.8(38)
57
Connessione Wi-Fi STA con ESP32 (con display LCD)
ES-25Avanzato

Connessione Wi-Fi STA con ESP32 (con display LCD)

In questo progetto colleghiamo l'ESP32 alla rete Wi-Fi domestica in modalità Station (STA) in modo sicuro e tollerante agli errori. Separiamo SSID e password in un file secrets.h per impedire fughe su Git, impostiamo un meccanismo di riconnessione automatica e visualizziamo il livello del segnale RSSI e l'indirizzo IP su un display LCD I2C. Il LED interno funge da indicatore di stato.

4.4(21)
38
ESP32: ora reale da Internet tramite NTP
ES-26Avanzato
Premium

ESP32: ora reale da Internet tramite NTP

L'ESP32 si collega al Wi-Fi e ottiene l'ora esatta dai server NTP (Network Time Protocol) con precisione al millisecondo. Con configTzTime() si applica in automatico il fuso orario turco (TRT, UTC+3) e, nei paesi con l'ora legale, il cambio (DST) è gestito da una stringa POSIX TZ. L'ora viene stampata sul Serial Monitor e su un display LCD I2C opzionale.

4.5(13)
22
Server web asincrono ESP32 (con indicazione dell'IP sul display LCD)
ES-27Avanzato

Server web asincrono ESP32 (con indicazione dell'IP sul display LCD)

In questo progetto trasformiamo l'ESP32 in un server web asincrono che potrete controllare dal vostro telefono o computer collegato alla stessa rete Wi-Fi. Grazie alla libreria ESPAsyncWebServer, il server è in grado di elaborare più richieste contemporaneamente (a differenza del classico WebServer.h, che si blocca su una singola richiesta).

4.8(16)
26
Contatore WebSocket ESP32 (2 pulsanti + LCD + Web in tempo reale)
ES-28Avanzato
Premium

Contatore WebSocket ESP32 (2 pulsanti + LCD + Web in tempo reale)

In questo progetto due pulsanti collegati all'ESP32 (GPIO 5 incrementa, GPIO 4 decrementa) modificano un contatore. Il valore si aggiorna all'istante su un display LCD I2C 16x2 e, grazie al supporto WebSocket di ESPAsyncWebServer, in tutti i browser collegati senza ricaricare la pagina. Al posto del polling HTTP si usa un'unica connessione persistente e l'ESP32 invia il nuovo valore a tutti con ws.textAll().

4.5(14)
23
ESP32 HTTPClient + API meteo (con schermo LCD)
ES-31Avanzato
Premium

ESP32 HTTPClient + API meteo (con schermo LCD)

L'ESP32 effettua via internet una chiamata REST a un'API meteo (wttr.in) con HTTPClient.h. La risposta JSON viene analizzata con ArduinoJson v7 e città, temperatura, umidità, condizioni meteo e vento compaiono su un display LCD I2C. wttr.in non richiede una chiave API: basta scrivere il nome di una città qualsiasi.

4.7(13)
20
Data Logger di Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Avanzato
Premium

Data Logger di Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)

Costruisci con l'ESP32 un registratore di temperatura e umidità con orario! Un sensore DHT22 legge temperatura e umidità una volta al minuto e ogni lettura viene salvata su una scheda microSD in formato CSV con l'ora reale del modulo RTC DS1307. Il display OLED mostra in tempo reale, a caratteri grandi, l'ultima temperatura, l'umidità, l'orario e il numero totale di registrazioni.

4.7(7)
12