Arduino Daten in Excel übertragen: Data Streamer, PLX-DAQ, Python

Arduino Daten in Excel zu übertragen heißt, die Werte, die der Arduino von seinen Sensoren liest, über das USB-Kabel an den Computer zu schicken und dort Zeile für Zeile in einer Excel-Tabelle zu sammeln. Der Arduino schreibt jede Messung als eine einzige, durch Kommas getrennte Zeile auf die serielle Schnittstelle; am Computer gibt es vier verbreitete Wege, diese Zeilen nach Excel zu bringen: die Ausgabe des seriellen Monitors als CSV speichern, das Add-in Data Streamer von Microsoft, das PLX-DAQ-Makro und die automatische Aufzeichnung mit Python. Das Prinzip ist immer gleich: Jede Zeile, die der Arduino sendet, wird in Excel zu einer Zeile, und jedes Komma beginnt eine neue Spalte.

In dieser Anleitung verwenden wir als Beispiel einen DHT11-Temperatur- und Feuchtigkeitssensor und einen LDR-Lichtsensor. Zuerst vergleichen wir die vier Methoden, damit du die passende auswählen kannst, dann richten wir jede Schritt für Schritt ein. Danach siehst du, wie du deinen Messwerten Zeitstempel hinzufügst, in Excel den richtigen Diagrammtyp wählst und eine Messtabelle für das Versuchsprotokoll erstellst, die du in der Schule oder bei Jugend forscht verwenden kannst. In den letzten Abschnitten erfährst du, wie das Gleiche mit einem ESP32 und einem Raspberry Pi Pico funktioniert und wie du die häufigsten Fehler behebst.

Wie funktioniert die Übertragung von Arduino-Daten nach Excel?

Der Arduino kann nicht direkt in Excel schreiben; er sendet mit Serial.print() nur Text an die serielle Schnittstelle. Der Computer erreicht diese Schnittstelle unter Windows unter einem Namen wie COM3, unter macOS als /dev/cu.usbmodem… und unter Linux als /dev/ttyACM0. Die gemeinsame Sprache von Excel und Arduino ist CSV (Comma Separated Values, kommagetrennte Werte): Eine Zeile wie 12.0,23.0,45,78 wird in vier Spalten aufgeteilt. Dein Sketch muss deshalb nur zwei Regeln einhalten: Setze zwischen die Werte immer dasselbe Trennzeichen und beende jede Messung mit Serial.println(). Die Grundlagen der seriellen Schnittstelle findest du ausführlich in der Anleitung zum Arduino Serial Monitor.

Beispielschaltung: DHT11 und LDR anschließen

Die Beispielschaltung hat zwei Sensoren. Der DHT11 misst die Temperatur mit 1 °C und die Luftfeuchtigkeit mit 1 % Auflösung; seine Genauigkeit liegt bei etwa ±2 °C und ±5 % relativer Feuchte, und er braucht nur einen Datenpin. Der LDR ist ein Fotowiderstand, dessen Widerstand bei mehr Licht sinkt; du baust mit einem 10-kΩ-Widerstand einen Spannungsteiler und verbindest den Mittelpunkt mit einem Analogpin. Mit der Verdrahtung unten steigt der Analogwert, wenn es heller wird. Die Zahl, die ein LDR liefert, ist kein Lux-Wert, sondern eine relative Helligkeit; im Protokoll solltest du sie ehrlicherweise als "Licht (%)" bezeichnen. Brauchst du echte Lux-Werte, nimm einen kalibrierten Lichtsensor wie den BH1750.

Arduino-Code: Messwerte als CSV-Zeilen senden

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}

Der Sketch nutzt die DHT sensor library von Adafruit; wenn du sie über die Bibliotheksverwaltung installierst, bestätige auch die Abhängigkeit Adafruit Unified Sensor. Die Messungen erfolgen alle 2 Sekunden und werden mit millis() statt delay() getaktet, sodass loop() nie blockiert (Details in der Anleitung zu millis und delay). Jede Zeile enthält der Reihe nach die Spalten Zeit, Temperatur, Feuchtigkeit und Licht. Serial.print(sicaklik, 1) gibt die Zahl mit einer Nachkommastelle und immer mit Punkt aus. Kann der Sensor nicht gelesen werden, schreibt der Sketch "HATA" (Fehler) statt einer Zahl, sodass du die fehlerhafte Zeile in der Tabelle sofort erkennst und herausfiltern kannst. Die Kopfzeile in setup() ist für den seriellen Monitor und für Python praktisch; nutzt du Data Streamer, kannst du sie löschen. Bei langsam veränderlichen Größen wie der Raumtemperatur setzt du ARALIK (Intervall) auf 60000 und misst einmal pro Minute.

Methode 1: Ausgabe des seriellen Monitors als CSV speichern

1. Lade den Sketch hoch, öffne Werkzeuge > Serieller Monitor und wähle im Geschwindigkeitsmenü 9600 Baud.
2. Wenn du möchtest, schalte Zeitstempel ein: In der Arduino IDE 2 klickst du auf das Uhrsymbol oben rechts im Fenster, in der IDE 1.8 auf das Zeitstempel-Kästchen unten. An den Anfang jeder Zeile wird dann die Uhrzeit des Computers im Format 14:03:21.512 -> gesetzt.
3. Wenn der Versuch beendet ist, markiere die Zeilen mit der Maus und kopiere sie mit Strg+C (Cmd+C unter macOS). Willst du die Rohdaten aufheben, füge sie in den Editor ein und speichere sie mit dem Dateityp Alle Dateien als olcum.csv.
4. Klicke in Excel auf Zelle A1 eines leeren Blatts und füge mit Strg+V ein; alle Zeilen landen in Spalte A.
5. Öffne bei markierter Spalte A Daten > Text in Spalten, wähle Getrennt und hake Komma als Trennzeichen an. Sind Zeitstempel eingeschaltet, hake auch Leerzeichen an: Die Uhrzeit landet in der ersten Spalte, die "->"-Zeichen in der zweiten, die du danach löschst.
6. Klicke im letzten Schritt auf Weitere und stelle als Dezimaltrennzeichen den Punkt ein; so erkennt das deutsche Excel Werte wie 23.5 als Zahlen. Klicke auf Fertig stellen und speichere die Datei als .xlsx.

Bis zu einigen hundert Zeilen ist diese Methode sehr praktisch; bei Tausenden von Zeilen wird das Markieren mühsam und das IDE-Fenster langsam. Für Aufzeichnungen über Stunden schreiben Terminalprogramme wie PuTTY (Session > Logging > All session output) oder CoolTerm, das unter Windows, macOS und Linux läuft (Connection > Capture to Text/Binary File), jede ankommende Zeile direkt in eine Datei. Diese Datei holst du mit denselben Schritten nach Excel. Denk daran: Solange ein Terminalprogramm oder der serielle Monitor die Schnittstelle belegt, können sich weder die Excel-Add-ins noch Python damit verbinden.

Methode 2: Live-Daten mit dem Excel Data Streamer

Data Streamer ist ein kostenloses Add-in, das Microsoft für den Unterricht entwickelt hat; es lässt CSV-Zeilen von der seriellen Schnittstelle direkt in ein Arbeitsblatt fließen. Es ist im Desktop-Excel von Microsoft 365 (ab Version 1902) enthalten und muss nur aktiviert werden. Da es ein COM-Add-in ist, läuft es nur unter Windows; in Excel für macOS und in Excel im Browser gibt es es nicht. Auf der Arduino-Seite musst du nichts ändern: Der Sketch oben funktioniert unverändert mit 9600 Baud, der Standardgeschwindigkeit des Add-ins.

1. Öffne in Excel Datei > Optionen > Add-Ins, wähle unten in der Liste Verwalten den Eintrag COM-Add-Ins und klicke auf Los.
2. Hake Microsoft Data Streamer for Excel an und klicke auf OK; im Menüband erscheint die Registerkarte Data Streamer.
3. Schließe den seriellen Monitor in der Arduino IDE; eine serielle Schnittstelle kann immer nur von einem Programm geöffnet werden.
4. Wähle über die Schaltfläche Connect a Device den COM-Port des Arduino und klicke dann auf Start Data. Je nach Sprache von Excel können die Schaltflächen übersetzt heißen.
5. Excel legt drei Blätter an: Data In (eingehende Daten), Data Out (Daten an den Arduino) und Settings (Einstellungen). Setze im Blatt Settings Data Channels auf 4 und erhöhe Data Rows, um mehr Verlauf in der Tabelle zu sehen.
6. Für eine dauerhafte Aufzeichnung startest du mit Record Data; wenn du mit Stop Recording anhältst, sind die Messwerte in einer CSV-Datei gespeichert. Diese Datei kannst du später mit Import Data File erneut abspielen.

Oben im Blatt Data In stehen die neuesten Werte (Current Data), darunter eine Tabelle, durch die die bisherigen Messungen laufen (Historical Data). Markierst du diese Tabelle und fügst über Einfügen > Empfohlene Diagramme ein Linien- oder Punktdiagramm ein, aktualisiert sich das Diagramm bei jedem neuen Wert von selbst; ideal, um der Klasse zu zeigen, wie die Lichtkurve sofort abfällt, wenn du die Hand über den Sensor hältst. Im Blatt Settings legt Data Interval (ms) fest, wie oft das Blatt aktualisiert wird, und Data Orientation, ob die neuesten Daten oben oder unten in der Tabelle erscheinen. Werte, die du ins Blatt Data Out schreibst, gehen ebenfalls als CSV-Zeile an den Arduino; der Arduino kann sie mit Serial.parseInt() lesen, sodass du zum Beispiel eine Alarmschwelle aus Excel heraus einstellen kannst.

Methode 3: Mit dem PLX-DAQ-Makro Zeile für Zeile in Excel schreiben

PLX-DAQ (Parallax Data Acquisition) ist ein VBA-Makro, das in Excel läuft und spezielle Befehle von der seriellen Schnittstelle in Excel-Zellen umsetzt. Weil die Originalversion von Parallax nur in 32-Bit-Excel funktioniert, verwendet man heute PLX-DAQ v2, das von der Arduino-Community weiterentwickelt wurde; es unterstützt 64-Bit-Excel und kommt als einzelne .xlsm-Datei. Da das Makro auf der Windows-API aufbaut, läuft es ebenfalls nur unter Windows. Der Unterschied zu Data Streamer: Hier steuert der Arduino Excel. Er schreibt die Überschriften, leert das Blatt und lässt Excel Datum und Uhrzeit eintragen.

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. Lade die PLX-DAQ-v2-Datei herunter und entpacke das Zip-Archiv. Klicke mit der rechten Maustaste auf die .xlsm-Datei und hake unter Eigenschaften das Kästchen Zulassen an; Office blockiert Makros in Dateien aus dem Internet standardmäßig.
2. Öffne die Datei und klicke in der gelben Leiste oben auf Inhalt aktivieren.
3. Schließe den seriellen Monitor in der Arduino IDE und klicke im Blatt auf die Schaltfläche Open PLX DAQ UI.
4. Trage im sich öffnenden Fenster bei Port nur die COM-Nummer ein (5 für COM5), wähle bei Baud 9600 und klicke auf Connect.
5. Erscheinen keine Überschriften, drücke die Reset-Taste des Arduino: setup() läuft erneut, die Befehle CLEARDATA und LABEL erreichen Excel und die Zeilen beginnen zu fließen.
6. Wenn du fertig bist, klicke auf Disconnect und speichere die Daten bei Bedarf als eigene .xlsx-Datei.

Methode 4: Automatische CSV- und Excel-Dateien mit Python

Wenn du mit einem Mac oder unter Linux arbeitest, stundenlang aufzeichnen willst oder den Bericht nicht jedes Mal von Hand erstellen möchtest, ist Python der flexibelste Weg. Installiere zuerst die beiden Pakete im Terminal mit python -m pip install pyserial openpyxl. Das erste Skript unten lauscht am Arduino und schreibt jede Messung zusammen mit der Uhrzeit des Computers in die Datei deney_olcumleri.csv. Themen wie das Finden des Ports, den automatischen Reset und Live-Diagramme haben wir ausführlich in der Anleitung zur seriellen Kommunikation zwischen Arduino und Python erklärt.

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)

Drei Details im Skript sorgen für die Kompatibilität mit Excel. Die Kodierung utf-8-sig setzt eine unsichtbare BOM an den Dateianfang; ohne sie zeigt Excel Zeichen wie "°C" oder Umlaute verstümmelt an. Die Konstanten AYIRICI (Trennzeichen) und ONDALIK (Dezimalzeichen) stehen auf Semikolon und Dezimalkomma und passen damit bereits zum deutschen Excel; bei englischen Ländereinstellungen änderst du sie einfach in Komma und Punkt. f.flush() schreibt jede Zeile sofort auf die Festplatte, sodass du höchstens die letzte Messung verlierst, wenn der Computer ausgeht oder sich das Kabel löst. Nachdem du das Skript mit Strg+C beendet hast, genügt ein Doppelklick auf die Datei, und die Spalten öffnen sich richtig getrennt. Willst du die Datei ansehen, während die Aufzeichnung noch läuft, öffne eine Kopie, denn Excel kann geöffnete Dateien sperren.

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)

Das zweite Skript wandelt die CSV in eine echte .xlsx-Datei um. In einer .xlsx werden Zahlen als Zahlen und nicht als Text gespeichert, daher verschwindet das Problem mit Trenn- und Dezimalzeichen vollständig; die Datei öffnet sich in deutschem, englischem oder türkischem Excel gleich. Außerdem fügt das Skript eine Übersichtstabelle mit Mittelwert, Minimum, Maximum und Standardabweichung sowie zwei Punktdiagramme für Temperatur und Licht hinzu. Die Formeln werden mit ihren englischen Namen (AVERAGE, MIN, MAX, STDEV) in die Datei geschrieben; Excel übersetzt sie beim Öffnen, im deutschen Excel siehst du MITTELWERT, MIN, MAX und STABW. Die Zeilen mit delete = False verhindern ein Problem, bei dem in Diagrammen aus neueren openpyxl-Versionen die Achsenbeschriftungen fehlen.

Zeitstempel hinzufügen: millis(), Uhr des Computers oder RTC

Bei Versuchen am Computer ist dessen Uhr am einfachsten, und unser Python-Skript schreibt sie in jede Zeile. Es ist aber eine gute Gewohnheit, auch die vom Arduino gesendete Zeit zu behalten: Sie zeigt den tatsächlichen Abstand zwischen den Messungen, und du merkst sofort, wenn eine Zeile fehlt. Sendest du den rohen millis()-Wert vom Arduino, rechnest du ihn in Excel mit =B2/1000 in Sekunden oder mit =B2/60000 in Minuten um. Soll der Arduino unabhängig vom Computer arbeiten und zum Beispiel auf eine SD-Karte schreiben, nimm Datum und Uhrzeit von einem RTC-Uhrmodul; wie du CSV auf eine SD-Karte schreibst, steht in der Anleitung zum SD-Kartenmodul. Mit einem ESP32 kannst du die Zeit auch aus dem Internet holen: NTP-Zeit mit dem ESP32.

Ein Diagramm in Excel erstellen

1. Markiere die Spalten für Zeit und Temperatur samt Überschriften; liegen sie nicht nebeneinander, halte beim Markieren der zweiten Spalte die Strg-Taste gedrückt.
2. Wähle unter Einfügen > Diagramme > Punkt (X, Y) einen Punkttyp mit Linien.
3. Schalte über die Schaltfläche + neben dem Diagramm die Achsentitel ein und benenne die Achsen mit ihren Einheiten: "Zeit (s)" und "Temperatur (°C)".
4. Um die Lichtreihe hinzuzufügen, klicke mit der rechten Maustaste auf das Diagramm und füge die Lichtspalte über Daten auswählen > Hinzufügen hinzu; da die Skalen sehr verschieden sind, klicke mit der rechten Maustaste auf die Reihe und wähle Datenreihen formatieren > Sekundärachse.
5. Klicke mit der rechten Maustaste auf die senkrechte Achse und lege unter Achse formatieren Minimum und Maximum fest, damit eine Änderung um 1 °C nicht wie ein riesiger Ausschlag aussieht.

Warum ein Punktdiagramm und kein Liniendiagramm? Das Liniendiagramm von Excel behandelt die Werte auf der waagerechten Achse als gleichmäßig verteilte Beschriftungen; fehlt eine Messung oder änderst du das Intervall, wird die Zeitachse unbemerkt verzerrt. Das Punktdiagramm (X, Y) setzt dagegen jeden Punkt an seine tatsächliche Zeit, und genau das erwartet man von einem wissenschaftlichen Diagramm. Vergleichst du nur wenige feste Werte, etwa die mittlere Temperatur in drei Räumen, ist ein Säulendiagramm leichter lesbar. Ist der Sensor verrauscht, klicke mit der rechten Maustaste auf die Reihe und glätte die Kurve mit Trendlinie hinzufügen > Gleitender Durchschnitt.

Beispiel für das Versuchsprotokoll: eine Messtabelle

Angenommen, die Frage deines Versuchs lautet: "Wie ändern sich Temperatur, Luftfeuchtigkeit und Helligkeit der Luft in der Nähe einer Schreibtischlampe, wenn sie eingeschaltet wird?" Wir haben die Sensoren etwa 15 cm von der Lampe entfernt aufgestellt und ARALIK im Sketch auf 60000 gesetzt, also eine Messung pro Minute. In Minute 1 haben wir die Lampe eingeschaltet, in Minute 6 wieder aus. Die Werte unten sind typische Beispielwerte, die du mit diesem Aufbau erhalten kannst; die letzten beiden Zeilen sind mit Excel-Formeln berechnete Zusammenfassungen:

Die Zusammenfassungszeilen berechnest du in Excel mit =MITTELWERT(B2:B10), =MIN(B2:B10) und =MAX(B2:B10); um zu zeigen, wie stark die Messwerte streuen, kannst du zusätzlich =STABW(B2:B10) verwenden. Beschreibe bei der Auswertung das Muster in der Tabelle: Sobald die Lampe anging, sprang das Licht von 14 % auf 81 %, während die Temperatur in etwa 3 Minuten langsam um 3 °C stieg; das nennt man thermische Trägheit. Als die Lampe ausging, fiel das Licht sofort ab, die Temperatur blieb aber noch einige Minuten erhöht. Die relative Luftfeuchtigkeit sank, während die Temperatur stieg, denn wärmere Luft kann mehr Feuchtigkeit aufnehmen, auch wenn die Wassermenge in ihr gleich bleibt. Eine Glüh- oder Halogenlampe zeigt diesen Effekt deutlich; bei einer LED-Lampe ist der Temperaturanstieg viel kleiner.

• Ziel: deine Forschungsfrage und deine Hypothese in einem Satz.
• Material: Board-Modell, Sensoren, Widerstände und die verwendete Software (Arduino IDE, Excel).
• Durchführung: Position der Sensoren, Messintervall (zum Beispiel 60 s), Dauer des Versuchs und die Methode, mit der die Daten nach Excel übertragen wurden.
• Messtabelle: Jede Spaltenüberschrift enthält ihre Einheit; im Text nutzt du die Übersichtstabelle, die vollständigen Rohdaten kommen in den Anhang.
• Diagramm: ein Punktdiagramm mit Achsentiteln, Einheiten und markierten Ereignissen (Lampe ein, Lampe aus).
• Ergebnis und Fehlerquellen: Vergleich der Ergebnisse mit der Hypothese und Grenzen wie die Genauigkeit des DHT11 von ±2 °C, der nicht kalibrierte LDR und der Abstand des Sensors zur Lampe.

ESP32-Daten in Excel übertragen

Auf dem ESP32 funktionieren alle Methoden genauso; für Data Streamer und PLX-DAQ ist der ESP32 einfach eine weitere serielle Schnittstelle. Drei Dinge ändern sich: Die Analogmessung hat 12 Bit (0–4095), der LDR-Spannungsteiler wird mit 3,3 V versorgt, und als Analogeingang solltest du einen der ADC1-Pins (GPIO 32–39) wählen, weil sie auch bei eingeschaltetem WLAN funktionieren. ESP32-Boards laufen meist mit 115200 Baud; passe die Geschwindigkeit im Python-Skript, in Data Streamer und in PLX-DAQ entsprechend an. Die Bootloader-Meldungen, die beim Start auf der seriellen Schnittstelle erscheinen, sind keine Zahlen und werden vom Python-Skript ohnehin übersprungen. Möchtest du die Messwerte ganz ohne Computer in die Cloud schicken, sieh dir die Anleitung zur Datenaufzeichnung mit dem ESP32 in Google Tabellen an.

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}

CSV-Aufzeichnung mit dem Raspberry Pi Pico (MicroPython)

Nutzt du MicroPython auf einem Raspberry Pi Pico, kannst du die Messwerte statt an einen Computer direkt in eine CSV-Datei im eigenen Flash-Speicher des Boards schreiben; so brauchst du gar keinen Computer und kannst den Pico mit einer Powerbank dort lassen, wo du messen willst. Der Code unten nutzt den eingebauten Temperatursensor (ADC4), der keine Zusatzhardware braucht, und einen LDR an GP26, und schreibt die Datei mit Semikolon und Dezimalkomma, passend für deutsches Excel. Da der eingebaute Sensor die Temperatur des Chips misst, kann er einige Grad über der Raumtemperatur liegen; für genaue Messungen nimm einen externen Sensor. Bist du neu bei MicroPython, beginne mit der Anleitung Was ist der 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)

Speicherst du den Code in Thonny als main.py auf dem Pico, startet die Aufzeichnung bei jedem Einschalten von selbst; gibt es die Datei schon, wird sie nicht gelöscht, und neue Zeilen werden angehängt. Ist die Messung beendet, schließe den Pico an den Computer an, klicke in Thonny auf Stop, klicke im Bereich Ansicht > Dateien mit der rechten Maustaste auf olcum.csv, lade die Datei auf deinen Computer herunter und öffne sie in Excel. Bei einer Zeile von etwa 20 Byte alle 10 Sekunden wächst die Datei um rund 170 KB pro Tag; im Dateisystem des Pico ist damit reichlich Platz für mehrere Tage Aufzeichnung. Nutzt du ein englisches Excel mit Dezimalpunkt, entferne einfach den Aufruf von replace() in der Funktion tr().

Häufige Fehler und ihre Lösungen

Projektideen mit Datenaufzeichnung in Excel

• Abkühlungskurve: Miss mit einem wasserdichten DS18B20, wie ein Glas heißes Wasser abkühlt, füge in Excel eine exponentielle Trendlinie hinzu und untersuche das newtonsche Abkühlungsgesetz.
• Mini-Wetterstation: Zeichne mit einem BME280 eine Woche lang Temperatur, Luftfeuchtigkeit und Luftdruck auf und stelle den Unterschied zwischen Tag und Nacht grafisch dar.
• Gießprotokoll für Pflanzen: Speichere den Wert des Bodenfeuchtesensors vor und nach dem Gießen und finde heraus, wie lange die Erde zum Austrocknen braucht.
• Bewegungsanalyse: Erstelle mit einem HC-SR04 eine Weg-Zeit-Tabelle und berechne in Excel aus den Differenzen aufeinanderfolgender Zeilen Geschwindigkeit und Beschleunigung.
• Entladekurve einer Batterie: Miss die Spannung einer Batterie mit einem Spannungsteiler, zeichne sie stundenlang auf und untersuche, wie die Spannung mit der Zeit sinkt.
• Projekt für den Wettbewerb: Vergleiche, wie stark sich verschiedenfarbige Kisten in der Sonne aufheizen; weitere Ideen findest du in der Anleitung mit Arduino-Projektideen für Wettbewerbe.

Welche Methode du auch wählst, die Grundlage bleibt gleich: Erzeuge auf dem Arduino saubere, einheitliche CSV-Zeilen und bringe sie am Computer mit dem richtigen Trennzeichen nach Excel. Für eine schnelle Kontrolle eignet sich der serielle Monitor am besten, für eine Live-Vorführung im Unterricht Data Streamer, für die Steuerung von Excel durch den Arduino PLX-DAQ und für lange, automatische Aufzeichnungen Python. In der BlueGrays-App findest du Projekte wie Temperatur- und Feuchtigkeitsmessung mit dem DHT11, das Messen der Lichtstärke mit einem LDR und einen ESP32-Temperaturlogger Schritt für Schritt mit Schaltplänen und Code, und die gemessenen Daten kannst du mit diesen Methoden nach Excel übertragen.