Willkommen zurück auf meinem Technikblog! Heute dreht sich alles um die faszinierende Kombination von MicroPython und dem ESP32-Board. In diesem Artikel werde ich dir zeigen, wie du mithilfe von MicroPython und dem ESP32 Sensorwerte mit Zeitstempel auf einer SD-Karte speichern kannst. Dieses spannende Projekt wurde von einem Kommentar inspiriert, den ich vor Kurzem erhalten habe. Der Kommentator fragte, ob es möglich ist, die Ausgabe in eine Datei umzuleiten, einen Zeitstempel hinzuzufügen und das Programm in einer Endlosschleife auszuführen. Nun werde ich genau darauf eingehen und dir Schritt für Schritt zeigen, wie du diese Funktionen in dein MicroPython-Programm integrieren kannst. Lass uns loslegen!
Wie man einen Temperatursensor DS18B20 am ESP32 in Micropython programmiert, hatte ich dir ja bereits im Beitrag Programmieren mit MicroPython #6: digitaler Temperatursensor DS18B20 am ESP32 gezeigt, hier möchte ich nun daran anknüpfen.
Inhaltsverzeichnis
- Varianten des Projektes
- Benötigte Ressourcen für dieses Projekt
- Aufbau der Schaltung
- Erstellen des Programmes in der Thonny IDE
- Programm – schreiben der Daten vom Sensor DS18B20 mit einem Zeitstempel auf eine SD-Karte in MicroPython am ESP32
- Abschluss
- Quellen für den Beitrag
Varianten des Projektes
Dieses kleine Projekt kann in zwei Varianten umgesetzt werden. Zum einen mit einer RealTimeClock DS3231 und mit einem Zugriff auf einen NTP-Server im Internet. Beide Varianten haben Ihren Charm zunächst werde ich mich auf die Variante mit dem NTP-Server konzentrieren und dir ggf. noch einen weiteren Beitrag mit der RTC DS3231 veröffentlichen.
Benötigte Ressourcen für dieses Projekt
Wenn du die Schaltung und das Projekt nachbauen möchtest, dann benötigst du:
- einen ESP32,
- ein Micro-USB Datenkabel,
- einen Temperatursensor DS18B20,
- ein SD-Karten Modul, sowie eine passende SD-Karte
- Breadboardkabel & ein 400 Pin Breadboard
Aufbau der Schaltung
Hier der Aufbau der Schaltung am ESP32.
Aus der Schaltung können wir nun folgenden Anschlussplan entnehmen:
| Komponente | ESP32 |
|---|---|
| SD-Card Modul | |
| GND | GND |
| VCC | 3.3 V |
| MISO | GP19 |
| MOSI | GP23 |
| SCK | GP18 |
| CS | GP2 |
| DS18B20 | |
| Pin1 | GND |
| Pin2 | GP4, 4,7 kOhm Widerstand > 3.3 V |
| Pin3 | 3.3 V |
SD-Karten Modul für Micro SD-Karten
Für diesen Beitrag verwende ich ein kleines SD-Karten Modul für Micro SD-Karten, es gibt aber auch Module für SD-Karten und somit kannst du auch deine ggf. alten Karten für dieses Projekt recyclen.
Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung!
Erstellen des Programmes in der Thonny IDE
Nachdem wir nun die Schaltung erstellt haben, können wir das Programm in Micropython in der Thonny IDE erstellen. Diese Entwicklungsumgebung kannst du dir kostenfrei unter https://thonny.org/ für macOS, Linux und Microsoft Windows herunterladen.
Schritt 1 – Auslesen des Temperatursensors DS18B20
Im ersten Schritt lesen wir die Temperatur des Sensors DS18B20 aus.
#Import der benötigten Module
from machine import Pin
from onewire import OneWire
from ds18x20 import DS18X20
from time import sleep
#der Temperatursensor DS18B20 ist am GPIO 4 angeschlossen
sensorPin = Pin(4)
sensor = DS18X20(OneWire(sensorPin))
#ermitteln der angeschlossenen Sensoren
roms = sensor.scan()
#ausgeben der Anzahl der Sensoren
print('gefundene Sensoren: ', len(roms))
#starten der Endlosschleife
while True:
#
sensor.convert_temp()
#nach dem Aufruf der Funktion convert_temp()
#muss man min. 750 Millisekunden warten
sleep(0.750)
#Schleife über die Sensoren
for rom in roms:
#auslesen des Sensorwertes
#und runden auf max. 2 Nachkommastellen
temp = round(sensor.read_temp(rom),2)
#ausgeben des Wertes auf der seriellen Schnittelle
#inkl. Grad Celsius
print(str(temp), "°C", sep=" ")
#Pause von 5 Sekunden einlegen
sleep(5)
Wenn wir den Code ausführen, dann wird auf der seriellen Schnittstelle die Temperatur mit 2 Nachkommastellen ausgegeben.
Der Sensor DS18B20 hat eigentlich eine Genauigkeit von ±0,5 °C, somit können wir auch locker auf 1 Stelle nach dem Komma kürzen.
Schritt 2 – Herstellen einer WiFi-Verbindung und auslesen eines Zeitstempels vom NTP-Server
Im nächsten Schritt stellen wir nun eine Verbindung zum lokalen WiFi-Netzwerk her und lesen einen Zeitstempel vom NTP-Server.
#Import der benötigten Module
#für den Aufbau der WiFi-Verbindung
#und das laden des Zeitstempels von
#einem NTP-Server
import time
from time import sleep
import ntptime
import network
ssid = 'xyz'
password = '123456789'
#Starten des Netzwerkes im Station Mode
sta=network.WLAN(network.STA_IF)
sta.active(True)
def doConnect():
#Wenn die Verbindung nicht erstellt wurde, dann...
if not sta.isconnected():
#Aufbau der WiFi-Verbindung mit den Daten
sta.connect(ssid, password)
#solange die Verbindung noch nicht hergestellt wurde
#dann soll diese Schleife laufen
while not sta.isconnected():
pass
#Wenn die WiFi-Verbindung erfolgreich aufgebaut wurde,
#dann soll auf der seriellen Schnittstelle der Text ausgegeben werden
print('Verbindung erfolgreich aufgebaut!')
def readTimestamp():
#setzen der Zeit auf dem Mikrocontroller
ntptime.settime()
#auslesen der Zeit in ein Tupel
timeTpl = time.gmtime()
#Auslesen der Werte in einzelene Variablen
print("Jahr", timeTpl[0])
print("Monat", timeTpl[1])
print("Tag", timeTpl[2])
print("Stunde", timeTpl[3]+2)
print("Minute", timeTpl[4])
print("Sekunde", timeTpl[5])
#Formatieren der Daten in ein deutsches Datum/Zeit Format
timestamp = "{day}.{month}.{year} {hour}:{minute}:{seconds}".format(day = timeTpl[2], month = timeTpl[1], year = timeTpl[0], hour = timeTpl[3]+2, minute = timeTpl[4], seconds = timeTpl[5])
#Ausgeben des Zeitstempels
print(timestamp)
#print("++++++++++++++++++++++++++++++++++++++++++")
#eine Pause von 1 Sekunde einlegen
sleep(1)
#starten der Endlosschleife
while True:
try:
#Wenn die WiFi-Verbindung abgebrochen ist, dann
#soll diese wiederhergestellt werden
if not sta.isconnected():
doConnect()
readTimestamp()
except:
print("Ein Fehler bei der Verarbeitung ist aufgetreten!")
Vom NTP-Server erhalten wir einen Zeitstempel, zu welchem wir noch zusätzlich 2 Stunden dazurechnen müssen (Zeitzone). Als Rückgabe beim Aufruf der Funktion time.gmttime() erhalten wir ein Tupel mit den Daten aus dem Zeitstempel.
vom NTP-Server geladen wurde
Schritt 3 – Speichern der Sensordaten inkl. Zeitstempel auf der SD-Karte in einer CSV-Datei
Für den Zugriff auf die SD-Karte benötigen wir zusätzlich ein Python Modul sdcard.py welches wir vom GitHub Repository micropython/micropython-lib herunterladen können.
import machine, os, sdcard
import time
import ntptime
from machine import Pin, SPI
import network
from onewire import OneWire
from ds18x20 import DS18X20
#Dateiname für die CSV-Datei
outputFilename = 'ds18b20.csv'
#Zugangsdaten zum lokalen WiFi-Netzwerk
ssid = 'HOTSPOT'
password = '123456789'
#Zeit welche zwischen zwei Lesevorgängen
#vergehen muss in Sekunden.
sleepBetweenMeasurements = 5
#Starten des Netzwerkes im Station Mode
sta= network.WLAN(network.STA_IF)
sta.active(True)
#der Temperatursensor DS18B20 ist am GPIO 4 angeschlossen
sensorPin = Pin(4)
sensor = DS18X20(OneWire(sensorPin))
sensors = ()
#CS Pin mit GP2 als Ausgang
cs = Pin(2, Pin.OUT)
#Initialisieren der SPI Kommunikation
spi = SPI(2, baudrate=1000000, polarity=0, phase=0, bits=8,
firstbit=SPI.MSB, sck=Pin(18), mosi=Pin(23), miso=Pin(19))
#Initialisieren des SD-Card Objektes mit
#der konfigurierten SPI Schnittstelle
sd = sdcard.SDCard(spi, cs)
def setup():
global sensors
#mounten / einbinden der SD-Karte
os.mount(sd, '/sd')
#einen Zugriffsversuch starten
#sollte dieser misslingen so wird eine Exception geworfen
os.listdir('/sd')
#ermitteln der angeschlossenen Sensoren
sensors = sensor.scan()
#ausgeben der Anzahl der Sensoren
print('gefundene DS18B20 Sensoren: ', len(sensors))
#aufbauen der WiFi-Verbindung
doConnect()
def writeLine(timestampValue, ds18b20Value):
#öffnen der Datei ds18b20.csv mit dem Parameter "a"
#für schreibzugriff mit anhängen (append)
file = open('/sd/'+outputFilename, 'a')
#schreiben einer Zeile
file.write("\"{timestamp}\";{value}\r\n".format(timestamp=timestampValue, value=ds18b20Value))
#schließen der Datei
file.close()
def doConnect():
#Wenn die Verbindung nicht erstellt wurde, dann...
if not sta.isconnected():
print("Aufbau der WiFi-Verbindung zu ", ssid)
#Aufbau der WiFi-Verbindung mit den Daten
sta.connect(ssid, password)
#solange die Verbindung noch nicht hergestellt wurde
#dann soll diese Schleife laufen
while not sta.isconnected():
pass
#Wenn die WiFi-Verbindung erfolgreich aufgebaut wurde,
#dann soll auf der seriellen Schnittstelle der Text ausgegeben werden
print("Verbindung erfolgreich zu {ssid} aufgebaut!".format(ssid=ssid))
def readTimestamp():
#setzen der Zeit auf dem Mikrocontroller
ntptime.settime()
#auslesen der Zeit in ein Tupel
timeTpl = time.gmtime()
#Formatieren der Daten in ein deutsches Datum/Zeit Format
return "{day}.{month}.{year} {hour}:{minute}:{seconds}".format(day = timeTpl[2], month = timeTpl[1], year = timeTpl[0], hour = timeTpl[3]+2, minute = timeTpl[4], seconds = timeTpl[5])
def readSensorValue():
sensor.convert_temp()
#nach dem Aufruf der Funktion convert_temp()
#muss man min. 750 Millisekunden warten
time.sleep(0.750)
return round(sensor.read_temp(sensors[0]),2)
def main():
#starten der Endlosschleife
while True:
#lesen des Zeitstempels vom NTP-Server
timestampValue = readTimestamp()
#lesen der Temperatur vom Sensor
ds18b20Value = readSensorValue()
#Ausgeben der Daten auf der seriellen Schnittstelle
print("{timestamp} - {tempValue}".format(timestamp=timestampValue, tempValue=ds18b20Value))
#Speichern der Daten in der CSV-Datei auf der SD-Karte
writeLine(timestampValue, ds18b20Value)
#eine kleine Pause einlegen
time.sleep(sleepBetweenMeasurements)
setup()
main()
Das Programm erzeugt nun eine zusätzliche Zeile in der CSV-Datei auf der SD-Karte und gibt zusätzlich noch die Daten auf der seriellen Schnittstelle aus.
Programm – schreiben der Daten vom Sensor DS18B20 mit einem Zeitstempel auf eine SD-Karte in MicroPython am ESP32
Hier nun das fertige Programm zu Download als ZIP-Datei.
Abschluss
Herzlichen Glückwunsch! Du hast es geschafft, dein eigenes Datenlogging-Programm mit MicroPython und dem ESP32 zu entwickeln. Indem du Sensorwerte mit Zeitstempel auf einer SD-Karte speicherst, eröffnen sich viele Möglichkeiten für deine IoT-Projekte. Denk daran, dass Programmieren eine kontinuierliche Lernreise ist, und ich hoffe, dieser Artikel hat dir geholfen, wichtige Konzepte zu verstehen und deine Fähigkeiten weiterzuentwickeln.
Wenn du das vollständige Programm herunterladen möchtest, findest du den Link dazu im Artikel. Zögere nicht, es anzupassen und zu erweitern, um es an deine spezifischen Anforderungen anzupassen. Vergiss nicht, dass das Experimentieren und das Hinzufügen eigener Ideen ein wichtiger Teil des Lernprozesses ist.
Wenn du Fragen oder Feedback hast, hinterlasse gerne einen Kommentar unter dem Beitrag. Ich stehe dir jederzeit zur Verfügung, um dir weiterzuhelfen. Viel Spaß beim Programmieren und bleib neugierig!
Quellen für den Beitrag
Für diesen Beitrag habe ich mich aus der offiziellen Dokumentation zu Micropython bedient.
- https://randomnerdtutorials.com/micropython-ds18b20-esp32-esp8266/
- https://github.com/orgs/micropython/discussions/10760
- https://www.coderdojotc.org/micropython/advanced-labs/09-micro-sd-card-reader/