Modul Kartu SD Arduino: Data Logger CSV dengan Timestamp RTC

Modul kartu SD Arduino adalah board kecil dan murah yang memungkinkanmu menyimpan hasil pembacaan suhu, kelembapan, jarak, atau lokasi dari sensormu sebagai file di kartu micro SD. Ini cara paling mudah untuk membuat data logger yang mengukur selama berhari-hari, bahkan berbulan-bulan, tanpa komputer yang tersambung: Arduino melakukan pengukuran, modul menulis setiap hasil sebagai baris baru di file CSV pada kartu, lalu kamu tinggal mencolokkan kartu ke komputer dan membuat grafik datanya di Excel. Modul ini tersambung lewat SPI dan bekerja hanya dengan beberapa baris kode memakai library SD yang sudah ikut terpasang bersama Arduino IDE.

Di panduan ini kamu akan belajar langkah demi langkah cara kerja modul, perbedaan modul 5 V dan 3,3 V, pengkabelan SPI untuk Arduino Uno, Mega, ESP32, dan Raspberry Pi Pico, cara memformat kartu sebagai FAT32, cara menulis dan membaca file, serta cara membuat log CSV bertanda tanggal dan jam dengan modul RTC. Kita juga membahas antarmuka SD_MMC ESP32 yang cepat, memakai kartu SD di Pico dengan MicroPython, dan cara mengatasi error “initialization failed” yang sangat sering muncul.

Apa itu modul kartu SD dan bagaimana cara kerjanya?

Kartu SD bekerja pada 3,3 V dan bisa berkomunikasi dengan dua cara: mode SD bawaan yang cepat dan mode SPI yang lebih sederhana. Mikrokontroler seperti Arduino berbicara dengan kartu lewat SPI. Tugas modul adalah membuat keduanya cocok secara listrik: regulatornya menurunkan 5 V menjadi 3,3 V yang dibutuhkan kartu, dan chip level shifter (biasanya 74LVC125A) mengubah sinyal 5 V dari Arduino menjadi 3,3 V yang aman untuk kartu. Di dalamnya, kartu terdiri dari blok-blok 512 byte, sedangkan konsep seperti file, folder, dan nama file diatur oleh sistem file FAT. Library SD mengerjakan semua bagian rumit ini untukmu; kamu cukup membuka file, menulis ke dalamnya, lalu menutupnya.

Modul kartu SD 5 V vs 3,3 V: mana yang sebaiknya kamu beli?

Kalau kamu memakai Arduino Uno, Nano, atau Mega, pilih modul micro SD dengan regulator dan level shifter seperti yang ada di foto, lalu sambungkan VCC ke pin 5V. ESP32 dan Pico bekerja pada 3,3 V; kamu juga bisa memakai modul yang sama dengan keduanya, tetapi tetap beri dayanya dari 5 V (VIN di ESP32, VBUS di Pico ketika diberi daya lewat USB). Karena level shifter diberi daya 3,3 V, sinyal MISO yang kembali ke mikrokontroler sudah bernilai 3,3 V. Modul tanpa regulator disambungkan langsung ke pin 3V3; kalau kamu terpaksa memakainya dengan Arduino 5 V, pasang pembagi tegangan 1 kΩ + 2 kΩ di masing-masing jalur MOSI, SCK, dan CS, atau pakai konverter level logika. Kamu bisa mengecek nilai resistornya dengan kalkulator pembagi tegangan.

Pengkabelan modul kartu SD: pin SPI

MISO, MOSI, dan SCK harus masuk ke pin SPI hardware di setiap board; CS (chip select) boleh pin digital mana saja, asalkan kamu memberikan nomor yang sama ke SD.begin() di kodemu. Di shield siap pakai, CS biasanya D4 atau D10. Kamu bisa menyambungkan beberapa perangkat ke bus SPI yang sama: semuanya berbagi MISO, MOSI, dan SCK, dan masing-masing mendapat pin CS sendiri. Cara kerja SPI kami jelaskan secara detail di Apa Itu SPI?. Untuk melihat letak pin di board-mu, pakai alat diagram pin.

Menyiapkan kartu SD: memformat sebagai FAT32

• Ukuran kartu: pilih kartu micro SDHC antara 4 dan 32 GB. Library SD Arduino mendukung kartu SDSC (sampai 2 GB) dan SDHC; kartu SDXC 64 GB ke atas datang dengan format exFAT, yang tidak bisa dibaca library ini.
• Sistem file: format kartu sebagai FAT32 (FAT16 juga bisa untuk kartu 2 GB atau lebih kecil). NTFS dan exFAT tidak akan berfungsi.
• Windows: klik kanan kartu di File Explorer, pilih Format, lalu pilih FAT32 sebagai sistem file dan ukuran allocation unit default. Windows tidak menawarkan FAT32 untuk kartu yang lebih besar dari 32 GB.
• macOS: pilih kartu di Disk Utility, klik Erase, lalu pilih MS-DOS (FAT) sebagai format dan Master Boot Record sebagai skema.
• Pilihan paling aman: alat gratis SD Card Formatter dari SD Association memformat kartu sesuai standar resmi dan membereskan sebagian besar error yang aneh.
• Satu partisi: kartu sebaiknya hanya punya satu partisi. Kartu yang sebelumnya dipakai di Raspberry Pi atau kamera mungkin masih punya beberapa partisi; hapus semuanya sebelum memformat.

Tes pertama langkah demi langkah: menulis ke kartu SD dan membacanya

1. Masukkan kartu yang sudah diformat ke modul, lalu sambungkan modul ke Arduino sesuai tabel di atas.
2. Library SD sudah ikut bersama Arduino IDE, jadi tidak ada yang perlu diinstal; kamu cukup menambahkan SPI.h dan SD.h di bagian atas sketch.
3. Upload kode di bawah ini dan buka Serial Monitor pada 9600 baud.
4. Kalau kamu melihat “tamam” (OK dalam bahasa Turki) dan isi file, berarti kartu dan pengkabelannya sudah benar. Setiap kali board menyala, satu baris baru ditambahkan ke TEST.TXT.
5. Ketika kartu kamu lepas dan colokkan ke komputer, TEST.TXT bisa dibuka dengan editor teks apa pun.

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}

Mencatat data sensor ke CSV dengan timestamp RTC

Format file paling praktis untuk data logger adalah CSV (comma-separated values, nilai yang dipisahkan koma): setiap baris adalah satu pengukuran, setiap kolom satu nilai, dan baris pertama berisi judul kolom. Supaya tahu kapan setiap pembacaan diambil, kamu perlu menambahkan tanggal dan jam di setiap baris. millis() hanya memberi tahu berapa lama Arduino sudah berjalan dan kembali ke nol setiap kali board restart, jadi kita memakai modul RTC (real-time clock, jam waktu nyata) dengan baterai koin. RTC terus menghitung bahkan ketika Arduino dimatikan. DS1307 murah tetapi bisa meleset beberapa detik per hari, sedangkan DS3231 hanya meleset sekitar satu menit per tahun berkat kristalnya yang terkompensasi suhu. Keduanya kami bandingkan di modul jam RTC.

Rangkaiannya: modul SD masuk ke pin SPI seperti pada tabel di atas, modul RTC ke bus I2C (di Uno SDA = A4, SCL = A5, VCC = 5V), dan pin data sensor DHT22 ke D2; kalau kamu memakai sensor tanpa modul, tambahkan resistor 10 kΩ di antara pin data dan VCC. Instal library RTClib (Adafruit) dan DHT sensor library dari Library Manager. Untuk detail pengkabelan sensornya, lihat sensor suhu dan kelembapan DHT11 dan DHT22.

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}

Setiap 10 detik kode membaca suhu dan kelembapan, mengambil tanggal dan jam dari RTC, lalu menambahkan baris seperti 2026-11-04,14:05:30,23.5,45.2 ke akhir VERI.CSV. Karena file ditutup setelah setiap catatan, data yang sudah tersimpan tetap aman bahkan ketika listrik padam. Di board AVR, sprintf() tidak mendukung bilangan desimal (%f), jadi nilainya diubah dulu menjadi teks dengan dtostrf(). Karena pengaturan waktunya memakai millis() alih-alih delay(), kamu juga bisa mengerjakan hal lain di loop(). Kalau RTC belum pernah diatur, jamnya diatur ke momen ketika kode dikompilasi. Kalau kamu memakai DS3231, cukup tulis RTC_DS3231 alih-alih RTC_DS1307 dan cek lostPower() alih-alih isrunning().

Berapa banyak ruang yang dipakai? Satu baris kira-kira 31 byte. Mencatat setiap 10 detik menghasilkan 8.640 baris per hari, atau sekitar 260 KB; dalam setahun jumlahnya kira-kira 95 MB. Jadi dengan laju ini, kartu 8 GB cukup untuk puluhan tahun. Batas sebenarnya bukan kartunya, melainkan catu dayanya: kalau proyekmu akan berjalan dengan baterai, hitung dulu berapa lama baterainya akan bertahan dengan kalkulator umur baterai.

Membuka data kartu SD di Excel

1. Putuskan daya Arduino, keluarkan kartu dari modul, lalu colokkan ke komputermu.
2. Salin VERI.CSV ke komputermu; bekerja dengan salinan lebih aman daripada langsung di kartu.
3. Buka workbook kosong di Excel dan pilih file lewat Data > From Text/CSV.
4. Di jendela pratinjau, pilih Comma sebagai pemisah (delimiter) lalu klik Load; kolom-kolomnya akan terbagi menjadi tanggal, jam, suhu, dan kelembapan.
5. Pilih kolom suhu dan kelembapan, lalu tambahkan grafik garis dari tab Insert untuk melihat perubahannya dari waktu ke waktu.

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

Kalau kamu lebih suka mengirim pembacaan secara langsung ke Excel selama Arduino tersambung ke komputer, tanpa mencabut kartu, coba lihat metode Data Streamer dan PLX-DAQ di mengirim data Arduino ke Excel. Sebaliknya, kartu SD wajib untuk proyek yang berjalan di lapangan, jauh dari komputer.

Memakai kartu SD dengan ESP32 (SPI)

Core Arduino untuk ESP32 punya library SD sendiri dan cara pakainya hampir sama, tetapi ada tiga perbedaan penting: path file diawali / ("/olcumler.csv"), nama file panjang diperbolehkan, dan FILE_WRITE menimpa file dari awal. Untuk menambahkan data di akhir, kamu harus memakai FILE_APPEND; kalau kode Uno kamu pindahkan begitu saja, data lamamu terhapus setiap kali board menyala. Pin SPI default-nya SCK 18, MISO 19, dan MOSI 23, dan GPIO 5 biasanya dipakai untuk CS. Kamu juga bisa membaca jenis dan ukuran kartu dengan satu baris:

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}

Kode ini mencatat nilai mentah (0–4095) dari LDR yang tersambung ke GPIO 34 setiap 5 detik. Di ESP32 kamu bahkan tidak perlu modul RTC untuk waktu nyata: kamu bisa terhubung ke Wi-Fi, mengambil waktu dari server NTP, dan menambahkan timestamp di setiap baris dengan getLocalTime(). Kalau kabelmu panjang atau kartunya tidak stabil, turunkan kecepatan SPI: SD.begin(5, SPI, 1000000) memulai kartu pada 1 MHz. Pada logger bertenaga baterai, memakai deep sleep di antara pembacaan bisa melipatgandakan umur baterai.

SD_MMC ESP32: antarmuka SD yang cepat dan ESP32-CAM

Selain SPI, ESP32 juga punya kontroler SDMMC yang berbicara dengan protokol cepat milik kartu itu sendiri. Dalam mode 4-bit, library SD_MMC beberapa kali lebih cepat daripada SPI, sehingga ideal untuk file besar seperti foto atau audio. Di ESP32 klasik pinnya tetap: CLK GPIO 14, CMD GPIO 15, D0 GPIO 2, D1 GPIO 4, D2 GPIO 12, D3 GPIO 13, dan jalur-jalur ini butuh resistor pull-up 10 kΩ. Dalam mode 1-bit hanya CLK, CMD, dan D0 yang dipakai; memang lebih lambat, tetapi GPIO 4, 12, dan 13 jadi bebas. Slot micro SD di board ESP32-CAM tersambung ke pin-pin ini, dan memakai mode 1-bit mencegah LED flash di GPIO 4 berkedip setiap kali kartu diakses.

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}

Kartu SD dengan Raspberry Pi Pico (MicroPython)

Di MicroPython, kartu SD ditangani oleh driver sdcard.py dari micropython-lib. Kalau di komputermu ada mpremote, instal dengan mpremote mip install sdcard, atau salin file-nya ke Pico dengan Thonny. Kartu di-mount sebagai folder /sd dengan os.mount(), lalu setelah itu kamu memakainya dengan perintah file Python biasa (open, write). Kode di bawah membaca sensor suhu bawaan Pico dan menulis satu baris CSV setiap 10 detik. Kalau kamu baru mengenal Pico, baca dulu Apa Itu 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 seconds

Pico tidak punya jam dengan baterai cadangan: ketika tersambung ke Thonny, jamnya diatur otomatis dari komputermu, tetapi kalau berjalan sendiri, jamnya mulai dari 1 Januari 2021. Untuk timestamp yang akurat, kamu bisa menambahkan modul DS3231, atau di Pico W mengambil waktu dari internet lewat NTP. Kalau tidak ada kartu yang terpasang atau pengkabelannya salah, driver akan memunculkan OSError: no SD card. Kalau kamu memprogram Pico dengan Arduino IDE (core arduino-pico), kamu bisa memakai cara yang sama dengan library SD; pin SPI0 default-nya sesuai dengan tabel, dan kamu cukup menulis SD.begin(17) untuk CS.

Mencegah kehilangan data: daya, frekuensi penulisan, dan umur kartu

• Tanpa close() atau flush(), tidak ada yang sampai ke kartu: library mengumpulkan data dulu di buffer 512 byte. Kalau file kamu biarkan terbuka terus, panggil flush() setiap beberapa baris.
• Jangan cabut kartu ketika sedang menulis: mencabut kartu atau memutus daya di tengah penulisan bisa merusak sistem file. Menambahkan tombol untuk menghentikan pencatatan dan LED yang menunjukkan pencatatan sedang aktif adalah kebiasaan yang baik.
• Jaga catu daya tetap kokoh: kartu menarik arus sampai 100 mA ketika menulis. Kapasitor 10–100 µF di antara VCC dan GND modul mengurangi penurunan tegangan dan error penulisan acak.
• Jangan terlalu sering membuka dan menutup file: kalau kamu mengambil puluhan pembacaan per detik, membuka dan menutup file untuk setiap baris itu lambat; tampung pembacaan di RAM dan tulis sekaligus per 10–20 baris.
• Umur kartu: kartu SD menyebarkan penulisan ke sel-sel yang berbeda di dalamnya (wear leveling), jadi logger yang menulis beberapa baris per menit tidak akan membuat kartu aus selama bertahun-tahun. Meski begitu, pilih kartu dari merek yang terkenal.
• Pecah file-nya: membuka file terpisah untuk setiap hari (misalnya 20261104.CSV) membuat file tetap kecil, dan kalau ada masalah, kamu hanya kehilangan data hari itu.

Ide proyek dengan modul kartu SD

• Logger stasiun cuaca: catat suhu, kelembapan, dan tekanan setiap jam dengan BME280 dan buat grafik untuk satu musim penuh.
• Log penyiraman tanaman: catat pembacaan sensor kelembapan tanah dan momen-momen ketika pompa menyala untuk mempelajari pola penyiramanmu.
• Logger rute GPS: simpan rute bersepeda atau hiking-mu sebagai CSV dengan GPS NEO-6M, lalu tampilkan di peta.
• Log akses berbasis kartu: tulis setiap kartu yang dipindai dengan RFID RC522 ke file beserta tanggal dan jamnya.
• Pemantau pemakaian energi: ukur dan catat arus yang ditarik sebuah perangkat sepanjang hari dengan sensor arus ACS712.
• Pemutar MP3: DFPlayer Mini memutar file audio dari slot micro SD-nya sendiri; Arduino hanya mengirim perintah.

Kesalahan umum dan cara memperbaikinya

Modul kartu SD mengubah proyek yang hanya mengukur menjadi perangkat yang menyimpan catatan, dan data nyata selama beberapa hari jauh lebih banyak bercerita daripada satu pembacaan saja. Di aplikasi BlueGrays kamu akan menemukan proyek Pencatat Data Suhu ESP32 dengan DHT22, RTC DS1307, micro SD, dan OLED, jam digital berbasis RTC, serta proyek suhu dan kelembapan, semuanya lengkap dengan skema rangkaian dan kode langkah demi langkah.