In diesem Artikel werden die Schritte zum Anschließen einer MicroSD-Karte an eine ESP32-Karte mithilfe der Arduino IDE erläutert.
Inhaltsverzeichnis:
2. So verbinden Sie ESP32 mit dem MicroSD-Kartenmodul
6. Ausführen verschiedener Funktionen auf einer MicroSD-Karte mit ESP32
- 6.1. Erstellen von Verzeichnissen auf einer MicroSD-Karte
- 6.2. Auflisten von Verzeichnissen auf der MicroSD-Karte
- 6.3. Verzeichnisse entfernen
- 6.4. Ermitteln Sie den MicroSD-Kartentyp
- 6.5. Holen Sie sich die SD-Kartengröße
1. MicroSD-Kartenmodul
Das MicroSD-Kartenmodul ist ein ESP32-Sensor, der die SD-Karte mit Ihrem Mikrocontroller-Board verbinden kann. Es funktioniert über das SPI-Kommunikationsprotokoll. Es ermöglicht dem ESP32 oder jedem anderen Mikrocontroller-Board wie Arduino, über das SPI-Protokoll auf die auf der SD-Karte gespeicherten Daten zuzugreifen.
Die Arbeitsspannung für das SD-Kartenmodul beträgt 3,3 V, daher ist es nicht möglich, es direkt an den ESP32 oder ein anderes Mikrocontroller-Board anzuschließen. Dazu müssen wir das SD-Kartenmodul oder den Sensor verwenden, der über 5 V arbeitet.
1.1. Pinbelegung
Die MicroSD-Karte verfügt über insgesamt sechs Pins. Zwei davon sind Power-Pins: VCC und GND. Beim Lesen werden vier Pins für das SPI-Kommunikationsprotokoll verwendet. Im Folgenden finden Sie die Details zu allen diesen sechs Pins:
Power-Pins:
- VCC: Wird an den 5-V-Pin des ESP32 angeschlossen.
- Masse: Wird mit dem Erdungsstift (GND) des ESP32 verbunden.
SPI-Pins:
- MISO: (Master In Slave Out) Verbindet sich mit dem ESP32 MOSI-Pin (Master Out Slave In).
- RAUCH: Verbindet sich mit dem ESP32 MISO-Pin (Master In Slave Out).
- SCK: Wird mit dem ESP32 SCK-Pin (Serial Clock) verbunden.
- SS: (Slave Select) Verbindet sich mit dem Pin, der im Arduino-Code als SS-Pin (Slave Select) angegeben ist.
2. So verbinden Sie ESP32 mit dem MicroSD-Kartenmodul
Um ESP32 mit dem MicroSD-Kartenmodul zu verbinden, müssen Sie die Stromanschlüsse für Ihren SD-Kartensensor einrichten. Als nächstes richten Sie die SPI-Pins ein. Hier haben Sie zwei Möglichkeiten: Sie können entweder die Standard-SPI-Pins festlegen oder Ihre eigenen benutzerdefinierten SPI-Pins definieren.
Wenn Sie Standard-SPI-Pins verwenden, fügen wir Folgendes hinzu SD. h Und SD_MMC.h Bibliotheken. Standardmäßig verwenden diese Bibliotheken die VSPI-SPI-Pins (23, 19, 18, 5) für die SPI-Kommunikation. Sie können jedoch auch andere Pins für die SPI-Kommunikation setzen.
Der ESP32 enthält zwei SPI-Schnittstellen HSPI und VSPI mit ihren Pins im Detail wie folgt:
| SPI | RAUCH | MISO | CLK | CS |
| VSPI | D23 | D19 | D18 | D5 |
| HSPI | D13 | D12 | D14 | D15 |
Verwandt: ESP32-Pinbelegungsreferenz – Eine vollständige Anleitung
2.2. Bereiten Sie die SD-Karte vor
Bevor Sie mit dem Lesen und Schreiben von Daten auf eine MicroSD-Karte fortfahren können, müssen Sie diese zunächst einrichten, indem Sie alle zuvor darin enthaltenen Daten formatieren.
Öffnen Sie Ihre SD-Karte mit einem beliebigen Kartenleser und Format Es.
Wählen Sie FAT32 für Ihr Kartendateisystem aus und klicken Sie Start .
Wählen Sie nach dem Formatieren der Karte aus OK .
Jetzt ist Ihre SD-Karte bereit, über das SD-Kartenmodul mit ESP32 verbunden zu werden.
2.3. Schematische Darstellung
Um den MicroSD-Kartensensor mit ESP32 zu verbinden, befolgen Sie die unten angegebene Konfiguration:
Nachfolgend finden Sie die Tabelle zur Pinbelegung des Anschlusskabels:
| Micro SD Karte | ESP32 |
| GND | GND |
| VCC | KOMMEN |
| CS | D5 |
| RAUCH | D23 |
| SCK | D18 |
| MISO | D19 |
3. Hardware
Für die Hardware benötigen Sie lediglich ein paar Überbrückungskabel, ein Steckbrett sowie ein ESP32- und SD-Kartenmodul.
4. Code
Jetzt schreiben wir einen Code, der eine Textdatei auf der MicroSD-Karte erstellt und anschließend eine Textzeichenfolge darauf schreibt. Sobald wir fertig sind, lesen wir den Inhalt der Textdatei auf dem seriellen Arduino IDE-Monitor.
Starten Sie die Arduino IDE und kompilieren Sie den angegebenen Code. Danach brennen Sie es auf Ihr ESP32-Board:
#include#include
Datei myFile ;
const int CS = 5 ;
// Schreibe die angegebene Nachricht in eine Datei im angegebenen Pfad
Leere WriteFile ( const verkohlen * Weg , const verkohlen * Nachricht ) {
// Öffne die Datei. Es unterstützt das gleichzeitige Öffnen einer Datei
// Schließen Sie die andere Datei, bevor Sie eine neue Datei öffnen
meine Datei = SD. offen ( Weg , FILE_WRITE ) ;
Wenn ( meine Datei ) {
Seriell. printf ( „Schreibe an %s“ , Weg ) ;
meine Datei. println ( Nachricht ) ;
meine Datei. schließen ( ) ; // Schließe die Datei
Seriell. println ( 'vollendet.' ) ;
} anders {
Seriell. println ( „Fehler beim Öffnen der Datei“ ) ;
Seriell. println ( Weg ) ;
}
}
// Dateiinhalt im angegebenen Pfad drucken
Leere ReadFile ( const verkohlen * Weg ) {
// Datei öffnen
meine Datei = SD. offen ( Weg ) ;
Wenn ( meine Datei ) {
Seriell. printf ( „Datei wird von %s gelesen \N ' , Weg ) ;
// Komplette Datei lesen, bis die letzte erreicht ist
während ( meine Datei. verfügbar ( ) ) {
Seriell. schreiben ( meine Datei. lesen ( ) ) ;
}
meine Datei. schließen ( ) ; // Schließe die Datei
} anders {
// Wenn die Datei nicht geöffnet werden konnte, wird eine Fehlermeldung ausgegeben:
Seriell. println ( „Fehler beim Öffnen von test.txt“ ) ;
}
}
Leere aufstellen ( ) {
Seriell. beginnen ( 9600 ) ;
Verzögerung ( 500 ) ;
während ( ! Seriell ) { ; }
Seriell. println ( „SD-Karte wird initialisiert…“ ) ;
Wenn ( ! SD. beginnen ( CS ) ) {
Seriell. println ( 'Initialisierung fehlgeschlagen!' ) ;
zurückkehren ;
}
Seriell. println ( „Initialisierung abgeschlossen.“ ) ;
WriteFile ( „/test.txt“ , „Linuxhint.com“ ) ;
ReadFile ( „/test.txt“ ) ;
}
Leere Schleife ( ) {
}
4.1. Code-Erklärung
Zum besseren Verständnis werden wir diesen Code in Unterteile unterteilen.
Initialisierung und Einrichtung: Zunächst begann der Code mit der Einbindung einiger wichtiger Bibliotheken im Zusammenhang mit dem SD-Kartenmodul. Die SPI.h-Bibliothek wird für die Kommunikation mit der SD-Karte und SD.h für die Handhabung von SD-Kartenvorgängen hinzugefügt. Als nächstes definiert es eine globale Variable meine Datei vom Typ Datei zur Verwaltung von Dateivorgängen. Die CS-Konstante ist auf Pin 5 eingestellt, der als Chip Select (CS)-Pin für die SD-Karte verwendet wird.
Setup()-Funktion: Innerhalb der Setup-Funktion wird die serielle Kommunikation gestartet. Danach haben wir das SD-Kartenmodul mit der Funktion SD.begin(CS) initialisiert. Darüber hinaus haben wir zwei verschiedene Funktionen zum Lesen und Schreiben von Text in eine Textdatei definiert.
Schreiben auf die SD-Karte: Die Funktion WriteFile() öffnet die Datei test.txt zum Schreiben mit SD.open(path, FILE_WRITE). Danach schreibt es die Zeichenfolge Linuxhint.com mit myFile.println(message) in die Datei.
Von der SD-Karte lesen: Um den Dateiinhalt zu lesen, haben wir die Funktion ReadFile() verwendet. Bei erfolgreichem Lesen werden die Daten an den seriellen Arduino-Port gesendet und auf dem seriellen Arduino IDE-Monitor angezeigt.
5. Ausgabe
In der Ausgabe können Sie sehen, dass dieselbe Zeichenfolge, die wir im Arduino IDE-Code definiert haben, auf Ihrem seriellen Arduino IDE-Monitor angezeigt wird.
6. Ausführen verschiedener Funktionen auf einer MicroSD-Karte mit ESP32
Wir können verschiedene Vorgänge wie das Erstellen, Entfernen oder Hinzufügen von Verzeichnissen auf MicroSD-Karten direkt über den Arduino IDE-Code ausführen.
6.1. Erstellen von Verzeichnissen auf einer MicroSD-Karte
Der folgende Code erstellt ein neues Verzeichnis auf der MicroSD-Karte. Es definiert eine aufgerufene Funktion createDir das ein Dateisystemobjekt (fs::FS) und einen Pfad als Eingabe benötigt. Diese Funktion versucht, ein Verzeichnis mit dem angegebenen Pfad zu erstellen und gibt Meldungen aus, die Erfolg oder Misserfolg anzeigen.
#include „FS.h“#include „SD.h“
#include „SPI.h“
Leere createDir ( fs :: FS & fs , const verkohlen * Weg ) {
Seriell. printf ( „Verzeichnis wird erstellt: %s \N ' , Weg ) ;
Wenn ( fs. mkdir ( Weg ) ) {
Seriell. println ( „Verzeichnis erstellt“ ) ;
} anders {
Seriell. println ( „mkdir fehlgeschlagen“ ) ;
}
}
Leere aufstellen ( ) {
Seriell. beginnen ( 115200 ) ;
// SD-Karte initialisieren
Wenn ( ! SD. beginnen ( ) ) {
Seriell. println ( „Kartenmontage fehlgeschlagen“ ) ;
zurückkehren ;
}
// Erstellen Sie ein Verzeichnis mit dem Namen „mydir“
createDir ( SD , „/meinVerzeichnis“ ) ;
}
Leere Schleife ( ) {
}
In der Ausgabe können Sie sehen, dass ein neues Verzeichnis erstellt wird /meindir Name.
6.2. Auflisten von Verzeichnissen auf der MicroSD-Karte
Im folgenden Code werden wir alle Verzeichnisse auflisten, die auf der MicroSD-Karte vorhanden sind. Der listDir Die Funktion listet rekursiv den Inhalt eines Verzeichnisses auf einer SD-Karte auf. Es druckt Informationen zu Verzeichnissen (mit dem Präfix „DIR“) und Dateien (mit dem Präfix „FILE“), einschließlich deren Namen und Größen.
#include „FS.h“#include „SD.h“
#include „SPI.h“
Leere listDir ( fs :: FS & fs , const verkohlen * Verzeichnisname , uint8_t Ebenen ) {
Seriell. printf ( „Auflistungsverzeichnis: %s \N ' , Verzeichnisname ) ;
Dateistamm = fs. offen ( Verzeichnisname ) ;
Wenn ( ! Wurzel ) {
Seriell. println ( „Verzeichnis konnte nicht geöffnet werden“ ) ;
zurückkehren ;
}
Wenn ( ! Wurzel. isDirectory ( ) ) {
Seriell. println ( „Kein Verzeichnis“ ) ;
zurückkehren ;
}
Dateidatei = Wurzel. openNextFile ( ) ;
während ( Datei ) {
Wenn ( Datei. isDirectory ( ) ) {
Seriell. drucken ( ' DU : ' ) ;
Seriell. println ( Datei. Name ( ) ) ;
Wenn ( Ebenen ) {
listDir ( fs , Datei. Name ( ) , Ebenen - 1 ) ;
}
} anders {
Seriell. drucken ( ' DATEI: ' ) ;
Seriell. drucken ( Datei. Name ( ) ) ;
Seriell. drucken ( ' GRÖSSE: ' ) ;
Seriell. println ( Datei. Größe ( ) ) ;
}
Datei = Wurzel. openNextFile ( ) ;
}
}
Leere aufstellen ( ) {
Seriell. beginnen ( 115200 ) ;
Wenn ( ! SD. beginnen ( ) ) {
Seriell. println ( „Kartenmontage fehlgeschlagen“ ) ;
zurückkehren ;
}
listDir ( SD , „/“ , 0 ) ;
}
Leere Schleife ( ) {
}
In der Ausgabe sehen Sie zwei verschiedene Dateien. Eine davon ist eine Textdatei und die andere ein Verzeichnis, das wir im vorherigen Code erstellt haben.
6.3. Verzeichnisse entfernen
Jetzt werden wir die zuvor erstellten Verzeichnisse und Textdateien entfernen. Dafür verwenden wir die RemoveDir Funktion: Es wird versucht, ein durch den Pfad angegebenes Verzeichnis zu entfernen. Bei Erfolg wird gedruckt Verzeichnis entfernt ; andernfalls wird gedruckt rmdir ist fehlgeschlagen .
#include „FS.h“#include „SD.h“
#include „SPI.h“
Leere RemoveDir ( fs :: FS & fs , const verkohlen * Weg ) {
Seriell. printf ( „Verzeichnis wird entfernt: %s \N ' , Weg ) ;
Wenn ( fs. ist rm ( Weg ) ) {
Seriell. println ( „Verzeichnis entfernt“ ) ;
} anders {
Seriell. println ( „rmdir fehlgeschlagen“ ) ;
}
}
Leere aufstellen ( ) {
Seriell. beginnen ( 115200 ) ;
Wenn ( ! SD. beginnen ( ) ) {
Seriell. println ( „Kartenmontage fehlgeschlagen“ ) ;
zurückkehren ;
}
}
Leere Schleife ( ) {
}
6.4. Ermitteln Sie den MicroSD-Kartentyp
MicroSD-Karte bzw S sicher D Die digitale Karte wurde ursprünglich von der SD Card Association entwickelt und für den Einsatz in tragbaren Geräten wie Smartphones und Kameras konzipiert. SD-Karten enthalten hauptsächlich vier Arten von Familien:
- SDSC (Standardkapazität SD): Diese Karten bieten eine bescheidene Speicherkapazität von 2 GB und verwenden die Dateisysteme FAT-12 und FAT-16.
- SDHC (SD mit hoher Kapazität): Diese Karten reichen von 2 GB bis 32 GB und verwenden das FAT-32-Dateisystem.
- SDXC (eXtended Capacity SD): Diese Karten verwenden das exFAT-Dateisystem und reichen von 32 GB bis zu 2 TB.
- SDIO: SDIO-Karten dienen einem doppelten Zweck, indem sie die Datenspeicherung mit INPUT/OUTPUT-Funktionen kombinieren.
Um Ihren Kartentyp zu überprüfen, führen Sie den folgenden Code aus:
#include „FS.h“#include „SD.h“
#include „SPI.h“
Leere aufstellen ( ) {
Seriell. beginnen ( 115200 ) ;
Wenn ( ! SD. beginnen ( ) ) {
Seriell. println ( „Kartenmontage fehlgeschlagen“ ) ;
zurückkehren ;
}
uint8_t Speicherkarten-Typ = SD. Speicherkarten-Typ ( ) ;
Wenn ( Speicherkarten-Typ == CARD_NONE ) {
Seriell. println ( „Keine SD-Karte angeschlossen“ ) ;
zurückkehren ;
}
Seriell. drucken ( „SD-Kartentyp:“ ) ;
Wenn ( Speicherkarten-Typ == CARD_MMC ) {
Seriell. println ( „MMC“ ) ;
} anders Wenn ( Speicherkarten-Typ == CARD_SD ) {
Seriell. println ( „SDSC“ ) ;
} anders Wenn ( Speicherkarten-Typ == CARD_SDHC ) {
Seriell. println ( „SDHC“ ) ;
} anders {
Seriell. println ( 'UNBEKANNT' ) ;
}
uint64_t Kartengröße = SD. Kartengröße ( ) / ( 1024 * 1024 ) ;
Seriell. printf ( „SD-Kartengröße: %lluMB \N ' , Kartengröße ) ;
}
Leere Schleife ( ) {
}
Da ich eine 32GB-Karte habe, sieht man, dass sie im Bereich von liegt SDHC Karten.
6.5. Holen Sie sich die MicroSD-Kartengröße
Sie können die Größe der SD-Karte auch ermitteln, indem Sie den folgenden Code auf Ihr ESP32-Board hochladen.
#include „FS.h“#include „SD.h“
#include „SPI.h“
Leere aufstellen ( ) {
Seriell. beginnen ( 115200 ) ;
Wenn ( ! SD. beginnen ( ) ) {
Seriell. println ( „Kartenmontage fehlgeschlagen“ ) ;
zurückkehren ;
}
uint8_t Speicherkarten-Typ = SD. Speicherkarten-Typ ( ) ;
Wenn ( Speicherkarten-Typ == CARD_NONE ) {
Seriell. println ( „Keine SD-Karte angeschlossen“ ) ;
zurückkehren ;
}
uint64_t Kartengröße = SD. Kartengröße ( ) / ( 1024 * 1024 ) ;
Seriell. printf ( „SD-Kartengröße: %lluMB \N ' , Kartengröße ) ;
// Andere Funktionen (listDir, createDir, removeDir usw.) können hier aufgerufen werden
}
Leere Schleife ( ) {
}
Aus der Ausgabe können Sie ersehen, dass ich eine SD-Karte mit ca. 30 GB habe.
Abschluss
Ein MicroSD-Kartenmodul dient zum Lesen und Schreiben der Daten von der SD-Karte mithilfe der ESP32-Karte. Das MicroSD-Kartenmodul kommuniziert über die SPI-Schnittstelle mit dem Mikrocontroller. Sie können also entweder die SPI-Bibliothek verwenden oder Ihre eigenen SPI-Pins im Code definieren. Sobald die Verbindung hergestellt ist, können Sie eine Textdatei lesen, schreiben oder neue Verzeichnisse auf Ihrer SD-Karte erstellen.