ESP Mikrocontroller 8266 mit sechs verschiedenen Sensoren Sensor

ESP | Sensordaten mit I2C auslesen mit MicroPython



Ideen: W. Kimmig, J. Schnaiter, Gewerblich-Technische Schule Offenburg, 2022
AI-unterstützte Lerninhalte

1 Was ist I2C?

I2C ist ein serieller Bus, der nur zwei Leitungen benötigt:

  • SDA (Serial Data): Hier werden die eigentlichen Daten (Bits) gesendet.
  • SCL (Serial Clock): Der Taktgeber, der das Tempo für den Datenversand vorgibt.
Shared Bus: Viele Sensoren teilen sich dieselben zwei Kabel!
Taster am Pin 17 und Poti am Pin 2
Abb. 1 Prinzipieller Aufbau von I2C-Master-und Slave.

2 Die I2C-Adresse

Da alle Geräte an der selben Leitung hängen, braucht jedes Gerät eine Adresse.

OLED Display
0x3C
ESP32
Der "Master"
Sensor für Luftfeuchte und Temperatur
0x38
Sensor für Beschleunigung
0x19
Sensor für Luftdruck
0x77

Der Controller sendet zuerst die Adresse. Nur das Gerät mit dieser Adresse antwortet.

3 Python Code für I2C

In MicroPython definieren wir den Bus über die Klasse I2C:

from machine import I2C, Pin

# 1. Bus initialisieren (Hardware I2C 0)
i2c = I2C(0, scl=Pin(22), sda=Pin(21), freq=400000)

# 2. Geräte suchen (Scan liefert Adressen in Dezimal)
geraete = i2c.scan()
print("Gefundene Adressen:", [hex(a) for a in geraete])

Man beachte bei der Verwendung von I2C-Sensoren oder -Aktoren wird dann bei der Initialisierung das I2C-Objekt mit übergeben. Hier wird dies am bereits eingeführten OLED-Display gezeigt:

oled = SSD1306_I2C(128, 64, i2c)

Erfahre mehr in der [MicroPython I2C Dokumentation](https://docs.micropython.org).

Luftfeuchtigkeit und Temperatur für die Luftqualität in Räumen DHT

Temperatur und Luffeuchtigkeit über I<sup>2</sup>C-Schnittstelle
Abb. 2 Temperatur und Luffeuchtigkeit über I2C-Schnittstelle.

Zur Vermeidung von Schimmel sollte die Luftfeuchtigkeit in Innenräumen unter 60 % bleiben. Hierzu werden Luftfeuchtigkeits­sensoren eingesetzt.

Die DHT-Sensoren (Digital Humidity & Temperature) sind kostengünstige digitale Sensoren mit einem kapazitiven Feuchtigkeitssensor und einem NTC-Temperatursensor zur Messung der Umgebungsluft. Der Sensor in Abb. 3 verfügt über eine I2C-Schnittstelle.

  • Add-ons for your ESP
  • DHT Temperatur- / Luftfeuchtesensor
    dht20.py
  • Python-Bibliothek für das OLED-Display:
    ssd1306.py

Micropython bietet eine DHT-Bibliothek, welche importiert wird. Einmal eingebunden kann ein Objekt der entsprechenden DHT-Klasse erzeugt werden.

Mit dem Aufruf dht.measurements wird die Messung durchgeführt und die Messwerte in einem Dictonary zurückgegeben. Zum extrahieren der beiden Messwerte greifen wir über den Schlüssel auf den jeweiligen Messwert zu. In diesem Fall wird die Messung und Ausgabe jede Sekunde zyklisch wiederholt.


from machine import Pin, I2C
import ssd1306, dht20, time

i2c = I2C(0, scl=Pin(22), sda=Pin(21))
dht=dht20.DHT20(0x38,i2c)
oled = ssd1306.SSD1306_I2C(128, 64, i2c, 0x3C)

while True:
    temperature = dht.measurements["t"]
    humidity = dht.measurements["rh"]
    
    oled.fill(0) #clear display
    oled.text(f"T: {temperature:.2f} `C", 0, 0)
    oled.text(f"H: {humidity:.2f} %", 0, 10)
    oled.show()
    
    time.sleep(1)

Luftdruck, Temperatur und 3-Achsen-Beschleunigung BMP180 und LIS3DHTR

Luftdruck- und Temperatursensor BMP180 sowie 3-Achsen-Beschleunigungssensor
Abb. 3 Luftdruck- und Temperatursensor BMP180 sowie 3-Achsen-Beschleunigungssensor LIS3DHTR über I2C.

Mit einem Luftdrucksensor lässt sich ein Tief- oder Hochdruckgebiet vorhersagen, aber ggf. auch die Höhe bestimmen. Der BMP180-Sensor in Abb. 4 misst sowohl die Temperatur als auch den Druck. Die Auflösung ist dabei so gut, dass damit auch die Höhe berechnet werden kann.

Der Beschleunigunssensor in Abb. 4 misst eine Änderung der Bewegung in x-, y- und z-Richtung. So kann man erkennen ob ein Gerät gedreht wird oder fällt. Auf dieser Basis funktioniert die Sturz- und Unfallerkennung, Bild- und Flugstabilisierung als auch die Schwingungserkennung. Die Kommunikation beider Sensoren läuft über die integrierte I2C-Schnittstelle.

  • Add-ons for your ESP
  • BMP180 Luftdruck- und Temperatursensor
    bmp280.py
  • MMA7660FC 3-Achsen-Beschleunigungssensor
    lis3dhtr.py

Um die Klasse BMP180 verwenden zu können muss die Bibliothek bmp180.py auf dem ESP-Controller kopiert werden.

Beim Erzeugen des BMP-Objekts wird zur Berechnung der Höhe der aktuelle Luftdruck in hPa übergeben.

Auf die Sensorwerte Luftdruck, Temperatur und Höhe kann dann über die drei Objektattribute bmp.pressure, bmp.temperature und bmp.altitude zugegriffen werden.


from machine import Pin, I2C
import ssd1306, bmp280, time

i2c = I2C(0, scl=Pin(22), sda=Pin(21))
oled = ssd1306.SSD1306_I2C(128, 64, i2c)
bmp = bmp280.BMP280(i2c, 0x77, 101700) #Tagesluftdruck

while True:
    oled.fill(0) #clear display
    oled.text(f"Temp:  {bmp.temperature:.2f} `C", 0, 0)
    oled.text(f"Druck: {bmp.pressure:.1f} hPa", 0, 10)
    oled.text(f"Hoehe: {bmp.altitude:.1f} m", 0, 20)
    oled.show()
    
    time.sleep(1)

Um die Klasse LIS3DHTR verwenden zu können muss die Bibliothek lis3dhtr.py auf dem ESP-Controller kopiert werden.

Beim Erzeugen des lis-Objekts kann die I2C-Adresse optional angegeben werden.

Auf die drei Sensorwerte x,y und z kann dann über die Funktion lis.read() zugegriffen werden. Diese Funktion gibt alle drei Werte zurück.

Das Auslesen wird alle halbe Sekunde zyklisch wiederholt.


from machine import Pin, I2C
import ssd1306, lis3dhtr, time

i2c = I2C(0, scl=Pin(22), sda=Pin(21))
oled = ssd1306.SSD1306_I2C(128, 64, i2c)
lis=lis3dhtr.LIS3DHTR(i2c,0x19)


while True:
    x, y, z = lis.read()
    
    oled.fill(0) #clear display
    oled.text(f"x: {x:.2f}", 0, 0)
    oled.text(f"y: {y:.2f}", 0, 10)
    oled.text(f"z: {z:.2f}", 0, 20)
    oled.show()
    
    time.sleep(0.5)

Arbeitsauftrag 1 reading sensor data via I2C

Luftfeuchte und Temperaturmessung

  1. Erstelle den Ordner I2C
  2. Erstelle die Datei humidity-basic.py und gib den passenden Code ein.
  3. Binde alle notwendigen Libraries ein.
  4. Übertrage die Bibliotheken auf den ESP und starte das Programm. Teste und verifiziere die Ausgabe.

Luftdruck, Temperatur und Höhe

  1. Erstelle den Ordner I2C
  2. Erstelle die Datei pressure-basic.py und gib den passenden Code ein.
  3. Binde alle notwendigen Libraries ein.
  4. Übertrage die Bibliotheken auf den ESP und starte das Programm. Teste und verifiziere die Ausgabe.
  5. Aktualisiere den Luftdruck, so dass die korrekte Höhe berechnet wird.
  6. Ergänze das Programm so, dass die Temperatur auch in Kelvin und Grad Fahrenheit angezeigt wird.
  7. Vergleiche die Temperaturwerte der beiden Sensoren (DHT und BMP). Recherchiere welcher der beiden Sensoren den exakteren Wert ermittelt und ermittle den Grund hierfür.

Arbeitsauftrag 2 Die Wasserwaage

Beschleunigungssensor LIS3DH mit OLED-Display

  1. Erstelle die Datei accelerometer-basic.py und gib den passenden Code ein.
  2. Kopiere die Bibliothek lis3dhtr.py auf den ESP-Controller.
  3. Übertrage das Programm auf den ESP und starte es. Beobachte die Ausgabe auf dem OLED-Display.
  4. Kippe den ESP in verschiedene Richtungen. Notiere welche Achse (x, y, z) sich bei welcher Bewegung verändert.

Erweiterung: Richtungserkennung

  1. Erstelle die Datei accelerometer-direction.py.
  2. Erweitere das Programm so, dass zusätzlich zu den Rohwerten auch die aktuelle Neigungsrichtung auf dem Display angezeigt wird.
  3. Verwende folgende Schwellwerte für die Erkennung:
    • x > 0.5 → RECHTS
    • x < -0.5 → LINKS
    • y > 0.5 → VORNE
    • y < -0.5 → HINTEN
    • sonst → GERADE
  4. Teste alle Richtungen und verifiziere die Ausgabe.

Erweiterung: Wasserwaage

  1. Erstelle die Datei accelerometer-level.py.
  2. Zeige statt Text einen grafischen Balken auf dem OLED-Display an, der die Neigung auf der x-Achse visualisiert.
  3. Der Balken soll sich je nach Neigung nach links oder rechts verschieben.
  4. Markiere die Mitte des Displays als Referenzlinie.

Arbeitsauftrag 3 - Wetterstation mit ESP32

Situationsbeschreibung

Du arbeitest als Techniker/Technikerin im Facility-Management eines Rechenzentrums in Friedrichshafen.

Das Rechenzentrum betreibt mehrere Serverräume, in denen Temperatur, Luftfeuchtigkeit und Luftdruck kontinuierlich überwacht werden müssen. Du sollst eine kompakte Wetterstation auf Basis eines ESP32 aufbauen, die alle Messwerte auf einem OLED-Display anzeigt und bei kritischen Werten einen Alarm ausgibt.

  • Der DHT20 misst Temperatur und Luftfeuchtigkeit.
  • Der BMP180 misst Luftdruck und Temperatur.
  • Ein SSD1306 OLED-Display zeigt alle Werte an.
Auftragsbearbeitung

2.1 Grundlagen zu den Sensoren:

2.1.1 Über welches Protokoll kommunizieren DHT20 und BMP180 mit dem ESP32?
Wähle eine Antwort.

  1. SPI (Serial Peripheral Interface)
  2. UART (Universal Asynchronous Receiver Transmitter)
  3. I²C (Inter-Integrated Circuit)
  4. 1-Wire


2.1.2 Welche zwei Pins werden für I²C am ESP32 standardmäßig verwendet?
Wähle eine Antwort.

  1. Pin 18 (SCL) und Pin 19 (SDA)
  2. Pin 22 (SCL) und Pin 21 (SDA)
  3. Pin 5 (SCL) und Pin 4 (SDA)
  4. Pin 22 (SDA) und Pin 21 (SCL)


2.1.3 Was gibt die Funktion dht.measurements beim DHT20 zurück?
Wähle eine Antwort.

  1. Nur die Temperatur als Float-Wert
  2. Nur die Luftfeuchtigkeit als Integer-Wert
  3. Ein Dictionary mit den Schlüsseln humidity und temperature
  4. Ein Tupel mit Luftdruck und Temperatur


2.1.4 Welche Aussage zum BMP180 ist korrekt?
Wähle zwei Antworten.

  1. Der BMP180 kann die Luftfeuchtigkeit messen.
  2. Aus dem Luftdruck lässt sich näherungsweise die Höhe berechnen.
  3. Der BMP180 misst Luftdruck und Temperatur.
  4. Der BMP180 verwendet das SPI-Protokoll.


2.1.5 Warum können DHT20 und BMP180 gleichzeitig am selben I²C-Bus betrieben werden?
Wähle eine Antwort.

  1. Weil beide Sensoren dieselbe I²C-Adresse haben.
  2. Weil I²C jeden Teilnehmer über eine eindeutige Adresse ansprechen kann.
  3. Weil sie unterschiedliche Protokolle verwenden.
  4. Weil der ESP32 zwei getrennte I²C-Busse hat.


2.1.6 Was passiert wenn oled.fill(0) nicht in der While-Schleife aufgerufen wird?
Wähle eine Antwort.

  1. Das Display wird nach jeder Messung heller.
  2. Die neuen Messwerte werden über die alten geschrieben und das Display wird unleserlich.
  3. Das Programm stürzt ab.
  4. Die Messwerte werden nicht aktualisiert.


2.2 Programmieraufgaben:

2.2.1 Schreibe den vollständigen Initialisierungscode für I²C-Bus, OLED-Display, DHT20 und BMP180. Kopiere die benötigten Bibliotheken auf den ESP32.

2.2.2 Erweitere das Programm um eine Alarmfunktion. Bei folgenden Grenzwerten soll statt der normalen Anzeige eine blinkende Warnmeldung erscheinen:

  • Temperatur (DHT20) > 30°C → TEMP KRITISCH
  • Luftfeuchtigkeit > 70% → FEUCHT KRITISCH

2.3 Das folgende Programm liest beide Sensoren aus und zeigt die Werte auf dem OLED an. Ergänze die fehlenden Stellen:


from machine import Pin, I2C
import ssd1306, bmp180, ahtx0, time

i2c = I2C(, scl=Pin(22), sda=Pin(21))
oled = ssd1306.SSD1306_I2C(128, 64, i2c)
bmp = bmp180.BMP180(i2c)
dht = ahtx0.AHTx0(i2c)

while True:
    messwerte = dht.
    temp_dht = messwerte["temperature"]
    hum      = messwerte["humidity"]
    temp_bmp = bmp.
    pressure = bmp.

    oled.(0)
    oled.text(f"T: {temp_dht:.1f} C",  0,  0)
    oled.text(f"H: {hum:.1f} %",       0, 12)
    oled.text(f"P: {pressure:.0f} hPa",0, 24)
    oled.text(f"T: {temp_bmp:.1f} C",  0, 36)
    oled.()

    time.sleep()

Wichtige Funktionen zum Ansteuern von Sensoren



from machine import Pin, I2C importieren der Klassen Pin und I2Caus dem Modul machine
i2c = I2C(0, scl=Pin(22), sda=Pin(21)) I2C-Objekt am Pin 21 und 22 erzeugen
print(f"H: {humidity:.2f} %") Formatierte Ausgabe eines Sensorwertes
x, y, z = lis.read() Funktionsaufruf mit drei Rückgabewerten
messwerte={"wert1": 20.1, "wert2": 36.2} Aufbau eines Dictionaries