Arduino SD-kaartmodule: CSV-datalogger met RTC-tijdstempels
Gids voor de Arduino SD-kaartmodule: SPI-bedrading, FAT32 formatteren, CSV-logging van sensoren met RTC-tijdstempels, ESP32 SD_MMC, Pico en het oplossen van initialization failed.
Een Arduino SD-kaartmodule is een klein, goedkoop board waarmee je de metingen van je sensoren (temperatuur, luchtvochtigheid, afstand of locatie) als bestanden op een micro-SD-kaart opslaat. Het is de makkelijkste manier om een datalogger te bouwen die dagen of zelfs maanden meet zonder aangesloten computer: de Arduino doet de metingen, de module schrijft elke meting als nieuwe regel in een CSV-bestand op de kaart, en jij steekt de kaart in je computer en maakt in Excel een grafiek van de data. De module werkt via SPI en heeft met de SD-bibliotheek uit de Arduino IDE maar een paar regels code nodig.
In deze gids leer je stap voor stap hoe de module werkt, wat het verschil is tussen 5V- en 3,3V-modules, hoe je de SPI-bedrading aansluit op Arduino Uno, Mega, ESP32 en Raspberry Pi Pico, hoe je de kaart als FAT32 formatteert, hoe je bestanden schrijft en leest, en hoe je met een RTC-module een CSV-log met datum en tijd bijhoudt. We behandelen ook de snelle SD_MMC-interface van de ESP32, het gebruik van een SD-kaart op de Pico met MicroPython en het oplossen van de veelvoorkomende foutmelding "initialization failed".

Wat is een SD-kaartmodule en hoe werkt hij?
SD-kaarten werken op 3,3 V en kunnen op twee manieren communiceren: de snelle native SD-modus en de eenvoudigere SPI-modus. Microcontrollers zoals de Arduino praten via SPI met de kaart. De module zorgt dat beide elektrisch compatibel zijn: de regelaar verlaagt 5 V naar de 3,3 V die de kaart nodig heeft, en een niveauconverterchip (meestal een 74LVC125A) zet de 5V-signalen van de Arduino om naar 3,3 V, wat de kaart aankan. Binnenin bestaat de kaart uit blokken van 512 byte, terwijl begrippen als bestanden, mappen en bestandsnamen door het FAT-bestandssysteem worden afgehandeld. De SD-bibliotheek doet al dit zware werk voor je; jij opent een bestand, schrijft erin en sluit het.
| Eigenschap | Waarde |
|---|---|
| Interface | SPI (MISO, MOSI, SCK, CS) |
| Voeding (micro-SD-module met regelaar) | 4,5–5,5 V, 3,3V-regelaar op het board |
| Signaalniveau | Compatibel met 3,3 V en 5 V (dankzij de niveauconverter) |
| Ondersteunde kaarten | micro SD (tot 2 GB) en micro SDHC (4–32 GB) |
| Bestandssysteem | FAT16 of FAT32 |
| Stroom | Een paar mA in rust, tot 100 mA tijdens het schrijven |
| Bestandsnaam (Arduino SD-bibliotheek) | 8.3-formaat: maximaal 8 tekens voor de naam + 3 voor de extensie |
5V- of 3,3V-SD-kaartmodules: welke moet je kopen?
| Type module | Voeding | Signaalniveau | Geschikt voor |
|---|---|---|---|
| Micro-SD-module met regelaar (74LVC125A) | 5 V | 3,3 V en 5 V | Uno, Nano, Mega; ESP32 en Pico bij voeding via 5 V |
| SD-kaartmodule op volledig formaat (+5- en +3.3-pinnen) | 5 V of 3,3 V | De meeste hebben geen echte niveauconverter | 3,3V-boards; onbetrouwbaar met 5V-signalen |
| Micro-SD-module zonder regelaar (kale sleuf) | Alleen 3,3 V | Alleen 3,3 V | ESP32, Raspberry Pi Pico |
| Boards met ingebouwde sleuf (zoals de ESP32-CAM) | Van het board | 3,3 V | Direct gebruikt met SD_MMC |
Gebruik je een Arduino Uno, Nano of Mega, kies dan een micro-SD-module met regelaar en niveauconverter zoals die op de foto, en sluit VCC aan op de 5V-pin. De ESP32 en Pico werken op 3,3 V; je kunt dezelfde module ook daarmee gebruiken, maar voed hem dan nog steeds met 5 V (VIN op de ESP32, VBUS op de Pico als die via USB wordt gevoed). Omdat de niveauconverter op 3,3 V werkt, is het MISO-signaal naar de microcontroller al 3,3 V. Modules zonder regelaar sluit je rechtstreeks aan op de 3V3-pin; moet je er een gebruiken met een 5V-Arduino, zet dan een spanningsdeler van 1 kΩ + 2 kΩ op elk van de MOSI-, SCK- en CS-lijnen, of gebruik een niveauconverter. De weerstandswaarden controleer je met de spanningsdelerrekenmachine.
Bedrading van de SD-kaartmodule: SPI-pinnen
| Modulepin | Arduino Uno / Nano | Arduino Mega | ESP32 | Raspberry Pi Pico |
|---|---|---|---|---|
| GND | GND | GND | GND | GND |
| VCC | 5V | 5V | VIN (5 V) | VBUS (5 V) |
| MISO | D12 | D50 | GPIO 19 | GP16 |
| MOSI | D11 | D51 | GPIO 23 | GP19 |
| SCK | D13 | D52 | GPIO 18 | GP18 |
| CS | D10 | D53 | GPIO 5 | GP17 |
MISO, MOSI en SCK moeten op elk board naar de hardware-SPI-pinnen; CS (chip select) kan elke digitale pin zijn, zolang je hetzelfde nummer meegeeft aan SD.begin() in je code. Op kant-en-klare shields is CS meestal D4 of D10. Je kunt meerdere apparaten op dezelfde SPI-bus aansluiten: ze delen allemaal MISO, MOSI en SCK en elk krijgt een eigen CS-pin. Hoe SPI precies werkt leggen we uit in SPI-communicatie. Om te zien waar de pinnen op je board zitten, gebruik je de pinout-tool.
De SD-kaart voorbereiden: formatteren als FAT32
- Kaartgrootte: kies een micro-SDHC-kaart van 4 tot 32 GB. De Arduino SD-bibliotheek ondersteunt SDSC- (tot 2 GB) en SDHC-kaarten; SDXC-kaarten van 64 GB en meer zijn als exFAT geformatteerd, en dat kan deze bibliotheek niet lezen.
- Bestandssysteem: formatteer de kaart als FAT32 (FAT16 werkt ook op kaarten van 2 GB of kleiner). NTFS en exFAT werken niet.
- Windows: klik met de rechtermuisknop op de kaart in Verkenner, kies Formatteren, selecteer FAT32 als bestandssysteem en de standaard grootte van de toewijzingseenheid. Windows biedt FAT32 niet aan voor kaarten groter dan 32 GB.
- macOS: selecteer de kaart in Schijfhulpprogramma, klik op Wissen en kies MS-DOS (FAT) als formaat en Master Boot Record als schema.
- De veiligste optie: de gratis tool SD Card Formatter van de SD Association formatteert de kaart volgens de officiële standaard en lost de meeste vreemde fouten op.
- Eén partitie: de kaart mag maar één partitie hebben. Kaarten die eerder in een Raspberry Pi of camera zijn gebruikt, hebben soms nog meerdere partities; verwijder die voordat je formatteert.
Eerste test stap voor stap: schrijven naar en lezen van de SD-kaart
- Steek de geformatteerde kaart in de module en sluit de module aan op de Arduino volgens de tabel hierboven.
- De SD-bibliotheek zit in de Arduino IDE, dus je hoeft niets te installeren; je voegt alleen SPI.h en SD.h toe bovenaan de sketch.
- Upload de onderstaande code en open de Serial Monitor op 9600 baud.
- Zie je "tamam" (OK) en de inhoud van het bestand, dan zijn de kaart en de bedrading in orde. Elke keer dat het board opstart, wordt een nieuwe regel aan TEST.TXT toegevoegd.
- Als je de kaart eruit haalt en in je computer steekt, kun je TEST.TXT openen in elke teksteditor.
1#include <SPI.h>
2#include <SD.h>
3
4const int CS_PIN = 10; // modülün CS pini / module CS pin
5
6void setup() {
7 Serial.begin(9600);
8 Serial.print(F("SD kart baslatiliyor... "));
9 if (!SD.begin(CS_PIN)) { // kart başlatılamadı / card init failed
10 Serial.println(F("initialization failed"));
11 while (true); // burada dur / stop here
12 }
13 Serial.println(F("tamam"));
14
15 File dosya = SD.open("TEST.TXT", FILE_WRITE); // yoksa oluşturur, sona ekler / creates it, appends
16 if (dosya) {
17 dosya.println(F("Merhaba BlueGrays!"));
18 dosya.close(); // tamponu karta yazar / flushes the buffer to the card
19 Serial.println(F("TEST.TXT yazildi"));
20 } else {
21 Serial.println(F("TEST.TXT acilamadi")); // dosya açılamadı / could not open file
22 }
23
24 dosya = SD.open("TEST.TXT"); // okumak için aç / open for reading
25 if (dosya) {
26 Serial.print(F("Boyut (bayt): "));
27 Serial.println(dosya.size());
28 while (dosya.available()) {
29 Serial.write(dosya.read()); // içeriği seri porta yaz / print contents to serial
30 }
31 dosya.close();
32 }
33}
34
35void loop() {
36}| Functie | Wat het doet |
|---|---|
| SD.begin(cs) | Initialiseert de kaart; geeft true terug bij succes |
| SD.open("NAME.TXT", FILE_WRITE) | Opent het bestand om te schrijven; maakt het aan als het ontbreekt, voegt toe aan het einde als het bestaat |
| SD.open("NAME.TXT") | Opent het bestand om te lezen (FILE_READ) |
| file.print() / println() | Schrijft tekst of een getal naar het bestand |
| file.flush() | Schrijft de gebufferde data naar de kaart zonder het bestand te sluiten |
| file.close() | Schrijft de resterende data naar de kaart en sluit het bestand |
| file.available() / read() | Controleert of er nog bytes te lezen zijn / leest één byte |
| SD.exists() / SD.remove() / SD.mkdir() | Controleert of een bestand bestaat / verwijdert een bestand / maakt een map aan |
Sensordata naar CSV loggen met RTC-tijdstempels
Het handigste bestandsformaat voor een datalogger is CSV (comma-separated values): elke regel is één meting, elke kolom is één waarde en de eerste regel bevat de kolomkoppen. Om te weten wanneer elke meting is gedaan, voeg je datum en tijd toe aan elke regel. millis() geeft alleen aan hoe lang de Arduino draait en begint bij elke herstart opnieuw, dus gebruiken we een RTC-module (real-time clock) met een knoopcel. De RTC blijft doortellen, ook als de Arduino uit staat. De DS1307 is goedkoop, maar kan een paar seconden per dag afwijken, terwijl de DS3231 dankzij zijn temperatuurgecompenseerde kristal maar ongeveer een minuut per jaar afwijkt. We vergelijken ze in RTC-kloksmodules.

De schakeling: de SD-module gaat naar de SPI-pinnen zoals in de tabel hierboven, de RTC-module naar de I2C-bus (op de Uno SDA = A4, SCL = A5, VCC = 5V) en de datapin van de DHT22-sensor naar D2; gebruik je een losse sensor, voeg dan een weerstand van 10 kΩ toe tussen de datapin en VCC. Installeer de bibliotheken RTClib (Adafruit) en DHT sensor library via de Library Manager. Voor details over het aansluiten van de sensor, zie DHT11- en DHT22-temperatuur- en vochtigheidssensor.
1#include <SPI.h>
2#include <SD.h>
3#include <Wire.h>
4#include <RTClib.h>
5#include <DHT.h>
6
7const int CS_PIN = 10; // SD modülü CS / SD module CS
8const unsigned long ARALIK = 10000; // 10 saniyede bir kayıt / log every 10 seconds
9
10RTC_DS1307 rtc; // DS3231 için RTC_DS3231 / RTC_DS3231 for a DS3231
11DHT dht(2, DHT22); // veri pini D2, DHT11 de olur / data pin D2, DHT11 also works
12unsigned long sonKayit = 0;
13
14void setup() {
15 Serial.begin(9600);
16 dht.begin();
17 if (!rtc.begin()) {
18 Serial.println(F("RTC bulunamadi")); // RTC yok / RTC not found
19 while (true);
20 }
21 if (!rtc.isrunning()) { // saat hiç kurulmamış / clock never set
22 rtc.adjust(DateTime(F(__DATE__), F(__TIME__))); // derleme anına kur / set to compile time
23 }
24 if (!SD.begin(CS_PIN)) {
25 Serial.println(F("SD kart hatasi")); // SD başlatılamadı / SD init failed
26 while (true);
27 }
28 if (!SD.exists("VERI.CSV")) { // yeni dosyaya başlık satırı / header row for a new file
29 File f = SD.open("VERI.CSV", FILE_WRITE);
30 if (f) {
31 f.println(F("tarih,saat,sicaklik_C,nem_yuzde"));
32 f.close();
33 }
34 }
35}
36
37void loop() {
38 if (millis() - sonKayit < ARALIK) return; // zamanı gelmedi / not time yet
39 sonKayit = millis();
40
41 float t = dht.readTemperature();
42 float h = dht.readHumidity();
43 if (isnan(t) || isnan(h)) { // sensör okunamadı / sensor read failed
44 Serial.println(F("DHT okuma hatasi"));
45 return;
46 }
47
48 DateTime simdi = rtc.now();
49 char ts[8], hs[8], satir[48];
50 dtostrf(t, 1, 1, ts); // AVR'de sprintf %f desteklemez / AVR sprintf has no %f
51 dtostrf(h, 1, 1, hs);
52 snprintf(satir, sizeof(satir), "%04d-%02d-%02d,%02d:%02d:%02d,%s,%s",
53 simdi.year(), simdi.month(), simdi.day(),
54 simdi.hour(), simdi.minute(), simdi.second(), ts, hs);
55
56 File f = SD.open("VERI.CSV", FILE_WRITE); // sona ekle / append
57 if (f) {
58 f.println(satir);
59 f.close(); // her kayıtta kapat: güç kesilse de veri kalır / close every time so data survives a power cut
60 Serial.println(satir);
61 } else {
62 Serial.println(F("VERI.CSV acilamadi"));
63 }
64}Elke 10 seconden leest de code temperatuur en luchtvochtigheid uit, haalt datum en tijd op bij de RTC en voegt een regel zoals 2026-11-04,14:05:30,23.5,45.2 toe aan het einde van VERI.CSV. Omdat het bestand na elke regel wordt gesloten, blijft de tot dan toe opgeslagen data zelfs bij stroomuitval bewaard. Op AVR-boards ondersteunt sprintf() geen kommagetallen (%f), dus worden de waarden eerst met dtostrf() naar tekst omgezet. Omdat de timing millis() in plaats van delay() gebruikt, kun je in loop() ook andere dingen doen. Is de RTC nog nooit ingesteld, dan wordt de klok gezet op het moment waarop de code is gecompileerd. Gebruik je een DS3231, schrijf dan gewoon RTC_DS3231 in plaats van RTC_DS1307 en controleer lostPower() in plaats van isrunning().
Hoeveel ruimte kost het? Eén regel is ongeveer 31 byte. Loggen elke 10 seconden geeft 8.640 regels per dag, ongeveer 260 KB; over een jaar is dat zo'n 95 MB. Met deze snelheid gaat een kaart van 8 GB dus tientallen jaren mee. De echte beperking is niet de kaart maar de voeding: draai je het project op batterijen, bereken dan vooraf hoe lang ze meegaan met de batterijduurcalculator.
De SD-kaartdata openen in Excel
- Haal de voeding van de Arduino los, neem de kaart uit de module en steek hem in je computer.
- Kopieer VERI.CSV naar je computer; werken met een kopie is veiliger dan rechtstreeks op de kaart.
- Open een leeg werkblad in Excel en kies het bestand via Gegevens > Uit tekst/CSV.
- Selecteer in het voorbeeldvenster Komma als scheidingsteken en klik op Laden; de kolommen worden gesplitst in datum, tijd, temperatuur en luchtvochtigheid.
- Selecteer de kolommen temperatuur en luchtvochtigheid en voeg via het tabblad Invoegen een lijndiagram toe om te zien hoe ze in de loop van de tijd veranderen.
1// Excel'de ondalık ayırıcı virgülse / if Excel uses a decimal comma
2// Bu iki fonksiyonu kayıt kodunda loop()'un üstüne ekle / add these two functions above loop() in the logging sketch
3void noktayiVirgulYap(char *s) {
4 for (; *s; s++) {
5 if (*s == '.') *s = ','; // 23.5 -> 23,5
6 }
7}
8
9void excelSatiri(char *satir, size_t boyut, const DateTime &simdi, char *ts, char *hs) {
10 noktayiVirgulYap(ts);
11 noktayiVirgulYap(hs);
12 snprintf(satir, boyut, "%04d-%02d-%02d;%02d:%02d:%02d;%s;%s", // ayırıcı ; / separator ;
13 simdi.year(), simdi.month(), simdi.day(),
14 simdi.hour(), simdi.minute(), simdi.second(), ts, hs);
15}
16
17// loop() içinde snprintf satırının yerine / in loop(), replace the snprintf line with:
18// excelSatiri(satir, sizeof(satir), simdi, ts, hs);
19// Başlık satırı da / header row too: tarih;saat;sicaklik_C;nem_yuzdeWil je de metingen liever live in Excel laten binnenkomen terwijl de Arduino op je computer is aangesloten, zonder de kaart te verwijderen, bekijk dan de methoden met Data Streamer en PLX-DAQ in Arduino-data naar Excel sturen. Een SD-kaart is daarentegen onmisbaar voor projecten die buiten draaien, ver van elke computer.
Een SD-kaart gebruiken met de ESP32 (SPI)
De ESP32 Arduino-core heeft zijn eigen SD-bibliotheek en die werkt bijna hetzelfde, maar er zijn drie belangrijke verschillen: bestandspaden beginnen met / ("/olcumler.csv"), lange bestandsnamen zijn toegestaan en FILE_WRITE overschrijft het bestand helemaal opnieuw. Om toe te voegen moet je FILE_APPEND gebruiken; neem je de Uno-code ongewijzigd over, dan worden je oude gegevens bij elke start van het board gewist. De standaard SPI-pinnen zijn SCK 18, MISO 19 en MOSI 23, en voor CS wordt meestal GPIO 5 gebruikt. Het kaarttype en de grootte kun je ook met één regel uitlezen:
1#include <SPI.h>
2#include <SD.h>
3
4const int CS_PIN = 5; // VSPI: SCK 18, MISO 19, MOSI 23 / default VSPI pins
5const char *DOSYA = "/olcumler.csv"; // yol / ile başlar / path starts with /
6
7void setup() {
8 Serial.begin(115200);
9 if (!SD.begin(CS_PIN)) { // varsayılan SPI hızı 4 MHz / default SPI clock 4 MHz
10 Serial.println("Card Mount Failed");
11 return;
12 }
13 uint8_t tur = SD.cardType();
14 if (tur == CARD_NONE) {
15 Serial.println("Kart takili degil"); // kart yok / no card inserted
16 return;
17 }
18 Serial.printf("Kart tipi: %s\n", tur == CARD_SDHC ? "SDHC" : (tur == CARD_SD ? "SDSC" : "MMC"));
19 Serial.printf("Boyut: %llu MB\n", SD.cardSize() / (1024 * 1024));
20
21 if (!SD.exists(DOSYA)) { // uzun dosya adı serbest / long file names are fine
22 File f = SD.open(DOSYA, FILE_WRITE); // FILE_WRITE dosyayı sıfırlar / FILE_WRITE truncates
23 if (f) {
24 f.println("sure_s,isik_ham");
25 f.close();
26 }
27 }
28}
29
30void loop() {
31 File f = SD.open(DOSYA, FILE_APPEND); // ESP32'de sona ekleme / append on ESP32
32 if (f) {
33 f.printf("%lu,%d\n", millis() / 1000, analogRead(34)); // GPIO34'teki LDR / LDR on GPIO34
34 f.close();
35 }
36 delay(5000);
37}De code logt elke 5 seconden de ruwe waarde (0–4095) van een LDR die op GPIO 34 is aangesloten. Op de ESP32 heb je voor de echte tijd niet eens een RTC-module nodig: je kunt verbinding maken met wifi, de tijd ophalen bij een NTP-server en met getLocalTime() een tijdstempel aan elke regel toevoegen. Zijn je draden lang of is de kaart onbetrouwbaar, verlaag dan de SPI-snelheid: SD.begin(5, SPI, 1000000) start de kaart op 1 MHz. In een logger op batterijen vermenigvuldigt deep sleep tussen de metingen de batterijduur.
ESP32 SD_MMC: de snelle SD-interface en de ESP32-CAM
Naast SPI heeft de ESP32 ook een SDMMC-controller die het eigen snelle protocol van de kaart spreekt. In 4-bitmodus is de SD_MMC-bibliotheek een aantal keer sneller dan SPI, wat ideaal is voor grote bestanden zoals foto's of audio. Op de klassieke ESP32 liggen de pinnen vast: CLK GPIO 14, CMD GPIO 15, D0 GPIO 2, D1 GPIO 4, D2 GPIO 12, D3 GPIO 13, en deze lijnen hebben pull-upweerstanden van 10 kΩ nodig. In 1-bitmodus worden alleen CLK, CMD en D0 gebruikt; dat is langzamer, maar GPIO 4, 12 en 13 komen dan vrij. De micro-SD-sleuf op het ESP32-CAM-board is op deze pinnen aangesloten, en met 1-bitmodus knippert de flashled op GPIO 4 niet meer bij elke kaarttoegang.
1#include "FS.h"
2#include "SD_MMC.h"
3
4void setup() {
5 Serial.begin(115200);
6 // 1-bit mod: yalnız CLK 14, CMD 15, D0 2 / 1-bit mode: only CLK 14, CMD 15, D0 2
7 if (!SD_MMC.begin("/sdcard", true)) {
8 Serial.println("SD_MMC baglanamadi"); // kart bağlanamadı / mount failed
9 return;
10 }
11 Serial.printf("Bos alan: %llu MB\n", (SD_MMC.totalBytes() - SD_MMC.usedBytes()) / (1024 * 1024));
12
13 File f = SD_MMC.open("/gunluk.txt", FILE_APPEND);
14 if (f) {
15 f.println("ESP32-CAM acildi"); // açılış kaydı / boot log line
16 f.close();
17 }
18}
19
20void loop() {
21}SD-kaart met de Raspberry Pi Pico (MicroPython)
In MicroPython worden SD-kaarten afgehandeld door het sdcard.py-stuurprogramma uit micropython-lib. Heb je mpremote op je computer, installeer het dan met mpremote mip install sdcard, of kopieer het bestand met Thonny naar de Pico. De kaart wordt met os.mount() gekoppeld als de map /sd, en daarna gebruik je hem met gewone Python-bestandscommando's (open, write). De onderstaande code leest de ingebouwde temperatuursensor van de Pico uit en schrijft elke 10 seconden een CSV-regel. Ben je nieuw met de Pico, lees dan eerst Wat is de Raspberry Pi Pico?
1from machine import Pin, SPI, ADC
2import os, time
3import sdcard # micropython-lib sürücüsü / micropython-lib driver
4
5spi = SPI(0, baudrate=1000000, sck=Pin(18), mosi=Pin(19), miso=Pin(16))
6sd = sdcard.SDCard(spi, Pin(17, Pin.OUT)) # CS = GP17; kart yoksa OSError / OSError if no card
7os.mount(os.VfsFat(sd), "/sd") # kart artık /sd klasörü / the card is now the /sd folder
8
9sensor = ADC(4) # dahili sıcaklık sensörü / internal temperature sensor
10DOSYA = "/sd/pico_log.csv"
11
12if "pico_log.csv" not in os.listdir("/sd"): # yeni dosyaya başlık / header for a new file
13 with open(DOSYA, "w") as f:
14 f.write("tarih,saat,sicaklik_C\n")
15
16while True:
17 v = sensor.read_u16() * 3.3 / 65535
18 t = 27 - (v - 0.706) / 0.001721 # RP2040 veri sayfası formülü / RP2040 datasheet formula
19 y, ay, g, sa, dk, sn = time.localtime()[:6]
20 with open(DOSYA, "a") as f: # "a" = sona ekle / append
21 f.write("{:04d}-{:02d}-{:02d},{:02d}:{:02d}:{:02d},{:.1f}\n".format(y, ay, g, sa, dk, sn, t))
22 print(sa, dk, sn, t)
23 time.sleep(10) # 10 saniye bekle / wait 10 secondsDe Pico heeft geen klok met batterijback-up: als hij op Thonny is aangesloten, wordt zijn klok automatisch ingesteld vanaf je computer, maar zelfstandig begint hij op 1 januari 2021. Voor nauwkeurige tijdstempels kun je een DS3231-module toevoegen, of op een Pico W de tijd via NTP van internet halen. Als er geen kaart in zit of de bedrading fout is, geeft het stuurprogramma OSError: no SD card. Programmeer je de Pico met de Arduino IDE (de arduino-pico-core), dan kun je dezelfde aanpak met de SD-bibliotheek gebruiken; de standaard SPI0-pinnen komen overeen met de tabel en voor CS schrijf je gewoon SD.begin(17).
Gegevensverlies voorkomen: voeding, schrijffrequentie en levensduur van de kaart
- Zonder close() of flush() komt er niets op de kaart: de bibliotheek verzamelt data eerst in een buffer van 512 byte. Houd je het bestand de hele tijd open, roep dan om de paar regels flush() aan.
- Haal de kaart er niet uit tijdens het schrijven: de kaart eruit trekken of de stroom onderbreken midden in een schrijfactie kan het bestandssysteem beschadigen. Een knop die het loggen stopt en een led die toont dat er gelogd wordt, zijn een goede gewoonte.
- Zorg voor een stabiele voeding: de kaart trekt tijdens het schrijven tot 100 mA. Een condensator van 10–100 µF tussen VCC en GND van de module vermindert spanningsdips en willekeurige schrijffouten.
- Open en sluit niet te vaak: doe je tientallen metingen per seconde, dan is het bestand voor elke regel openen en sluiten traag; buffer de metingen in het RAM en schrijf ze in groepen van 10–20 regels weg.
- Levensduur van de kaart: SD-kaarten spreiden schrijfacties intern over verschillende cellen (wear leveling), dus een logger die een paar regels per minuut schrijft, slijt de kaart jarenlang niet. Kies toch een kaart van een bekend merk.
- Splits het bestand: door voor elke dag een apart bestand te openen (bijv. 20261104.CSV) blijven bestanden klein, en als er iets misgaat verlies je alleen de data van die dag.
Projectideeën met een SD-kaartmodule
- Weerstationlogger: registreer elk uur temperatuur, luchtvochtigheid en luchtdruk met een BME280 en zet een heel seizoen in een grafiek.
- Logboek voor plantenbewatering: registreer de metingen van een bodemvochtsensor en de momenten waarop de pomp draait om je bewateringspatroon te onderzoeken.
- GPS-routelogger: sla je fiets- of wandelroute als CSV op met een NEO-6M GPS en toon hem daarna op een kaart.
- Toegangslog met kaarten: schrijf elke kaart die met een RFID RC522 wordt gescand samen met datum en tijd naar een bestand.
- Energieverbruiktracker: meet en log de stroom die een apparaat de hele dag trekt met een ACS712-stroomsensor.
- MP3-speler: de DFPlayer Mini speelt audiobestanden af van zijn eigen micro-SD-sleuf; de Arduino stuurt alleen commando's.
Veelgemaakte fouten en hoe je ze oplost
| Symptoom | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| "initialization failed" | Geen kaart geplaatst, verkeerde bedrading, of de CS-pin komt niet overeen met de code | Controleer of MISO, MOSI en SCK op de hardware-SPI-pinnen zitten en of het CS-nummer in SD.begin() klopt |
| "initialization failed" (bedrading is correct) | Een module met regelaar wordt met 3,3 V gevoed, of de voeding is zwak | Voed de module met 5 V, gebruik kortere draden, voeg een condensator toe tussen VCC en GND |
| "Could not find FAT16/FAT32 partition" | De kaart is als exFAT of NTFS geformatteerd; een SDXC-kaart van 64 GB of meer | Formatteer een kaart van maximaal 32 GB als FAT32 |
| Het bestand gaat niet open ("error opening") | De bestandsnaam voldoet niet aan de 8.3-regel, of het vorige bestand is niet gesloten | Gebruik een korte naam als VERI.CSV en sluit elk bestand met close() |
| Het bestand is leeg of de laatste regels ontbreken | De stroom viel weg voordat close() of flush() werd aangeroepen | Sluit het bestand na elke regel of roep regelmatig flush() aan |
| De SD-kaart werkt niet meer als je een ander SPI-apparaat toevoegt | De CS van het andere apparaat zweeft, of de module geeft de MISO-lijn niet vrij | Zet aan het begin van setup() elke CS-pin op OUTPUT en HIGH; gebruik zo nodig een module die MISO vrijgeeft |
| De Uno loopt vast of gedraagt zich vreemd | Het RAM is vol: de SD-bibliotheek gebruikt ongeveer 650 byte en de buffer van een OLED-display 1 KB | Verpak tekst in F(); stap zo nodig over op een Mega of een ESP32 |
| Op de ESP32 worden oude gegevens bij elke start gewist | Het bestand wordt geopend met FILE_WRITE | Gebruik FILE_APPEND om aan het einde toe te voegen |
| "Card Mount Failed" op de ESP32 | Voeding, bedrading, een te hoge SPI-snelheid, of ontbrekende pull-ups bij SD_MMC | Verlaag de SPI-snelheid naar 1 MHz; probeer 1-bitmodus met SD_MMC |
Een SD-kaartmodule verandert een project dat alleen meet in een apparaat dat gegevens bijhoudt, en een paar dagen echte data vertellen je veel meer dan één enkele meting ooit kan. In de BlueGrays-app vind je de ESP32-temperatuurlogger met DHT22, DS1307 RTC, micro-SD en OLED, digitale klokken op basis van RTC en projecten met temperatuur en luchtvochtigheid, allemaal met schakelschema's en code stap voor stap.
Veelgestelde vragen
Welke grootte SD-kaart kan een Arduino gebruiken?
De standaard Arduino SD-bibliotheek ondersteunt SDSC- en SDHC-kaarten die als FAT16 of FAT32 zijn geformatteerd, dus kaarten tot 32 GB. SDXC-kaarten van 64 GB en meer hebben exFAT en kunnen door deze bibliotheek niet worden gelezen. Voor een datalogger is een kaart van 4–16 GB ruim voldoende.
Waarom meldt mijn SD-kaart "initialization failed"?
De meest voorkomende oorzaken zijn een verkeerde CS-pin, MISO, MOSI of SCK die niet op de hardware-SPI-pinnen zijn aangesloten, een kaart die niet als FAT32 is geformatteerd, en een module met regelaar die met 3,3 V wordt gevoed. Draai eerst het CardInfo-voorbeeld en probeer dan kortere draden en voeding van de module met 5 V.
Werkt een SD-kaartmodule op 3,3 V?
Modules zonder regelaar werken rechtstreeks op 3,3 V en passen bij de ESP32 of Pico. Micro-SD-modules met regelaar en niveauconverter hebben 4,5–5,5 V nodig; bij voeding met 3,3 V krijgt de kaart te weinig spanning. Je kunt deze modules voeden via VIN op de ESP32 of VBUS op de Pico.
Hoe open ik een Arduino-CSV-bestand van de SD-kaart in Excel?
Kopieer het bestand naar je computer en importeer het in Excel via Gegevens > Uit tekst/CSV, met komma als scheidingsteken. Gebruikt jouw Excel een decimale komma, dan kunnen de getallen er verkeerd uitzien; zet de kolommen dan om met de landinstelling Engels (Verenigde Staten) of gebruik in je code een puntkomma als scheidingsteken.
Hoe vaak kan een Arduino naar een SD-kaart schrijven?
Een paar regels per seconde schrijven is geen probleem, maar het bestand voor elke regel openen en sluiten kost tijd. Buffer bij snelle metingen de data in het RAM en schrijf die in groepen weg, of houd het bestand open en roep regelmatig flush() aan. Bij lage snelheden zoals één regel per minuut is openen-schrijven-sluiten de veiligste methode.
Kan ik een SD-kaartmodule tegelijk met RFID of een TFT-display gebruiken?
Ja. SPI-apparaten delen de MISO-, MOSI- en SCK-lijnen en elk gebruikt zijn eigen CS-pin. Krijg je problemen, zet dan aan het begin van setup() elke CS-pin op OUTPUT en HIGH. De niveauconverter op sommige goedkope micro-SD-modules geeft de MISO-lijn nooit vrij; gebruik in dat geval een module die dat wel doet, of een tweede SPI-bus op de ESP32.
Projecten om hierna te bouwen
Alle projecten bekijken
Temperatuur en luchtvochtigheid met DHT11
Hoe warm is je kamer, en is de lucht vochtig of droog? De DHT11-sensor meet temperatuur en luchtvochtigheid en de Arduino schrijft de waarden op een lcd-scherm met twee regels, dat om de paar…

ESP32-temperatuurlogger (DHT22 + DS1307 RTC + microSD + OLED)
Bouw met de ESP32 een temperatuur- en vochtigheidslogger met tijdstempel! Een DHT22-sensor meet elke minuut temperatuur en luchtvochtigheid en elke meting wordt als CSV op een microSD-kaart opgeslagen, met de actuele tijd van de DS1307 RTC-module. Het OLED-display toont in grote letters live de laatste temperatuur, vochtigheid, tijdstempel en het totale aantal records.

Digitale klok met ESP32 en DS1307-RTC (I2C + LCD)
In dit project tonen we de tijd en de datum op een 16x2 I2C-LCD met de DS1307 realtimeklok-module (RTC). De DS1307 is een RTC met batterijback-up die de tijd bijhoudt, ook als de ESP32 uit staat. Beide modules delen dezelfde I2C-bus (SDA/SCL), zodat je leert hoe je met slechts twee signaaldraden meerdere apparaten bestuurt. Met dit project krijg je praktische kennis van het I2C-communicatieprotocol, de werking van RTC-modules en het dynamisch tonen van gegevens op een LCD.

ESP32 DHT22 temperatuur en luchtvochtigheid (met LCD)
Dit project meet de omgevingstemperatuur en luchtvochtigheid met een DHT22-sensor en toont de gegevens in realtime op een 16x2 I2C-LCD. De data wordt met het one-wire-protocol via de Adafruit DHT-bibliotheek uit de sensor gelezen. Dit project is de basis voor IoT-weerstations, slimme domotica of omgevingsbewaking in kassen. De communicatie met de DHT22 loopt via pin GPIO 4 van de ESP32.

ESP32 Deep Sleep: batterij sparen (OLED + RTC RAM-teller)
De Deep Sleep-modus van de ESP32 schakelt de CPU en de meeste randapparatuur uit, waardoor het stroomverbruik daalt tot ongeveer 10µA; dat is cruciaal voor IoT-apparaten op batterijen. Dit project gebruikt drie wekbronnen: een timer (15 s), een externe pin (EXT0, de knop op GPIO 33) en een touchpin (T0/GPIO 4). Tellers met RTC_DATA_ATTR blijven behouden tijdens deep sleep.

Echte tijd van internet met ESP32 en NTP
De ESP32 verbindt met Wi-Fi en haalt met milliseconde-precisie de echte tijd op bij NTP-servers (Network Time Protocol). configTzTime() past de Turkse tijdzone (TRT, UTC+3) automatisch toe, en in landen met zomertijd wordt de overgang naar zomertijd (DST) geregeld met een POSIX TZ-string. De tijd wordt zowel naar de Serial Monitor als naar een optioneel I2C-lcd gestuurd.

Dotmatrixklok, kalender en weerstation (MAX7219, DS1307)
Een scrollend tekstbord voor op je bureau of aan de muur dat om de beurt de tijd, de datum en het weer in de kamer toont.

DS1302 RTC-klok met LCD-display
Een kleine bureauklok die de tijd bijhoudt, ook als de stroom uitvalt. De DS1302-klokmodule houdt de tijd bij dankzij een eigen kleine batterij; de Arduino leest hem elke seconde uit en schrijft tijd…
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

