Inviare dati da Arduino a Excel: Data Streamer, PLX-DAQ e Python

Inviare dati da Arduino a Excel significa mandare al computer, tramite il cavo USB, i valori che Arduino legge dai suoi sensori e raccoglierli riga per riga in un foglio di calcolo. Arduino scrive ogni misura sulla porta seriale come un'unica riga separata da virgole; sul computer ci sono quattro modi diffusi per portare queste righe in Excel: salvare l'uscita del monitor seriale come CSV, il componente aggiuntivo Data Streamer di Microsoft, la macro PLX-DAQ e la registrazione automatica con Python. Il principio è sempre lo stesso: ogni riga inviata da Arduino diventa una riga di Excel e ogni virgola apre una nuova colonna.

In questa guida usiamo come esempio un sensore di temperatura e umidità DHT11 e un sensore di luce LDR. Prima confrontiamo i quattro metodi, così puoi scegliere quello più adatto a te, poi li configuriamo uno per uno, passo dopo passo. Vedrai poi come aggiungere un timestamp alle misure, come scegliere il tipo di grafico giusto in Excel e come preparare una tabella delle misure per la relazione di laboratorio da usare a scuola o a una fiera della scienza. Nelle ultime sezioni imparerai a fare lo stesso con un ESP32 e un Raspberry Pi Pico e a risolvere gli errori più comuni.

Come funziona l'invio di dati da Arduino a Excel?

Arduino non può scrivere direttamente in Excel; si limita a inviare testo sulla porta seriale con Serial.print(). Il computer raggiunge questa porta con un nome come COM3 su Windows, /dev/cu.usbmodem… su macOS o /dev/ttyACM0 su Linux. La lingua comune tra Excel e Arduino è il CSV (Comma Separated Values, valori separati da virgole): una riga come 12.0,23.0,45,78 viene divisa in quattro colonne. Il tuo sketch deve quindi rispettare solo due regole: metti sempre lo stesso separatore tra i valori e termina ogni misura con Serial.println(). Trovi le basi della porta seriale spiegate in dettaglio nella guida al monitor seriale di Arduino.

Circuito di esempio: collegare il DHT11 e la LDR

Il circuito di esempio ha due sensori. Il DHT11 misura la temperatura con una risoluzione di 1 °C e l'umidità con una risoluzione dell'1 %; la sua precisione è di circa ±2 °C e ±5 % di umidità relativa, e gli basta un solo pin dati. La LDR è una fotoresistenza la cui resistenza diminuisce quando la luce aumenta; con una resistenza da 10 kΩ realizzi un partitore di tensione e colleghi il punto centrale a un ingresso analogico. Con il collegamento qui sotto, il valore analogico sale quando c'è più luce. Il numero fornito da una LDR non è in lux ma è un livello di luce relativo, quindi è corretto indicarlo nella relazione come "luce (%)". Se ti servono lux veri, usa un sensore di luce calibrato come il BH1750.

Codice Arduino: inviare le misure come righe CSV

1// DHT11 + LDR ölçümlerini CSV satırı olarak gönderir / Sends DHT11 + LDR readings as CSV lines
2#include <DHT.h>
3
4const int DHT_PIN = 2;                 // DHT11 veri pini / DHT11 data pin
5const int LDR_PIN = A0;                // LDR + 10k gerilim bölücü / LDR + 10k voltage divider
6const unsigned long ARALIK = 2000;     // ölçüm aralığı, ms (DHT11 için en az 1000) / interval in ms (at least 1000 for DHT11)
7
8DHT dht(DHT_PIN, DHT11);               // DHT22 kullanıyorsan DHT22 yaz / write DHT22 if you use one
9unsigned long sonOlcum = 0;
10
11void setup() {
12  Serial.begin(9600);                  // Data Streamer ve PLX-DAQ varsayılanı / default of Data Streamer and PLX-DAQ
13  dht.begin();
14  Serial.println("zaman_s,sicaklik_C,nem_yuzde,isik_yuzde");   // başlık satırı / header row
15}
16
17void loop() {
18  if (millis() - sonOlcum < ARALIK) return;   // zamanı gelmediyse çık / not time yet
19  sonOlcum = millis();
20
21  float sicaklik = dht.readTemperature();     // santigrat derece / degrees Celsius
22  float nem = dht.readHumidity();             // bağıl nem, % / relative humidity, %
23  int isik = map(analogRead(LDR_PIN), 0, 1023, 0, 100);   // göreli ışık, % / relative light, %
24
25  if (isnan(sicaklik) || isnan(nem)) {
26    Serial.println("HATA,DHT okunamadi");     // sayı olmadığı için kolay ayıklanır / easy to filter out, not a number
27    return;
28  }
29
30  Serial.print(sonOlcum / 1000.0, 1);         // açılıştan beri geçen saniye / seconds since power-up
31  Serial.print(',');                          // sütun ayırıcı / column separator
32  Serial.print(sicaklik, 1);
33  Serial.print(',');
34  Serial.print(nem, 0);
35  Serial.print(',');
36  Serial.println(isik);                       // satır sonu = yeni Excel satırı / line end = new Excel row
37}

Lo sketch usa la DHT sensor library di Adafruit; quando la installi dal gestore librerie, accetta di installare anche la sua dipendenza, Adafruit Unified Sensor. Le misure vengono prese ogni 2 secondi e temporizzate con millis() invece di delay(), così loop() non si blocca mai (dettagli nella guida a millis e delay). Ogni riga contiene, in quest'ordine, le colonne tempo, temperatura, umidità e luce. Serial.print(sicaklik, 1) scrive il numero con un decimale e sempre con il punto. Se il sensore non risponde, lo sketch scrive "HATA" (errore) al posto di un numero, così individui subito la riga difettosa nella tabella e puoi filtrarla. La riga di intestazione in setup() è comoda per il monitor seriale e per Python; se usi Data Streamer puoi cancellarla. Per grandezze che cambiano lentamente, come la temperatura di una stanza, imposta ARALIK (intervallo) a 60000 per fare una misura al minuto.

Metodo 1: salvare l'uscita del monitor seriale come CSV

1. Carica lo sketch, apri Strumenti > Monitor seriale e scegli 9600 baud nel menu della velocità.
2. Se vuoi, attiva il timestamp: in Arduino IDE 2 fai clic sull'icona dell'orologio in alto a destra nella finestra; nell'IDE 1.8 sulla casella del timestamp in basso. All'inizio di ogni riga viene aggiunta l'ora del computer nel formato 14:03:21.512 ->.
3. Alla fine dell'esperimento, seleziona le righe con il mouse e copiale con Ctrl+C (Cmd+C su macOS). Se vuoi conservare i dati grezzi, incollali nel Blocco note e salvali come olcum.csv scegliendo il tipo Tutti i file.
4. In Excel, fai clic sulla cella A1 di un foglio vuoto e incolla con Ctrl+V; tutte le righe finiscono nella colonna A.
5. Con la colonna A selezionata, apri Dati > Testo in colonne, scegli Delimitati e spunta Virgola come separatore. Se il timestamp è attivo, spunta anche Spazio: l'ora va nella prima colonna e i segni "->" nella seconda, che poi elimini.
6. Nell'ultimo passaggio fai clic su Avanzate e imposta il punto come separatore decimale; così l'Excel italiano riconosce valori come 23.5 come numeri. Fai clic su Fine e salva il file in formato .xlsx.

Questo metodo è molto pratico fino a qualche centinaio di righe; con migliaia di righe la selezione diventa scomoda e la finestra dell'IDE rallenta. Per registrazioni di ore, programmi terminale come PuTTY (Session > Logging > All session output) o CoolTerm, che funziona su Windows, macOS e Linux (Connection > Capture to Text/Binary File), scrivono ogni riga ricevuta direttamente in un file. Poi porti quel file in Excel con gli stessi passaggi. Ricorda: finché un programma terminale o il monitor seriale usa la porta, né i componenti aggiuntivi di Excel né Python possono collegarsi.

Metodo 2: dati in diretta con Excel Data Streamer

Data Streamer è un componente aggiuntivo gratuito che Microsoft ha creato per la didattica; fa scorrere le righe CSV della porta seriale direttamente in un foglio di lavoro. È incluso nell'Excel desktop di Microsoft 365 (versione 1902 e successive), quindi basta attivarlo. Essendo un componente aggiuntivo COM, funziona solo su Windows; non esiste in Excel per macOS né in Excel per il web. Sul lato Arduino non devi cambiare nulla: lo sketch qui sopra funziona così com'è a 9600 baud, la velocità predefinita del componente.

1. In Excel, apri File > Opzioni > Componenti aggiuntivi, scegli Componenti aggiuntivi COM nell'elenco Gestisci in basso e fai clic su Vai.
2. Spunta Microsoft Data Streamer for Excel e fai clic su OK; nella barra multifunzione compare la scheda Data Streamer.
3. Chiudi il monitor seriale dell'Arduino IDE; una porta seriale può essere aperta da un solo programma alla volta.
4. Con il pulsante Connect a Device scegli la porta COM di Arduino, poi fai clic su Start Data. A seconda della lingua di Excel, i pulsanti possono apparire tradotti.
5. Excel crea tre fogli: Data In (dati in ingresso), Data Out (dati da inviare ad Arduino) e Settings (impostazioni). Nel foglio Settings imposta Data Channels a 4 e aumenta Data Rows per vedere più storico nella tabella.
6. Per una registrazione permanente, avvia la registrazione con Record Data; quando la fermi con Stop Recording, le misure sono salvate in un file CSV. Più tardi puoi riprodurre quel file con Import Data File.

Nella parte alta del foglio Data In ci sono i valori più recenti (Current Data) e, sotto, una tabella in cui scorrono le misure precedenti (Historical Data). Se selezioni questa tabella e aggiungi un grafico a linee o a dispersione con Inserisci > Grafici consigliati, il grafico si aggiorna da solo a ogni nuovo dato; è ideale per mostrare alla classe come la curva della luce crolla appena metti la mano sopra il sensore. Nel foglio Settings, Data Interval (ms) stabilisce ogni quanto si aggiorna il foglio e Data Orientation se i dati più recenti compaiono in cima o in fondo alla tabella. Anche i valori che scrivi nel foglio Data Out vengono inviati ad Arduino come riga CSV; Arduino può leggerli con Serial.parseInt(), così puoi per esempio impostare una soglia di allarme da Excel.

Metodo 3: scrivere in Excel riga per riga con la macro PLX-DAQ

PLX-DAQ (Parallax Data Acquisition) è una macro VBA che gira dentro Excel e trasforma in celle alcuni comandi speciali che arrivano dalla porta seriale. Poiché la versione originale di Parallax funziona solo con Excel a 32 bit, oggi si usa PLX-DAQ v2, sviluppata dalla comunità Arduino; supporta Excel a 64 bit ed è un unico file .xlsm. Dato che la macro si basa sulle API di Windows, anche questa funziona solo su Windows. La differenza rispetto a Data Streamer è che qui è Arduino a comandare Excel: scrive le intestazioni, svuota il foglio e fa aggiungere a Excel la data e l'ora.

1// PLX-DAQ v2: Excel'e tarih, saat ve ölçüm satırı yazar / PLX-DAQ v2: writes date, time and readings into Excel
2#include <DHT.h>
3
4DHT dht(2, DHT11);                     // DHT11 veri pini D2 / DHT11 data pin D2
5const int LDR_PIN = A0;
6
7void setup() {
8  Serial.begin(9600);                  // PLX-DAQ'ta da 9600 seç / choose 9600 in PLX-DAQ too
9  dht.begin();
10  Serial.println("CLEARDATA");         // eski ölçümleri sil / clear old readings
11  Serial.println("LABEL,Tarih,Saat,Sure (s),Sicaklik (C),Nem (%),Isik (%)");   // 1. satır başlıkları / row 1 headers
12  Serial.println("RESETTIMER");        // TIMER sayacını sıfırla / reset the TIMER counter
13}
14
15void loop() {
16  float sicaklik = dht.readTemperature();
17  float nem = dht.readHumidity();
18  int isik = map(analogRead(LDR_PIN), 0, 1023, 0, 100);
19
20  if (!isnan(sicaklik) && !isnan(nem)) {
21    Serial.print("DATA,DATE,TIME,TIMER,");   // DATE, TIME, TIMER'ı Excel doldurur / Excel fills in DATE, TIME, TIMER
22    Serial.print(sicaklik, 1);
23    Serial.print(',');
24    Serial.print(nem, 0);
25    Serial.print(',');
26    Serial.println(isik);
27  }
28  delay(2000);                         // DHT11 saniyede en fazla 1 ölçüm verir / DHT11 gives at most 1 reading per second
29}

1. Scarica il file di PLX-DAQ v2 ed estrailo dallo zip. Fai clic destro sul file .xlsm e, in Proprietà, spunta la casella Annulla blocco; Office blocca per impostazione predefinita le macro dei file scaricati da internet.
2. Apri il file e fai clic su Abilita contenuto nella barra gialla in alto.
3. Chiudi il monitor seriale dell'Arduino IDE e fai clic sul pulsante Open PLX DAQ UI nel foglio.
4. Nella finestra che si apre, scrivi nella casella Port solo il numero della COM (5 per COM5), scegli 9600 come Baud e fai clic su Connect.
5. Se le intestazioni non compaiono, premi il pulsante di reset di Arduino: setup() riparte, i comandi CLEARDATA e LABEL arrivano a Excel e le righe iniziano a scorrere.
6. Quando hai finito, fai clic su Disconnect e, se vuoi, salva i dati in un file .xlsx separato.

Metodo 4: file CSV ed Excel automatici con Python

Se usi un Mac o Linux, devi registrare per ore o sei stanco di preparare ogni volta il report a mano, Python è la strada più flessibile. Per prima cosa installa i due pacchetti da terminale con python -m pip install pyserial openpyxl. Il primo script qui sotto ascolta Arduino e scrive ogni misura, insieme all'ora del computer, nel file deney_olcumleri.csv. Argomenti come trovare la porta, il reset automatico e i grafici in diretta li abbiamo spiegati in dettaglio nella guida alla comunicazione seriale tra Arduino e Python.

1import csv
2import time
3from datetime import datetime
4
5import serial
6
7PORT = "COM3"               # macOS: /dev/cu.usbmodem…, Linux: /dev/ttyACM0
8BAUD = 9600                 # Arduino'daki Serial.begin ile aynı / same as Serial.begin on the Arduino
9DOSYA = "deney_olcumleri.csv"
10AYIRICI = ";"               # Türkçe Excel ; bekler, İngilizce Excel , / Turkish Excel expects ;, English Excel ,
11ONDALIK = ","               # Türkçe Excel ondalık virgül, İngilizce nokta / decimal comma in Turkish Excel, dot in English
12
13
14def sayi(x):
15    return f"{x:.1f}".replace(".", ONDALIK)   # 23.5 -> "23,5"
16
17
18with serial.Serial(PORT, BAUD, timeout=3) as ser, \
19        open(DOSYA, "w", newline="", encoding="utf-8-sig") as f:   # BOM: Excel Türkçe harfleri doğru gösterir / BOM keeps accents readable
20    time.sleep(2)                       # Uno port açılınca resetlenir / the Uno resets when the port opens
21    ser.reset_input_buffer()            # yarım kalmış satırları at / drop partial lines
22    yazici = csv.writer(f, delimiter=AYIRICI)
23    yazici.writerow(["Zaman", "Süre (s)", "Sıcaklık (°C)", "Nem (%)", "Işık (%)"])
24    print("Kayıt başladı, durdurmak için Ctrl+C / logging, press Ctrl+C to stop")
25    try:
26        while True:
27            satir = ser.readline().decode("utf-8", errors="ignore").strip()
28            parca = satir.split(",")
29            if len(parca) != 4:
30                continue                # boş, hata ya da başlık satırı / empty, error or header line
31            try:
32                sure, sicaklik, nem, isik = (float(p) for p in parca)
33            except ValueError:
34                continue                # sayı olmayan satır / non-numeric line
35            simdi = datetime.now()
36            yazici.writerow([simdi.strftime("%Y-%m-%d %H:%M:%S"),   # bilgisayar saati / PC clock
37                             sayi(sure), sayi(sicaklik), sayi(nem), sayi(isik)])   # süre Arduino'dan gelir / elapsed time comes from the Arduino
38            f.flush()                   # satırı hemen diske yaz / write the row to disk now
39            print(simdi.strftime("%H:%M:%S"), sicaklik, nem, isik)
40    except KeyboardInterrupt:
41        print("Kayıt bitti / logging stopped:", DOSYA)

Tre dettagli dello script garantiscono la compatibilità con Excel. La codifica utf-8-sig aggiunge un BOM invisibile all'inizio del file; senza di esso Excel mostra rovinati caratteri come "°C" o le lettere accentate. Le costanti AYIRICI (separatore) e ONDALIK (decimale) sono impostate su punto e virgola e virgola decimale, quindi vanno già bene per l'Excel italiano; con impostazioni internazionali inglesi basta cambiarle in virgola e punto. f.flush() scrive subito ogni riga sul disco: se il computer si spegne o il cavo si stacca, perdi al massimo l'ultima misura. Dopo aver fermato lo script con Ctrl+C, basta un doppio clic sul file e le colonne si aprono separate correttamente. Se vuoi guardare il file mentre la registrazione è ancora in corso, aprine una copia, perché Excel può bloccare i file che apre.

1import csv
2from datetime import datetime
3
4from openpyxl import Workbook
5from openpyxl.chart import Reference, ScatterChart, Series
6
7GIRIS = "deney_olcumleri.csv"
8CIKIS = "deney_raporu.xlsx"
9
10wb = Workbook()
11ws = wb.active
12ws.title = "Olcumler"
13
14with open(GIRIS, encoding="utf-8-sig", newline="") as f:
15    okuyucu = csv.reader(f, delimiter=";")
16    ws.append(next(okuyucu))                               # başlık satırı / header row
17    for satir in okuyucu:
18        zaman = datetime.strptime(satir[0], "%Y-%m-%d %H:%M:%S")
19        degerler = [float(x.replace(",", ".")) for x in satir[1:]]   # "23,5" -> 23.5
20        ws.append([zaman] + degerler)                      # .xlsx sayıyı sayı olarak saklar / .xlsx stores real numbers
21
22son = ws.max_row
23for hucre in ws["A"][1:]:
24    hucre.number_format = "hh:mm:ss"                       # zaman sütunu biçimi / time column format
25ws.column_dimensions["A"].width = 12
26
27# Özet tablo: formüller İngilizce yazılır, Excel kendi diline çevirir
28# Summary: formulas are written in English, Excel shows them in its own language
29ws["G1"], ws["H1"], ws["I1"], ws["J1"] = "Özet", "Sıcaklık (°C)", "Nem (%)", "Işık (%)"
30for i, (ad, fonk) in enumerate([("Ortalama", "AVERAGE"), ("En düşük", "MIN"),
31                                ("En yüksek", "MAX"), ("Std. sapma", "STDEV")], start=2):
32    ws.cell(row=i, column=7, value=ad)
33    for sutun, harf in ((8, "C"), (9, "D"), (10, "E")):
34        ws.cell(row=i, column=sutun, value=f"={fonk}({harf}2:{harf}{son})")
35
36# Her ölçüm için süre-değer (XY dağılım) grafiği / one time-value (XY scatter) chart per reading
37x = Reference(ws, min_col=2, min_row=2, max_row=son)       # Süre (s) sütunu / elapsed time column
38for sutun, baslik, konum in ((3, "Sıcaklık (°C)", "G8"), (5, "Işık (%)", "G24")):
39    grafik = ScatterChart()
40    grafik.title = baslik + " - süre"
41    grafik.x_axis.title = "Süre (s)"
42    grafik.y_axis.title = baslik
43    grafik.x_axis.delete = False                           # yeni Excel'de eksenler görünsün / keep axes visible
44    grafik.y_axis.delete = False
45    y = Reference(ws, min_col=sutun, min_row=1, max_row=son)
46    grafik.series.append(Series(y, x, title_from_data=True))
47    grafik.width, grafik.height = 18, 8                    # cm
48    ws.add_chart(grafik, konum)
49
50wb.save(CIKIS)
51print(son - 1, "ölçüm yazıldı / readings written:", CIKIS)

Il secondo script converte il CSV in un vero file .xlsx. In un .xlsx i numeri sono salvati come numeri e non come testo, quindi il problema di separatori e decimali sparisce del tutto; il file si apre allo stesso modo in un Excel italiano, inglese o tedesco. Lo script aggiunge anche una tabella riassuntiva con media, minimo, massimo e deviazione standard, oltre a due grafici a dispersione per temperatura e luce. Le formule vengono scritte nel file con i loro nomi inglesi (AVERAGE, MIN, MAX, STDEV) ed Excel le traduce all'apertura: in un Excel italiano vedrai MEDIA, MIN, MAX e DEV.ST. Le righe delete = False evitano un problema per cui le etichette degli assi non compaiono nei grafici creati con le versioni recenti di openpyxl.

Aggiungere un timestamp: millis(), orologio del computer o RTC

Negli esperimenti collegati a un computer la soluzione più semplice è il suo orologio, e il nostro script Python lo scrive in ogni riga. È comunque una buona abitudine conservare anche il tempo inviato da Arduino: mostra l'intervallo reale tra le misure e ti fa notare subito se manca una riga. Se da Arduino invii il valore grezzo di millis(), in Excel lo converti in secondi con =B2/1000 o in minuti con =B2/60000. Se Arduino deve lavorare senza computer, per esempio registrando su una scheda SD, devi prendere data e ora da un modulo orologio RTC; i dettagli della registrazione CSV su scheda SD sono nella guida al modulo scheda SD. Con un ESP32 puoi anche prendere l'ora da internet: ora NTP con l'ESP32.

Creare un grafico in Excel

1. Seleziona le colonne del tempo e della temperatura con le loro intestazioni; se non sono vicine, tieni premuto il tasto Ctrl mentre selezioni la seconda.
2. Scegli un tipo di dispersione con linee da Inserisci > Grafici > Dispersione (X, Y).
3. Con il pulsante + accanto al grafico attiva i Titoli degli assi e dai un nome agli assi con le unità: "Tempo (s)" e "Temperatura (°C)".
4. Per aggiungere la serie della luce, fai clic destro sul grafico e aggiungi la colonna della luce con Seleziona dati > Aggiungi; dato che le scale sono molto diverse, fai clic destro sulla serie e scegli Formato serie dati > Asse secondario.
5. Fai clic destro sull'asse verticale e fissa i valori minimo e massimo in Formato asse, così una variazione di 1 °C non sembrerà un'oscillazione enorme.

Perché un grafico a dispersione e non a linee? Il grafico a Linee di Excel tratta i valori dell'asse orizzontale come etichette equidistanti; se manca una misura o cambi l'intervallo, l'asse del tempo si deforma senza avvisarti. Il grafico a Dispersione (X, Y), invece, colloca ogni punto nel suo tempo reale, ed è proprio ciò che ci si aspetta da un grafico scientifico. Se confronti solo pochi valori fissi, come la temperatura media di tre stanze, un istogramma è più leggibile. Se il sensore è rumoroso, fai clic destro sulla serie e smussa la curva con Aggiungi linea di tendenza > Media mobile.

Esempio di tabella delle misure per la relazione di laboratorio

Supponiamo che la domanda del tuo esperimento sia: "Come cambiano la temperatura, l'umidità e il livello di luce dell'aria vicino a una lampada da scrivania quando la si accende?" Abbiamo messo i sensori a circa 15 cm dalla lampada e impostato ARALIK a 60000 nello sketch, cioè una misura al minuto. Abbiamo acceso la lampada al minuto 1 e l'abbiamo spenta al minuto 6. I valori qui sotto sono valori di esempio tipici che puoi ottenere con questo montaggio; le ultime due righe sono riepiloghi calcolati con formule di Excel:

Le righe di riepilogo si calcolano in Excel con =MEDIA(B2:B10), =MIN(B2:B10) e =MAX(B2:B10); per mostrare quanto sono disperse le misure puoi aggiungere anche =DEV.ST(B2:B10). Quando interpreti i risultati, descrivi l'andamento della tabella: appena la lampada si è accesa, la luce è salita dal 14 % all'81 %, mentre la temperatura è salita lentamente di 3 °C in circa 3 minuti; questo si chiama inerzia termica. Quando la lampada si è spenta, la luce è calata subito, ma la temperatura è rimasta alta ancora per qualche minuto. L'umidità relativa è diminuita mentre la temperatura saliva, perché l'aria più calda può contenere più vapore acqueo anche se la quantità d'acqua che contiene non cambia. Una lampadina a incandescenza o alogena mostra bene questo effetto; con una lampada LED l'aumento di temperatura è molto più piccolo.

• Scopo: la domanda di ricerca e la tua ipotesi in una frase.
• Materiali: modello di scheda, sensori, resistenze e software usati (Arduino IDE, Excel).
• Procedimento: posizione dei sensori, intervallo di misura (per esempio 60 s), durata dell'esperimento e metodo usato per portare i dati in Excel.
• Tabella delle misure: ogni intestazione di colonna deve riportare l'unità; nel testo usa la tabella riassuntiva e allega tutti i dati grezzi in appendice.
• Grafico: un grafico a dispersione con titoli degli assi, unità ed eventi segnati (lampada accesa, spenta).
• Conclusioni e fonti di errore: confronta i risultati con l'ipotesi e indica i limiti, come la precisione di ±2 °C del DHT11, la LDR non calibrata e la distanza del sensore dalla lampada.

Inviare i dati dell'ESP32 a Excel

Sull'ESP32 tutti i metodi funzionano allo stesso modo; per Data Streamer e PLX-DAQ l'ESP32 è semplicemente un'altra porta seriale. Cambiano tre cose: la lettura analogica è a 12 bit (0–4095), il partitore della LDR si alimenta a 3,3 V e come ingresso analogico conviene scegliere uno dei pin ADC1 (GPIO 32–39), perché funzionano anche con il Wi-Fi attivo. Le schede ESP32 si usano di solito a 115200 baud, quindi cambia la velocità nello script Python, in Data Streamer e in PLX-DAQ. I messaggi del bootloader che compaiono sulla porta seriale all'avvio non sono numeri, quindi lo script Python li salta comunque. Se vuoi inviare le misure al cloud senza collegare nulla a un computer, dai un'occhiata alla guida per registrare i dati dell'ESP32 su Fogli Google.

1// ESP32: aynı CSV çıktısı, 12 bit ADC ve 3,3 V / ESP32: same CSV output, 12-bit ADC and 3.3 V
2#include <DHT.h>
3
4const int DHT_PIN = 4;                 // güvenli bir GPIO / a safe GPIO
5const int LDR_PIN = 34;                // ADC1 pini, Wi-Fi açıkken de okur / ADC1 pin, still reads with Wi-Fi on
6DHT dht(DHT_PIN, DHT11);
7
8void setup() {
9  Serial.begin(115200);                // Python'da ve Data Streamer'da da 115200 / 115200 in Python and Data Streamer too
10  dht.begin();
11  analogReadResolution(12);            // 0-4095
12}
13
14void loop() {
15  float sicaklik = dht.readTemperature();
16  float nem = dht.readHumidity();
17  int isik = map(analogRead(LDR_PIN), 0, 4095, 0, 100);   // göreli ışık, % / relative light, %
18
19  if (!isnan(sicaklik) && !isnan(nem)) {
20    // zaman_s,sicaklik,nem,isik biçimi, Uno koduyla aynı / same zaman_s,temp,hum,light format as the Uno sketch
21    Serial.printf("%.1f,%.1f,%.0f,%d\n", millis() / 1000.0, sicaklik, nem, isik);
22  }
23  delay(2000);
24}

Registrazione CSV con il Raspberry Pi Pico (MicroPython)

Se usi MicroPython su un Raspberry Pi Pico, puoi scrivere le misure in un file CSV nella memoria flash della scheda invece di inviarle a un computer; così il computer non serve e puoi lasciare il Pico, alimentato da un power bank, dove vuoi misurare. Il codice qui sotto usa il sensore di temperatura integrato (ADC4), che non richiede hardware aggiuntivo, e una LDR collegata a GP26, e scrive il file con punto e virgola e virgola decimale, adatto all'Excel italiano. Dato che il sensore integrato misura la temperatura del chip, può segnare qualche grado in più rispetto all'ambiente; per misure precise usa un sensore esterno. Se sei alle prime armi con MicroPython, parti dalla guida Che cos'è il Raspberry Pi Pico.

1import os
2import time
3
4import machine
5
6ldr = machine.ADC(26)                 # GP26 = ADC0, LDR + 10k bölücü / LDR + 10k divider
7ic_sensor = machine.ADC(4)            # yongadaki sıcaklık sensörü / on-chip temperature sensor
8DOSYA = "olcum.csv"
9ARALIK_S = 10                         # ölçüm aralığı, saniye / interval in seconds
10
11
12def tr(x):
13    return "{:.1f}".format(x).replace(".", ",")   # Türkçe Excel için ondalık virgül / decimal comma for Turkish Excel
14
15
16try:
17    os.stat(DOSYA)                    # dosya varsa silme, sonuna ekle / keep an existing file, append to it
18except OSError:
19    with open(DOSYA, "w") as f:
20        f.write("Sure (s);Sicaklik (C);Isik (%)\n")   # ASCII başlık / ASCII header
21
22baslangic = time.ticks_ms()
23while True:
24    volt = ic_sensor.read_u16() * 3.3 / 65535
25    sicaklik = 27 - (volt - 0.706) / 0.001721       # RP2040 veri sayfası formülü / RP2040 datasheet formula
26    isik = ldr.read_u16() * 100 / 65535             # göreli ışık, % / relative light, %
27    sure = time.ticks_diff(time.ticks_ms(), baslangic) / 1000
28    satir = "{};{};{}".format(tr(sure), tr(sicaklik), tr(isik))
29    print(satir)                                    # Thonny kabuğunda da görünür / also shown in the Thonny shell
30    with open(DOSYA, "a") as f:                     # her satırda aç-kapat / open and close for every line
31        f.write(satir + "\n")                       # elektrik kesilse de veri kalır / data survives a power cut
32    time.sleep(ARALIK_S)

Se salvi il codice sul Pico da Thonny con il nome main.py, la scheda inizia a registrare da sola a ogni accensione; se il file esiste già non viene cancellato e le nuove righe si aggiungono in fondo. Finita la misura, collega il Pico al computer, fai clic su Stop in Thonny, fai clic destro su olcum.csv nel pannello Visualizza > File, scaricalo sul computer e aprilo in Excel. Con una riga di circa 20 byte ogni 10 secondi, il file cresce di circa 170 KB al giorno; nel file system del Pico c'è quindi spazio in abbondanza per diversi giorni di registrazione. Se il tuo Excel usa il punto decimale, basta togliere la chiamata a replace() nella funzione tr().

Errori comuni e soluzioni

Idee di progetto con la registrazione dei dati in Excel

• Curva di raffreddamento: misura come si raffredda un bicchiere d'acqua calda con un DS18B20 impermeabile, aggiungi in Excel una linea di tendenza esponenziale e studia la legge di raffreddamento di Newton.
• Mini stazione meteo: registra temperatura, umidità e pressione con un BME280 per una settimana e mostra con un grafico la differenza tra giorno e notte.
• Diario di irrigazione: salva il valore del sensore di umidità del terreno prima e dopo l'annaffiatura e scopri quanto tempo impiega il terreno ad asciugarsi.
• Analisi del moto: costruisci una tabella spazio-tempo con un HC-SR04 e calcola in Excel velocità e accelerazione dalle differenze tra righe consecutive.
• Curva di scarica di una pila: misura la tensione di una pila con un partitore di tensione, registrala per ore e studia come cala nel tempo.
• Progetto per la fiera della scienza: confronta quanto si scaldano al sole scatole di colori diversi; per altre idee guarda la guida con le idee di progetto con Arduino per fiere della scienza.

Qualunque metodo tu scelga, la base è la stessa: produci su Arduino righe CSV pulite e coerenti e portale in Excel sul computer con il separatore giusto. Il monitor seriale è il migliore per un controllo veloce, Data Streamer per una dimostrazione in diretta in classe, PLX-DAQ per comandare Excel da Arduino e Python per registrazioni lunghe e automatiche. Nell'app BlueGrays trovi progetti come la misura di temperatura e umidità con il DHT11, la lettura dell'intensità luminosa con una LDR e un registratore di temperatura con ESP32, passo dopo passo con schemi e codice, e puoi inviare a Excel i dati che misuri con questi metodi.