Artikel ini akan menjelaskan langkah-langkah untuk menghubungkan kartu MicroSD dengan board ESP32 menggunakan Arduino IDE.
Daftar isi:
2. Cara Antarmuka ESP32 dengan Modul Kartu MicroSD
6. Menjalankan Fungsi Berbeda pada Kartu MicroSD Menggunakan ESP32
- 6.1. Membuat Direktori di Kartu MicroSD
- 6.2. Daftar Direktori di Kartu MicroSD
- 6.3. Menghapus Direktori
- 6.4. Dapatkan Jenis Kartu MicroSD
- 6.5. Dapatkan Ukuran Kartu SD
1. Modul Kartu MicroSD
Modul kartu MicroSD merupakan sensor ESP32 yang dapat menghubungkan kartu SD ke papan mikrokontroler Anda. Ia bekerja melalui protokol komunikasi SPI. Hal ini memungkinkan ESP32 atau papan mikrokontroler lainnya seperti Arduino untuk mengakses data yang disimpan di kartu SD melalui protokol SPI.
Tegangan kerja modul SD card adalah 3,3V, sehingga tidak dapat dihubungkan langsung ke ESP32 atau board mikrokontroler lainnya. Untuk itu kita perlu menggunakan modul atau sensor kartu SD yang bekerja di atas 5V.
1.1. Pinout
Kartu MicroSD memiliki total enam pin. Dua di antaranya adalah pin daya: VCC dan GND. Sedangkan pembacaan empat pin digunakan untuk protokol komunikasi SPI. Berikut detail keenam pin tersebut:
Pin Daya:
- VCC: Terhubung ke pin ESP32 5V.
- GND: Terhubung ke pin ground ESP32 (GND).
Pin SPI:
- SUP KEDELAI JEPANG: (Master In Slave Out) Menyambungkan ke pin ESP32 MOSI (Master Out Slave In).
- MEROKOK: Terhubung ke pin ESP32 MISO (Master In Slave Out).
- SCK: Terhubung ke pin ESP32 SCK (Serial Clock).
- SS: (Slave Select) Menghubungkan ke pin yang ditentukan dalam kode Arduino sebagai pin SS (Slave Select).
2. Cara Antarmuka ESP32 dengan Modul Kartu MicroSD
Untuk menghubungkan ESP32 dengan modul kartu MicroSD, Anda perlu mengatur pin daya untuk sensor kartu SD Anda. Selanjutnya atur pin SPI. Di sini Anda memiliki dua pilihan, Anda dapat mengatur pin SPI default atau menentukan pin SPI kustom Anda sendiri.
Saat menggunakan pin SPI default, kita akan menambahkan SD jam Dan SD_MMC.h perpustakaan. Secara default, perpustakaan ini mengambil pin VSPI SPI (23, 19, 18, 5) untuk komunikasi SPI. Namun, Anda juga dapat mengatur pin lain untuk komunikasi SPI.
ESP32 berisi dua antarmuka SPI HSPI dan VSPI dengan detail pinnya sebagai berikut:
| SPI | MEROKOK | SUP KEDELAI JEPANG | CLK | CS |
| VSPI | D23 | D19 | D18 | D5 |
| HSPI | D13 | D12 | D14 | D15 |
Terkait: Referensi Pinout ESP32 – Panduan Lengkap
2.2. Siapkan Kartu SD
Selanjutnya, sebelum Anda dapat melanjutkan membaca dan menulis data ke kartu MicroSD, Anda harus mengaturnya terlebih dahulu dengan memformat data sebelumnya yang ada di dalamnya.
Buka kartu SD Anda menggunakan pembaca kartu apa saja dan format dia.
Pilih FAT32 untuk sistem file kartu Anda dan klik Awal .
Setelah memformat kartu, pilih OKE .
Sekarang kartu SD Anda siap dihubungkan dengan ESP32 menggunakan modul kartu SD.
2.3. Diagram skematik
Untuk menghubungkan sensor kartu MicroSD dengan ESP32, ikuti konfigurasi yang diberikan di bawah ini:
Berikut tabel konfigurasi pin kabel sambungan:
| Kartu MicroSD | ESP32 |
| GND | GND |
| VCC | DATANG |
| CS | D5 |
| MEROKOK | D23 |
| SCK | D18 |
| SUP KEDELAI JEPANG | D19 |
3. Perangkat keras
Untuk perangkat keras, Anda hanya memerlukan beberapa kabel jumper, papan tempat memotong roti beserta modul ESP32 dan kartu SD.
4. Kode
Sekarang kita akan menulis kode yang akan membuat file teks di dalam kartu MicroSD dan setelah itu, ia menulis beberapa string teks ke dalamnya. Setelah selesai, kita akan membaca isi file teks pada monitor serial Arduino IDE.
Mulai Arduino IDE dan kompilasi kode yang diberikan. Setelah itu bakar ke papan ESP32 Anda:
#termasuk#termasuk
File File saya ;
konstanta ke dalam CS = 5 ;
// Tulis pesan yang diberikan ke file di jalur yang ditentukan
ruang kosong File Tulis ( konstanta arang * jalur , konstanta arang * pesan ) {
// Buka berkasnya. Ini mendukung satu file untuk dibuka pada satu waktu
// tutup file lainnya sebelum membuka file baru
file saya = SD. membuka ( jalur , FILE_TULIS ) ;
jika ( file saya ) {
Serial. printf ( 'Menulis ke %s' , jalur ) ;
file saya. cetakln ( pesan ) ;
file saya. menutup ( ) ; // Tutup berkasnya
Serial. cetakln ( 'lengkap.' ) ;
} kalau tidak {
Serial. cetakln ( 'kesalahan saat membuka file' ) ;
Serial. cetakln ( jalur ) ;
}
}
// Cetak konten file pada jalur yang ditentukan
ruang kosong File Baca ( konstanta arang * jalur ) {
// Membuka file
file saya = SD. membuka ( jalur ) ;
jika ( file saya ) {
Serial. printf ( 'Membaca file dari %s \N ' , jalur ) ;
// Baca file lengkap hingga mencapai yang terakhir
ketika ( file saya. tersedia ( ) ) {
Serial. menulis ( file saya. membaca ( ) ) ;
}
file saya. menutup ( ) ; // Tutup berkasnya
} kalau tidak {
// Jika file gagal dibuka, cetak kesalahan:
Serial. cetakln ( 'kesalahan saat membuka test.txt' ) ;
}
}
ruang kosong mempersiapkan ( ) {
Serial. mulai ( 9600 ) ;
menunda ( 500 ) ;
ketika ( ! Serial ) { ; }
Serial. cetakln ( 'Menginisialisasi kartu SD...' ) ;
jika ( ! SD. mulai ( CS ) ) {
Serial. cetakln ( 'Inisialisasi gagal!' ) ;
kembali ;
}
Serial. cetakln ( 'Inisialisasi selesai.' ) ;
File Tulis ( '/test.txt' , 'Linuxhint.com' ) ;
File Baca ( '/test.txt' ) ;
}
ruang kosong lingkaran ( ) {
}
4.1. Penjelasan Kode
Untuk pemahaman yang lebih baik, kami akan membagi kode ini menjadi beberapa subbagian.
Inisialisasi dan Pengaturan: Pertama, kode dimulai dengan memasukkan beberapa perpustakaan penting yang terkait dengan modul kartu SD. Pustaka SPI.h ditambahkan untuk komunikasi dengan kartu SD dan SD.h untuk menangani pengoperasian kartu SD. Selanjutnya, ia mendefinisikan variabel global file saya dari jenis file untuk mengelola operasi file. Konstanta CS diatur ke pin 5, yang akan digunakan sebagai pin Chip Select (CS) untuk kartu SD.
Pengaturan() Fungsi: Di dalam fungsi pengaturan, komunikasi serial dimulai. Setelah itu, kami menginisialisasi modul kartu SD menggunakan fungsi SD.begin(CS). Selanjutnya, kami juga telah mendefinisikan dua fungsi berbeda untuk membaca dan menulis teks ke file teks.
Menulis ke Kartu SD: Fungsi WriteFile() membuka file test.txt untuk menulis menggunakan SD.open(path, FILE_WRITE). Setelah itu, ia menulis string Linuxhint.com ke file menggunakan myFile.println(message).
Membaca dari Kartu SD: Untuk membaca konten file, kami telah menggunakan fungsi ReadFile(). Jika berhasil terbaca maka data akan dikirim ke port serial arduino dan ditampilkan pada monitor serial arduino IDE.
5. Keluaran
Pada outputnya, Anda dapat melihat string yang sama yang kami definisikan di dalam kode Arduino IDE ditampilkan pada monitor serial Arduino IDE Anda.
6. Menjalankan Fungsi Berbeda pada Kartu MicroSD Menggunakan ESP32
Kita dapat melakukan berbagai operasi seperti membuat, menghapus, atau menambahkan direktori di kartu MicroSD langsung melalui kode Arduino IDE.
6.1. Membuat Direktori di Kartu MicroSD
Kode di bawah ini akan membuat direktori baru di dalam kartu MicroSD. Ini mendefinisikan fungsi yang disebut buatDir yang mengambil objek sistem file (fs::FS) dan jalur sebagai input. Fungsi ini mencoba membuat direktori dengan jalur yang ditentukan dan mencetak pesan yang menunjukkan keberhasilan atau kegagalan.
#sertakan 'FS.h'#sertakan 'SD.h'
#sertakan 'SPI.h'
ruang kosong buatDir ( fs :: FS & fs , konstanta arang * jalur ) {
Serial. printf ( 'Membuat Dir: %s \N ' , jalur ) ;
jika ( fs. mkdir ( jalur ) ) {
Serial. cetakln ( 'Dir dibuat' ) ;
} kalau tidak {
Serial. cetakln ( 'mkdir gagal' ) ;
}
}
ruang kosong mempersiapkan ( ) {
Serial. mulai ( 115200 ) ;
// Inisialisasi kartu SD
jika ( ! SD. mulai ( ) ) {
Serial. cetakln ( 'Pemasangan Kartu Gagal' ) ;
kembali ;
}
// Buat direktori bernama 'mydir'
buatDir ( SD , '/ mydir' ) ;
}
ruang kosong lingkaran ( ) {
}
Di output, Anda dapat melihat direktori baru dibuat /mydir nama.
6.2. Daftar Direktori di Kartu MicroSD
Dalam kode di bawah ini, kami akan mencantumkan semua direktori yang ada di dalam kartu MicroSD. Itu daftarDir fungsi secara rekursif mencantumkan isi direktori pada kartu SD. Ini mencetak informasi tentang direktori (diawali dengan “DIR”) dan file (diawali dengan “FILE”), termasuk nama dan ukurannya.
#sertakan 'FS.h'#sertakan 'SD.h'
#sertakan 'SPI.h'
ruang kosong daftarDir ( fs :: FS & fs , konstanta arang * nama dirname , uint8_t tingkat ) {
Serial. printf ( 'Daftar direktori: %s \N ' , nama dirname ) ;
Akar berkas = fs. membuka ( nama dirname ) ;
jika ( ! akar ) {
Serial. cetakln ( 'Gagal membuka direktori' ) ;
kembali ;
}
jika ( ! akar. adalahDirektori ( ) ) {
Serial. cetakln ( 'Bukan direktori' ) ;
kembali ;
}
berkas berkas = akar. buka File Berikutnya ( ) ;
ketika ( mengajukan ) {
jika ( mengajukan. adalahDirektori ( ) ) {
Serial. mencetak ( ' ANDA : ' ) ;
Serial. cetakln ( mengajukan. nama ( ) ) ;
jika ( tingkat ) {
daftarDir ( fs , mengajukan. nama ( ) , tingkat - 1 ) ;
}
} kalau tidak {
Serial. mencetak ( ' FILE : ' ) ;
Serial. mencetak ( mengajukan. nama ( ) ) ;
Serial. mencetak ( ' UKURAN: ' ) ;
Serial. cetakln ( mengajukan. ukuran ( ) ) ;
}
mengajukan = akar. buka File Berikutnya ( ) ;
}
}
ruang kosong mempersiapkan ( ) {
Serial. mulai ( 115200 ) ;
jika ( ! SD. mulai ( ) ) {
Serial. cetakln ( 'Pemasangan Kartu Gagal' ) ;
kembali ;
}
daftarDir ( SD , '/' , 0 ) ;
}
ruang kosong lingkaran ( ) {
}
Hasilnya, Anda dapat melihat dua file berbeda. Salah satunya adalah file teks dan yang lainnya adalah direktori yang kita buat di dalam kode sebelumnya.
6.3. Menghapus Direktori
Sekarang kita akan menghapus direktori dan file teks yang dibuat sebelumnya. Untuk itu kita akan menggunakan hapusDir fungsinya, Ini akan mencoba menghapus direktori yang ditentukan oleh jalur. Jika berhasil, itu akan dicetak Dir dihapus ; jika tidak, itu akan dicetak rmdir gagal .
#sertakan 'FS.h'#sertakan 'SD.h'
#sertakan 'SPI.h'
ruang kosong hapusDir ( fs :: FS & fs , konstanta arang * jalur ) {
Serial. printf ( 'Menghapus Dir: %s \N ' , jalur ) ;
jika ( fs. adalah rm ( jalur ) ) {
Serial. cetakln ( 'Dir dihapus' ) ;
} kalau tidak {
Serial. cetakln ( 'rmdir gagal' ) ;
}
}
ruang kosong mempersiapkan ( ) {
Serial. mulai ( 115200 ) ;
jika ( ! SD. mulai ( ) ) {
Serial. cetakln ( 'Pemasangan Kartu Gagal' ) ;
kembali ;
}
}
ruang kosong lingkaran ( ) {
}
6.4. Dapatkan Jenis Kartu MicroSD
Kartu MicroSD atau S aman D Kartu igital awalnya dirancang oleh asosiasi kartu SD, dan dirancang untuk digunakan pada perangkat portabel seperti ponsel cerdas dan kamera. Kartu SD pada dasarnya berisi empat jenis keluarga:
- SDSC (Kapasitas Standar SD): Kartu ini menawarkan kapasitas penyimpanan sederhana sebesar 2GB dan menggunakan sistem file FAT-12 dan FAT-16.
- SDHC (SD Kapasitas Tinggi): Kartu ini berkisar dari 2GB hingga 32GB dan menggunakan sistem file FAT-32.
- SDXC (SD Kapasitas Tambahan): Kartu ini menggunakan sistem file exFAT dan mulai dari 32GB hingga 2TB.
- SDIO: Kartu SDIO memiliki tujuan ganda dengan menggabungkan penyimpanan data dengan fungsi INPUT/OUTPUT.
Untuk memeriksa jenis kartu Anda, jalankan kode di bawah ini:
#sertakan 'FS.h'#sertakan 'SD.h'
#sertakan 'SPI.h'
ruang kosong mempersiapkan ( ) {
Serial. mulai ( 115200 ) ;
jika ( ! SD. mulai ( ) ) {
Serial. cetakln ( 'Pemasangan Kartu Gagal' ) ;
kembali ;
}
uint8_t tipe kartu = SD. tipe kartu ( ) ;
jika ( tipe kartu == CARD_NONE ) {
Serial. cetakln ( 'Tidak ada kartu SD yang terpasang' ) ;
kembali ;
}
Serial. mencetak ( 'Jenis Kartu SD:' ) ;
jika ( tipe kartu == KARTU_MMC ) {
Serial. cetakln ( 'MMC' ) ;
} kalau tidak jika ( tipe kartu == KARTU_SD ) {
Serial. cetakln ( 'SDSC' ) ;
} kalau tidak jika ( tipe kartu == KARTU_SDHC ) {
Serial. cetakln ( 'SDHC' ) ;
} kalau tidak {
Serial. cetakln ( 'TIDAK DIKENAL' ) ;
}
uint64_t ukuran kartu = SD. ukuran kartu ( ) / ( 1024 * 1024 ) ;
Serial. printf ( 'Ukuran Kartu SD: %lluMB \N ' , ukuran kartu ) ;
}
ruang kosong lingkaran ( ) {
}
Karena saya memiliki kartu 32GB, Anda dapat melihat bahwa kartu tersebut berada dalam kisaran SDHC kartu-kartu.
6.5. Dapatkan Ukuran Kartu MicroSD
Anda juga bisa mendapatkan ukuran kartu SD dengan mengunggah kode di bawah ini ke papan ESP32 Anda.
#sertakan 'FS.h'#sertakan 'SD.h'
#sertakan 'SPI.h'
ruang kosong mempersiapkan ( ) {
Serial. mulai ( 115200 ) ;
jika ( ! SD. mulai ( ) ) {
Serial. cetakln ( 'Pemasangan Kartu Gagal' ) ;
kembali ;
}
uint8_t tipe kartu = SD. tipe kartu ( ) ;
jika ( tipe kartu == CARD_NONE ) {
Serial. cetakln ( 'Tidak ada kartu SD yang terpasang' ) ;
kembali ;
}
uint64_t ukuran kartu = SD. ukuran kartu ( ) / ( 1024 * 1024 ) ;
Serial. printf ( 'Ukuran Kartu SD: %lluMB \N ' , ukuran kartu ) ;
// Fungsi lain (listDir, createDir, deleteDir, dll.) dapat dipanggil di sini
}
ruang kosong lingkaran ( ) {
}
Dari outputnya, Anda dapat melihat saya memiliki kartu SD berukuran sekitar 30GB.
Kesimpulan
Modul kartu MicroSD digunakan untuk membaca dan menulis data dari kartu SD menggunakan papan ESP32. Modul kartu MicroSD berkomunikasi dengan mikrokontroler melalui antarmuka SPI. Jadi Anda bisa menggunakan perpustakaan SPI atau menentukan pin SPI Anda sendiri di dalam kode. Setelah terhubung, Anda dapat membaca, menulis file teks, atau membuat direktori baru di kartu SD Anda.