Denne artikkelen vil forklare trinnene for å koble et MicroSD-kort med et ESP32-kort ved å bruke Arduino IDE.
Innholdsfortegnelse:
2. Hvordan grensesnitt ESP32 med MicroSD-kortmodul
6. Utføre forskjellige funksjoner på MicroSD-kort ved å bruke ESP32
- 6.1. Opprette kataloger i MicroSD-kort
- 6.2. Listekataloger i MicroSD-kort
- 6.3. Fjerner kataloger
- 6.4. Få MicroSD-korttype
- 6.5. Få SD-kortstørrelse
1. MicroSD-kortmodul
MicroSD-kortmodulen er en ESP32-sensor som kan koble SD-kortet til mikrokontrollerkortet ditt. Den fungerer over SPI-kommunikasjonsprotokollen. Det lar ESP32 eller et hvilket som helst annet mikrokontrollerkort som Arduino få tilgang til dataene som er lagret på SD-kortet over SPI-protokollen.
Arbeidsspenningen for SD-kortmodulen er 3,3V, så det er ikke mulig å koble den direkte til ESP32 eller noe annet mikrokontrollerkort. Til det må vi bruke SD-kortmodulen eller sensoren som fungerer over 5V.
1.1. Pinout
MicroSD-kortet har totalt seks pinner. To av dem er strømpinner: VCC og GND. Mens lesing fire pinner brukes for SPI kommunikasjonsprotokoll. Følgende er detaljene for alle disse seks pinnene:
Power Pins:
- VCC: Kobles til ESP32 5V pin.
- GND: Kobles til ESP32 jording (GND) pinne.
SPI-pinner:
- MISO: (Master In Slave Out) Kobles til ESP32 MOSI (Master Out Slave In) pinne.
- RØYK: Kobles til ESP32 MISO (Master In Slave Out) pinne.
- SCK: Kobles til ESP32 SCK (Serial Clock) pinne.
- SS: (Slave Select) Kobles til pinnen som er spesifisert i Arduino-koden som SS (Slave Select)-pinnen.
2. Hvordan grensesnitt ESP32 med MicroSD-kortmodul
For å koble ESP32 til MicroSD-kortmodulen, må du sette opp strømpinnene for SD-kortsensoren. Sett deretter opp SPI-pinnene. Her har du to valg, du kan enten angi standard SPI-pinner eller definere dine egne tilpassede SPI-pinner.
Når du bruker standard SPI-pinner, skal vi legge til SD h og SD_MMC.h biblioteker. Som standard tar disse bibliotekene VSPI SPI-pinnene (23, 19, 18, 5) for SPI-kommunikasjon. Du kan imidlertid også angi andre pinner for SPI-kommunikasjon.
ESP32 inneholder to SPI-grensesnitt HSPI og VSPI med pinnedetaljer som følger:
| SPI | RØYK | MISO | CLK | CS |
| VSPI | D23 | D19 | D18 | D5 |
| HSPI | D13 | D12 | D14 | D15 |
I slekt: ESP32 Pinout Reference – En komplett veiledning
2.2. Gjør SD-kortet klart
Deretter, før du kan fortsette med å lese og skrive data til et MicroSD-kort, må du først sette opp det ved å formatere tidligere data i det.
Åpne SD-kortet ditt med en hvilken som helst kortleser og format den.
Velg FAT32 for kortets filsystem og klikk Start .
Etter formatering av kortet, velg OK .
Nå er SD-kortet ditt klart til å kobles til ESP32 ved hjelp av SD-kortmodulen.
2.3. Skjematisk diagram
For å koble til MicroSD-kortsensoren med ESP32, følg konfigurasjonen nedenfor:
Følgende er tabellen for pin-konfigurasjon av tilkoblingsledningen:
| MicroSD-kort | ESP32 |
| GND | GND |
| VCC | KOMME |
| CS | D5 |
| RØYK | D23 |
| SCK | D18 |
| MISO | D19 |
3. Maskinvare
For maskinvare trenger du bare noen jumper ledninger et brødbrett sammen med ESP32 og SD-kortmodul.
4. Kode
Nå skal vi skrive en kode som vil lage en tekstfil inne i MicroSD-kortet, og etter det skriver den en tekststreng til det. Når det er gjort, vil vi lese innholdet i tekstfilen på Arduino IDE seriell monitor.
Start Arduino IDE og kompiler den gitte koden. Etter det brenner du det til ESP32-kortet ditt:
#inkludere#include
Fil myFile ;
konst int CS = 5 ;
// Skriv den gitte meldingen til en fil på den angitte banen
tomrom Skriv fil ( konst røye * sti , konst røye * beskjed ) {
// Åpne filen. Den støtter én fil å åpne om gangen
// lukk den andre filen før du åpner en ny fil
min fil = SD. åpen ( sti , FILE_WRITE ) ;
hvis ( min fil ) {
Seriell. printf ( 'Skriver til %s' , sti ) ;
min fil. println ( beskjed ) ;
min fil. Lukk ( ) ; // Lukk filen
Seriell. println ( 'fullført.' ) ;
} ellers {
Seriell. println ( 'feil ved åpning av fil' ) ;
Seriell. println ( sti ) ;
}
}
// Skriv ut filinnhold på den angitte banen
tomrom ReadFile ( konst røye * sti ) {
// Åpen fil
min fil = SD. åpen ( sti ) ;
hvis ( min fil ) {
Seriell. printf ( 'Leser fil fra %s \n ' , sti ) ;
// Les hele filen til den siste
samtidig som ( min fil. tilgjengelig ( ) ) {
Seriell. skrive ( min fil. lese ( ) ) ;
}
min fil. Lukk ( ) ; // Lukk filen
} ellers {
// Hvis filen ikke åpnet, skriv ut en feil:
Seriell. println ( 'feil ved åpning av test.txt' ) ;
}
}
tomrom oppsett ( ) {
Seriell. begynne ( 9600 ) ;
forsinkelse ( 500 ) ;
samtidig som ( ! Seriell ) { ; }
Seriell. println ( 'Initialiserer SD-kort...' ) ;
hvis ( ! SD. begynne ( CS ) ) {
Seriell. println ( 'Initialisering mislyktes!' ) ;
komme tilbake ;
}
Seriell. println ( 'Initialisering utført.' ) ;
Skriv fil ( '/test.txt' , 'Linuxhint.com' ) ;
ReadFile ( '/test.txt' ) ;
}
tomrom Løkke ( ) {
}
4.1. Kodeforklaring
For bedre forståelse vil vi dele denne koden inn i underdeler.
Initialisering og oppsett: Først startet koden med å inkludere noen viktige biblioteker relatert til SD-kortmodulen. SPI.h-biblioteket er lagt til for kommunikasjon med SD-kortet og SD.h for håndtering av SD-kortoperasjoner. Deretter definerer den en global variabel min fil av typen fil for å administrere filoperasjoner. CS-konstanten er satt til pinne 5, som vil bli brukt som Chip Select (CS) pin for SD-kortet.
Setup() funksjon: Inne i oppsettfunksjonen startes seriell kommunikasjon. Etter det initialiserte vi SD-kortmodulen ved å bruke SD.begin(CS)-funksjonen. Videre har vi også definert to forskjellige funksjoner for å lese og skrive tekst til en tekstfil.
Skrive til SD-kortet: WriteFile()-funksjonen åpner filen test.txt for skriving med SD.open(path, FILE_WRITE). Etter det skriver den strengen Linuxhint.com til filen ved å bruke myFile.println(melding).
Leser fra SD-kortet: For å lese filinnholdet har vi brukt ReadFile()-funksjonen. Ved vellykket lesing vil dataene bli sendt til Arduino serieport og vist på Arduino IDE seriell monitor.
5. Utgang
I utgangen kan du se den samme strengen som vi definerte inne i Arduino IDE-koden, vises på din Arduino IDE-serieskjerm.
6. Utføre forskjellige funksjoner på MicroSD-kort ved å bruke ESP32
Vi kan utføre ulike operasjoner som å opprette, fjerne eller legge til kataloger i MicroSD-kort direkte gjennom Arduino IDE-koden.
6.1. Opprette kataloger i MicroSD-kort
Koden nedenfor vil opprette en ny katalog inne i MicroSD-kortet. Den definerer en funksjon kalt oppretteDir som tar et filsystemobjekt (fs::FS) og en bane som input. Denne funksjonen prøver å opprette en katalog med den angitte banen og skriver ut meldinger som indikerer suksess eller fiasko.
#include 'FS.h'#include 'SD.h'
#include 'SPI.h'
tomrom oppretteDir ( fs :: FS & fs , konst røye * sti ) {
Seriell. printf ( 'Oppretter Dir: %s \n ' , sti ) ;
hvis ( fs. mkdir ( sti ) ) {
Seriell. println ( 'Dir opprettet' ) ;
} ellers {
Seriell. println ( 'mkdir mislyktes' ) ;
}
}
tomrom oppsett ( ) {
Seriell. begynne ( 115200 ) ;
// Initialiser SD-kort
hvis ( ! SD. begynne ( ) ) {
Seriell. println ( 'Kortmontering mislyktes' ) ;
komme tilbake ;
}
// Lag en katalog som heter 'mydir'
oppretteDir ( SD , '/mydir' ) ;
}
tomrom Løkke ( ) {
}
I utgangen kan du se en ny katalog er opprettet med /mydir Navn.
6.2. Listekataloger i MicroSD-kort
I koden nedenfor skal vi liste opp alle katalogene som finnes på MicroSD-kortet. De listeDir funksjonen viser rekursivt innholdet i en katalog på et SD-kort. Den skriver ut informasjon om både kataloger (prefiks med 'DIR') og filer (prefiks med 'FILE'), inkludert deres navn og størrelser.
#include 'FS.h'#include 'SD.h'
#include 'SPI.h'
tomrom listeDir ( fs :: FS & fs , konst røye * dirname , uint8_t nivåer ) {
Seriell. printf ( 'Oppføringsmappe: %s \n ' , dirname ) ;
Filrot = fs. åpen ( dirname ) ;
hvis ( ! rot ) {
Seriell. println ( 'Kunne ikke åpne katalogen' ) ;
komme tilbake ;
}
hvis ( ! rot. isDirectory ( ) ) {
Seriell. println ( 'Ikke en katalog' ) ;
komme tilbake ;
}
Fil fil = rot. openNextFile ( ) ;
samtidig som ( fil ) {
hvis ( fil. isDirectory ( ) ) {
Seriell. skrive ut ( 'DU:' ) ;
Seriell. println ( fil. Navn ( ) ) ;
hvis ( nivåer ) {
listeDir ( fs , fil. Navn ( ) , nivåer - 1 ) ;
}
} ellers {
Seriell. skrive ut ( ' FIL: ' ) ;
Seriell. skrive ut ( fil. Navn ( ) ) ;
Seriell. skrive ut ( ' STØRRELSE: ' ) ;
Seriell. println ( fil. størrelse ( ) ) ;
}
fil = rot. openNextFile ( ) ;
}
}
tomrom oppsett ( ) {
Seriell. begynne ( 115200 ) ;
hvis ( ! SD. begynne ( ) ) {
Seriell. println ( 'Kortmontering mislyktes' ) ;
komme tilbake ;
}
listeDir ( SD , '/' , 0 ) ;
}
tomrom Løkke ( ) {
}
I utdata kan du se to forskjellige filer. Den ene er en tekstfil og den andre er en katalog som vi opprettet inne i forrige kode.
6.3. Fjerner kataloger
Nå vil vi fjerne de tidligere opprettede katalogene og tekstfilene. Til det skal vi bruke fjern Dir funksjon, vil den forsøke å fjerne en katalog spesifisert av banen. Hvis den lykkes, skrives den ut Dir fjernet ; ellers skrives den ut rmdir mislyktes .
#include 'FS.h'#include 'SD.h'
#include 'SPI.h'
tomrom fjern Dir ( fs :: FS & fs , konst røye * sti ) {
Seriell. printf ( 'Fjerner Dir: %s \n ' , sti ) ;
hvis ( fs. er rm ( sti ) ) {
Seriell. println ( 'Dir fjernet' ) ;
} ellers {
Seriell. println ( 'rmdir mislyktes' ) ;
}
}
tomrom oppsett ( ) {
Seriell. begynne ( 115200 ) ;
hvis ( ! SD. begynne ( ) ) {
Seriell. println ( 'Kortmontering mislyktes' ) ;
komme tilbake ;
}
}
tomrom Løkke ( ) {
}
6.4. Få MicroSD-korttype
MicroSD-kort eller S ecure D igital-kortet ble opprinnelig designet av SD-kortforeningen, og designet for bruk i bærbare enheter som smarttelefoner og kameraer. SD-kort inneholder hovedsakelig fire typer familier:
- SDSC (Standard Capacity SD): Disse kortene tilbyr et beskjedent utvalg av lagringskapasitet på 2 GB og bruker filsystemene FAT-12 og FAT-16.
- SDHC (SD med høy kapasitet): Disse kortene varierer fra 2 GB til 32 GB og bruker FAT-32-filsystemet.
- SDXC (eXtended Capacity SD): Disse kortene bruker exFAT-filsystemet og starter fra 32 GB til så høyt som 2 TB.
- SDIO: SDIO-kort har to formål ved å kombinere datalagring med INPUT/OUTPUT-funksjoner.
For å sjekke korttypen din, kjør koden nedenfor:
#include 'FS.h'#include 'SD.h'
#include 'SPI.h'
tomrom oppsett ( ) {
Seriell. begynne ( 115200 ) ;
hvis ( ! SD. begynne ( ) ) {
Seriell. println ( 'Kortmontering mislyktes' ) ;
komme tilbake ;
}
uint8_t Kort type = SD. Kort type ( ) ;
hvis ( Kort type == CARD_NONE ) {
Seriell. println ( 'Ingen SD-kort tilkoblet' ) ;
komme tilbake ;
}
Seriell. skrive ut ( 'SD-korttype: ' ) ;
hvis ( Kort type == CARD_MMC ) {
Seriell. println ( 'MMC' ) ;
} ellers hvis ( Kort type == CARD_SD ) {
Seriell. println ( 'SDSC' ) ;
} ellers hvis ( Kort type == CARD_SDHC ) {
Seriell. println ( 'SDHC' ) ;
} ellers {
Seriell. println ( 'UKJENT' ) ;
}
uint64_t kortstørrelse = SD. kortstørrelse ( ) / ( 1024 * 1024 ) ;
Seriell. printf ( 'SD-kortstørrelse: %lluMB \n ' , kortstørrelse ) ;
}
tomrom Løkke ( ) {
}
Ettersom jeg har et 32GB-kort, kan du se at det ligger innenfor rekkevidden til SDHC kort.
6.5. Få MicroSD-kortstørrelse
Du kan også få størrelsen på SD-kortet ved å laste opp koden nedenfor til ESP32-kortet ditt.
#include 'FS.h'#include 'SD.h'
#include 'SPI.h'
tomrom oppsett ( ) {
Seriell. begynne ( 115200 ) ;
hvis ( ! SD. begynne ( ) ) {
Seriell. println ( 'Kortmontering mislyktes' ) ;
komme tilbake ;
}
uint8_t Kort type = SD. Kort type ( ) ;
hvis ( Kort type == CARD_NONE ) {
Seriell. println ( 'Ingen SD-kort tilkoblet' ) ;
komme tilbake ;
}
uint64_t kortstørrelse = SD. kortstørrelse ( ) / ( 1024 * 1024 ) ;
Seriell. printf ( 'SD-kortstørrelse: %lluMB \n ' , kortstørrelse ) ;
// Andre funksjoner (listDir, createDir, removeDir, etc.) kan kalles her
}
tomrom Løkke ( ) {
}
Fra utgangen kan du se at jeg har et SD-kort på omtrent 30 GB.
Konklusjon
En MicroSD-kortmodul brukes til å lese og skrive data fra SD-kortet ved hjelp av ESP32-kortet. MicroSD-kortmodulen kommuniserer med mikrokontrolleren ved å bruke SPI-grensesnittet. Så du kan enten bruke SPI-biblioteket eller definere dine egne SPI-pinner inne i koden. Når du er koblet til, kan du lese og skrive en tekstfil, eller opprette nye kataloger på SD-kortet ditt.