Ipapaliwanag ng artikulong ito ang mga hakbang para sa interfacing ng MicroSD card sa isang ESP32 board gamit ang Arduino IDE.
Talaan ng mga Nilalaman:
2. Paano Mag-interface ng ESP32 gamit ang MicroSD Card Module
6. Gumaganap ng Iba't ibang Function sa MicroSD Card Gamit ang ESP32
- 6.1. Paglikha ng mga Direktoryo sa MicroSD Card
- 6.2. Listahan ng mga Direktoryo sa MicroSD Card
- 6.3. Pag-alis ng mga Direktoryo
- 6.4. Kunin ang Uri ng MicroSD Card
- 6.5. Kunin ang Sukat ng SD Card
1. MicroSD Card Module
Ang module ng MicroSD card ay isang ESP32 sensor na maaaring ikonekta ang SD card sa iyong microcontroller board. Gumagana ito sa protocol ng komunikasyon ng SPI. Pinapayagan nito ang ESP32 o anumang iba pang microcontroller board tulad ng Arduino na ma-access ang data na nakaimbak sa SD card sa SPI protocol.
Ang gumaganang boltahe para sa module ng SD card ay 3.3V, kaya hindi posible na direktang ikonekta ito sa ESP32 o anumang iba pang microcontroller board. Para diyan, kailangan naming gamitin ang module ng SD card o sensor na gumagana nang higit sa 5V.
1.1. Pinout
Nagtatampok ang MicroSD card ng kabuuang anim na pin. Dalawa sa mga ito ay mga power pin: VCC at GND. Habang ang pagbabasa ng apat na pin ay ginagamit para sa protocol ng komunikasyon ng SPI. Ang mga sumusunod ay ang mga detalye para sa lahat ng anim na pin na ito:
Mga Power Pin:
- VCC: Kumokonekta sa ESP32 5V pin.
- GND: Kumokonekta sa ESP32 ground (GND) pin.
Mga SPI Pin:
- MISO: (Master In Slave Out) Kumokonekta sa ESP32 MOSI (Master Out Slave In) pin.
- Usok: Kumokonekta sa ESP32 MISO (Master In Slave Out) pin.
- SCK: Kumokonekta sa ESP32 SCK (Serial Clock) pin.
- SS: (Slave Select) Kumokonekta sa pin na tinukoy sa Arduino code bilang SS (Slave Select) pin.
2. Paano Mag-interface ng ESP32 gamit ang MicroSD Card Module
Upang ma-interface ang ESP32 sa module ng MicroSD card, kakailanganin mong i-set up ang mga power pin para sa sensor ng iyong SD card. Susunod na i-set up ang mga SPI pin. Dito mayroon kang dalawang pagpipilian, maaari mong itakda ang mga default na SPI pin o tukuyin ang iyong sariling mga custom na SPI pin.
Kapag gumagamit ng mga default na SPI pin, idaragdag namin ang SD.h at SD_MMC.h mga aklatan. Bilang default, kinukuha ng mga library na ito ang mga VSPI SPI pin (23, 19, 18, 5) para sa komunikasyon ng SPI. Gayunpaman, maaari ka ring magtakda ng iba pang mga pin para sa komunikasyon ng SPI.
Ang ESP32 ay naglalaman ng dalawang SPI interface na HSPI at VSPI kasama ang detalye ng kanilang mga pin tulad ng sumusunod:
| SPI | Usok | MISO | CLK | CS |
| VSPI | D23 | D19 | D18 | D5 |
| HSPI | D13 | D12 | D14 | D15 |
Kaugnay: ESP32 Pinout Reference – Isang Kumpletong Gabay
2.2. Ihanda ang SD Card
Susunod, bago ka magpatuloy sa pagbabasa at pagsulat ng data sa isang MicroSD card, una, kailangan mo munang i-set up ito sa pamamagitan ng pag-format ng anumang nakaraang data dito.
Buksan ang iyong SD card gamit ang anumang card reader at pormat ito.
Piliin ang FAT32 para sa iyong card file system at i-click Magsimula .
Pagkatapos i-format ang card, piliin OK .
Ngayon ang iyong SD card ay handa nang ma-interface sa ESP32 gamit ang SD card module.
2.3. Schematic Diagram
Para ikonekta ang MicroSD card sensor sa ESP32, sundin ang ibinigay na configuration sa ibaba:
Ang sumusunod ay ang talahanayan para sa pagsasaayos ng pin ng wire ng koneksyon:
| MicroSD Card | ESP32 |
| GND | GND |
| VCC | Halika |
| CS | D5 |
| Usok | D23 |
| SCK | D18 |
| MISO | D19 |
3. Hardware
Para sa hardware, kailangan mo lang ng ilang jumper wire sa isang breadboard kasama ng ESP32 at SD card module.
4. Kodigo
Ngayon ay magsusulat kami ng isang code na lilikha ng isang text file sa loob ng MicroSD card at pagkatapos nito, nagsusulat ito ng ilang text string doon. Kapag tapos na, babasahin namin ang nilalaman ng text file sa Arduino IDE serial monitor.
Simulan ang Arduino IDE at i-compile ang ibinigay na code. Pagkatapos ay sunugin ito sa iyong ESP32 board:
#include#include
I-file ang myFile ;
const int CS = 5 ;
// Isulat ang ibinigay na mensahe sa isang file sa tinukoy na landas
walang bisa WriteFile ( const char * landas , const char * mensahe ) {
// Buksan ang file. Sinusuportahan nito ang isang file upang buksan sa isang pagkakataon
// isara ang ibang file bago magbukas ng bagong file
myFile = SD. bukas ( landas , FILE_WRITE ) ;
kung ( myFile ) {
Serial. printf ( 'Nagsusulat sa %s ' , landas ) ;
myFile. println ( mensahe ) ;
myFile. malapit na ( ) ; // Isara ang file
Serial. println ( 'nakumpleto.' ) ;
} iba pa {
Serial. println ( 'error sa pagbubukas ng file' ) ;
Serial. println ( landas ) ;
}
}
// I-print ang nilalaman ng file sa tinukoy na landas
walang bisa ReadFile ( const char * landas ) {
// Buksan ang file
myFile = SD. bukas ( landas ) ;
kung ( myFile ) {
Serial. printf ( 'Binabasa ang file mula sa %s \n ' , landas ) ;
// Basahin ang kumpletong file hanggang maabot ang huli
habang ( myFile. magagamit ( ) ) {
Serial. magsulat ( myFile. basahin ( ) ) ;
}
myFile. malapit na ( ) ; // Isara ang file
} iba pa {
// Kung nabigong buksan ang file, mag-print ng error:
Serial. println ( 'error sa pagbubukas ng test.txt' ) ;
}
}
walang bisa setup ( ) {
Serial. magsimula ( 9600 ) ;
pagkaantala ( 500 ) ;
habang ( ! Serial ) { ; }
Serial. println ( 'Ini-initialize ang SD card...' ) ;
kung ( ! SD. magsimula ( CS ) ) {
Serial. println ( 'Nabigo ang pagsisimula!' ) ;
bumalik ;
}
Serial. println ( 'Tapos na ang initialization.' ) ;
WriteFile ( '/test.txt' , 'Linuxhint.com' ) ;
ReadFile ( '/test.txt' ) ;
}
walang bisa loop ( ) {
}
4.1. Paliwanag ng Code
Para sa mas mahusay na pag-unawa, hahatiin natin ang code na ito sa mga subpart.
Pagsisimula at Pag-setup: Una, nagsimula ang code sa pamamagitan ng pagsasama ng ilang mahahalagang aklatan na nauugnay sa module ng SD card. Ang SPI.h library ay idinagdag para sa komunikasyon sa SD card at SD.h para sa paghawak ng SD card operations. Susunod, tinutukoy nito ang isang pandaigdigang variable myFile ng uri ng file upang pamahalaan ang mga pagpapatakbo ng file. Ang CS constant ay nakatakda sa pin 5, na gagamitin bilang Chip Select (CS) pin para sa SD card.
Setup() Function: Sa loob ng setup function, sinisimulan ang serial communication. Pagkatapos noon, sinimulan namin ang module ng SD card gamit ang SD.begin(CS) function. Dagdag pa, tinukoy din namin ang dalawang magkaibang mga function para sa pagbabasa at pagsulat ng teksto sa isang text file.
Pagsusulat sa SD Card: Binubuksan ng WriteFile() function ang file test.txt para sa pagsusulat gamit ang SD.open(path, FILE_WRITE). Pagkatapos nito, isinusulat nito ang string Linuxhint.com sa file gamit ang myFile.println(mensahe).
Pagbasa mula sa SD Card: Upang basahin ang nilalaman ng file, ginamit namin ang function na ReadFile(). Kung matagumpay na basahin, ang data ay ipapadala sa Arduino serial port at ipapakita sa Arduino IDE serial monitor.
5. Output
Sa output, makikita mo ang parehong string na tinukoy namin sa loob ng Arduino IDE code na ipinapakita sa iyong Arduino IDE serial monitor.
6. Gumaganap ng Iba't ibang Function sa MicroSD Card Gamit ang ESP32
Maaari kaming magsagawa ng iba't ibang mga operasyon tulad ng paggawa, pag-alis, o pagdaragdag ng mga direktoryo sa mga MicroSD card nang direkta sa pamamagitan ng Arduino IDE code.
6.1. Paglikha ng mga Direktoryo sa MicroSD Card
Ang code sa ibaba ay lilikha ng bagong direktoryo sa loob ng MicroSD card. Tinutukoy nito ang isang function na tinatawag createDir na kumukuha ng file system object (fs::FS) at isang path bilang input. Sinusubukan ng function na ito na lumikha ng isang direktoryo na may tinukoy na landas at nagpi-print ng mga mensahe na nagpapahiwatig ng tagumpay o pagkabigo.
#include 'FS.h'#include 'SD.h'
#include 'SPI.h'
walang bisa createDir ( fs :: FS at fs , const char * landas ) {
Serial. printf ( 'Paglikha ng Dir: %s \n ' , landas ) ;
kung ( fs. mkdir ( landas ) ) {
Serial. println ( 'Ginawa ni Dir' ) ;
} iba pa {
Serial. println ( 'bigo ang mkdir' ) ;
}
}
walang bisa setup ( ) {
Serial. magsimula ( 115200 ) ;
// I-initialize ang SD card
kung ( ! SD. magsimula ( ) ) {
Serial. println ( 'Nabigo ang Pag-mount ng Card' ) ;
bumalik ;
}
// Lumikha ng isang direktoryo na pinangalanang 'mydir'
createDir ( SD , '/mydir' ) ;
}
walang bisa loop ( ) {
}
Sa output, makikita mo ang isang bagong direktoryo na nilikha gamit ang /mydir pangalan.
6.2. Listahan ng mga Direktoryo sa MicroSD Card
Sa code sa ibaba, ililista namin ang lahat ng mga direktoryo na nasa loob ng MicroSD card. Ang listDir function na recursively naglilista ng mga nilalaman ng isang direktoryo sa isang SD card. Nagpi-print ito ng impormasyon tungkol sa parehong mga direktoryo (na may prefix na 'DIR') at mga file (na may prefix na 'FILE'), kasama ang kanilang mga pangalan at laki.
#include 'FS.h'#include 'SD.h'
#include 'SPI.h'
walang bisa listDir ( fs :: FS at fs , const char * diname , uint8_t mga antas ) {
Serial. printf ( 'Direktoryo ng listahan: %s \n ' , diname ) ;
ugat ng file = fs. bukas ( diname ) ;
kung ( ! ugat ) {
Serial. println ( 'Nabigong buksan ang direktoryo' ) ;
bumalik ;
}
kung ( ! ugat. isDirectory ( ) ) {
Serial. println ( 'Hindi isang direktoryo' ) ;
bumalik ;
}
file file = ugat. openNextFile ( ) ;
habang ( file ) {
kung ( file. isDirectory ( ) ) {
Serial. print ( ' IKAW : ' ) ;
Serial. println ( file. pangalan ( ) ) ;
kung ( mga antas ) {
listDir ( fs , file. pangalan ( ) , mga antas - 1 ) ;
}
} iba pa {
Serial. print ( ' FILE: ' ) ;
Serial. print ( file. pangalan ( ) ) ;
Serial. print ( 'SIZE:' ) ;
Serial. println ( file. laki ( ) ) ;
}
file = ugat. openNextFile ( ) ;
}
}
walang bisa setup ( ) {
Serial. magsimula ( 115200 ) ;
kung ( ! SD. magsimula ( ) ) {
Serial. println ( 'Nabigo ang Pag-mount ng Card' ) ;
bumalik ;
}
listDir ( SD , '/' , 0 ) ;
}
walang bisa loop ( ) {
}
Sa output, makikita mo ang dalawang magkaibang mga file. Ang isa ay isang text file at ang isa ay isang direktoryo na ginawa namin sa loob ng nakaraang code.
6.3. Pag-alis ng mga Direktoryo
Ngayon ay aalisin namin ang naunang nilikha na mga direktoryo at mga text file. Para doon ay gagamitin namin ang alisinDir function, Susubukan nitong tanggalin ang isang direktoryo na tinukoy ng landas. Kung matagumpay, ito ay nagpi-print Tinanggal ni Dir ; kung hindi, ito ay nagpi-print Nabigo ang rmdir .
#include 'FS.h'#include 'SD.h'
#include 'SPI.h'
walang bisa alisinDir ( fs :: FS at fs , const char * landas ) {
Serial. printf ( 'Pag-alis ng Dir: %s \n ' , landas ) ;
kung ( fs. ay rm ( landas ) ) {
Serial. println ( 'Tinanggal si Dir' ) ;
} iba pa {
Serial. println ( 'bigo ang rmdir' ) ;
}
}
walang bisa setup ( ) {
Serial. magsimula ( 115200 ) ;
kung ( ! SD. magsimula ( ) ) {
Serial. println ( 'Nabigo ang Pag-mount ng Card' ) ;
bumalik ;
}
}
walang bisa loop ( ) {
}
6.4. Kunin ang Uri ng MicroSD Card
MicroSD card o S ligtas D Ang igital card ay orihinal na idinisenyo ng SD card association, at idinisenyo para magamit sa mga portable na device tulad ng mga smartphone at camera. Pangunahing naglalaman ang mga SD card ng apat na uri ng pamilya:
- SDSC (Standard Capacity SD): Nag-aalok ang mga card na ito ng katamtamang hanay ng storage capacity na 2GB at ginagamit ang FAT-12 at FAT-16 file system.
- SDHC (Mataas na Kapasidad SD): Ang mga card na ito ay mula 2GB hanggang 32GB at ginagamit ang FAT-32 file system.
- SDXC (EXtended Capacity SD): Ang mga card na ito ay gumagamit ng exFAT file system at nagsisimula sa 32GB hanggang sa kasing taas ng 2TB.
- SDIO: Ang mga SDIO card ay nagsisilbi ng dalawahang layunin sa pamamagitan ng pagsasama ng imbakan ng data sa mga function ng INPUT/OUTPUT.
Upang suriin ang uri ng iyong card, patakbuhin ang code sa ibaba:
#include 'FS.h'#include 'SD.h'
#include 'SPI.h'
walang bisa setup ( ) {
Serial. magsimula ( 115200 ) ;
kung ( ! SD. magsimula ( ) ) {
Serial. println ( 'Nabigo ang Pag-mount ng Card' ) ;
bumalik ;
}
uint8_t uri ng card = SD. uri ng card ( ) ;
kung ( uri ng card == CARD_NONE ) {
Serial. println ( 'Walang naka-attach na SD card' ) ;
bumalik ;
}
Serial. print ( 'Uri ng SD Card: ' ) ;
kung ( uri ng card == CARD_MMC ) {
Serial. println ( 'MMC' ) ;
} iba pa kung ( uri ng card == CARD_SD ) {
Serial. println ( 'SDSC' ) ;
} iba pa kung ( uri ng card == CARD_SDHC ) {
Serial. println ( 'SDHC' ) ;
} iba pa {
Serial. println ( 'HINDI ALAM' ) ;
}
uint64_t laki ng card = SD. laki ng card ( ) / ( 1024 * 1024 ) ;
Serial. printf ( 'Laki ng SD Card: %lluMB \n ' , laki ng card ) ;
}
walang bisa loop ( ) {
}
Dahil mayroon akong 32GB card, makikita mo na nasa hanay ito ng SDHC mga card.
6.5. Kunin ang Sukat ng MicroSD Card
Makukuha mo rin ang laki ng SD card sa pamamagitan ng pag-upload ng code sa ibaba sa iyong ESP32 board.
#include 'FS.h'#include 'SD.h'
#include 'SPI.h'
walang bisa setup ( ) {
Serial. magsimula ( 115200 ) ;
kung ( ! SD. magsimula ( ) ) {
Serial. println ( 'Nabigo ang Pag-mount ng Card' ) ;
bumalik ;
}
uint8_t uri ng card = SD. uri ng card ( ) ;
kung ( uri ng card == CARD_NONE ) {
Serial. println ( 'Walang naka-attach na SD card' ) ;
bumalik ;
}
uint64_t laki ng card = SD. laki ng card ( ) / ( 1024 * 1024 ) ;
Serial. printf ( 'Laki ng SD Card: %lluMB \n ' , laki ng card ) ;
// Iba pang mga function (listDir, createDir, removeDir, atbp.) ay maaaring tawagan dito
}
walang bisa loop ( ) {
}
Mula sa output, makikita mong mayroon akong SD card na humigit-kumulang 30GB.
Konklusyon
Ginagamit ang MicroSD card module para basahin at isulat ang data mula sa SD card gamit ang ESP32 board. Nakikipag-ugnayan ang module ng MicroSD card sa microcontroller sa pamamagitan ng paggamit ng interface ng SPI. Kaya maaari mong gamitin ang SPI library o tukuyin ang iyong sariling mga SPI pin sa loob ng code. Kapag nakakonekta na, maaari kang magbasa ng magsulat ng text file, o lumikha ng mga bagong direktoryo sa iyong SD card.