ESP32 MicroPython - Daten mit Zeitstempel auf SD-Karte protokollieren
Diese Anleitung zeigt Ihnen, wie Sie mit dem ESP32 und MicroPython einen Datenlogger bauen, der Einträge mit Zeitstempel auf einer Micro-SD-Karte speichert. Folgendes behandeln wir:
- Daten mit Zeitstempel in einer einzigen Protokolldatei auf der Micro-SD-Karte aufzeichnen.
- Protokolle auf mehrere Dateien auf der Micro-SD-Karte aufteilen, wobei für jeden Tag eine eigene Datei erstellt wird.
Datum und Uhrzeit werden von einem DS3231-RTC-Modul bezogen und zusammen mit den Sensormesswerten auf die Micro-SD-Karte geschrieben.
Die protokollierten Daten können jede Art von Messwert enthalten, zum Beispiel:
- Messwerte von Temperatur-, Feuchtigkeits- oder anderen Sensoren.
- Zugangsereignisse eines Türschlosssystems.
Der Einfachheit halber verwendet diese Anleitung Messwerte von zwei analogen Eingangspins als Beispieldaten. Sie können den Code leicht anpassen, um jede andere Art von Information zu protokollieren.
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 and RTC Module
Benötigen Sie Hilfe beim Einstieg mit dem Micro-SD-Kartenmodul oder dem RTC-Modul? Sehen Sie sich diese Schritt-für-Schritt-Tutorials zu Pinbelegung, Verdrahtung und Programmierung an:
- Tutorial ESP32 MicroPython - Micro-SD-Karte.
- Tutorial ESP32 MicroPython - RTC-Modul.
Verdrahtungsdiagramm
Dieses Bild wurde mit Fritzing erstellt. Klicken Sie, um das Bild zu vergrößern.
Kein Steckbrett? Dieselbe Schaltung lässt sich auch ohne verdrahten, wie unten gezeigt:
Dieses Bild wurde mit Fritzing erstellt. Klicken Sie, um das Bild zu vergrößern.
Die folgende Verdrahtungstabelle zeigt, wie Sie das Micro-SD-Kartenmodul und das DS3231-RTC-Modul mit dem ESP32 verbinden:
| Micro-SD-Kartenmodul | ESP32 |
|---|---|
| VCC | 5V |
| GND | GND |
| MISO | GPIO19 |
| MOSI | GPIO23 |
| SCK | GPIO18 |
| CS | GPIO5 |
| DS3231-RTC-Modul | ESP32 |
|---|---|
| VCC | 3.3V |
| GND | GND |
| SDA | GPIO21 |
| SCL | GPIO22 |
※ 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 - Daten mit Zeitstempel auf Micro-SD-Karte aufzeichnen
/*
* 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-log-data-with-timestamp-to-sd-card
*/
import machine
import os
import time
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)
# Define I2C pins for the RTC module
I2C_SDA_PIN = 21 # The ESP32 pin GPIO21 connected to SDA
I2C_SCL_PIN = 22 # The ESP32 pin GPIO22 connected to SCL
FILE_NAME = "/sd/log.txt"
# Initialize I2C and RTC (DS3231)
i2c = machine.I2C(0, sda=machine.Pin(I2C_SDA_PIN), scl=machine.Pin(I2C_SCL_PIN))
# DS3231 I2C address
DS3231_ADDR = 0x68
def bcd_to_dec(bcd):
return (bcd >> 4) * 10 + (bcd & 0x0F)
def get_datetime():
buf = i2c.readfrom_mem(DS3231_ADDR, 0x00, 7)
second = bcd_to_dec(buf[0])
minute = bcd_to_dec(buf[1])
hour = bcd_to_dec(buf[2])
day = bcd_to_dec(buf[4])
month = bcd_to_dec(buf[5] & 0x1F)
year = bcd_to_dec(buf[6]) + 2000
return (year, month, day, hour, minute, second)
# 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
print("--------------------")
# Define analog pins
analog_pin_1 = machine.ADC(machine.Pin(36)) # A0
analog_pin_2 = machine.ADC(machine.Pin(39)) # A1
analog_pin_1.atten(machine.ADC.ATTN_11DB) # set attenuation to 11 dB (up to ~3.3V input)
analog_pin_2.atten(machine.ADC.ATTN_11DB)
while True:
try:
f = open(FILE_NAME, "a")
print("Writing log to SD Card")
# Get timestamp from RTC
year, month, day, hour, minute, second = get_datetime()
timestamp = "{}-{}-{} {}:{}:{}".format(year, month, day, hour, minute, second)
# Read data
analog_1 = analog_pin_1.read()
analog_2 = analog_pin_2.read()
# Write timestamp and data
f.write("{} analog_1 = {}, analog_2 = {}\n".format(timestamp, analog_1, analog_2))
f.close()
except Exception as e:
print("SD Card: Issue encountered while attempting to open the file", FILE_NAME, e)
time.sleep(2) # delay 2 seconds
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.
- Führen Sie die Verdrahtung wie im obigen Bild durch.
- 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.
- Stellen Sie sicher, dass die Micro-SD-Karte als FAT16 oder FAT32 formatiert ist (suchen Sie bei Bedarf online nach einer Anleitung).
- 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.
Shell x
>>> %Run -c $EDITOR_CONTENT
MPY: soft reboot
SD CARD INITIALIZED.
--------------------
Writing log to SD Card
Writing log to SD Card
Writing log to SD Card
Writing log to SD Card
Writing log to SD Card
Writing log to SD Card
Writing log to SD Card
MicroPython (ESP32) • CP2102 USB To UART Bridge Controller @ COM12 ≡
- Entnehmen Sie die Micro-SD-Karte aus dem Modul.
- Stecken Sie sie in einen USB-SD-Kartenleser, der mit Ihrem PC verbunden ist.
- Öffnen Sie die Datei log.txt auf Ihrem Computer — ihr Inhalt sollte etwa so aussehen:
Wenn Sie keinen USB-SD-Kartenleser haben, können Sie den Inhalt der Protokolldatei überprüfen, indem Sie den folgenden MicroPython-Code auf dem ESP32 ausführen.
/*
* 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-log-data-with-timestamp-to-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)
FILE_NAME = "/sd/log.txt"
# 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
# Open file for reading
try:
f = open(FILE_NAME, "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", FILE_NAME, e)
os.umount("/sd")
ESP32 MicroPython - Protokollierung in separate Tagesdateien
Wenn alle Protokolle in einer Datei gespeichert werden, wird diese mit der Zeit sehr groß und schwerer zu handhaben. Der folgende Code teilt die Protokolle auf mehrere Dateien auf:
- Für jeden Tag wird eine neue Datei erstellt.
- Jeder Dateiname hat das Format: YYYYMMDD.txt
/*
* 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-log-data-with-timestamp-to-sd-card
*/
import machine
import os
import time
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)
# Define I2C pins for the RTC module
I2C_SDA_PIN = 21 # The ESP32 pin GPIO21 connected to SDA
I2C_SCL_PIN = 22 # The ESP32 pin GPIO22 connected to SCL
# Initialize I2C and RTC (DS3231)
i2c = machine.I2C(0, sda=machine.Pin(I2C_SDA_PIN), scl=machine.Pin(I2C_SCL_PIN))
# DS3231 I2C address
DS3231_ADDR = 0x68
def bcd_to_dec(bcd):
return (bcd >> 4) * 10 + (bcd & 0x0F)
def get_datetime():
buf = i2c.readfrom_mem(DS3231_ADDR, 0x00, 7)
second = bcd_to_dec(buf[0])
minute = bcd_to_dec(buf[1])
hour = bcd_to_dec(buf[2])
day = bcd_to_dec(buf[4])
month = bcd_to_dec(buf[5] & 0x1F)
year = bcd_to_dec(buf[6]) + 2000
return (year, month, day, hour, minute, second)
# 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
print("--------------------")
# Define analog pins
analog_pin_1 = machine.ADC(machine.Pin(36)) # A0
analog_pin_2 = machine.ADC(machine.Pin(39)) # A1
analog_pin_1.atten(machine.ADC.ATTN_11DB) # set attenuation to 11 dB (up to ~3.3V input)
analog_pin_2.atten(machine.ADC.ATTN_11DB)
while True:
year, month, day, hour, minute, second = get_datetime()
# Generate filename: /sd/YYYYMMDD.txt
filename = "/sd/{:04d}{:02d}{:02d}.txt".format(year, month, day)
try:
f = open(filename, "a")
print("Writing log to SD Card")
# Write timestamp
timestamp = "{}-{}-{} {}:{}:{}".format(year, month, day, hour, minute, second)
# Read data
analog_1 = analog_pin_1.read()
analog_2 = analog_pin_2.read()
# Write timestamp and data
f.write("{} analog_1 = {}, analog_2 = {}\n".format(timestamp, analog_1, analog_2))
f.close()
except Exception as e:
print("SD Card: Issue encountered while attempting to open the file", filename, e)
time.sleep(2) # delay 2 seconds
Wenn Sie nach längerer Laufzeit:
- Die Micro-SD-Karte aus dem Modul entnehmen
- Sie in einen USB-SD-Kartenleser stecken, der mit Ihrem PC verbunden ist
- Finden Sie mehrere Protokolldateien, wie unten gezeigt:
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.