Acest articol va explica pașii pentru interfațarea unui card MicroSD cu o placă ESP32 folosind Arduino IDE.
Cuprins:
2. Cum să interfați ESP32 cu modulul cardului MicroSD
6. Efectuarea diferitelor funcții pe cardul MicroSD utilizând ESP32
- 6.1. Crearea directoarelor pe cardul MicroSD
- 6.2. Listarea directoarelor pe cardul MicroSD
- 6.3. Eliminarea directoarelor
- 6.4. Obțineți tipul cardului MicroSD
- 6.5. Obțineți dimensiunea cardului SD
1. Modulul cardului MicroSD
Modulul cardului MicroSD este un senzor ESP32 care poate conecta cardul SD la placa microcontrolerului. Funcționează prin protocolul de comunicare SPI. Permite ESP32 sau orice altă placă de microcontroler precum Arduino să acceseze datele stocate pe cardul SD prin protocolul SPI.
Tensiunea de lucru pentru modulul cardului SD este de 3,3 V, deci nu este posibil să-l conectați direct la ESP32 sau la orice altă placă de microcontroler. Pentru asta, trebuie să folosim modulul cardului SD sau senzorul care funcționează peste 5V.
1.1. Pinout
Cardul MicroSD are un total de șase pini. Două dintre ele sunt pini de alimentare: VCC și GND. În timp ce citirea, patru pini sunt utilizați pentru protocolul de comunicare SPI. Următoarele sunt detaliile pentru toți acești șase pini:
Pini de alimentare:
- VCC: Se conectează la pinul ESP32 5V.
- GND: Se conectează la pinul de masă ESP32 (GND).
Pinuri SPI:
- MISO: (Master In Slave Out) Se conectează la pinul ESP32 MOSI (Master Out Slave In).
- FUM: Se conectează la pinul ESP32 MISO (Master In Slave Out).
- SCK: Se conectează la pinul ESP32 SCK (Serial Clock).
- SS: (Slave Select) Se conectează la pinul specificat în codul Arduino ca pin SS (Slave Select).
2. Cum să interfați ESP32 cu modulul cardului MicroSD
Pentru a interfața ESP32 cu modulul cardului MicroSD, va trebui să configurați pinii de alimentare pentru senzorul cardului SD. Apoi configurați pinii SPI. Aici aveți două opțiuni, puteți fie să setați pinii SPI impliciti, fie să vă definiți propriile pini SPI personalizați.
Când folosim pinii SPI impliciti, vom adăuga SD h și SD_MMC.h biblioteci. În mod implicit, aceste biblioteci iau pinii VSPI SPI (23, 19, 18, 5) pentru comunicarea SPI. Cu toate acestea, puteți seta și alți pini pentru comunicarea SPI.
ESP32 conține două interfețe SPI HSPI și VSPI cu pinii lor detaliați după cum urmează:
| SPI | FUM | MISO | CLK | CS |
| VSPI | D23 | D19 | D18 | D5 |
| HSPI | D13 | D12 | D14 | D15 |
Legate de: ESP32 Pinout Reference – Un ghid complet
2.2. Pregătiți cardul SD
Apoi, înainte de a putea continua cu citirea și scrierea datelor pe un card MicroSD, mai întâi trebuie să îl configurați prin formatarea oricăror date anterioare din acesta.
Deschideți cardul SD folosind orice cititor de carduri și format aceasta.
Selectați FAT32 pentru sistemul de fișiere card și faceți clic start .
După formatarea cardului, selectați Bine .
Acum cardul SD este gata pentru a fi interfațat cu ESP32 folosind modulul cardului SD.
2.3. Diagramă schematică
Pentru a conecta senzorul cardului MicroSD la ESP32, urmați configurația de mai jos:
Următorul este tabelul pentru configurația pinului firului de conectare:
| Card MicroSD | ESP32 |
| GND | GND |
| VCC | VENI |
| CS | D5 |
| FUM | D23 |
| SCK | D18 |
| MISO | D19 |
3. Hardware
Pentru hardware, aveți nevoie doar de niște fire jumper, o placă de breadboard împreună cu ESP32 și modulul cardului SD.
4. Cod
Acum vom scrie un cod care va crea un fișier text în interiorul cardului MicroSD și după aceea, va scrie un șir de text pe acesta. Odată terminat, vom citi conținutul fișierului text pe monitorul serial Arduino IDE.
Porniți Arduino IDE și compilați codul dat. După aceea ardeți-l pe placa ESP32:
#include#include
File myFile ;
const int CS = 5 ;
// Scrieți mesajul dat într-un fișier la calea specificată
gol WriteFile ( const char * cale , const char * mesaj ) {
// Deschideți fișierul. Acceptă un fișier pentru a deschide o dată
// închide celălalt fișier înainte de a deschide un fișier nou
Dosarul meu = SD. deschis ( cale , FILE_WRITE ) ;
dacă ( Dosarul meu ) {
Serial. printf ( „Se scrie la %s” , cale ) ;
Dosarul meu. println ( mesaj ) ;
Dosarul meu. închide ( ) ; // Închideți fișierul
Serial. println ( 'efectuat.' ) ;
} altfel {
Serial. println ( „eroare la deschiderea fișierului” ) ;
Serial. println ( cale ) ;
}
}
// Imprimați conținutul fișierului pe calea specificată
gol Citiți fișierul ( const char * cale ) {
// Deschide fișierul
Dosarul meu = SD. deschis ( cale ) ;
dacă ( Dosarul meu ) {
Serial. printf ( „Se citesc fișierul de la %s \n ' , cale ) ;
// Citiți fișierul complet până la ultimul
in timp ce ( Dosarul meu. disponibil ( ) ) {
Serial. scrie ( Dosarul meu. citit ( ) ) ;
}
Dosarul meu. închide ( ) ; // Închideți fișierul
} altfel {
// Dacă fișierul nu s-a deschis, imprimați o eroare:
Serial. println ( „eroare la deschiderea test.txt” ) ;
}
}
gol înființat ( ) {
Serial. ÎNCEPE ( 9600 ) ;
întârziere ( 500 ) ;
in timp ce ( ! Serial ) { ; }
Serial. println ( „Se inițializează cardul SD...” ) ;
dacă ( ! SD. ÎNCEPE ( CS ) ) {
Serial. println ( 'Inițializare eșuată!' ) ;
întoarcere ;
}
Serial. println ( „Inițializarea s-a încheiat”. ) ;
WriteFile ( „/test.txt” , „Linuxhint.com” ) ;
Citiți fișierul ( „/test.txt” ) ;
}
gol buclă ( ) {
}
4.1. Explicația codului
Pentru o mai bună înțelegere, vom împărți acest cod în subpărți.
Inițializare și configurare: În primul rând, codul a început prin includerea unor biblioteci importante legate de modulul cardului SD. Biblioteca SPI.h este adăugată pentru comunicarea cu cardul SD și SD.h pentru gestionarea operațiunilor cardului SD. Apoi, definește o variabilă globală Dosarul meu de tip fișier pentru a gestiona operațiunile cu fișiere. Constanta CS este setată la pinul 5, care va fi folosit ca pin Chip Select (CS) pentru cardul SD.
Funcția Setup(): În cadrul funcției de configurare, comunicarea în serie este pornită. După aceea, am inițializat modulul cardului SD folosind funcția SD.begin(CS). În plus, am definit și două funcții diferite pentru citirea și scrierea textului într-un fișier text.
Scrierea pe cardul SD: Funcția WriteFile() deschide fișierul test.txt pentru scriere folosind SD.open(cale, FILE_WRITE). După aceea, scrie șirul Linuxhint.com în fișier folosind myFile.println(message).
Citirea de pe cardul SD: Pentru a citi conținutul fișierului, am folosit funcția ReadFile(). Dacă sunt citite cu succes, datele vor fi trimise la portul serial Arduino și afișate pe monitorul serial Arduino IDE.
5. Ieșire
În rezultat, puteți vedea că același șir pe care l-am definit în codul IDE Arduino este afișat pe monitorul dvs. serial Arduino IDE.
6. Efectuarea diferitelor funcții pe cardul MicroSD utilizând ESP32
Putem efectua diverse operațiuni precum crearea, eliminarea sau adăugarea directoarelor pe cardurile MicroSD direct prin codul IDE Arduino.
6.1. Crearea directoarelor pe cardul MicroSD
Codul de mai jos va crea un nou director în interiorul cardului MicroSD. Acesta definește o funcție numită createDir care ia ca intrare un obiect de sistem de fișiere (fs::FS) și o cale. Această funcție încearcă să creeze un director cu calea specificată și tipărește mesaje care indică succesul sau eșecul.
#include „FS.h”#include „SD.h”
#include „SPI.h”
gol createDir ( fs :: FS & fs , const char * cale ) {
Serial. printf ( „Crearea directorului: %s \n ' , cale ) ;
dacă ( fs. mkdir ( cale ) ) {
Serial. println ( „Dir creat” ) ;
} altfel {
Serial. println ( 'mkdir a eșuat' ) ;
}
}
gol înființat ( ) {
Serial. ÎNCEPE ( 115200 ) ;
// Inițializați cardul SD
dacă ( ! SD. ÎNCEPE ( ) ) {
Serial. println ( „Montarea cardului a eșuat” ) ;
întoarcere ;
}
// Creați un director numit „mydir”
createDir ( SD , '/mydir' ) ;
}
gol buclă ( ) {
}
În rezultat, puteți vedea un director nou cu care este creat /mydir Nume.
6.2. Listarea directoarelor pe cardul MicroSD
În codul de mai jos, vom enumera toate directoarele prezente în interiorul cardului MicroSD. The listDir funcția listează în mod recursiv conținutul unui director de pe un card SD. Tipărește informații despre ambele directoare (prefixate cu „DIR”) și fișiere (prefixate cu „FILE”), inclusiv numele și dimensiunile acestora.
#include „FS.h”#include „SD.h”
#include „SPI.h”
gol listDir ( fs :: FS & fs , const char * dirname , uint8_t niveluri ) {
Serial. printf ( „Directorul de listare: %s \n ' , dirname ) ;
Rădăcina fișierului = fs. deschis ( dirname ) ;
dacă ( ! rădăcină ) {
Serial. println ( „Nu s-a putut deschide directorul” ) ;
întoarcere ;
}
dacă ( ! rădăcină. isDirectory ( ) ) {
Serial. println ( „Nu este un director” ) ;
întoarcere ;
}
Fișier fișier = rădăcină. deschidețiNextFile ( ) ;
in timp ce ( fişier ) {
dacă ( fişier. isDirectory ( ) ) {
Serial. imprimare ( ' TU : ' ) ;
Serial. println ( fişier. Nume ( ) ) ;
dacă ( niveluri ) {
listDir ( fs , fişier. Nume ( ) , niveluri - 1 ) ;
}
} altfel {
Serial. imprimare ( ' FIȘIER: ' ) ;
Serial. imprimare ( fişier. Nume ( ) ) ;
Serial. imprimare ( ' MĂRIMEA: ' ) ;
Serial. println ( fişier. mărimea ( ) ) ;
}
fişier = rădăcină. deschidețiNextFile ( ) ;
}
}
gol înființat ( ) {
Serial. ÎNCEPE ( 115200 ) ;
dacă ( ! SD. ÎNCEPE ( ) ) {
Serial. println ( „Montarea cardului a eșuat” ) ;
întoarcere ;
}
listDir ( SD , '/' , 0 ) ;
}
gol buclă ( ) {
}
În ieșire, puteți vedea două fișiere diferite. Unul este un fișier text, iar celălalt este un director pe care l-am creat în interiorul codului anterior.
6.3. Eliminarea directoarelor
Acum vom elimina directoarele și fișierele text create anterior. Pentru asta vom folosi removeDir funcția, va încerca să elimine un director specificat de cale. Dacă reușește, se imprimă Dir eliminat ; în caz contrar, se imprimă rmdir a eșuat .
#include „FS.h”#include „SD.h”
#include „SPI.h”
gol removeDir ( fs :: FS & fs , const char * cale ) {
Serial. printf ( „Se elimină Dir: %s \n ' , cale ) ;
dacă ( fs. este rm ( cale ) ) {
Serial. println ( „Dir eliminat” ) ;
} altfel {
Serial. println ( 'rmdir a eșuat' ) ;
}
}
gol înființat ( ) {
Serial. ÎNCEPE ( 115200 ) ;
dacă ( ! SD. ÎNCEPE ( ) ) {
Serial. println ( „Montarea cardului a eșuat” ) ;
întoarcere ;
}
}
gol buclă ( ) {
}
6.4. Obțineți tipul cardului MicroSD
card microSD sau S sigur D cardul digital a fost conceput inițial de asociația cardurilor SD și conceput pentru a fi utilizat în dispozitive portabile, cum ar fi smartphone-uri și camere. Cardurile SD conțin în principal patru tipuri de familii:
- SDSC (capacitate standard SD): Aceste carduri oferă o gamă modestă de capacitate de stocare de 2 GB și folosesc sistemele de fișiere FAT-12 și FAT-16.
- SDHC (SD de mare capacitate): Aceste carduri variază de la 2 GB la 32 GB și utilizează sistemul de fișiere FAT-32.
- SDXC (SD cu capacitate extinsă): Aceste carduri folosesc sistemul de fișiere exFAT și încep de la 32 GB până la 2 TB.
- SDIO: Cardurile SDIO au un scop dublu prin combinarea stocării datelor cu funcțiile INPUT/OUTPUT.
Pentru a verifica tipul cardului, rulați codul de mai jos:
#include „FS.h”#include „SD.h”
#include „SPI.h”
gol înființat ( ) {
Serial. ÎNCEPE ( 115200 ) ;
dacă ( ! SD. ÎNCEPE ( ) ) {
Serial. println ( „Montarea cardului a eșuat” ) ;
întoarcere ;
}
uint8_t tipul cardului = SD. tipul cardului ( ) ;
dacă ( tipul cardului == CARD_NONE ) {
Serial. println ( „Nu este atașat niciun card SD” ) ;
întoarcere ;
}
Serial. imprimare ( „Tip card SD:” ) ;
dacă ( tipul cardului == CARD_MMC ) {
Serial. println ( 'MMC' ) ;
} altfel dacă ( tipul cardului == CARD_SD ) {
Serial. println ( „SDSC” ) ;
} altfel dacă ( tipul cardului == CARD_SDHC ) {
Serial. println ( 'SDHC' ) ;
} altfel {
Serial. println ( 'NECUNOSCUT' ) ;
}
uint64_t Dimensiune card = SD. Dimensiune card ( ) / ( 1024 * 1024 ) ;
Serial. printf ( „Dimensiunea cardului SD: %lluMB \n ' , Dimensiune card ) ;
}
gol buclă ( ) {
}
Deoarece am un card de 32 GB, puteți vedea că se află în intervalul de SDHC carduri.
6.5. Obțineți dimensiunea cardului MicroSD
De asemenea, puteți obține dimensiunea cardului SD încărcând codul de mai jos pe placa ESP32.
#include „FS.h”#include „SD.h”
#include „SPI.h”
gol înființat ( ) {
Serial. ÎNCEPE ( 115200 ) ;
dacă ( ! SD. ÎNCEPE ( ) ) {
Serial. println ( „Montarea cardului a eșuat” ) ;
întoarcere ;
}
uint8_t tipul cardului = SD. tipul cardului ( ) ;
dacă ( tipul cardului == CARD_NONE ) {
Serial. println ( „Nu este atașat niciun card SD” ) ;
întoarcere ;
}
uint64_t Dimensiune card = SD. Dimensiune card ( ) / ( 1024 * 1024 ) ;
Serial. printf ( „Dimensiunea cardului SD: %lluMB \n ' , Dimensiune card ) ;
// Alte funcții (listDir, createDir, removeDir etc.) pot fi apelate aici
}
gol buclă ( ) {
}
Din ieșire, puteți vedea că am un card SD de aproximativ 30 GB.
Concluzie
Un modul de card MicroSD este folosit pentru a citi și scrie datele de pe cardul SD folosind placa ESP32. Modulul cardului MicroSD comunică cu microcontrolerul utilizând interfața SPI. Deci, puteți fie să utilizați biblioteca SPI, fie să vă definiți propriile pini SPI în interiorul codului. Odată conectat, puteți citi și scrie un fișier text sau puteți crea directoare noi pe cardul SD.