ESP32 MicroPython - SD-Karte
Diese Anleitung führt Sie durch die Anbindung einer Micro-SD-Karte an den ESP32 mit MicroPython. Sie lernen:
- Eine Datei auf der Micro-SD-Karte mit MicroPython auf dem ESP32 zu öffnen oder zu erstellen.
- Daten in einer Datei auf der Micro-SD-Karte zu speichern.
- Dateiinhalte Zeichen für Zeichen von der Micro-SD-Karte zu lesen.
- Eine Datei auf der Micro-SD-Karte Zeile für Zeile zu lesen und zu verarbeiten.
- Neue Daten an eine vorhandene Datei auf der Micro-SD-Karte anzuhängen.
- Den Inhalt einer Datei auf der Micro-SD-Karte zu überschreiben.
Erforderliche Hardware
Oder Sie können die folgenden Kits kaufen:
| 1 | × | DIYables ESP32 Starter-Kit (ESP32 enthalten) | |
| 1 | × | DIYables Sensor-Kit (18 Sensoren/Displays) |
Offenlegung: Einige der in diesem Abschnitt bereitgestellten Links sind Amazon-Affiliate-Links. Wir können eine Provision für Käufe erhalten, die über diese Links getätigt werden, ohne zusätzliche Kosten für Sie. Wir schätzen Ihre Unterstützung.
Überblick über Micro SD Card Module
Ein Micro-SD-Kartenmodul dient als Adapter, über den der ESP32 per SPI-Protokoll mit einer Micro-SD-Karte kommunizieren kann. Es fungiert als Verbindungsstück zwischen dem Mikrocontroller und der Speicherkarte.
Pinbelegung
Das Micro-SD-Kartenmodul hat 6 Pins:
- VCC-Pin: versorgt das Modul mit Strom, mit dem 5V-Ausgang des ESP32 verbinden.
- GND-Pin: Massebezug, mit GND des ESP32 verbinden.
- MISO-Pin: (Master In Slave Out) Datenleitung von der SD-Karte zum ESP32.
- MOSI-Pin: (Master Out Slave In) Datenleitung vom ESP32 zur SD-Karte.
- SCK-Pin: SPI-Taktsignal, mit SCK des ESP32 verbinden.
- SS-Pin: (Slave Select) Chip-Select-Pin, wird im MicroPython-Code zugewiesen.
Vorbereitung
- Stecken Sie die Micro-SD-Karte in einen USB-3.0-SD-Kartenleser und verbinden Sie ihn mit Ihrem PC.
- Überprüfen Sie, ob die Micro-SD-Karte das Format FAT16 oder FAT32 verwendet (suchen Sie bei Bedarf online nach einer Anleitung).
Verdrahtungsdiagramm
Dieses Bild wurde mit Fritzing erstellt. Klicken Sie, um das Bild zu vergrößern.
Die folgende Verdrahtungstabelle zeigt, wie Sie das Micro-SD-Kartenmodul mit dem ESP32 verbinden:
| Micro-SD-Kartenmodul | ESP32 |
|---|---|
| VCC | 5V |
| GND | GND |
| MISO | GPIO19 |
| MOSI | GPIO23 |
| SCK | GPIO18 |
| CS | GPIO5 |
※ Notiz:
Wenn Ihr Shield (z. B. ein Ethernet-Shield) bereits einen eingebauten Micro-SD-Kartensteckplatz hat, können Sie auf das externe Modul verzichten und die Karte direkt in das Shield einsetzen.
ESP32 MicroPython - Eine Datei auf der Micro-SD-Karte öffnen und erstellen
ESP32 MicroPython-Code
/*
* Dieser ESP32 MicroPython Code wurde von newbiely.de entwickelt
* Dieser ESP32 MicroPython Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt.
* Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte:
* https://newbiely.de/tutorials/esp32-micropython/esp32-micropython-micro-sd-card
*/
import machine
import os
import sdcard
# Define SPI pins for the Micro SD Card module
SPI_SCK_PIN = 18 # The ESP32 pin GPIO18 connected to SCK
SPI_MOSI_PIN = 23 # The ESP32 pin GPIO23 connected to MOSI
SPI_MISO_PIN = 19 # The ESP32 pin GPIO19 connected to MISO
SPI_CS_PIN = 5 # The ESP32 pin GPIO5 connected to SS (CS)
# Initialize SD card using SoftSPI and sdcard driver
spi = machine.SoftSPI(baudrate=1000000, polarity=0, phase=0,
sck=machine.Pin(SPI_SCK_PIN),
mosi=machine.Pin(SPI_MOSI_PIN),
miso=machine.Pin(SPI_MISO_PIN))
cs = machine.Pin(SPI_CS_PIN, machine.Pin.OUT)
try:
sd = sdcard.SDCard(spi, cs)
os.mount(sd, "/sd")
print("SD CARD INITIALIZED.")
except Exception as e:
print("SD CARD FAILED, OR NOT PRESENT!", e)
raise SystemExit
# Check if the file exists
file_path = "/sd/esp32.txt"
if file_path.replace("/sd/", "") not in os.listdir("/sd"):
print("esp32.txt doesn't exist. Creating esp32.txt file...")
# Create a new file by opening it and immediately closing it
f = open(file_path, "w")
f.close()
# Recheck if file is created or not
if file_path.replace("/sd/", "") in os.listdir("/sd"):
print("esp32.txt exists on SD Card.")
else:
print("esp32.txt doesn't exist on SD Card.")
os.umount("/sd")
Schnelle Schritte
So richten Sie Ihren MicroPython-Code auf dem ESP32 mit der Thonny IDE ein und führen ihn aus:
- Stellen Sie sicher, dass die Thonny IDE auf Ihrem Computer installiert ist.
- Vergewissern Sie sich, dass die MicroPython-Firmware auf Ihrem ESP32-Board installiert ist.
- Wenn Sie zum ersten Mal einen ESP32 mit MicroPython verwenden, lesen Sie die Anleitung ESP32 MicroPython Erste Schritte mit Schritt-für-Schritt-Anweisungen.
- Setzen Sie die Micro-SD-Karte in das Micro-SD-Kartenmodul ein.
- Verdrahten Sie das Micro-SD-Kartenmodul und den ESP32 wie im obigen Schaltplan.
- Verbinden Sie das ESP32-Board über ein USB-Kabel mit Ihrem Computer.
- Öffnen Sie die Thonny IDE auf Ihrem Computer.
- Gehen Sie in der Thonny IDE zu Tools Options.
- Wählen Sie im Tab Interpreter aus dem Dropdown-Menü MicroPython (ESP32) aus.
- Stellen Sie sicher, dass der richtige Port ausgewählt ist. Die Thonny IDE erkennt ihn normalerweise automatisch, eventuell müssen Sie ihn aber manuell auswählen (z. B. COM3 unter Windows oder /dev/ttyACM0 unter Linux).
- Navigieren Sie in der Thonny IDE zu Tools Manage packages.
- Suchen Sie nach "sdcard" und finden Sie die von micropython-lib bereitgestellte sdcard-Bibliothek.
- Klicken Sie auf sdcard und dann auf die Schaltfläche Install, um die SD-Karten-Bibliothek zu installieren.
- Kopieren Sie den bereitgestellten MicroPython-Code und fügen Sie ihn in den Editor von Thonny ein.
- Speichern Sie den Code auf Ihrem ESP32:
- Klicken Sie auf die Schaltfläche Save oder drücken Sie Ctrl+S.
- Wählen Sie im Speicherdialog MicroPython device.
- Nennen Sie die Datei main.py.
- Klicken Sie auf die grüne Schaltfläche Run (oder drücken Sie F5), um das Skript auszuführen.
- Sehen Sie sich die Meldung in der Shell unten in Thonny an.
- Das Ergebnis in der Shell beim ersten Durchlauf
Shell x
>>> %Run -c $EDITOR_CONTENT
MPY: soft reboot
SD CARD INITIALIZED.
esp32.txt doesn't exist. Creating esp32.txt file...
esp32.txt exists on SD Card.
MicroPython (ESP32) • CP2102 USB To UART Bridge Controller @ COM12 ≡
- Das Ergebnis in der Shell bei den folgenden Durchläufen
Shell x
>>> %Run -c $EDITOR_CONTENT
MPY: soft reboot
SD CARD INITIALIZED.
esp32.txt exists on SD Card.
MicroPython (ESP32) • CP2102 USB To UART Bridge Controller @ COM12 ≡
- Entnehmen Sie die Micro-SD-Karte aus dem Modul.
- Stecken Sie die Micro-SD-Karte in einen USB-SD-Kartenleser.
- Verbinden Sie den USB-SD-Kartenleser mit dem PC.
- Prüfen Sie, ob die Datei vorhanden ist oder nicht.
ESP32 MicroPython - Daten auf der Micro-SD-Karte schreiben und lesen
Der folgende MicroPython-Code führt zwei Vorgänge aus:
- Speichert Daten in einer Datei auf der SD-Karte
- Liest den Dateiinhalt Zeichen für Zeichen und zeigt ihn in der Shell an
/*
* Dieser ESP32 MicroPython Code wurde von newbiely.de entwickelt
* Dieser ESP32 MicroPython Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt.
* Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte:
* https://newbiely.de/tutorials/esp32-micropython/esp32-micropython-micro-sd-card
*/
import machine
import os
import sdcard
# Define SPI pins for the Micro SD Card module
SPI_SCK_PIN = 18 # The ESP32 pin GPIO18 connected to SCK
SPI_MOSI_PIN = 23 # The ESP32 pin GPIO23 connected to MOSI
SPI_MISO_PIN = 19 # The ESP32 pin GPIO19 connected to MISO
SPI_CS_PIN = 5 # The ESP32 pin GPIO5 connected to SS (CS)
# Initialize SD card using SoftSPI and sdcard driver
spi = machine.SoftSPI(baudrate=1000000, polarity=0, phase=0,
sck=machine.Pin(SPI_SCK_PIN),
mosi=machine.Pin(SPI_MOSI_PIN),
miso=machine.Pin(SPI_MISO_PIN))
cs = machine.Pin(SPI_CS_PIN, machine.Pin.OUT)
try:
sd = sdcard.SDCard(spi, cs)
os.mount(sd, "/sd")
print("SD CARD INITIALIZED.")
except Exception as e:
print("SD CARD FAILED, OR NOT PRESENT!", e)
raise SystemExit
file_path = "/sd/esp32.txt"
# Open file for writing (append mode)
try:
f = open(file_path, "a")
f.write("Created by newbiely.com\n") # write a line to esp32.txt
f.write("Learn ESP32 and SD Card\n") # write another line to esp32.txt
f.close()
except Exception as e:
print("SD Card: Issue encountered while attempting to open the file esp32.txt", e)
# Open file for reading
try:
f = open(file_path, "r")
while True:
ch = f.read(1) # read characters one by one from Micro SD Card
if not ch:
break
print(ch, end="") # print the character to the Shell
f.close()
except Exception as e:
print("SD Card: Issue encountered while attempting to open the file esp32.txt", e)
os.umount("/sd")
- Die Shell zeigt den Dateiinhalt an:
Shell x
>>> %Run -c $EDITOR_CONTENT
MPY: soft reboot
Created by newbiely.com
Learn ESP32 and SD Card
MicroPython (ESP32) • CP2102 USB To UART Bridge Controller @ COM12 ≡
※ Notiz:
Standardmäßig werden neue Daten am Ende der Datei angehängt. Wenn Sie den ESP32 mit demselben Code neu starten, wird der Text erneut hinzugefügt, sodass die Ausgabe in der Shell so aussieht:
Shell x
>>> %Run -c $EDITOR_CONTENT
MPY: soft reboot
Created by newbiely.com
Learn ESP32 and SD Card
Created by newbiely.com
Learn ESP32 and SD Card
MicroPython (ESP32) • CP2102 USB To UART Bridge Controller @ COM12 ≡
Sie können die Micro-SD-Karte auch aus dem Modul entnehmen und ihren Inhalt auf Ihrem PC ansehen (ein USB-SD-Kartenleser ist erforderlich).
ESP32 MicroPython - Eine Datei Zeile für Zeile von der Micro-SD-Karte lesen
/*
* Dieser ESP32 MicroPython Code wurde von newbiely.de entwickelt
* Dieser ESP32 MicroPython Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt.
* Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte:
* https://newbiely.de/tutorials/esp32-micropython/esp32-micropython-micro-sd-card
*/
import machine
import os
import sdcard
# Define SPI pins for the Micro SD Card module
SPI_SCK_PIN = 18 # The ESP32 pin GPIO18 connected to SCK
SPI_MOSI_PIN = 23 # The ESP32 pin GPIO23 connected to MOSI
SPI_MISO_PIN = 19 # The ESP32 pin GPIO19 connected to MISO
SPI_CS_PIN = 5 # The ESP32 pin GPIO5 connected to SS (CS)
# Initialize SD card using SoftSPI and sdcard driver
spi = machine.SoftSPI(baudrate=1000000, polarity=0, phase=0,
sck=machine.Pin(SPI_SCK_PIN),
mosi=machine.Pin(SPI_MOSI_PIN),
miso=machine.Pin(SPI_MISO_PIN))
cs = machine.Pin(SPI_CS_PIN, machine.Pin.OUT)
try:
sd = sdcard.SDCard(spi, cs)
os.mount(sd, "/sd")
print("SD CARD INITIALIZED.")
except Exception as e:
print("SD CARD FAILED, OR NOT PRESENT!", e)
raise SystemExit
file_path = "/sd/esp32.txt"
# Open file for writing (append mode)
try:
f = open(file_path, "a")
f.write("Created by newbiely.com\n") # write a line to esp32.txt
f.write("Learn ESP32 and SD Card\n") # write another line to esp32.txt
f.close()
except Exception as e:
print("SD Card: Issue encountered while attempting to open the file esp32.txt", e)
# Open file for reading line-by-line
try:
f = open(file_path, "r")
line_count = 0
while True:
line = f.readline() # read line-by-line from Micro SD Card
if not line:
break
line_count += 1
print("Line {}: {}".format(line_count, line.strip())) # print the line to the Shell
f.close()
except Exception as e:
print("SD Card: Issue encountered while attempting to open the file esp32.txt", e)
os.umount("/sd")
- Das Ergebnis in der Shell
Shell x
>>> %Run -c $EDITOR_CONTENT
MPY: soft reboot
SD CARD INITIALIZED.
Line 1: Created by newbiely.com
Line 2: Learn ESP32 and SD Card
MicroPython (ESP32) • CP2102 USB To UART Bridge Controller @ COM12 ≡
※ Notiz:
In der Shell können zusätzliche Zeilen erscheinen, wenn die Datei bereits Daten aus früheren Durchläufen enthält.
ESP32 MicroPython - Eine Datei auf der Micro-SD-Karte überschreiben
Da Daten standardmäßig angehängt werden, ist der einfachste Weg zum Überschreiben einer Datei, zuerst die vorhandene Datei zu löschen und dann eine neue Datei mit demselben Namen zu erstellen.
/*
* Dieser ESP32 MicroPython Code wurde von newbiely.de entwickelt
* Dieser ESP32 MicroPython Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt.
* Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte:
* https://newbiely.de/tutorials/esp32-micropython/esp32-micropython-micro-sd-card
*/
import machine
import os
import sdcard
# Define SPI pins for the Micro SD Card module
SPI_SCK_PIN = 18 # The ESP32 pin GPIO18 connected to SCK
SPI_MOSI_PIN = 23 # The ESP32 pin GPIO23 connected to MOSI
SPI_MISO_PIN = 19 # The ESP32 pin GPIO19 connected to MISO
SPI_CS_PIN = 5 # The ESP32 pin GPIO5 connected to SS (CS)
# Initialize SD card using SoftSPI and sdcard driver
spi = machine.SoftSPI(baudrate=1000000, polarity=0, phase=0,
sck=machine.Pin(SPI_SCK_PIN),
mosi=machine.Pin(SPI_MOSI_PIN),
miso=machine.Pin(SPI_MISO_PIN))
cs = machine.Pin(SPI_CS_PIN, machine.Pin.OUT)
try:
sd = sdcard.SDCard(spi, cs)
os.mount(sd, "/sd")
print("SD CARD INITIALIZED.")
except Exception as e:
print("SD CARD FAILED, OR NOT PRESENT!", e)
raise SystemExit
file_path = "/sd/esp32.txt"
# Delete the file if it exists (to overwrite)
try:
os.remove(file_path)
except OSError:
pass
# Create new file by opening file for writing
try:
f = open(file_path, "w")
f.write("Created by newbiely.com\n") # write a line to esp32.txt
f.write("Learn ESP32 and SD Card\n") # write another line to esp32.txt
f.close()
except Exception as e:
print("SD Card: Issue encountered while attempting to open the file esp32.txt", e)
# Open file for reading
try:
f = open(file_path, "r")
while True:
ch = f.read(1) # read characters one by one from Micro SD Card
if not ch:
break
print(ch, end="") # print the character to the Shell
f.close()
except Exception as e:
print("SD Card: Issue encountered while attempting to open the file esp32.txt", e)
os.umount("/sd")
- Das Ergebnis in der Shell
Shell x
>>> %Run -c $EDITOR_CONTENT
MPY: soft reboot
SD CARD INITIALIZED.
Created by newbiely.com
Learn ESP32 and SD Card
MicroPython (ESP32) • CP2102 USB To UART Bridge Controller @ COM12 ≡
- Starten Sie den ESP32 neu.
- Überprüfen Sie, ob der Dateiinhalt in der Shell ersetzt oder angehängt wurde.
Alternativ können Sie die Micro-SD-Karte aus dem Modul entnehmen und die Datei auf Ihrem PC prüfen (ein USB-SD-Kartenleser ist erforderlich).
Video Tutorial
Wir erwägen die Erstellung von Video-Tutorials. Wenn Sie Video-Tutorials für wichtig halten, abonnieren Sie bitte unseren YouTube-Kanal , um uns zu motivieren, die Videos zu erstellen.