ESP | Aktoren smart steuern - LED, Buzzer, OLED-Display

Ideen: W. Kimmig, J. Schnaiter, Gewerblich-Technische Schule Offenburg, 2022

Aktoren empfangen elektrische Signale und wandeln diese in eine physikalische Aktion um. In diesem Abschnitt lernst du, wie man eine LED, einen Summer und ein OLED-Display ansteuert.

use your ESP Aktor: LED-Blinklicht

Die rote LED am Kit soll blinken (s. Abb. 1). Sie ist am Pin 27 angeschlossen.

In der Thonny IDE wird mit der Programmiersprache Python programmiert. Die Programme sind in zwei Bereiche aufgeteilt.

Der erste Bereich ist der Setup-Bereich. Hier werden Bibliotheken importiert, stehen Initialisierungen und einmalige Aufrufe.

Der zweite Bereich ist die Schleife while True:. Hier stehen Aufrufe, welche ständig wiederholt werden. Dieser zyklische Wiederholungsvorgang ist auch typisch für eine Speicherprogrammierbare Steuerung die in großen Industrieanalgen eingesetzt wird.

Abb. 1 Aktoren: Rote LED am Portpin 27 und Buzzer am Portpin 16.

from machine import Pin	#Bibliothek zur Ansteuerung der Pins
import time		#Bibliothek für Zeitfunktionen
led = Pin(27, mode=Pin.OUT)	#Der Pin 27 ist digitaler Ausgang

while True:	    
    led.on()		#LED einschalten
    time.sleep(0.5)	#0,5 s warten
    led.off()		#LED ausschalten
    time.sleep(0.5)	#0,5 s warten

Nach dem Import der beiden Bibliotheken wird ein Objekt angelegt: led = Pin(27, Pin.OUT). Dabei wird der der ausgewählte Pin 27 als digitaler Ausgang festgelegt.

Mit dem Funktionsaufruf led.on() schaltet man die LED ein, mit led.off() schaltet man sie aus.

Mit dem Funktionsaufruf time.sleep(0.5) erzeugt man eine Zeitverzögerung. Der Wert 0.5 steht hierbei für 0,5 s. So kann man die Blinkfrequenz verändern.

Beachte: In der Programmiersprache Python gibt es keine geschweiften Klammern und keinerlei Semikolon. Dafür wird durch Einrücken des Quelltextes die Logik beeinflusst.

Hinweis: Sollte es Schwierigkeiten beim Hochladen geben, kann das kurze Betätigen des Reset Buttons am ESP32 Abhilfe schaffen.

Arbeitsauftrag 1 my 1st ESP program

Abb. 2 Quelltext in der Thonny IDE für ein Blinklicht mit dem ESP-Mikrocontroller.

Im ersten Schritt wird die Thonny IDE installiert und die notwendigen Konfigurationen vorgenommen.

Lade die Thonny IDE herunter.
Verbinde den ESP-Mikrocontroller mit USB-Kabel mit deinem Rechner und nimm die korrekte Änderungen in den Einstellungen vor: Wähle den korrekten Interpreter und den COM-Port. Installiere falls notwendig den richtigen USB-Treiber.
Installiere falls notwendig den aktuellen MikroPython Interpreter aus dem ESP.
Hinweis: Falls das Flashen mit Thonny nicht funktioniert, lade die aktuelle Firmware von micropython.org herunter und verwende die Software MuEditor zum Flashen.

Im zweiten Schritt wird das Programm geschrieben, verifiziert und auf den ESP-Mikrocontroller ausgeführt.

Erstelle eine neue Datei unter speicher sie unter dem Namen BlinkendeLED.py.
Verifiziere den Code und starte das Programm auf den Mikrocontroller.
Teste die Funktion, ändere die Zeiten und teste es erneut.
Mit der Funktion print("Hello World") lassen sich Textausgaben anzeigen. Lass Kommentare zu Deinem Programm ausgeben, bzw. den aktuellen Status Deiner LED (An/Aus)
Teste den Buzzer und passe die Zeiten so an, dass Du einen hörbaren Ton bekommst. Achte dabei darauf, dass Deine Mitschülerinnen und Mitschüler nicht zu sehr durch den Geräuschpegel gestört werden.

use your ESP Aktor: OLED-Display

Das OLED-Display in Abb. 3 ist ein einfarbiges OLED-128×64-Punktmatrix-Displaymodul mit der Grove 4-Pin-I2C-Schnittstelle. Über den I²C-Bus ist es unter der Adresse 0x3C erreichbar.

Mit Hilfe der Bibliothek ssd1306.py können wir das Display ansteuern.

Add-ons for your ESP
Python-Bibliothek für das OLED-Display:
ssd1306.py

Einfarbiges OLED-128×64-Punktmatrix-Displaymodul mit der I<sup>2</sup>C-Adresse 0x3C — Abb. 3 Aktor: Einfarbiges OLED-128×64-Punktmatrix-Displaymodul mit der Grove 4-Pin-I²C-Schnittstelle..

from machine import Pin, I2C
from ssd1306 import SSD1306_I2C
from time import sleep

i2c = I2C(0, scl=Pin(22), sda=Pin(21))  
oled = SSD1306_I2C(128, 64, i2c)

while True:
    oled.fill(0) #clear display
    oled.text('Licht: ein', 0, 0) #Position links Zeile 1
    oled.show()
    
    sleep(1)

Nach dem die Datei ssd1306.py auf den Controller geladen wurde importieren wir die Klassen Pin, I2C, sleepSSD1306_I2C.Es wird das Objekt i2c und oled angelegt. Die I²C-Adresse 0x3C wird nicht mit übergeben, da sie bereits in der Bibliothek hinterlegt ist.

Mit dem Funktionsaufruf oled.fill(0) löscht man den Displayinhalt, mit oled.text('Licht: ein', 0, 0) gibt man einen Text an Position x = 0, y = 0, d.h. links oben aus.

Mit dem Funktionsaufruf sleep(1) erzeugt man eine Zeitverzögerung. Das bedeutet, das der Inhalt zyklisch jede Sekunde überschrieben wird.

Man beachte: Möchte man den Inhalt einer Variable, bspw. x = 4 ausgeben, geht dies über die formatierte Ausgabe: oled.text(f"Wert: {x}", 0, 0).

Arbeitsauftrag 2 OLED-Display ansteuern

Abb. 4 Aktor: Mit Micropython programmiertes OLED-Display des Sensorkits.

Das OLED-Display ist am I2C-Bus mit der Adresse 0x3C angeschlossen. Diese Adresse ist bereits in der Bibliothek hinterlegt.

from machine import Pin, I2C
from ssd1306 import SSD1306_I2C
from time import sleep

i2c = I2C(0, scl=Pin(22), sda=Pin(21))  
oled = SSD1306_I2C(128, 64, i2c)

while True:
    oled.fill(0) #clear display
    oled.text('Licht: ein', 0, 0) #Position links Zeile 1
    oled.text('...', 0, 10) #Position links Zeile 2
    oled.show()
    
    sleep(1)

Erstelle eine neue Datei unter speicher sie unter dem Namen OLED-Display-basic.py.
Lade die Datei ssd1306.py herunter und kopiere sie auf den ESP32-Mikrocontroller.
Erstelle eine Anzeige auf dem OLED-Display.
Teste wie viele Zeilen das Display hat.
Lass die LED im Sekundentakt blinken und gib jeweils den aktuellen Zustand der LED (an/aus) am Display aus.
Für Fortgeschrittene: Ändere in der Datei ssd1306.py den Kontrast und die Ausrichtung. Teste Sonderzeichen und weitere Funktionen.

🎯 Arbeitsauftrag 3 Smart-Home Warnsystem

Situationsbeschreibung

Du arbeitest als Junior-Entwickler/Entwicklerin in einem Projektteam für Smart-Home-Produkte. Deine Aufgabe ist es, ein kleines Warnsystem zur Temperaturüberwachung für einen Raum zu entwickeln. Das System soll:

Eine rote LED einschalten, sobald eine Temperatur von 23 °C überschritten wird.
Einen Buzzer ein akustisches Warnsignal ausgeben lassen.
Den Status auf einem OLED-Display (128×64, SSD1306) anzeigen.

Bevor der Sensor integriert wird, soll zunächst eine Testversion erstellt werden, die durch die Verwendung einer Variablen temperatur simuliert wird.

Hardwareaufbau
Die LED ist wie in Abb. 5 gezeigt an Pin 27, der Summer an Pin 16 angeschlossen. Das Display wird über den I²C über die Adresse 0x3C angesprochen.

Abb. 5 Pin-Belegung der Status-LED und des Buzzers.

Folgender Beispiel-Code ist bereits vorhanden:

from machine import Pin, I2C
from ssd1306 import SSD1306_I2C
from time import sleep

i2c = I2C(0, scl=Pin(22), sda=Pin(21))  
oled = SSD1306_I2C(128, 64, i2c)

temperatur = 23

while True:
    oled.fill(0)
    oled.text("Temperatur: ", 0, 0) 
    oled.show()
    
    sleep(1)

Auftragsbearbeitung

3.1 Du möchtest die LED und den Buzzer in das Programm einbinden. Das OLED-Display wurde bereits eingebunden.

3.1.1 Wähle den Quelltext aus, der die LED als digitalen Ausgang definiert.
Wähle eine Antwort.

led = Pin(27, mode=Pin.OUT)
led = Pin(mode=Pin.OUT,27)
led = Pin(16, mode=Pin.OUT)
led = Pin(27, mode=Pin.IN)

3.1.2 Dein Kollege schlägt folgende fehlerhafte Codezeile zum Einbinden des Buzzers vor:
buzzer = Pin(6, mode=Pin.OUT). Wähle einen Fehler aus.

Der Pin wurde als Eingang definiert
Pin ist keine Klasse
Die Namenskonvention wurde verletzt
Dem Pin wurde die falsche ID zugeordnet

3.1.3 Wähle die korrekte Begründung wieso nach oled.text(...) immer oled.show() aufgerufen wird. Wähle eine Antwort.

Das Display wird so gelöscht
Dadurch wird das Display initialisiert
Die Daten werden an den OLED-Speicher übertragen
Der Text muss zuerst invertiert werden

3.1.4 Nachdem der Buzzer integriert wurde, programmierst du:buzzer.on()
Wähle die Auswirkung des Befehls aus den vier Vorschlägen aus. Wähle eine Antwort.

Der Pin wird aus HIGH gesetzt
Der Buzzer piept
Der Buzzer wird stummgeschaltet
Der Buzzer wird eingeschaltet

3.2 Bevor du mit der eigentlichen Lösung des Problems beginnst, möchtest Du nochmal das Thema Entscheidungen trainieren. Dein Kollege zeigt Dir hierzu zwei Codeschnippsel.

3.2.1 Quelltext:


				if temperatur >= 23:
  print(f"T: {temperatur:.2f}")

Gib die Ausgabe an. Wähle eine Antwort.

T: 23
T: 23.00
Die Ausgabe ist nicht eindeutig
T: 23.0000

3.2.2 Quelltext
if i == 23: print(f"T: {temperatur+0.01:5.2f}")
Gib die Ausgabe an. Wähle eine Antwort.

T: 23.1
T: 23.01
T: 23.01
t: 23.0

3.3 Entwickle ein Programm zur Steuerung

der Status-LED,
des Buzzertons und
die Ausgabe der aktuellen Temperatur auf dem Display.

Dein Quelltext:

Die Lösung sollte folgendermaßen aussehen:


while True:
    oled.fill(0)
    oled.text(f"Temperatur: {temperatur:.2f}", 0, 0) 
    oled.show()

	if temperatur >= 23:
		led.on()
		buzzer.toggle()
	else:
		led.off()
    
    sleep(0.0025)

Wichtige Funktionen zum Programmieren des ESP

`import ...`	Einbinden von Bibliotheken
`led = Pin(2, Pin.OUT)`	Objekterzeugung: Pin 2 ist ein digitaler Ausgang
`while True:`	zyklische Programmwiederholung

`led.on()`	LED wird mit Spannung versorgt
`time.sleep(2)`	Zeitverzögerung von 2 s erzeugen