Guide · 10 min di lettura

ESP32 Google Sheets: salvare i dati dei sensori via WiFi

Guida ESP32 Google Sheets: app web Apps Script, righe aggiunte con doPost, richiesta HTTPS, timestamp, DHT22 + LDR, grafico, quote e token segreto.

Collegare l'ESP32 a Google Sheets è il modo più semplice per raccogliere i dati dei sensori in un foglio di calcolo gratuito e raggiungibile ovunque, senza gestire un server. Ogni minuto l'ESP32 legge temperatura, umidità e luce, le invia a Google via WiFi e in Google Sheets compare una nuova riga. Aprendo il foglio sul telefono vedi l'ultima lettura, il suo timestamp e un grafico che si aggiorna da solo. Il ponte che rende possibile tutto questo è una piccola app web scritta con Apps Script, il servizio gratuito di Google.

In questa guida preparerai il foglio, scriverai il codice Apps Script che controlla i dati in arrivo e aggiunge una riga, lo pubblicherai come app web e invierai i dati dall'ESP32 in HTTPS. Poi vedremo timestamp, più sensori e dispositivi, come disegnare un grafico, i limiti di quota di Google, i codici di errore e come tenere segreto l'URL dell'app web. Nell'ultima parte trovi un confronto con alternative come ThingSpeak. Se sei alle prime armi con l'ESP32, leggi prima Che cos'è l'ESP32?; puoi anche vedere come l'ESP32 fa richieste HTTP nell'esempio dell'API meteo.

Scheda di sviluppo ESP32
ESP32: grazie al WiFi integrato può inviare richieste HTTPS direttamente a Google, senza gateway né computer in mezzo.

Come scrive l'ESP32 i dati su Google Sheets?

L'ESP32 non può scrivere direttamente nel foglio: l'API di Sheets di Google richiede l'autenticazione OAuth, scomoda per un piccolo microcontrollore. Scrivi invece un progetto Apps Script collegato al foglio e lo pubblichi come app web. Google ti dà un indirizzo del tipo script.google.com/macros/s/.../exec. Quando l'ESP32 invia dati a quell'indirizzo, il flusso è questo:

  1. L'ESP32 legge i sensori e trasforma i valori in un breve testo JSON.
  2. Il JSON viene inviato in HTTPS con una richiesta POST all'indirizzo /exec dell'app web.
  3. Google passa la richiesta alla funzione doPost(e), che gira con il tuo account; la funzione controlla il token segreto e aggiunge una riga con appendRow().
  4. Google non risponde subito ma restituisce un redirect 302; l'ESP32 richiede il nuovo indirizzo con GET e riceve la risposta prodotta dalla tua funzione.
  5. Se l'ESP32 vede "ok":true nella risposta, il lavoro è fatto; altrimenti aspetta un attimo e riprova.

Passo 1: Prepara il file di Google Sheets

  1. Crea un nuovo foglio di calcolo in Google Drive e chiamalo per esempio "Registro ESP32".
  2. Rinomina la scheda in basso in Veri; deve coincidere esattamente con SHEET_NAME nel codice, maiuscole comprese (oppure cambia entrambi).
  3. Scrivi le intestazioni nella prima riga: Ora, Dispositivo, Temperatura, Umidità, Luce. Puoi bloccare la riga con Visualizza > Blocca.
  4. Seleziona le colonne inutilizzate dalla F alla Z ed eliminale. Nella sezione sulle quote vedrai perché è importante.
  5. In File > Impostazioni imposta il fuso orario sulla tua zona; i timestamp vengono scritti in quel fuso.

Passo 2: Scrivi doPost e doGet in Apps Script

Con il foglio aperto scegli Estensioni > Apps Script; si apre un progetto collegato al foglio. Cancella tutto in Code.gs, incolla il codice qui sotto e salva. Poi apri le Impostazioni progetto dall'icona a ingranaggio a sinistra, aggiungi in fondo, in Proprietà script, una proprietà chiamata TOKEN e assegnale un valore lungo che nessuno possa indovinare. Tenere la chiave nelle proprietà invece che nel codice evita che trapeli quando condividi il codice.

C++ (Arduino IDE)
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}
ParteFunzione
doPost(e)Riceve la richiesta POST dell'ESP32; il corpo è in e.postData.contents
doGet(e)Permette di testare dal browser o con una semplice richiesta GET; i valori sono in e.parameter
PropertiesServiceConserva il TOKEN fuori dal codice, nelle impostazioni del progetto
LockServiceEvita che le righe si sovrascrivano quando due dispositivi inviano insieme
appendRow([...])Aggiunge una nuova riga sotto l'ultima riga piena
ContentServiceRestituisce all'ESP32 una piccola risposta JSON come {"ok":true}

Passo 3: Pubblica lo script come app web

  1. Fai clic su Esegui il deployment > Nuovo deployment in alto a destra e scegli App web come tipo.
  2. Imposta "Esegui come" su Me e "Chi può accedere" su Chiunque; è necessario perché l'ESP32 non può accedere con un account Google.
  3. Fai clic su Esegui il deployment; Google chiede l'autorizzazione ad accedere al foglio. Scegli il tuo account, apri il progetto dal link "Avanzate" e consenti l'accesso.
  4. Copia l'URL dell'app web che termina con /exec; lo incollerai nella variabile SCRIPT_URL del codice dell'ESP32.
Ogni volta che modifichi il codice Apps Script devi pubblicare una nuova versione; salvare non basta. In Esegui il deployment > Gestisci deployment fai clic sulla matita, scegli Nuova versione in Versione ed esegui il deployment. Così l'URL non cambia. Se scegli "Nuovo deployment", Google crea un nuovo URL e l'ESP32 continua a parlare con il vecchio codice; è la causa numero uno di "ho corretto il codice ma non cambia niente".
Prima di passare all'ESP32, prova la configurazione nel browser: aggiungi ?token=TUACHIAVE&device=test&temp=21.5&hum=40&light=1200 alla fine dell'URL e aprilo. Vedrai {"ok":true,"row":2} e troverai la riga nel foglio. La risposta "unauthorized" indica che la chiave non corrisponde, una pagina di accesso Google che l'accesso non è impostato su "Chiunque".

Passo 4: Collegamento di DHT22 e LDR

Sensore di temperatura e umidità DHT22
DHT22: misura da -40 a 80 °C con precisione di ±0,5 °C e l'umidità con ±2-5%; si collega direttamente all'ESP32 a 3,3 V.
ComponenteCollegamentoPin dell'ESP32
DHT22VCC3V3
DHT22DATA (pull-up da 10 kΩ verso 3V3 se il sensore è nudo)GPIO 4
DHT22GNDGND
LDRUn piedino a 3V3, l'altro a GPIO 343V3 / GPIO 34
Resistenza da 10 kΩTra GPIO 34 e GNDGPIO 34 / GND

La LDR e la resistenza da 10 kΩ formano un partitore di tensione: più luce c'è, più scende la resistenza della LDR e più sale la tensione su GPIO 34. GPIO 34 è scelto apposta; sull'ESP32 i pin ADC2 (GPIO 0, 2, 4, 12-15, 25-27) non possono fare letture analogiche con il WiFi attivo, quindi collega sempre i sensori analogici ai pin ADC1, GPIO 32-39. Il DHT22 è un sensore digitale e funziona senza problemi su GPIO 4. Per approfondire la famiglia DHT, consulta la guida a DHT11 e DHT22.

Passo 5: Inviare la richiesta HTTPS dall'ESP32

Nell'Arduino IDE installa la libreria DHT sensor library (Adafruit) dal Gestore librerie e accetta la dipendenza Adafruit Unified Sensor se richiesta. Le librerie WiFi, WiFiClientSecure e HTTPClient sono incluse nel pacchetto ESP32. Sostituisci i dati del WiFi, l'URL dell'app web che hai copiato e il valore di TOKEN con i tuoi, carica lo sketch e apri il Monitor seriale a 115200 baud.

C++ (Arduino IDE)
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}
  • Senza setFollowRedirects(HTTPC_STRICT_FOLLOW_REDIRECTS) l'ESP32 si ferma alla risposta 302 di Google e non vede mai la risposta vera; la riga viene comunque aggiunta, ma non puoi confermare il successo.
  • client.setInsecure() cifra la connessione ma non verifica il certificato del server. Per un progetto domestico va bene; per una sicurezza maggiore aggiungi il certificato radice di Google con setCACert().
  • setTimeout(15000) è importante; Apps Script a volte impiega 2-5 secondi a rispondere e il tempo predefinito può non bastare.
  • Se l'invio fallisce, il codice riprova tre volte aspettando 2, 4 e 6 secondi; così si perdono meno dati quando la rete cade per poco.
  • La temporizzazione usa millis(), quindi il ciclo non si blocca mai; puoi aggiungere nello stesso ciclo l'aggiornamento di un display o la lettura di pulsanti.

Timestamp, più sensori e dispositivi

Scrivere il timestamp in Apps Script con new Date() è la soluzione più pratica: l'ESP32 non deve conoscere l'ora e tutti i dispositivi condividono la stessa fonte di tempo. L'unico svantaggio è che il timestamp indica quando il dato è arrivato a Google, non l'istante della misura; la differenza di solito è di pochi secondi. Se accumuli letture e le invii a blocchi, prendi l'ora sull'ESP32 con NTP e aggiungila al JSON come campo ts. Per aggiungere un sensore basta cambiare tre punti: il campo nel testo JSON dell'ESP32, una riga num(data.nuovo) nell'array di appendRow in Apps Script e l'intestazione nel foglio. Più ESP32 possono scrivere nello stesso foglio; dai a ogni scheda un nome DEVICE diverso e potrai filtrare le righe per quella colonna o aprire una scheda per dispositivo.

Creare un grafico in tempo reale in Google Sheets

  1. Seleziona le colonne intere dalla A alla D facendo clic sulle lettere di colonna, non sulle intestazioni (A:D); così le nuove righe entrano da sole nel grafico.
  2. Apri Inserisci > Grafico e nell'editor scegli il tipo Grafico a linee.
  3. Lascia la colonna Ora come asse X e Temperatura e Umidità come serie; togli la colonna Dispositivo dalle serie.
  4. Poiché la luce va da 0 a 4095 schiaccia le altre curve; mostrala in un grafico separato o sull'asse destro da Personalizza > Serie.
  5. Con Pubblica grafico dai tre puntini in alto a destra del grafico ottieni un link che mostra il grafico senza aprire il foglio.

Quote e limiti: ogni quanto puoi inviare dati?

LimiteValoreCosa significa in pratica
Numero di celle10 milioni di celle per foglio di calcoloContano anche le colonne vuote; elimina quelle inutilizzate
Esecuzioni simultaneeCirca 30 per utenteMolti dispositivi che inviano nello stesso secondo possono ricevere errori
Tempo di esecuzione6 minuti per chiamataNessun problema per appendRow
Tempo di rispostaDi solito 1-5 secondiNon adatto a più letture al secondo
Intervallo consigliato1 minuto o piùPiù che sufficiente per monitorare casa o serra

Rendiamo concreto il limite di celle. Una riga al minuto fa 1440 righe al giorno. Se nel foglio lasci solo 5 colonne, usi 7200 celle al giorno e i 10 milioni di celle durano circa 3,8 anni. Se non elimini le 26 colonne predefinite di un foglio nuovo, ogni riga conta 26 celle e lo stesso limite si raggiunge in circa 9 mesi. Per registrazioni lunghe, aprire una nuova scheda ogni anno o spostare i dati vecchi in un altro file mantiene anche il foglio veloce; un foglio con centinaia di migliaia di righe si apre lentamente sul telefono.

Gestione degli errori: cosa significano i codici HTTP?

Nel Monitor serialeSignificatoCosa fare
HTTP 200 + "ok":trueRiga aggiuntaTutto a posto
HTTP 200 + unauthorizedIl TOKEN non coincide o manca la proprietàConfronta il codice con le proprietà dello script
HTTP 302Il redirect non è stato seguitoAggiungi la riga setFollowRedirects
HTTP 401 / 403 o pagina di accesso HTMLL'accesso non è su "Chiunque"Modifica il deployment e imposta l'accesso
HTTP 404URL errato o deployment archiviatoCopia l'URL attuale che termina con /exec
Codice negativo (-1, -11)Nessuna connessione o timeoutControlla il segnale WiFi e il valore di setTimeout

Su un dispositivo che lavora a lungo, le interruzioni di rete sono inevitabili. Per quelle brevi basta il ciclo a tre tentativi del codice. Se non vuoi perdere dati durante interruzioni di ore, accumula le letture in un array o in un file nella flash dell'ESP32 e inviale in ordine quando torna la connessione. Se non riesci proprio a collegarti al WiFi, i passi dell'articolo l'ESP32 non si connette al WiFi ti aiutano a trovare la causa.

Tenere segreto l'URL dell'app web

  • Poiché l'accesso è su "Chiunque", chi conosce l'URL può aggiungere righe; togli sempre URL e chiave prima di condividere il codice online.
  • Non andare mai online senza il controllo del TOKEN; le richieste senza chiave vengono rifiutate senza toccare il foglio.
  • Se metti password WiFi, URL e chiave in un file separato secrets.h incluso con #include, è facile lasciarlo fuori quando condividi il codice.
  • Se l'URL è trapelato, archivia il vecchio deployment da Gestisci deployment, creane uno nuovo e cambia il TOKEN.
  • Non serve condividere il foglio con "chiunque abbia il link"; l'app web gira con il tuo account, quindi il foglio può restare privato.

ThingSpeak e altre alternative

MetodoPunto di forzaPunto debole
Google SheetsGratis, interfaccia nota, formule e condivisione faciliRisposte lente, non adatto a dati più frequenti di uno al minuto
ThingSpeakGrafici pronti, analisi MATLAB, API HTTP sempliceNel piano gratuito almeno 15 s tra gli invii, 8 campi per canale
MQTT + Home AssistantIstantaneo, bidirezionale, si integra con la domoticaServe un server sempre acceso in casa
BlynkInterfaccia per telefono pronta, notificheIl piano gratuito limita dispositivi e dati
Scheda SDNon serve internet, registrazione velocissimaNon puoi vedere i dati a distanza

Quale scegliere? Se vuoi modificare i dati in un foglio, elaborarli con le formule o condividerli, Google Sheets è imbattibile. Se ti basta guardare i grafici, le dashboard pronte di ThingSpeak richiedono meno lavoro. Se hai già un sistema domotico, MQTT con Home Assistant è l'opzione più flessibile. Se preferisci lavorare con Excel sul computer, guarda il metodo via porta seriale in inviare dati da Arduino a Excel, e per i luoghi senza internet la registrazione su scheda SD.

Idee di progetti con ESP32 e Google Sheets

  • Diario della serra: scrivi nel foglio temperatura, umidità dell'aria e del terreno ogni 10 minuti e decidi l'irrigazione in base allo storico.
  • Stazione esterna a batteria: risveglia l'ESP32 dal deep sleep ogni 15 minuti, invia la lettura e rimettilo a dormire.
  • Contatore di porta e movimento: registra ogni apertura della porta o rilevamento PIR con il timestamp e crea il grafico dei totali giornalieri.
  • Monitoraggio dei consumi elettrici: invia la lettura di un sensore di corrente come media al minuto e calcola i kWh con una formula nel foglio.
  • Esperimento in classe: più schede degli studenti scrivono nello stesso foglio con nomi DEVICE diversi e confrontate insieme i risultati.
I numeri scritti nel foglio non dipendono dalle impostazioni locali: la funzione num() di Apps Script trasforma il testo in un numero vero, quindi anche in un foglio impostato in italiano 23.5 viene salvato come decimale e appare correttamente nel grafico. Se invii e scrivi i valori come testo, la confusione tra virgola e punto può lasciare il grafico vuoto.

Una volta capito come scrivere dati su Google Sheets, ogni progetto con l'ESP32 diventa un piccolo dispositivo IoT con storico delle misure e grafico. Nell'app BlueGrays trovi progetti con l'ESP32 come la connessione WiFi, temperatura e umidità con il DHT22, l'ora NTP, il meteo con HTTPClient e il deep sleep, ognuno con schema e codice passo passo, a cui aggiungere la registrazione su Google Sheets di questo articolo.

Domande frequenti

Come si inviano dati dall'ESP32 a Google Sheets?

Scrivi una funzione doPost in un progetto Google Apps Script collegato al foglio e lo pubblichi come app web. L'ESP32 usa WiFiClientSecure e HTTPClient per inviare una richiesta HTTPS POST con JSON all'URL /exec dell'app, e la funzione aggiunge una nuova riga con appendRow.

Serve una chiave API di Google Sheets?

Con il metodo dell'app web di Apps Script non servono chiavi API né configurazioni OAuth. Lo script gira con il tuo account e scrive lui stesso nel foglio. Per la sicurezza basta controllare una chiave segreta (TOKEN) scelta da te.

Perché l'ESP32 riceve un errore 302 da Google Sheets?

L'app web di Apps Script risponde prima alla richiesta POST con un redirect 302. HTTPClient sull'ESP32 non segue i redirect per impostazione predefinita, quindi vedi il codice 302. Aggiungendo http.setFollowRedirects(HTTPC_STRICT_FOLLOW_REDIRECTS) ricevi la risposta vera.

Ogni quanto posso inviare dati a Google Sheets?

Ogni richiesta richiede 1-5 secondi e le esecuzioni simultanee sono limitate, quindi conviene inviare una volta al minuto o meno. Un foglio contiene fino a 10 milioni di celle; una riga da 5 colonne al minuto dura circa 3,8 anni. Se ti servono più letture al secondo, fai la media sull'ESP32 e invia a blocchi.

Ho cambiato il codice Apps Script ma l'ESP32 riceve il vecchio risultato. Perché?

Un'app web esegue la versione pubblicata; salvare il codice non basta. In Esegui il deployment > Gestisci deployment modifica il deployment esistente e scegli Nuova versione. Se crei un nuovo deployment, l'URL cambia e devi aggiornarlo anche sull'ESP32.

Meglio ThingSpeak o Google Sheets?

Se vuoi grafici pronti e una semplice dashboard IoT, ThingSpeak si configura prima, ma il piano gratuito impone almeno 15 secondi tra gli invii e 8 campi per canale. Se vuoi elaborare, modificare e condividere i dati con le formule, Google Sheets è più flessibile.

Vedi tutti i progetti
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 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
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
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
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
ESP32 Deep Sleep — Risparmio della batteria (OLED + contatore in RTC RAM)
ES-33Avanzato
Premium

ESP32 Deep Sleep — Risparmio della batteria (OLED + contatore in RTC RAM)

La modalità Deep Sleep dell'ESP32 spegne la CPU e quasi tutte le periferiche e riduce il consumo a circa 10µA, un aspetto cruciale per i dispositivi IoT a batteria. Il progetto usa tre sorgenti di risveglio: un timer (15 s), un pin esterno (EXT0, il pulsante su GPIO 33) e un pin touch (T0/GPIO 4). I contatori marcati con RTC_DATA_ATTR restano salvati durante il deep sleep.

4.3(10)
16
Lettura dell'intensità luminosa con il modulo LDR ESP32
ES-11Principiante

Lettura dell'intensità luminosa con il modulo LDR ESP32

Monitoraggio in tempo reale sul Serial Monitor del valore grezzo dell'ADC del modulo LDR e della percentuale relativa di luce calcolata dai valori di riferimento al buio e alla luce. Questa percentuale non è una misurazione in lux. Spiega il principio di calibrazione del modulo. È consigliabile eseguirlo prima del Progetto 10, poiché serve a determinare il valore di soglia.

4.6(36)
55