Arduino SD Kart Modülü: Veri Kaydı, CSV, RTC ve Hata Çözümleri

Arduino SD kart modülü, sensörlerden okuduğun sıcaklık, nem, mesafe ya da konum verilerini microSD karta dosya olarak kaydetmeni sağlayan küçük ve ucuz bir karttır. Bilgisayara bağlı kalmadan günlerce, hatta aylarca ölçüm yapan bir veri kaydedici (datalogger) kurmanın en kolay yolu budur: Arduino ölçer, modül her ölçümü karttaki bir CSV dosyasına satır satır yazar, sen de kartı bilgisayara takıp verileri Excel'de grafiğe dökersin. Modül SPI ile bağlanır ve Arduino IDE ile birlikte gelen SD kütüphanesiyle birkaç satır kodla çalışır.

Bu rehberde modülün nasıl çalıştığını, 5V ve 3.3V modüller arasındaki farkı, Arduino Uno, Mega, ESP32 ve Raspberry Pi Pico için SPI bağlantısını, kartı FAT32 olarak biçimlendirmeyi, dosya yazıp okumayı ve bir RTC modülüyle tarih-saat damgalı CSV kaydı tutmayı adım adım öğreneceksin. Ayrıca ESP32'nin hızlı SD_MMC arayüzünü, Pico'da MicroPython ile SD kart kullanımını ve en sık karşılaşılan "initialization failed" hatasının çözümlerini ele alıyoruz.

SD kart modülü nedir, nasıl çalışır?

SD kartlar 3,3 V ile çalışır ve iki farklı yolla haberleşebilir: hızlı SD modu ve daha basit SPI modu. Arduino gibi mikrodenetleyiciler kartla SPI üzerinden konuşur. Modülün görevi aradaki elektriksel uyumu sağlamaktır: üzerindeki regülatör 5 V'u karta uygun 3,3 V'a düşürür, seviye dönüştürücü entegre (çoğunlukla 74LVC125A) ise Arduino'nun 5 V'luk sinyallerini kartın kaldırabileceği 3,3 V'a çevirir. Kartın içi 512 baytlık bloklardan oluşur; dosya, klasör ve dosya adı gibi kavramları FAT dosya sistemi yönetir. SD kütüphanesi bu karmaşık işleri senin yerine yapar; sen yalnızca dosya açar, yazar ve kapatırsın.

5V ve 3.3V modül farkı: hangisini almalısın?

Arduino Uno, Nano ya da Mega kullanıyorsan fotoğraftaki gibi regülatörlü ve seviye dönüştürücülü microSD modülünü seç ve VCC'yi 5V pinine bağla. ESP32 ve Pico 3,3 V ile çalışır; bu kartlarda da aynı modülü kullanabilirsin, ancak beslemesini yine 5 V'tan vermelisin (ESP32'de VIN, Pico USB'den beslenirken VBUS pini). Seviye dönüştürücü 3,3 V ile beslendiği için MISO hattından mikrodenetleyiciye giden sinyal zaten 3,3 V olur. Regülatörsüz modüller doğrudan 3V3 pinine bağlanır; bunları 5 V'luk bir Arduino ile kullanmak zorundaysan MOSI, SCK ve CS hatlarına 1 kΩ + 2 kΩ'luk birer gerilim bölücü koymalı ya da bir lojik seviye dönüştürücü kullanmalısın. Direnç değerlerini gerilim bölücü hesaplayıcı ile kontrol edebilirsin.

SD kart modülü bağlantısı: SPI pinleri

MISO, MOSI ve SCK her kartta donanımsal SPI pinlerine bağlanmak zorundadır; CS (chip select) ise herhangi bir dijital pin olabilir, yeter ki aynı numarayı koddaki SD.begin() fonksiyonuna yaz. Hazır shield'larda CS genellikle D4 ya da D10'dur. Aynı SPI hattına birden fazla cihaz bağlayabilirsin: hepsi MISO, MOSI ve SCK'yi paylaşır, her birinin kendi CS pini olur. SPI'ın çalışma mantığını SPI haberleşmesi yazısında ayrıntılı anlattık. Pinlerin kart üzerindeki yerini görmek için pin diyagramı aracını kullanabilirsin.

SD kartı hazırlamak: FAT32 biçimlendirme

• Kart boyutu: 4–32 GB arası bir microSDHC kart seç. Arduino SD kütüphanesi SDSC (2 GB'a kadar) ve SDHC kartları destekler; 64 GB ve üstü SDXC kartlar fabrikadan exFAT ile gelir ve bu kütüphane exFAT okuyamaz.
• Dosya sistemi: Kartı FAT32 olarak biçimlendir (2 GB ve altı kartlarda FAT16 da olur). NTFS ve exFAT çalışmaz.
• Windows: Dosya Gezgini'nde karta sağ tıkla, Biçimlendir'i seç, dosya sistemi olarak FAT32'yi ve varsayılan ayırma birimi boyutunu seç. 32 GB'tan büyük kartlarda Windows FAT32 seçeneği sunmaz.
• macOS: Disk İzlencesi'nde kartı seç, Sil'e tıkla, biçim olarak MS-DOS (FAT), şema olarak Ana Önyükleme Kaydı'nı seç.
• En güvenli yol: SD Association'ın ücretsiz SD Card Formatter programı kartı standarda uygun biçimlendirir ve garip hataların çoğunu giderir.
• Tek bölüm: Kartta tek bir bölüm (partition) olmalı. Daha önce Raspberry Pi ya da kamera gibi cihazlarda kullanılmış kartlarda birden fazla bölüm kalmış olabilir; biçimlendirmeden önce bunları sil.

Adım adım ilk test: SD karta yazma ve okuma

1. Biçimlendirdiğin kartı modüle tak ve modülü yukarıdaki tabloya göre Arduino'ya bağla.
2. SD kütüphanesi Arduino IDE ile birlikte gelir, ayrıca kurman gerekmez; kodun başına yalnızca SPI.h ve SD.h eklenir.
3. Aşağıdaki kodu yükle ve Seri Monitör'ü 9600 baud hızında aç.
4. "tamam" yazısını ve dosyanın içeriğini görüyorsan kart ve bağlantı doğrudur. Arduino her başladığında TEST.TXT dosyasına yeni bir satır eklenir.
5. Kartı çıkarıp bilgisayara taktığında TEST.TXT dosyasını herhangi bir metin düzenleyiciyle açabilirsin.

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}

CSV formatında sensör kaydı ve RTC ile zaman damgası

Bir datalogger için en pratik dosya biçimi CSV'dir (virgülle ayrılmış değerler): her satır bir ölçüm, her sütun bir değerdir ve ilk satıra sütun başlıkları yazılır. Ölçümlerin ne zaman yapıldığını bilmek için her satıra tarih ve saat eklemelisin. millis() yalnızca Arduino açıldığından beri geçen süreyi verir ve her resetlemede sıfırlanır; bu yüzden düğme pilli bir RTC (gerçek zamanlı saat) modülü kullanırız. RTC, Arduino kapalıyken bile saati saymayı sürdürür. DS1307 ucuzdur ama günde birkaç saniye kayabilir; DS3231 ise sıcaklık dengelemeli kristali sayesinde yılda yalnızca yaklaşık bir dakika sapar. Farklarını RTC saat modülleri yazısında karşılaştırdık.

Devre: SD modülü önceki tablodaki gibi SPI pinlerine, RTC modülü I2C hattına (Uno'da SDA = A4, SCL = A5, VCC = 5V), DHT22 sensörünün veri ucu ise D2'ye bağlanır; çıplak sensör kullanıyorsan veri ucu ile VCC arasına 10 kΩ'luk bir direnç ekle. Kütüphane Yöneticisi'nden RTClib (Adafruit) ve DHT sensor library kütüphanelerini kur. Sensör bağlantısının ayrıntıları için DHT11 ve DHT22 sıcaklık-nem sensörü yazısına bakabilirsin.

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}

Kod her 10 saniyede bir sıcaklık ve nemi okur, RTC'den tarih ve saati alır ve 2026-11-04,14:05:30,23.5,45.2 biçiminde bir satırı VERI.CSV dosyasının sonuna ekler. Dosya her kayıttan sonra kapatıldığı için elektrik kesilse bile o ana kadarki veriler kaybolmaz. AVR tabanlı kartlarda sprintf() ondalık sayıları (%f) desteklemez, bu yüzden sayılar önce dtostrf() ile metne çevrilir. Bekleme için delay() yerine millis() kullanıldığından loop() içinde başka işler de yapabilirsin. RTC hiç ayarlanmamışsa saat, kodun derlendiği ana kurulur. DS3231 kullanıyorsan RTC_DS1307 yerine RTC_DS3231 yazman ve isrunning() yerine lostPower() kontrolü yapman yeterlidir.

Ne kadar yer kaplar? Bir satır yaklaşık 31 bayttır. 10 saniyede bir kayıtla günde 8.640 satır, yani yaklaşık 260 KB veri oluşur; bir yılda bu yaklaşık 95 MB eder. Yani 8 GB'lık bir kart bu hızda onlarca yıl yeter. Asıl sınır kart değil beslemedir: projeyi pille çalıştıracaksan pil ömrü hesaplayıcı ile ne kadar dayanacağını önceden hesapla.

SD karttaki verileri Excel'de açmak

1. Arduino'nun beslemesini kes, kartı modülden çıkar ve bilgisayara tak.
2. VERI.CSV dosyasını bilgisayara kopyala; doğrudan kart üzerinde çalışmak yerine kopyayla çalışmak daha güvenlidir.
3. Excel'de boş bir çalışma kitabı aç ve Veri > Metinden/CSV'den ile dosyayı seç.
4. Önizleme penceresinde sınırlayıcı olarak Virgül'ü seç ve Yükle'ye tıkla; sütunlar tarih, saat, sıcaklık ve nem olarak ayrılır.
5. Sıcaklık ve nem sütunlarını seçip Ekle sekmesinden bir çizgi grafik ekle; değişimi zamana göre görürsün.

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

Arduino bilgisayara bağlıyken ölçümleri kartı çıkarmadan, canlı olarak Excel'e aktarmak istersen Arduino'dan Excel'e veri aktarma yazısındaki Data Streamer ve PLX-DAQ yöntemlerine göz at. SD kart ise bilgisayardan uzakta, sahada çalışan projelerin vazgeçilmezidir.

ESP32 ile SD kart kullanımı (SPI)

ESP32'nin Arduino çekirdeği kendi SD kütüphanesiyle gelir ve kullanımı neredeyse aynıdır, ancak üç önemli fark vardır: dosya yolları / ile başlar ("/olcumler.csv"), uzun dosya adları serbesttir ve FILE_WRITE dosyayı sıfırdan yazar. Sona eklemek için FILE_APPEND kullanmalısın; Uno kodunu olduğu gibi taşırsan her açılışta eski verilerin silinir. Varsayılan SPI pinleri SCK 18, MISO 19 ve MOSI 23'tür, CS için genellikle GPIO 5 kullanılır. Kart tipi ve boyutu da tek satırla okunabilir:

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}

Kod her 5 saniyede bir GPIO 34'e bağlı bir LDR'nin ham değerini (0–4095) kaydeder. ESP32'de gerçek saat için RTC modülü şart değildir: Wi-Fi'ye bağlanıp saati NTP sunucusundan alabilir, getLocalTime() ile her satıra zaman damgası ekleyebilirsin. Kablolar uzunsa ya da kart kararsız çalışıyorsa SPI hızını düşür: SD.begin(5, SPI, 1000000) kartı 1 MHz ile başlatır. Pille çalışan bir kaydedicide ölçümler arasında deep sleep kullanmak pil ömrünü kat kat uzatır.

ESP32 SD_MMC: hızlı SD arayüzü ve ESP32-CAM

ESP32'de SPI'ın yanında kartın kendi hızlı protokolünü konuşan bir SDMMC denetleyicisi de vardır. SD_MMC kütüphanesi 4-bit modda SPI'dan birkaç kat hızlıdır; fotoğraf ya da ses gibi büyük dosyalar için idealdir. Klasik ESP32'de pinler sabittir: CLK GPIO 14, CMD GPIO 15, D0 GPIO 2, D1 GPIO 4, D2 GPIO 12, D3 GPIO 13; bu hatlarda 10 kΩ'luk pull-up dirençleri gerekir. 1-bit modda yalnızca CLK, CMD ve D0 kullanılır; hız düşer ama GPIO 4, 12 ve 13 serbest kalır. ESP32-CAM kartındaki microSD yuvası bu pinlere bağlıdır ve 1-bit modu kullanmak, GPIO 4'teki flaş LED'inin her kart erişiminde yanıp sönmesini önler.

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}

Raspberry Pi Pico ile SD kart (MicroPython)

MicroPython'da SD kart için micropython-lib içindeki sdcard.py sürücüsü kullanılır. Bilgisayarında mpremote varsa mpremote mip install sdcard komutuyla kurabilir ya da dosyayı Thonny ile Pico'ya kopyalayabilirsin. Kart os.mount() ile /sd klasörü olarak bağlanır ve sonrasında sıradan Python dosya komutlarıyla (open, write) kullanılır. Aşağıdaki kod Pico'nun dahili sıcaklık sensörünü okuyup 10 saniyede bir CSV satırı yazar. Pico'yu yeni tanıyorsan önce Raspberry Pi Pico nedir yazısına göz at.

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

Pico'nun pilli bir saati yoktur: Thonny'ye bağlandığında saati bilgisayardan otomatik ayarlanır, tek başına çalışırken ise 1 Ocak 2021'den başlar. Doğru zaman damgası için bir DS3231 modülü ekleyebilir ya da Pico W'da saati NTP ile internetten alabilirsin. Kart takılı değilse ya da kablolar yanlışsa sürücü OSError: no SD card hatası verir. Pico'yu Arduino IDE ile (arduino-pico çekirdeği) programlıyorsan aynı SD kütüphanesi mantığını kullanabilirsin; varsayılan SPI0 pinleri tablodakilerle aynıdır ve CS için SD.begin(17) yazman yeterlidir.

Veri kaybını önlemek: güç, yazma sıklığı ve kart ömrü

• close() ya da flush() olmadan veri karta yazılmaz: Kütüphane veriyi önce 512 baytlık bir tamponda biriktirir. Dosyayı sürekli açık tutuyorsan birkaç satırda bir flush() çağır.
• Yazarken kartı çıkarma: Yazma sırasında kartı çekmek ya da beslemeyi kesmek dosya sistemini bozabilir. Kaydı durduran bir buton ve kaydın sürdüğünü gösteren bir LED eklemek iyi bir alışkanlıktır.
• Beslemeyi güçlü tut: Kart yazma anında 100 mA'e kadar akım çeker. Modülün VCC ile GND uçları arasına 10–100 µF'lık bir kondansatör eklemek gerilim düşmelerini ve rastgele yazma hatalarını azaltır.
• Çok sık açıp kapatma: Saniyede onlarca ölçüm alıyorsan her satırda dosyayı açıp kapatmak yavaştır; ölçümleri RAM'de biriktirip 10–20 satırda bir toplu yaz.
• Kart ömrü: SD kartlar yazmaları kendi içinde farklı hücrelere dağıtır (wear leveling); dakikada birkaç satırlık bir kaydedici kartı yıllarca yıpratmaz. Yine de bilinen bir markanın kartını tercih et.
• Dosyayı böl: Her gün için ayrı bir dosya (ör. 20261104.CSV) açmak dosyaları küçük tutar; bir sorun çıkarsa yalnızca o günün verisini kaybedersin.

SD kart modülüyle proje fikirleri

• Hava istasyonu kaydedici: BME280 ile sıcaklık, nem ve basıncı saatlik kaydet, mevsimlik grafik çıkar.
• Bitki sulama günlüğü: Toprak nem sensörü değerlerini ve pompanın çalıştığı anları kaydedip sulama düzenini incele.
• GPS rota kaydedici: NEO-6M GPS ile bisiklet ya da yürüyüş rotanı CSV olarak kaydet, sonra haritada göster.
• Kartlı giriş-çıkış kaydı: RFID RC522 ile okutulan her kartı tarih ve saatiyle dosyaya yaz.
• Enerji tüketimi takibi: ACS712 akım sensörü ile bir cihazın gün boyu çektiği akımı ölç ve kaydet.
• MP3 çalar: DFPlayer Mini kendi microSD yuvasıyla ses dosyalarını çalar; Arduino yalnızca komut gönderir.

Sık yapılan hatalar ve çözümleri

SD kart modülü, yalnızca ölçen bir projeyi kayıt tutan bir cihaza dönüştürür; birkaç gün boyunca topladığın gerçek veriler, tek bir anlık okumadan çok daha fazlasını anlatır. BlueGrays uygulamasında DHT22, DS1307 RTC, microSD ve OLED'li ESP32 sıcaklık kaydedici projesini, RTC'li dijital saatleri ve sıcaklık-nem ölçüm projelerini adım adım devre şemaları ve kodlarıyla bulabilirsin.