In dit artikel worden de stappen uitgelegd voor het koppelen van een MicroSD-kaart aan een ESP32-bord met behulp van de Arduino IDE.
Inhoudsopgave:
2. ESP32 koppelen met MicroSD-kaartmodule
6. Verschillende functies uitvoeren op een MicroSD-kaart met behulp van ESP32
- 6.1. Mappen maken op een MicroSD-kaart
- 6.2. Lijst met mappen op de MicroSD-kaart
- 6.3. Mappen verwijderen
- 6.4. Verkrijg het MicroSD-kaarttype
- 6.5. Verkrijg SD-kaartgrootte
1. MicroSD-kaartmodule
De MicroSD-kaartmodule is een ESP32-sensor die de SD-kaart op uw microcontrollerbord kan aansluiten. Het werkt via het SPI-communicatieprotocol. Hiermee kan de ESP32 of een ander microcontrollerbord zoals Arduino toegang krijgen tot de gegevens die op de SD-kaart zijn opgeslagen via het SPI-protocol.
De werkspanning voor de SD-kaartmodule is 3,3 V, dus het is niet mogelijk om deze rechtstreeks op de ESP32 of een ander microcontrollerbord aan te sluiten. Daarvoor moeten we de SD-kaartmodule of sensor gebruiken die via 5V werkt.
1.1. Pin-out
De MicroSD-kaart beschikt in totaal over zes pinnen. Twee daarvan zijn stroompinnen: VCC en GND. Terwijl de uitlezing vier pinnen worden gebruikt voor het SPI-communicatieprotocol. Hieronder volgen de details voor al deze zes pinnen:
Stroompinnen:
- VCC: Wordt aangesloten op de ESP32 5V-pin.
- GND: Wordt aangesloten op de ESP32-aardepin (GND).
SPI-pinnen:
- MISO: (Master In Slave Out) Wordt aangesloten op de ESP32 MOSI-pin (Master Out Slave In).
- ROOK: Wordt aangesloten op de ESP32 MISO-pin (Master In Slave Out).
- SCK: Wordt aangesloten op de ESP32 SCK-pin (seriële klok).
- RVS: (Slave Select) Maakt verbinding met de pin die in de Arduino-code is gespecificeerd als de SS (Slave Select) pin.
2. ESP32 koppelen met MicroSD-kaartmodule
Om ESP32 te koppelen met de MicroSD-kaartmodule, moet u de stroompinnen voor uw SD-kaartsensor instellen. Stel vervolgens de SPI-pinnen in. Hier heeft u twee keuzes: u kunt de standaard SPI-pinnen instellen of uw eigen aangepaste SPI-pinnen definiëren.
Als we standaard SPI-pinnen gebruiken, gaan we de SD h En SD_MMC.h bibliotheken. Standaard gebruiken deze bibliotheken de VSPI SPI-pinnen (23, 19, 18, 5) voor SPI-communicatie. U kunt echter ook andere pinnen instellen voor SPI-communicatie.
De ESP32 bevat twee SPI-interfaces HSPI en VSPI met hun pinnen als volgt gedetailleerd:
| SPI | ROOK | MISO | CLK | CS |
| VSPI | D23 | D19 | D18 | D5 |
| HSPI | D13 | D12 | D14 | D15 |
Verwant: ESP32 Pinout-referentie – Een complete gids
2.2. Maak de SD-kaart gereed
Voordat u verder kunt gaan met het lezen en schrijven van gegevens naar een MicroSD-kaart, moet u deze eerst instellen door eventuele eerdere gegevens erop te formatteren.
Open uw SD-kaart met een kaartlezer en formaat Het.
Selecteer de FAT32 voor uw kaartbestandssysteem en klik Begin .
Selecteer na het formatteren van de kaart OK .
Nu is uw SD-kaart klaar om te worden gekoppeld aan ESP32 met behulp van de SD-kaartmodule.
2.3. Schematisch diagram
Om de MicroSD-kaartsensor met ESP32 te verbinden, volgt u de onderstaande configuratie:
Hieronder volgt de tabel voor de pinconfiguratie van de verbindingsdraad:
| Micro SD kaart | ESP32 |
| GND | GND |
| VCC | KOMEN |
| CS | D5 |
| ROOK | D23 |
| SCK | D18 |
| MISO | D19 |
3. Hardware
Voor hardware heb je alleen wat verbindingsdraden, een breadboard nodig, samen met ESP32 en SD-kaartmodule.
4. Coderen
Nu zullen we een code schrijven die een tekstbestand op de MicroSD-kaart zal creëren en daarna zal het daar een tekststring naar schrijven. Als we klaar zijn, lezen we de inhoud van het tekstbestand op de Arduino IDE seriële monitor.
Start Arduino IDE en compileer de gegeven code. Brand het daarna op uw ESP32-bord:
#include#include
Bestand mijnBestand ;
const int CS = 5 ;
// Schrijf het gegeven bericht naar een bestand op het opgegeven pad
leegte Schrijfbestand ( const verkoold * pad , const verkoold * bericht ) {
//Open het bestand. Het ondersteunt het openen van één bestand tegelijk
// sluit het andere bestand voordat u een nieuw bestand opent
mijn bestand = SD. open ( pad , FILE_WRITE ) ;
als ( mijn bestand ) {
Serieel. afdrukkenf ( 'Schrijven naar %s ' , pad ) ;
mijn bestand. println ( bericht ) ;
mijn bestand. dichtbij ( ) ; // Sluit het bestand
Serieel. println ( 'voltooid.' ) ;
} anders {
Serieel. println ( 'fout bij openen bestand' ) ;
Serieel. println ( pad ) ;
}
}
// Druk de bestandsinhoud af op het opgegeven pad
leegte LeesBestand ( const verkoold * pad ) {
// Open bestand
mijn bestand = SD. open ( pad ) ;
als ( mijn bestand ) {
Serieel. afdrukkenf ( 'Bestand van %s lezen \N ' , pad ) ;
// Lees het volledige bestand tot het laatste
terwijl ( mijn bestand. beschikbaar ( ) ) {
Serieel. schrijven ( mijn bestand. lezen ( ) ) ;
}
mijn bestand. dichtbij ( ) ; // Sluit het bestand
} anders {
// Als het bestand niet kan worden geopend, drukt u een foutmelding af:
Serieel. println ( 'Fout bij openen test.txt' ) ;
}
}
leegte opgericht ( ) {
Serieel. beginnen ( 9600 ) ;
vertraging ( 500 ) ;
terwijl ( ! Serieel ) { ; }
Serieel. println ( 'SD-kaart initialiseren...' ) ;
als ( ! SD. beginnen ( CS ) ) {
Serieel. println ( 'Initialisatie gefaald!' ) ;
opbrengst ;
}
Serieel. println ( 'Initialisatie voltooid.' ) ;
Schrijfbestand ( '/test.txt' , 'Linuxhint.com' ) ;
LeesBestand ( '/test.txt' ) ;
}
leegte lus ( ) {
}
4.1. Code-uitleg
Voor een beter begrip zullen we deze code in subdelen verdelen.
Initialisatie en configuratie: Ten eerste begon de code met het opnemen van enkele belangrijke bibliotheken gerelateerd aan de SD-kaartmodule. De SPI.h-bibliotheek is toegevoegd voor communicatie met de SD-kaart en SD.h voor het afhandelen van SD-kaartbewerkingen. Vervolgens definieert het een globale variabele mijn bestand van het type bestand om bestandsbewerkingen te beheren. De CS-constante is ingesteld op pin 5, die zal worden gebruikt als de Chip Select (CS) pin voor de SD-kaart.
Setup()-functie: Binnen de setup-functie wordt seriële communicatie gestart. Daarna hebben we de SD-kaartmodule geïnitialiseerd met behulp van de functie SD.begin(CS). Verder hebben we ook twee verschillende functies gedefinieerd voor het lezen en schrijven van tekst naar een tekstbestand.
Schrijven naar de SD-kaart: De functie WriteFile() opent het bestand test.txt om te schrijven met SD.open(pad, FILE_WRITE). Daarna schrijft het de string Linuxhint.com naar het bestand met behulp van myFile.println(message).
Lezen vanaf de SD-kaart: Om de bestandsinhoud te lezen, hebben we de functie ReadFile() gebruikt. Als het lezen succesvol is, worden de gegevens naar de seriële poort van Arduino verzonden en weergegeven op de seriële Arduino IDE-monitor.
5. Uitgang
In de uitvoer ziet u dat dezelfde string die we hebben gedefinieerd in de Arduino IDE-code wordt weergegeven op uw Arduino IDE seriële monitor.
6. Verschillende functies uitvoeren op een MicroSD-kaart met behulp van ESP32
We kunnen verschillende bewerkingen uitvoeren, zoals het maken, verwijderen of toevoegen van mappen op MicroSD-kaarten, rechtstreeks via de Arduino IDE-code.
6.1. Mappen maken op een MicroSD-kaart
De onderstaande code maakt een nieuwe map op de MicroSD-kaart. Het definieert een functie genaamd creërenDir waarvoor een bestandssysteemobject (fs::FS) en een pad als invoer nodig zijn. Deze functie probeert een map met het opgegeven pad aan te maken en drukt berichten af die aangeven dat dit is gelukt of mislukt.
#include 'FS.h'#include 'SD.h'
#include 'SPI.h'
leegte creërenDir ( fs :: FS & fs , const verkoold * pad ) {
Serieel. afdrukkenf ( 'Maak map: %s aan \N ' , pad ) ;
als ( fs. mkdir ( pad ) ) {
Serieel. println ( 'Dir gemaakt' ) ;
} anders {
Serieel. println ( 'mkdir mislukt' ) ;
}
}
leegte opgericht ( ) {
Serieel. beginnen ( 115200 ) ;
// Initialiseer de SD-kaart
als ( ! SD. beginnen ( ) ) {
Serieel. println ( 'Kaartmontage mislukt' ) ;
opbrengst ;
}
// Maak een map met de naam 'mydir'
creërenDir ( SD , '/mijnmap' ) ;
}
leegte lus ( ) {
}
In de uitvoer kunt u zien dat er een nieuwe map is gemaakt met /mijndir naam.
6.2. Lijst met mappen op de MicroSD-kaart
In de onderstaande code gaan we alle mappen op de MicroSD-kaart vermelden. De lijstDir functie geeft recursief de inhoud van een map op een SD-kaart weer. Het drukt informatie af over zowel mappen (voorafgegaan door “DIR”) als bestanden (voorafgegaan door “FILE”), inclusief hun namen en groottes.
#include 'FS.h'#include 'SD.h'
#include 'SPI.h'
leegte lijstDir ( fs :: FS & fs , const verkoold * mapnaam , uint8_t niveaus ) {
Serieel. afdrukkenf ( 'Lijstmap: %s \N ' , mapnaam ) ;
Bestandswortel = fs. open ( mapnaam ) ;
als ( ! wortel ) {
Serieel. println ( 'Kan map niet openen' ) ;
opbrengst ;
}
als ( ! wortel. isDirectory ( ) ) {
Serieel. println ( 'Geen map' ) ;
opbrengst ;
}
Bestand bestand = wortel. openVolgendeBestand ( ) ;
terwijl ( bestand ) {
als ( bestand. isDirectory ( ) ) {
Serieel. afdrukken ( ' JIJ : ' ) ;
Serieel. println ( bestand. naam ( ) ) ;
als ( niveaus ) {
lijstDir ( fs , bestand. naam ( ) , niveaus - 1 ) ;
}
} anders {
Serieel. afdrukken ( ' BESTAND: ' ) ;
Serieel. afdrukken ( bestand. naam ( ) ) ;
Serieel. afdrukken ( ' MAAT: ' ) ;
Serieel. println ( bestand. maat ( ) ) ;
}
bestand = wortel. openVolgendeBestand ( ) ;
}
}
leegte opgericht ( ) {
Serieel. beginnen ( 115200 ) ;
als ( ! SD. beginnen ( ) ) {
Serieel. println ( 'Kaartmontage mislukt' ) ;
opbrengst ;
}
lijstDir ( SD , '/' , 0 ) ;
}
leegte lus ( ) {
}
In de uitvoer ziet u twee verschillende bestanden. De ene is een tekstbestand en de andere is een map die we in de vorige code hebben gemaakt.
6.3. Mappen verwijderen
Nu zullen we de eerder gemaakte mappen en tekstbestanden verwijderen. Daarvoor gaan we gebruik maken van de verwijderDir functie, zal het proberen een map te verwijderen die door het pad is opgegeven. Als dit lukt, wordt het afgedrukt Dir verwijderd ; anders wordt het afgedrukt rmdir is mislukt .
#include 'FS.h'#include 'SD.h'
#include 'SPI.h'
leegte verwijderDir ( fs :: FS & fs , const verkoold * pad ) {
Serieel. afdrukkenf ( 'Directory: %s verwijderd \N ' , pad ) ;
als ( fs. is rm ( pad ) ) {
Serieel. println ( 'Dir verwijderd' ) ;
} anders {
Serieel. println ( 'rmdir mislukt' ) ;
}
}
leegte opgericht ( ) {
Serieel. beginnen ( 115200 ) ;
als ( ! SD. beginnen ( ) ) {
Serieel. println ( 'Kaartmontage mislukt' ) ;
opbrengst ;
}
}
leegte lus ( ) {
}
6.4. Verkrijg het MicroSD-kaarttype
MicroSD-kaart of S veilig D igital-kaart is oorspronkelijk ontworpen door de SD-kaartvereniging en ontworpen voor gebruik in draagbare apparaten zoals smartphones en camera's. SD-kaarten bevatten hoofdzakelijk vier soorten families:
- SDSC (standaardcapaciteit SD): Deze kaarten bieden een bescheiden opslagcapaciteit van 2 GB en maken gebruik van de FAT-12- en FAT-16-bestandssystemen.
- SDHC (SD met hoge capaciteit): Deze kaarten variëren van 2 GB tot 32 GB en gebruiken het FAT-32-bestandssysteem.
- SDXC (uitgebreide capaciteit SD): Deze kaarten gebruiken het exFAT-bestandssysteem en beginnen vanaf 32 GB tot wel 2 TB.
- SDIO: SDIO-kaarten dienen een tweeledig doel door de gegevensopslag te combineren met INPUT/OUTPUT-functies.
Voer de onderstaande code uit om uw kaarttype te controleren:
#include 'FS.h'#include 'SD.h'
#include 'SPI.h'
leegte opgericht ( ) {
Serieel. beginnen ( 115200 ) ;
als ( ! SD. beginnen ( ) ) {
Serieel. println ( 'Kaartmontage mislukt' ) ;
opbrengst ;
}
uint8_t kaarttype = SD. kaarttype ( ) ;
als ( kaarttype == CARD_NONE ) {
Serieel. println ( 'Geen SD-kaart aangesloten' ) ;
opbrengst ;
}
Serieel. afdrukken ( 'SD-kaarttype:' ) ;
als ( kaarttype == CARD_MMC ) {
Serieel. println ( 'MMC' ) ;
} anders als ( kaarttype == CARD_SD ) {
Serieel. println ( 'SDSC' ) ;
} anders als ( kaarttype == CARD_SDHC ) {
Serieel. println ( 'SDHC' ) ;
} anders {
Serieel. println ( 'ONBEKEND' ) ;
}
uint64_t kaartgrootte = SD. kaartgrootte ( ) / ( 1024 * 1024 ) ;
Serieel. afdrukkenf ( 'SD-kaartgrootte: %lluMB \N ' , kaartgrootte ) ;
}
leegte lus ( ) {
}
Omdat ik een kaart van 32 GB heb, kun je zien dat deze binnen het bereik ligt SDHC kaarten.
6.5. Verkrijg het microSD-kaartformaat
Je kunt ook de grootte van de SD-kaart achterhalen door de onderstaande code naar je ESP32-bord te uploaden.
#include 'FS.h'#include 'SD.h'
#include 'SPI.h'
leegte opgericht ( ) {
Serieel. beginnen ( 115200 ) ;
als ( ! SD. beginnen ( ) ) {
Serieel. println ( 'Kaartmontage mislukt' ) ;
opbrengst ;
}
uint8_t kaarttype = SD. kaarttype ( ) ;
als ( kaarttype == CARD_NONE ) {
Serieel. println ( 'Geen SD-kaart aangesloten' ) ;
opbrengst ;
}
uint64_t kaartgrootte = SD. kaartgrootte ( ) / ( 1024 * 1024 ) ;
Serieel. afdrukkenf ( 'SD-kaartgrootte: %lluMB \N ' , kaartgrootte ) ;
// Andere functies (listDir, createDir, removeDir, etc.) kunnen hier worden aangeroepen
}
leegte lus ( ) {
}
Uit de uitvoer kun je zien dat ik een SD-kaart van ongeveer 30 GB heb.
Conclusie
Een MicroSD-kaartmodule wordt gebruikt om de gegevens van de SD-kaart te lezen en te schrijven met behulp van het ESP32-bord. De MicroSD-kaartmodule communiceert met de microcontroller via de SPI-interface. U kunt dus de SPI-bibliotheek gebruiken of uw eigen SPI-pinnen in de code definiëren. Eenmaal verbonden, kunt u een tekstbestand lezen of nieuwe mappen op uw SD-kaart maken.