Componenten · 13 min leestijd

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".

Arduino micro-SD-kaartmodule
Micro-SD-kaartmodule: kaartsleuf, 3,3V-regelaar, niveauconverterchip en 6 pinnen (GND, VCC, MISO, MOSI, SCK, CS).

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.

EigenschapWaarde
InterfaceSPI (MISO, MOSI, SCK, CS)
Voeding (micro-SD-module met regelaar)4,5–5,5 V, 3,3V-regelaar op het board
SignaalniveauCompatibel met 3,3 V en 5 V (dankzij de niveauconverter)
Ondersteunde kaartenmicro SD (tot 2 GB) en micro SDHC (4–32 GB)
BestandssysteemFAT16 of FAT32
StroomEen 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 moduleVoedingSignaalniveauGeschikt voor
Micro-SD-module met regelaar (74LVC125A)5 V3,3 V en 5 VUno, 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 VDe meeste hebben geen echte niveauconverter3,3V-boards; onbetrouwbaar met 5V-signalen
Micro-SD-module zonder regelaar (kale sleuf)Alleen 3,3 VAlleen 3,3 VESP32, Raspberry Pi Pico
Boards met ingebouwde sleuf (zoals de ESP32-CAM)Van het board3,3 VDirect 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.

De meest gemaakte fout is een micro-SD-module met regelaar voeden met 3,3 V. De AMS1117-regelaar op de module laat ongeveer 1 V weg, dus er komt maar zo'n 2,3 V bij de kaart, en meestal meldt die dan initialization failed. Het omgekeerde is even erg: 5 V op de pinnen van een module zonder regelaar zetten kan de kaart blijvend beschadigen. Lees de labels op de module en controleer of er een regelaar op zit voordat je hem aansluit.

Bedrading van de SD-kaartmodule: SPI-pinnen

ModulepinArduino Uno / NanoArduino MegaESP32Raspberry Pi Pico
GNDGNDGNDGNDGND
VCC5V5VVIN (5 V)VBUS (5 V)
MISOD12D50GPIO 19GP16
MOSID11D51GPIO 23GP19
SCKD13D52GPIO 18GP18
CSD10D53GPIO 5GP17

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.
De SD-bibliotheek op de Arduino Uno verwerkt alleen korte bestandsnamen in het 8.3-formaat: een naam van maximaal 8 tekens en een extensie van maximaal 3, zonder spaties of speciale tekens. DATA.CSV of LOG01.TXT werkt, maar een lange naam als temperature-log.csv laat SD.open() zonder melding mislukken. Op de ESP32 en Pico kun je gewoon lange bestandsnamen gebruiken.

Eerste test stap voor stap: schrijven naar en lezen van de SD-kaart

  1. Steek de geformatteerde kaart in de module en sluit de module aan op de Arduino volgens de tabel hierboven.
  2. 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.
  3. Upload de onderstaande code en open de Serial Monitor op 9600 baud.
  4. 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.
  5. Als je de kaart eruit haalt en in je computer steekt, kun je TEST.TXT openen in elke teksteditor.
C++ (Arduino IDE)
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}
FunctieWat 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.

DS1307 RTC-klokmodule
De DS1307 RTC-module wordt via I2C (SDA, SCL) aangesloten en houdt de tijd bij op zijn knoopcel, ook als de Arduino uit staat.

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.

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

  1. Haal de voeding van de Arduino los, neem de kaart uit de module en steek hem in je computer.
  2. Kopieer VERI.CSV naar je computer; werken met een kopie is veiliger dan rechtstreeks op de kaart.
  3. Open een leeg werkblad in Excel en kies het bestand via Gegevens > Uit tekst/CSV.
  4. Selecteer in het voorbeeldvenster Komma als scheidingsteken en klik op Laden; de kolommen worden gesplitst in datum, tijd, temperatuur en luchtvochtigheid.
  5. 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.
Gebruikt jouw Excel een komma als decimaalteken (zoals bij Nederlandse, Turkse, Duitse, Franse, Spaanse of Italiaanse instellingen), dan wordt een waarde als 23.5 mogelijk niet als getal herkend en verschijnt die als tekst, datum of een verkeerd getal. Er zijn twee oplossingen: klik tijdens het importeren op Gegevens transformeren en zet de kolommen temperatuur en luchtvochtigheid om naar decimale getallen met de landinstelling Engels (Verenigde Staten), of pas de code zoals hieronder aan zodat die een puntkomma als scheidingsteken en een komma als decimaalteken gebruikt. Met de tweede optie dubbelklik je gewoon op het bestand en splitst Excel de kolommen zelf.
C++ (Arduino IDE)
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_yuzde

Wil 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:

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

C++ (Arduino IDE)
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}
GPIO 12 is een strapping-pin die de spanning van het flashgeheugen bepaalt tijdens het opstarten van de ESP32. In 4-bitmodus kan de pull-upweerstand op de D2-lijn ervoor zorgen dat sommige modules helemaal niet opstarten; gebeurt dat, gebruik dan 1-bitmodus. Op nieuwere chips zoals de ESP32-S3 kun je de pinnen vrij kiezen met SD_MMC.setPins().

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?

MicroPython
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 seconds

De 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

SymptoomWaarschijnlijke oorzaakOplossing
"initialization failed"Geen kaart geplaatst, verkeerde bedrading, of de CS-pin komt niet overeen met de codeControleer 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 zwakVoed 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 meerFormatteer 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 geslotenGebruik een korte naam als VERI.CSV en sluit elk bestand met close()
Het bestand is leeg of de laatste regels ontbrekenDe stroom viel weg voordat close() of flush() werd aangeroepenSluit het bestand na elke regel of roep regelmatig flush() aan
De SD-kaart werkt niet meer als je een ander SPI-apparaat toevoegtDe CS van het andere apparaat zweeft, of de module geeft de MISO-lijn niet vrijZet 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 vreemdHet RAM is vol: de SD-bibliotheek gebruikt ongeveer 650 byte en de buffer van een OLED-display 1 KBVerpak tekst in F(); stap zo nodig over op een Mega of een ESP32
Op de ESP32 worden oude gegevens bij elke start gewistHet bestand wordt geopend met FILE_WRITEGebruik FILE_APPEND om aan het einde toe te voegen
"Card Mount Failed" op de ESP32Voeding, bedrading, een te hoge SPI-snelheid, of ontbrekende pull-ups bij SD_MMCVerlaag de SPI-snelheid naar 1 MHz; probeer 1-bitmodus met SD_MMC
De snelste manier om het probleem op te sporen is het voorbeeld File > Examples > SD > CardInfo in de Arduino IDE. Toont het het kaarttype (SD1, SD2 of SDHC) maar vindt het geen partitie, dan zit het probleem in de formattering; kan het zelfs het kaarttype niet tonen, controleer dan de bedrading en de voeding.

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.

Alle projecten bekijken
Temperatuur en luchtvochtigheid met DHT11
AR-55Gemiddeld

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…

4.7(47)
83
ESP32-temperatuurlogger (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Gevorderd
Premium

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.

4.7(7)
12
Digitale klok met ESP32 en DS1307-RTC (I2C + LCD)
ES-18Gemiddeld
Premium

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.

4.6(26)
40
ESP32 DHT22 temperatuur en luchtvochtigheid (met LCD)
ES-15Gemiddeld

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.

4.8(38)
57
ESP32 Deep Sleep: batterij sparen (OLED + RTC RAM-teller)
ES-33Gevorderd
Premium

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.

4.3(10)
16
Echte tijd van internet met ESP32 en NTP
ES-26Gevorderd
Premium

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.

4.5(13)
22
Dotmatrixklok, kalender en weerstation (MAX7219, DS1307)
AR-85Gemiddeld
Premium

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.

5.0(50)
66
DS1302 RTC-klok met LCD-display
AR-46Gemiddeld
Premium

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…

4.7(41)
51