MicroPython mit ESP32: IR-Signale empfangen und verarbeiten
In diesem Beitrag möchte ich dir gerne zeigen, wie du IR-Signale am ESP32 in MicroPython empfangen und verarbeiten kannst. Dem Rich Shield liegt eine kleine Infrarotfernbedienung bei, welche ich nachfolgend auslesen und über die Tasten, die LEDs und die Segmentanzeige steuern möchte.
https://youtu.be/aIXV3dH80DY
Wie du eine Infrarotfernbedienung am ESP32 in MicroPython programmierst, habe ich dir bereits im Beitrag Infrarot-Fernbedienung mit dem ESP32 und MicroPython auslesen: Ein Anfängerleitfaden gezeigt. Hier möchte ich an diesen Beitrag anknüpfen und dir ein paar Anwendungsfälle am Rich Shield von Open Smart zeigen.
Aufbau der Schaltung ohne Rich Shield
Wenn du das Rich Shield von Open Smart nicht hast, dann kannst du dir diese kleine Schaltung auch sehr einfach und günstig nachbauen.
Den Infrarotempfänger bekommst du als einzelne Diode und auch als fertigen Baustein auf einer Platine. Ich würde dir empfehlen zu einer Platine zu greifen, das ist deutlich einfacher als die Schaltung mit der einzelnen Diode.
- einen ESP32 D1 R32*,
- ein Micro-USB Datenkabel*,
- einen IR-Empfänger (KY-022)*,
- eine IR-Fernbedienung*
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!
Infrarotfernbedienungen
Es gibt zu diversen mobilen Geräten Infrarotfernbedienungen, welche wir am Mikrocontroller auslesen können. Zumeist funktioniert dieses auch recht gut, nur manchmal muss man die Protokolle durchspielen, um es zum Laufen zu bekommen.
Infrarot Fernbedienung
Infrarotfernbedienung
IR Fernbedienung für Grundig LED Spots
In diesem Beitrag verwende ich eine einfache IR-Fernbedienung, welche dem Rich Shield von Open Smart beiliegt. Du bekommst diese aber auch inkl. IR-Empfänger in einem Set recht günstig auf ebay.de oder aliexpress.com.
Auslesen der Infrarotfernbedienung
Bevor wir den Tasten der Infrarotfernbedienung eine Aktion zuweisen können, müssen wir diese zunächst auslesen. Dazu wiederum benötigen wir ein Modul, welches wir vom GitHub Repository peterhinch/micropython_ir als ZIP-Datei herunterladen können.
Der folgende Python-Code ist für einen Mikrocontroller geschrieben und ermöglicht es, Signale von einer Infrarot-Fernbedienung (IR-Fernbedienung) zu empfangen und zu verarbeiten.
1. Import der benötigten Module
Zuerst importieren wir die notwendigen Module:
from machine import Pin, freq
from ir_rx.print_error import print_error
from ir_rx.nec import NEC_16
- Pin und freq stammen aus dem machine Modul. Diese helfen uns dabei, mit den Pins des Mikrocontrollers zu arbeiten und die Frequenz einzustellen.
- print_error importieren wir aus dem Modul ir_rx.print_error, um Fehler anzeigen zu können.
- NEC_16 importieren wir aus ir_rx.nec. Dies ist das Protokoll, das wir für unsere IR-Fernbedienung verwenden.
2. Konfiguration des IR-Empfängers
Hier konfigurieren wir den Pin, an dem unser IR-Empfänger angeschlossen ist:
pin_ir = Pin(26, Pin.IN)
- Der IR-Empfänger ist an GPIO26 (Pin 26) angeschlossen und wird als Eingabepin (Pin.IN) definiert.
3. Dekodierung der Tastenwerte
Wir definieren eine Funktion, die die empfangenen Daten ausgibt:
def decodeKeyValue(data):
print(data)
- Diese Funktion gibt einfach den empfangenen Datenwert aus. Hier können wir später Logik hinzufügen, um auf verschiedene Tasten zu reagieren.
4. Callback-Funktion
Diese Funktion wird aufgerufen, wenn eine Taste auf der Fernbedienung gedrückt wird:
def callback(data, addr, ctrl):
if data < 0:
pass
else:
decodeKeyValue(data)
- Wenn ungültige Daten empfangen werden (data < 0), passiert nichts.
- Bei gültigen Daten rufen wir die decodeKeyValue(data) Funktion auf.
5. Initialisierung des IR-Empfängers
Hier richten wir das IR-Modul ein:
ir = NEC_16(pin_ir, callback)
ir.error_function(print_error)
- Wir initialisieren das IR-Modul und geben den Pin sowie die Callback-Funktion an.
- Bei Fehlern wird die print_error Funktion aufgerufen.
6. Hauptprogramm
Das Hauptprogramm läuft in einer Endlosschleife:
try:
while True:
pass
except KeyboardInterrupt:
ir.close()
- Das Programm bleibt in einer Endlosschleife (while True).
- Wenn das Programm durch Strg + C oder durch die IDE unterbrochen wird (KeyboardInterrupt), wird die Verbindung zum IR-Modul sauber geschlossen (ir.close()).
#Import der benötigten Module
from machine import Pin, freq
from ir_rx.print_error import print_error
#Für die IR-Fernbedienung benötige ich das Modul NEC-16
#ggf. musst du hier den Import anpassen.
from ir_rx.nec import NEC_16
#IR-Receiver am Pin GPIO14 angeschlossen
pin_ir = Pin(26, Pin.IN)
#Funktion um den Code der Taste auszuwerten,
#hier können wir später mit einem Switch oder einer
#If-Bedienung auf die Tasten reagieren.
def decodeKeyValue(data):
print(data)
#Funktion welche bei einem Tastendruck auf
#der IR-Fernbedienung ausgeführt werden soll.
def callback(data, addr, ctrl):
#Wenn keine gültigen Daten empfangen wurden
#dann soll nichts passieren.
if data < 0:
pass
else:
#Wenn jedoch gültige Daten empfangen wurden,
#dann soll die Funktion decodeKeyValue mit
#diesen aufgerufen werden.
print(decodeKeyValue(data))
#Definieren das, dass IR-Modul am Pin 14 angeschlossen ist,
#zusätzlich wird noch ein Callback angegeben welcher aufgerufen wird,
#wenn eine Taste betätigt wird.
ir = NEC_16(pin_ir, callback)
#Im Fehlerfall soll die das Modul "print_error" angesteuert werden
ir.error_function(print_error)
#Try-Except Block
try:
#starten einer leeren Endlosschleife
while True:
pass
#Wenn das Programm über Strg + C oder
#über die IDE abgebrochen wird, wird ebenso
#die Verbindung zum IR-Modul geschlossen.
except KeyboardInterrupt:
ir.close()
Steuern der LEDs via Infrarotfernbedienung
Auf dem Rich Shield sind vier LEDs verbaut, welche wir bereits in den letzten Beiträgen ausgiebig genutzt haben, in diesem Beispiel möchte ich diese nun mit der Infrarotfernbedienung Ein-/Ausschalten.
Da die LEDs mit LED1, LED2 ... beschriftet sind, bieten sich hier die Tasten 1 bis 4 an.
#Import der benötigten Module
from machine import Pin, freq
from ir_rx.print_error import print_error
#Für die IR-Fernbedienung benötige ich das Modul NEC-16
#ggf. musst du hier den Import anpassen.
from ir_rx.nec import NEC_16
#IR-Receiver am Pin GPIO26 angeschlossen
pin_ir = Pin(26, Pin.IN)
#rote LED am GPIO17
ledRed = Pin(17, Pin.OUT)
#gruene LED am GPIO16
ledGreen = Pin(16, Pin.OUT)
#blaue LED am GPIO27
ledBlue = Pin(27, Pin.OUT)
#gelbe LED am GPIO14
ledYellow = Pin(14, Pin.OUT)
#alle LEDs deaktivieren
ledRed.off()
ledGreen.off()
ledBlue.off()
ledYellow.off()
#Funktion um den Code der Taste auszuwerten,
#hier können wir später mit einem Switch oder einer
#If-Bedienung auf die Tasten reagieren.
def decodeKeyValue(data):
print(data)
if data == 12: #Taste 1
toggleLed(ledRed)
elif data == 24: #Taste 2
toggleLed(ledGreen)
elif data == 94: #Taste 3
toggleLed(ledBlue)
elif data == 8: #Taste 4
toggleLed(ledYellow)
elif data == 69: #Taste POWER
ledRed.value(0)
ledGreen.value(0)
ledBlue.value(0)
ledYellow.value(0)
#Funktion zum umkehren eines zustandes am Pin
#aus einem aktiven Pin wird ein deaktiver
def toggleLed(pin):
if not pin.value():
pin.value(1)
else:
pin.value(0)
#Funktion welche bei einem Tastendruck auf
#der IR-Fernbedienung ausgeführt werden soll.
def callback(data, addr, ctrl):
#Wenn keine gültigen Daten empfangen wurden
#dann soll nichts passieren.
if data < 0:
pass
else:
decodeKeyValue(data)
#Definieren das, dass IR-Modul am Pin 14 angeschlossen ist,
#zusätzlich wird noch ein Callback angegeben welcher aufgerufen wird,
#wenn eine Taste betätigt wird.
ir = NEC_16(pin_ir, callback)
#Im Fehlerfall soll die das Modul "print_error" angesteuert werden
ir.error_function(print_error)
#Try-Except Block
try:
#starten einer leeren Endlosschleife
while True:
pass
#Wenn das Programm über Strg + C oder
#über die IDE abgebrochen wird, wird ebenso
#die Verbindung zum IR-Modul geschlossen.
except KeyboardInterrupt:
ir.close()
Read the full article
0 notes
MicroPython mit ESP32: Töne erzeugen mit dem Piezo Buzzer
In diesem Beitrag möchte ich dir jetzt zeigen, wie du Töne und sogar ganze Lieder mit einem Piezo Buzzer am ESP32 mit MicroPython erzeugen kannst.
https://youtu.be/2GHp5eZNJOg
Im Beitrag MicroPython mit ESP32: Helligkeitsregelung von LEDs mit PWM hatte ich dir bereits gezeigt, wie du PWM Signale erstellen kannst, um die Helligkeit einer LED zu regeln. Für das Erzeugen eines Tones benötigen wir ebenfalls ein PWM Signal, in diesem Fall regeln wir damit die Frequenz des Tones.
Auf meinem Blog hatte ich dir bereits einen ähnlichen Beitrag in der Vergangenheit zu diesem Thema unter Programmieren mit MicroPython #5: Piezo Buzzer am ESP32 betreiben veröffentlicht, hier möchte ich jedoch passend zum Rich Shield von Open Smart speziell auf dieses eingehen.
Schaltung - Piezo Buzzer am ESP32 D1 R32
Für diese Beitragsreihe verwende ich wie bereits erwähnt das Rich Shield von Open Smart. Auf diesem ist ein Piezo Buzzer verbaut, welcher wie folgt, mit dem Mikrocontroller verbunden ist:
BauteilESP32 D1 R32Arduino UNO R3Piezo BuzzerIO25D4
Rich Shield von Open Smart auf dem ESP32 D1 R32
Schaltung ohne Rich Shield von Open Smart
Wenn du das genannte Shield nicht hast, dann kannst du dir recht einfach diese kleine Schaltung selber nachbauen.
- einen ESP32 D1 R32*
- einen Piezo Buzzer*
- ein 170 Pin Breadboard*
- zwei Breadboardkabel*, männlich-männlich
Schaltung - Piezo Buzzer am ESP32 D1 R32
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!
Erzeugen eines Tones am Piezo Buzzer mit MicroPython
Der kleine Piezo Buzzer nutzt die Spannung vom GPIO und somit benötigst du keine zusätzliche Stromquelle. Das macht die Schaltung einfach, jedoch ist dieser dadurch auch nicht besonders laut.
Für kleine Spielereien am Mikrocontroller sind diese jedoch ideal!
from machine import Pin, PWM # Importiere die notwendigen Module Pin und PWM aus der machine-Bibliothek
import time # Importiere das time-Modul für Zeitsteuerungsfunktionen
# Initialisiere den Piezo Buzzer auf Pin 25 mit einer Frequenz von 440 Hz und einem Duty Cycle von 50% (512 von 1024)
beeper = PWM(Pin(25), freq=440, duty=512)
# Lasse den Ton für 0,5 Sekunden erklingen
time.sleep(0.5)
# Deinitialisiere den PWM-Kanal, um den Ton zu stoppen
beeper.deinit()
Erklärung der einzelnen Codezeilen:
- from machine import Pin, PWM:
- Diese Zeile importiert die Pin und PWM Klassen aus dem machine Modul. Pin wird verwendet, um die GPIO-Pins zu konfigurieren, und PWM wird verwendet, um PWM-Signale zu erzeugen.
- import time:
- Das time Modul wird importiert, um Verzögerungen einzufügen.
- beeper = PWM(Pin(25), freq=440, duty=512):
- Pin(25): Initialisiert den GPIO-Pin 25 als PWM-Ausgang.
- freq=440: Setzt die PWM-Frequenz auf 440 Hz, was der Frequenz des Tons A entspricht (auch bekannt als der Kammerton A).
- duty=512: Setzt den Duty Cycle auf 512, was 50 % der maximalen Duty Cycle (0 …1023) entspricht. Dies bedeutet, dass das Signal gleichmäßig zwischen an und aus wechselt.
- time.sleep(0.5):
- Wartet 0,5 Sekunden, während der Piezo Buzzer den Ton mit der eingestellten Frequenz und Duty Cycle ausgibt.
- beeper.deinit():
- Deinitialisiert den PWM-Kanal, wodurch der Ton gestoppt wird. Der PWM-Ausgang wird deaktiviert und der GPIO-Pin wird in seinen ursprünglichen Zustand zurückversetzt.
Dieser einfache Code erzeugt einen Ton mit einer Frequenz von 440 Hz (A4) für eine halbe Sekunde über einen Piezo Buzzer, der an GPIO-Pin 25 des ESP32 angeschlossen ist.
Regeln der Frequenz mit dem Drehpotentiometer
Im Beitrag MicroPython mit ESP32: Einführung in analoge Sensoren habe ich dir erläutert wie du einen Drehpotentiometer auslesen kannst, mit diesem analogen Bauteil kannst du auch die Frequenz anpassen.
In dem Code habe ich eine zusätzliche Funktion implementiert welche den Wertebereich des analogen Sensors (Drehpotentiometer) auf einen Frequenzbereich mappt.
# Funktion zum Mappen der analogen Werte des Drehpotentiometers (0..1023)
# auf eine Frequenz von 200 Hz bis 1500 Hz
def map_value(x, in_min=0, in_max=1023, out_min=200, out_max=1500):
return (x - in_min) * (out_max - out_min) // (in_max - in_min) + out_min
Wenn du die Frequenz erhöhen möchtest dann kannst du die Parameter out_min & out_max entweder in der Funktion anpassen oder du gibst diese als namedparameter beim aurufen der Funktion mit.
# Module zum Zugriff auf die GPIOs
from machine import Pin, ADC, PWM
# Modul zum Zugriff auf Funktionen
# wie zum einlegen einer Pause im Code
from time import sleep
# ADC12 am GPIO2, als Eingang
adc_pin = Pin(2, mode=Pin.IN)
# Initialisieren eines ADC Objektes
# (analog digital converter)
adc = ADC(adc_pin)
# Auflösung auf 0..1023 (10bit)
adc.atten(ADC.ATTN_11DB)
adc.width(ADC.WIDTH_10BIT)
# Initialisiere den Piezo Buzzer auf Pin 25
# mit einer Frequenz von 440 Hz und einem Duty Cycle von 50% (512 von 1024)
beeper = PWM(Pin(25), freq=440, duty=512)
# Funktion zum Mappen der analogen Werte des Drehpotentiometers (0..1023)
# auf eine Frequenz von 200 Hz bis 1500 Hz
def map_value(x, in_min=0, in_max=1023, out_min=200, out_max=1500):
return (x - in_min) * (out_max - out_min) // (in_max - in_min) + out_min
try:
# Starten der Endlosschleife
while True:
analogValue = adc.read()
frequenz = map_value(analogValue)
beeper.freq(frequenz)
print("analogValue:", analogValue)
print("frequenz:", frequenz)
sleep(0.25)
except KeyboardInterrupt:
# Deinitialisiere den PWM-Kanal, um den Ton zu stoppen
beeper.deinit()
Hier nun das komplette Programm zum steuern der Frequenz mit einem Drehpotentiometer. Natürlich kannst du auch einen Fotowiderstand verwenden welcher ähnlich funktioniert.
Ein Lied auf dem Piezo Buzzer abspielen
Ein Lied ist quasi lediglich eine Aneinanderreihung von Tönen, welche in einer bestimmten Frequenz und Dauer abgespielt werden. Natürlich kannst du über den Piezo Buzzer über diese technische Lösung keine umfangreichen MP3-Dateien abspielen, jedoch kleine Lieder im Klassischen 8Bit Style sind easy möglich.
Programm - abspielen des Songs Für Elise von Beethoven auf dem ESP32 in MicroPythonHerunterladen
Bei nachfolgenden Liedern habe ich mich aus dem GitHub Repository robsoncouto/arduino-songs bedient welche eigentlich für den Arduino gedacht sind, jedoch ist der Code so einfach, das man diesen mit wenig aufwand zu MicroPython konvertieren kann.
from machine import Pin, PWM
from time import sleep
import urandom
# Definition der Notenfrequenzen
NOTE_B0 = 31
NOTE_C1 = 33
NOTE_CS1 = 35
NOTE_D1 = 37
NOTE_DS1 = 39
NOTE_E1 = 41
NOTE_F1 = 44
NOTE_FS1 = 46
NOTE_G1 = 49
NOTE_GS1 = 52
NOTE_A1 = 55
NOTE_AS1 = 58
NOTE_B1 = 62
NOTE_C2 = 65
NOTE_CS2 = 69
NOTE_D2 = 73
NOTE_DS2 = 78
NOTE_E2 = 82
NOTE_F2 = 87
NOTE_FS2 = 93
NOTE_G2 = 98
NOTE_GS2 = 104
NOTE_A2 = 110
NOTE_AS2 = 117
NOTE_B2 = 123
NOTE_C3 = 131
NOTE_CS3 = 139
NOTE_D3 = 147
NOTE_DS3 = 156
NOTE_E3 = 165
NOTE_F3 = 175
NOTE_FS3 = 185
NOTE_G3 = 196
NOTE_GS3 = 208
NOTE_A3 = 220
NOTE_AS3 = 233
NOTE_B3 = 247
NOTE_C4 = 262
NOTE_CS4 = 277
NOTE_D4 = 294
NOTE_DS4 = 311
NOTE_E4 = 330
NOTE_F4 = 349
NOTE_FS4 = 370
NOTE_G4 = 392
NOTE_GS4 = 415
NOTE_A4 = 440
NOTE_AS4 = 466
NOTE_B4 = 494
NOTE_C5 = 523
NOTE_CS5 = 554
NOTE_D5 = 587
NOTE_DS5 = 622
NOTE_E5 = 659
NOTE_F5 = 698
NOTE_FS5 = 740
NOTE_G5 = 784
NOTE_GS5 = 831
NOTE_A5 = 880
NOTE_AS5 = 932
NOTE_B5 = 988
NOTE_C6 = 1047
NOTE_CS6 = 1109
NOTE_D6 = 1175
NOTE_DS6 = 1245
NOTE_E6 = 1319
NOTE_F6 = 1397
NOTE_FS6 = 1480
NOTE_G6 = 1568
NOTE_GS6 = 1661
NOTE_A6 = 1760
NOTE_AS6 = 1865
NOTE_B6 = 1976
NOTE_C7 = 2093
NOTE_CS7 = 2217
NOTE_D7 = 2349
NOTE_DS7 = 2489
NOTE_E7 = 2637
NOTE_F7 = 2794
NOTE_FS7 = 2960
NOTE_G7 = 3136
NOTE_GS7 = 3322
NOTE_A7 = 3520
NOTE_AS7 = 3729
NOTE_B7 = 3951
NOTE_C8 = 4186
NOTE_CS8 = 4435
NOTE_D8 = 4699
NOTE_DS8 = 4978
REST = 0
# Ändere dies, um das Lied langsamer oder schneller zu machen
tempo = 100
# Ändere dies auf den Pin, den du verwenden möchtest
buzzer_pin = 25
buzzer = PWM(Pin(buzzer_pin))
# Noten der Melodie gefolgt von der Dauer
melody =
# Anzahl der Noten berechnen
notes = len(melody) // 2
# Dauer einer ganzen Note in ms berechnen
wholenote = (60000 * 4) / tempo
led1 = Pin(17, Pin.OUT)
led2 = Pin(16, Pin.OUT)
led3 = Pin(27, Pin.OUT)
led4 = Pin(14, Pin.OUT)
leds =
lastRandomNumber = -1
# Funktion zum Abspielen eines Tons
def play_tone(pwm, freq, duration):
pwm.freq(freq)
pwm.duty(512)
sleep(duration / 1000)
pwm.duty(0)
sleep(duration / 1000 * 0.1)
# Setup und Melodie abspielen
for i in range(0, len(melody), 2):
note = melody
duration = melody
randomNumber = -1
while (lastRandomNumber == randomNumber):
randomNumber = urandom.randint(0, 3)
lastRandomNumber = randomNumber
led = leds
led.on()
if duration > 0:
note_duration = wholenote / duration
else:
note_duration = (wholenote / abs(duration)) * 1.5
if note == REST:
sleep(note_duration / 1000)
else:
play_tone(buzzer, note, note_duration * 0.9)
led.off()
buzzer.deinit()
Ausblick
Im nächsten Beitrag werde ich dir zeigen, wie du mit einer Infrarot Fernbedienung die LEDs und den Piezo Buzzer bedienen kannst.
ESP32 D1 R32, Rich Shield + IR-Fernbedienung
Read the full article
0 notes
MicroPython mit ESP32: Helligkeitsregelung von LEDs mit PWM
In diesem Beitrag lernst du, wie du Pulsweitenmodulation (kurz PWM) mit dem ESP32 D1 R32 und MicroPython einsetzen kannst. PWM ist eine vielseitige Technik, die in vielen Anwendungen, von der LED-Dimmung bis zur Motorsteuerung, weit verbreitet ist. Mit dem ESP32 und MicroPython ist es einfach, PWM-Signale zu erzeugen und zu steuern.
https://youtu.be/tIgmYc-dfaI
Wie du den Mikrocontroller für die Programmierung in MicroPython vorbereitest, habe ich dir bereits im Beitrag MicroPython mit ESP32: Einführung in den ESP32 D1 R32 gezeigt. Im letzten Beitrag MicroPython mit ESP32: GPIO-Pins steuern – LEDs und Taster hatte ich ebenso bereits gezeigt, wie du Taster und vor allem LEDs steuern kannst, jedoch fehlte dort noch der Abschnitt mit dem Dimmen von LEDs, was ich hier gerne nachholen möchte.
Was ist PWM?
PWM steht für Pulsweitenmodulation. Das ist eine Methode, um analoge Geräte mit digitalen Signalen zu steuern. Dabei wird das Signal schnell ein- und ausgeschaltet, wobei die Dauer des Ein- und Ausschaltens verändert wird. Ein Beispiel ist die Steuerung der Helligkeit einer LED oder der Geschwindigkeit eines Motors.
Erzeugen eines PWM Signals am ESP32 in MicroPython
Steigen wir ein und erzeugen ein PWM Signal am ESP32 D1 R32 in MicroPython.
Wenn du das Rich Shield von Open Smart nicht hast, dann kannst du dir diese Schaltung auch recht einfach an einem Breadboard nachbauen.
Schauen wir uns den Quellcode zum Erzeugen eines PWM Signals an einer LED etwas genauer an:
Schritt 1 - import der benötigten Module
Damit wir einen GPIO Pin ansteuern und später ein PWM Signal am ESP32 erzeugen können, benötigen wir die Module Pin & PWM aus machine. Das Modul sleep laden wir uns aus time, damit wir im Code eine kleine Pause einlegen können.
# Module zum steuern der GPIO-Pins
from machine import Pin, PWM
# Modul zum einlegen einer Pause im Code
from time import sleep
Schritt 2 - Initialisieren eines GPIO Pins
In meinem Fall möchte ich die rote LED1 am Rich Shield verwenden, welche am GPIO 17 angeschlossen ist, dieser Pin muss natürlich als Ausgang dienen.
# Initialisieren eines PWM Pins
led = PWM(Pin(17, Pin.OUT))
Schritt 3 - Konfigurieren des PWM Signals
Für eine LED reicht es aus die Frequenz auf 5 kHz zu setzen.
Das Setzen der PWM-Frequenz auf 5 kHz (Kilohertz) hat mehrere Gründe, die sich hauptsächlich auf die gewünschte Anwendung und die Eigenschaften der gesteuerten Geräte beziehen. Hier sind einige wichtige Punkte, die erklären, warum 5 kHz eine gute Wahl sein kann:
Vermeidung von Flimmern bei LEDs
Bei LEDs kann eine zu niedrige PWM-Frequenz Flimmern verursachen, das für das menschliche Auge sichtbar und störend sein kann. Eine Frequenz von 5 kHz liegt weit über der Wahrnehmungsgrenze des menschlichen Auges, wodurch das Flimmern effektiv vermieden wird.
Effizienz bei der Motorsteuerung
Bei der Steuerung von DC-Motoren kann eine höhere PWM-Frequenz zu einer ruhigeren und gleichmäßigeren Bewegung führen. Eine Frequenz von 5 kHz sorgt dafür, dass die Motoren effizienter und mit weniger Vibrationen arbeiten.
Allgemeine Kompatibilität
Eine Frequenz von 5 kHz ist für viele PWM-Anwendungen geeignet, sei es für LEDs, Motoren oder andere Geräte. Sie bietet eine gute Balance zwischen Leistung und Kompatibilität.
Vermeidung von Geräuschen
Bei manchen Anwendungen können niedrigere Frequenzen hörbare Geräusche erzeugen (z.B. Brummen bei Motoren oder Summen bei Lautsprechern). Eine Frequenz von 5 kHz liegt außerhalb des hörbaren Bereichs für die meisten Menschen, wodurch diese Geräusche vermieden werden.
# Frequenz auf 5 kHz setzen
led.freq(5000)
Schritt 4 - setzen des PWM Wertes
Mit der Funktion duty am PWM Objekt setzen wir im Falle einer LED die Helligkeit. Wir können hier Werte zwischen 0 und 1023 eingeben.
# Helligkeit auf 1/4 setzen (0..1023)
led.duty(128)
Schritt 5 - deinitialisieren des GPIO Pins
Zum Schluss ergibt es größtenteils Sinn, die verwendeten Pins wieder zu deaktivieren, da sonst die angeschlossenen Aktoren (LEDs, Motoren etc.) weiterbetrieben werden. Im Falle einer LED würde die lediglich weiter leuchten.
# Pin deinitialisieren
led.deinit()
Programmieren eines Fade Effekts an einer LED
Im Nachfolgenden möchte ich dir nun zeigen, wie man einen Fade Effekt programmiert. Dieser Effekt lässt eine LED langsam auf-/ableuchten.
Für diesen Effekt an einer LED starten wir eine For-Schleife von 0 bis 1023 und nutzen den Index von dieser für die Helligkeit der LED. Wichtig ist auch hier die kleine Pause von 15 ms. damit wir den Effekt auch sehen können.
# Schleife von 0 bis 1023
for value in range(0,1024):
# setzen des aktuellen Wertes
# des Indexes aus der Schleife
# als Helligkeitswert
led.duty(value)
# eine Pause von 15 ms.
sleep(0.015)
Hier nun der komplette Code:
# Module zum steuern der GPIO-Pins
from machine import Pin, PWM
# Modul zum einlegen einer Pause im Code
from time import sleep
# Initialisieren eines PWM Pins
led = PWM(Pin(17, Pin.OUT))
# Frequenz auf 5 kHz setzen
led.freq(5000)
# Schleife von 0 bis 1023
for value in range(0,1024):
# setzen des aktuellen Wertes
# des Indexes aus der Schleife
# als Helligkeitswert
led.duty(value)
# eine Pause von 15 ms.
sleep(0.015)
# Pin deinitialisieren
led.deinit()
Steuern der Helligkeit einer LED über Tasten
Am Rich Shield von Open Smart findest du auch zwei Tasten, mit welchen du die Helligkeit der LED steuern kannst. Da es jedoch eher mühsam wäre alle 1023 Schritte über Tasten zu betätigen, setze ich die Helligkeit in 100er-Schritte.
# Module zum steuern der GPIO-Pins
from machine import Pin, PWM
# Modul zum einlegen einer Pause im Code
from time import sleep
# anlegen der Variablen für die Taster
# Taster K1 am GPIO12
k1 = Pin(12, Pin.IN, Pin.PULL_UP)
#Taster K2 am GPIO13
k2 = Pin(13, Pin.IN, Pin.PULL_UP)
# Initialisieren eines PWM Pins
led = PWM(Pin(17, Pin.OUT))
# Frequenz auf 5 kHz setzen
led.freq(5000)
# Variable zum zwischenspeichern
# des Wertes der Helligkeit
helligkeit = 0
# Funktion zum setzen der Helligkeit
def setLEDHelligkeit():
# wird benötigt um einen Zugriff auf
# die globale Variable zu erlangen
global helligkeit
# Ausgeben des Wertes auf der Kommandozeile
print("Helligkeit:", helligkeit)
# setzen der Helligkeit an der LED
led.duty(helligkeit)
# Try/Catch Block
# dient zum Abfangen von Ausnahmen / Exceptions
try:
# starten der Endlosschleife
while True:
# Wenn der Taster K1 betätigt wurde und
# der Wert der Helligkeit kleiner 1000 ist, dann...
if not k1.value() and helligkeit < 1000:
# erhöhen der Helligkeit um den Wert 100
helligkeit += 100
# setzen der Helligkeit
setLEDHelligkeit()
# einlegen einer kleinen Pause von 300 ms.
sleep(0.3)
# Wenn der Taster K2 betätigt wird und der Wert größer 0 ist,
# dann soll der Wert um 100 verringert werden.
if not k2.value() and helligkeit > 0:
helligkeit -= 100
setLEDHelligkeit()
sleep(0.3)
# Wenn das Programm über die Schaltfläche STOP, abgebrochen wurde,
# dann wird eine KeyboardInterrupt Exception geworfen.
# Diese Exception fangen wir ab und deaktivieren die LED.
except KeyboardInterrupt:
led.deinit()
Ausblick
Im nächsten Beitrag werden wir uns den Drehpotentiometer anschauen und ich werde dir zeigen wie dieser ausgelesen werden kann und damit die LEDs gesteuert werden können.
Read the full article
0 notes
MicroPython mit ESP32: GPIO-Pins steuern – LEDs und Taster
Nachdem ich dir gezeigt habe, wie du den ESP32 für MicroPython flasht und wie die Programmiersprache aufgebaut ist, wollen wir LEDs und Taster via GPIO-Pins steuern.
https://youtu.be/DptfSzv8_Dk
Für diese Beitragsreihe verwende ich den ESP32 D1 R32 sowie das Rich Shield Two von Open Smart. Wenn du dieses nicht hast, so gebe ich dir trotzdem jeweils die Hinweise wie du die Schaltung auf einem Breadboard aufbauen kannst.
ESP32 D1 R32
ESP32 D1 R32 mit Rich Shield von Open Smart
ESP-WROOM-32 Chip auf dem ESP32 D1 R32
Sollten trotzdem Fragen offen bleiben, so kannst du mir gerne eine Mail an
[email protected] senden oder hier einen Kommentar hinterlassen.
LEDs am Rich Shield von Open Smart
Die LEDs am Rich Shield von Open Smart sind an nachfolgende Pins angeschlossen:
LEDESP32 D1 R32Arduino UNO R3LED1 (rot)IO17D4LED2 (grün)IO16D5LED3 (blau)IO27D6LED4 (gelb)IO14D7
Schaltung ohne Rich Shield
Hier nun die Schaltung, wenn du das Rich Shield von Open Smart nicht hast, aber trotzdem dieses Tutorial nachprogrammieren möchtest.
Steuern der GPIO-Pins der LEDs
Ein GPIO Pin kann als Eingang und Ausgang dienen. Eine LED dient zur Ausgabe (in diesem Fall Licht) und daher wird der Pin als Pin.OUT definiert. Hätten wir einen Taster, wäre dieses dann Pin.IN.
Damit wir im Code eine kleine Pause einlegen können, müssen wir das Modul time implementieren. Dieses Modul bietet viele Funktionen, eine davon ist time.sleep() wobei als Parameter hier die Sekunden eingegeben werden. (Anders als wie bei der Arduino IDE mit dem Befehl delay welcher Millisekunden erwartet.)
#Modul für den Zugriff auf die GPIO Pins
import machine
#Modul für den Zugriff auf Funktionen
#wie zum einlegen einer Pause im Code
import time
#anlegen einer Variable,
#GPIO17, als Ausgang
led1 = machine.Pin(17, machine.Pin.OUT)
led1.value(1) #aktivieren des Pins
time.sleep(1) #eine Pause von 1 Sekunde
led1.value(0) #deaktivieren des Pins
Wenn wir den Code ausführen, dann wird die LED1 (rot) für 1 Sekunde aktiviert und danach wieder deaktiviert. Anschließen beendet sich das Programm von selber.
LED blinken lassen
Im Beitrag MicroPython mit ESP32: Grundlagen der Programmierung habe ich dir die Schleifen vorgestellt. Mit einer Schleife können wir jetzt die LED blinken lassen. Dabei können wir entweder diese für eine Anzahl x, Zeit x oder dauerhaft blinken lassen.
LED eine bestimmte Anzahl blinken lassen
Um eine LED eine bestimmte Anzahl blinken zu lassen, müssen wir mit einer For-Schleife lediglich von / bis Zählen. Im unten stehenden Code zähle ich von 1 bis 5, wobei ich hier die Laufvariable i nicht verwende.
#Modul für den Zugriff auf die GPIO Pins
import machine
#Modul für den Zugriff auf Funktionen
#wie zum einlegen einer Pause im Code
import time
#Wert für die Pause in der Schleife
pause = 0.250
#anlegen einer Variable,
#GPIO17, als Ausgang
led1 = machine.Pin(17, machine.Pin.OUT)
#eine Schleife von 1 bis 5
for i in range(1,6):
led1.value(1) #aktivieren des Pins
time.sleep(pause) #eine Pause
led1.value(0) #deaktivieren des Pins
time.sleep(pause) #eine Pause
In dem Video siehst du das die kleine rote 5 mm LED insgesamt 5-mal aufblinkt. Wenn wir die Range in der For-Schleife auf range(1,11) anpassen würden, dann würde diese 10-mal blinken.
LED eine bestimmte Zeit blinken lassen
Wenn wir die LEDs eine bestimmte Zeit blinken lassen wollen, dann benötigen zum einen den aktuellen Zeitstempel und die Dauer. Hier hilft uns einfache Mathematik und eine While-Schleife weiter.
#Modul für den Zugriff auf die GPIO Pins
import machine
#Modul für den Zugriff auf Funktionen
#wie zum einlegen einer Pause im Code
import time
#Wert für die Pause in der Schleife
pause = 0.250
#anlegen einer Variable,
#GPIO17, als Ausgang
led1 = machine.Pin(17, machine.Pin.OUT)
#aktuelle Millisekunden, seitdem das Programm
#gestartet wurde
currentTimestamp = time.ticks_ms()
#die Dauer, wielange die LED blinken soll
duration = 5000
#LED eine Zeit blinken lassen
#Funktion ticks_ms() liefert bei jedem Aufruf,
#die aktuellen Millisekunden, seitdem das Programm
#gestartet wurde.
while (time.ticks_ms() < (currentTimestamp + duration)):
led1.value(1) #aktivieren des Pins
time.sleep(pause) #eine Pause
led1.value(0) #deaktivieren des Pins
time.sleep(pause) #eine Pause
In dem Video lasse ich die LED 2 Sekunden lang blinken, bei einer Pause von jeweils 0,25 Sekunden sind das dann 4x.
LED dauerhaft blinken lassen
Um die LED dauerhaft blinken zu lassen, müssen wir unsere While-Schleife lediglich in eine Endlosschleife umstellen und als Prüfung ein True übergeben.
#Modul für den Zugriff auf die GPIO Pins
import machine
#Modul für den Zugriff auf Funktionen
#wie zum einlegen einer Pause im Code
import time
#Wert für die Pause in der Schleife
pause = 0.250
#anlegen einer Variable,
#GPIO17, als Ausgang
led1 = machine.Pin(17, machine.Pin.OUT)
#aktuelle Millisekunden, seitdem das Programm
#gestartet wurde
currentTimestamp = time.ticks_ms()
#die Dauer, wielange die LED blinken soll
duration = 5000
#starten der Endlosschleife
while True:
led1.value(1) #aktivieren des Pins
time.sleep(pause) #eine Pause
led1.value(0) #deaktivieren des Pins
time.sleep(pause) #eine Pause
Lauflicht programmieren
Wenn wir nun die LEDs nacheinander aktivieren und wieder deaktivieren, dann können wir uns ein kleines Lauflicht erstellen.
Damit wir etwas weniger Schreibarbeit haben und auch der Code nicht zu lang wird, erzeuge ich mir zum setzen eines Status der LED eine zusätzliche Funktion.
#Modul für den Zugriff auf die GPIO Pins
import machine
#Modul für den Zugriff auf Funktionen
#wie zum einlegen einer Pause im Code
import time
#Wert für die Pause in der Schleife
pause = 0.130
#anlegen einer Variable,
#GPIO17, als Ausgang
led1 = machine.Pin(17, machine.Pin.OUT)
led2 = machine.Pin(16, machine.Pin.OUT)
led3 = machine.Pin(27, machine.Pin.OUT)
led4 = machine.Pin(14, machine.Pin.OUT)
#Funktion zum setzen eines Status der LEDs
def ledLightUp(led1Status, led2Status, led3Status, led4Status):
led1.value(led1Status)
led2.value(led2Status)
led3.value(led3Status)
led4.value(led4Status)
time.sleep(pause) #einlegen einer Pause
#starten der Endlosschleife
while True:
#aufrufen der Funktion ledLightUp
#als Parameter wird der neue Status der LED übergben
ledLightUp(1,0,0,0) #rote LED an
ledLightUp(0,0,0,0) #alle LEDs aus
ledLightUp(0,1,0,0) #grüne LED an
ledLightUp(0,0,0,0) #alle LEDs aus
ledLightUp(0,0,1,0) #blaue LED an
ledLightUp(0,0,0,0) #alle LEDs aus
ledLightUp(0,0,0,1) #gelbe LED an
ledLightUp(0,0,0,0) #alle LEDs aus
Taster auslesen
Auf dem kleinen Shield finden wir noch zwei zusätzliche Taster, welche wir im Nachfolgenden nutzen möchten, um die LEDs zu aktivieren und auch verschiedene Programme starten möchten.
TasterESP32 D1 R32Arduino UNO R3K1IO12D8K2IO13D9
Schaltung ohne Rich Shield
Hier die kleine Schaltung auf dem 400 Pin Breadboard.
Auslesen des Status der Taster
Für das Auslesen der Taster benötigen wir nun eine Endlosschleife, denn wenn wir unser Programm ohne starten würden, hätten wir keine Chance eine Tastaktion auszulesen / auszuwerten.
#Modul für den Zugriff auf die GPIO Pins
import machine
#Modul für den Zugriff auf Funktionen
#wie zum einlegen einer Pause im Code
import time
#anlegen der Variablen für die Taster
#Taster K1 am GPIO12
k1 = machine.Pin(12, machine.Pin.IN, machine.Pin.PULL_UP)
#Taster K2 am GPIO13
k2 = machine.Pin(13, machine.Pin.IN, machine.Pin.PULL_UP)
#Starten der Endlosschleife
while True:
#Wenn der Wert von Value gleich 0 / False ist, dann..
if not k1.value():
#Ausgeben der Textzeile auf der Kommandozeile
print("Taster K1 gedrückt!")
#eine kleine Pause einlegen damit der Taster entprellt wird
time.sleep(0.25)
if not k2.value():
print("Taster K2 gedrückt!")
time.sleep(0.25)
Wenn wir einen der Taster betätigen, dann wird auf der Kommandozeile der Text "Taster Kn gedrückt!" ausgegeben. Zusätzlich legen wir danach eine kleine Pause von 0,25 Sekunden ein, diese Pause wird benötigt, um den Taster zu entprellen.
Aktivieren einer LED mit einem Taster
Jetzt können wir mit dem Wissen aus dem Abschnitt der LED und dem kleinen Beispiel zum Taster nun die LEDs steuern.
#Modul für den Zugriff auf die GPIO Pins
import machine
#Modul für den Zugriff auf Funktionen
#wie zum einlegen einer Pause im Code
import time
#anlegen der Variablen für die Taster
#Taster K1 am GPIO12
k1 = machine.Pin(12, machine.Pin.IN, machine.Pin.PULL_UP)
#Taster K2 am GPIO13
k2 = machine.Pin(13, machine.Pin.IN, machine.Pin.PULL_UP)
#LED1 (rot)
led1 = machine.Pin(17, machine.Pin.OUT)
#Starten der Endlosschleife
while True:
#Wenn der Taster K1 betätigt wird, dann
#soll die rote LED1 aktiviert werden.
if not k1.value():
led1.value(1)
time.sleep(0.25)
#Wenn der Taster K1 betätigt wird, dann
#soll die rote LED1 deaktiviert werden.
if not k2.value():
led1.value(0)
time.sleep(0.25)
Wenn wir jetzt den Taster K1 betätigen, dann wird die LED1 (rot) aktiviert und beim Betätigen des Tasters K2 wieder deaktiviert.
Aktivieren und Deaktivieren einer LED mit nur einem Taster (Toggeln)
Wir können aber auch recht einfach mit nur einem Taster die LED aktivieren und auch deaktivieren, dazu prüfen wir den Status des Pins und wenn dieser aktiviert ist, dann deaktivieren wir diesen und umgekehrt.
#Modul für den Zugriff auf die GPIO Pins
import machine
#Modul für den Zugriff auf Funktionen
#wie zum einlegen einer Pause im Code
import time
#anlegen der Variablen für die Taster
#Taster K1 am GPIO12
k1 = machine.Pin(12, machine.Pin.IN, machine.Pin.PULL_UP)
#Taster K2 am GPIO13
k2 = machine.Pin(13, machine.Pin.IN, machine.Pin.PULL_UP)
#LED1 (rot)
led1 = machine.Pin(17, machine.Pin.OUT)
#LED2 (grün)
led2 = machine.Pin(16, machine.Pin.OUT)
#Starten der Endlosschleife
while True:
#Wenn der Taster K1 betätigt wird, dann
#soll die rote LED1 aktiviert werden.
if not k1.value():
#Wenn der aktuelle Status des Pins LOW / 0 ist, dann...
if not led1.value():
#Pin auf HIGH / 1 setzen
led1.value(1)
else: #Wenn der Pin jedoch auf HIGH / 1 ist, dann...
#Pin auf LOW / 0 setzen
led1.value(0)
time.sleep(0.25) #eine kleine Pause von 250 Millisekunden
#Taster K2 kann nun eine weitere LED steuern
if not k2.value():
#Wenn der aktuelle Status des Pins LOW / 0 ist, dann...
if not led2.value():
#Pin auf HIGH / 1 setzen
led2.value(1)
else: #Wenn der Pin jedoch auf HIGH / 1 ist, dann...
#Pin auf LOW / 0 setzen
led2.value(0)
time.sleep(0.25) #eine kleine Pause von 250 Millisekunden
Wir können nun mit den beiden Tastern die beiden roten und grünen LEDs steuern.
Fazit & Ausblick
Damit möchte ich diesen kleinen Beitrag schließen, im nächsten Beitrag möchte ich zeigen wie du den analogen Drehpotentiometer auslesen und die Werte auf die LEDs mappen kannst.
Read the full article
0 notes
MicroPython mit ESP32: Grundlagen der Programmierung
In diesem Beitrag möchte ich dir die Grundlagen zur Programmierung in MicroPython anhand des ESP32 D1 R32 näher bringen. Du kannst dieses jedoch auch sehr einfach auf andere Mikrocontroller anwenden, welche ebenso mit MicroPython arbeiten.
https://youtu.be/ua_qigAk6s0
Im letzten Beitrag MicroPython mit ESP32: Einführung in den ESP32 D1 R32 habe ich dir bereits den Mikrocontroller ESP32 D1 R32 vorgestellt und aufgezeigt wie dieser für MicroPython geflasht wird.
MicroPython vs. Python
MicroPython ist eine vollständige Implementierung der Programmiersprache Python 3, die direkt auf eingebetteter Hardware wie dem ESP32 D1 R32 oder dem Raspberry Pi Pico läuft. Während beide Sprachen auf der gleichen Grundlage basieren, gibt es einige wesentliche Unterschiede und Anpassungen, die MicroPython besonders für den Einsatz in Mikrocontrollern geeignet machen:
- Interaktive Eingabeaufforderung (REPL): MicroPython bietet eine interaktive Eingabeaufforderung (REPL - Read-Eval-Print Loop), die es ermöglicht, Befehle sofort über USB-Serial auszuführen. Dies ist besonders nützlich für schnelles Testen und Debuggen von Code auf der Hardware.
- Eingebautes Dateisystem: MicroPython beinhaltet ein eingebautes Dateisystem, das auf dem Flash-Speicher des Mikrocontrollers gespeichert wird. Dies ermöglicht das Speichern und Verwalten von Skripten und Daten direkt auf dem Gerät.
- Modulspezifischer Zugriff auf Hardware: Der ESP32-Port von MicroPython umfasst spezielle Module, die den Zugriff auf hardware-spezifische Funktionen des Chips ermöglichen. Dazu gehören beispielsweise GPIO-Steuerung, PWM, I2C, SPI und andere Peripheriegeräte.
- Ressourceneffizienz: MicroPython ist so konzipiert, dass es auf ressourcenbeschränkten Geräten läuft. Es verwendet weniger Speicher und Rechenleistung im Vergleich zu einer vollständigen Python-Implementierung auf einem Desktop-Computer.
- Bibliotheken und Module: MicroPython enthält eine Auswahl an Standardbibliotheken und modulspezifischen Bibliotheken, die für die Entwicklung von Embedded-Anwendungen nützlich sind. Während einige Bibliotheken aus der Standard-Python-Bibliothek fehlen, gibt es spezielle Bibliotheken, die für die Arbeit mit Mikrocontrollern optimiert sind.
Diese Unterschiede machen MicroPython zu einer idealen Wahl für die Programmierung von Mikrocontrollern wie dem ESP32 D1 R32, da es die Leistungsfähigkeit und Einfachheit von Python mit der Effizienz und Funktionalität für Embedded-Systeme kombiniert.
Aufbau des Quellcodes in MicroPython
In MicroPython gibt es keine Klammern für das Zusammenfassen von Codeblöcken, du musst hier mit Einrückungen arbeiten. Du kannst hier wählen zwischen Leerschritte und Tabulatoren. Jedoch wenn du dich einmal auf eine Art festgelegt hast, dann musst du diese weiterverwenden!
Solltest du also nachfolgende Fehlermeldung erhalten, so prüfe zuerst die Anzahl der Leerschritte / Tabs vor deinen Codeblöcken.
Traceback (most recent call last):
File "", line 1
IndentationError: unexpected indent
Kommentare
Mit Kommentaren kannst du Text in deinen Quellcode einfügen, welcher keinen Einfluss auf das Verhalten des Codes hat. Kommentare werden meist verwendet, um komplizierten Code zu beschreiben oder für andere Entwickler einen leichteren Einstieg in den Quellcode zu schaffen.
Auch kannst du Code auskommentieren, um die Funktion / den Codeblock zu überspringen.
Du kannst einzelne Zeilen mit einem "#" Symbol auskommentieren und wenn du einen mehrzeiligen Kommentar erstellen möchtest, dann leitest du diesen mit drei doppelte Anführungszeichen ein und beendest dieses auch damit.
# Hier steht ein einzeiliger Kommentar
"""
Hier können
mehrere Zeilen
gleichzeig auskommentiert werden
"""
Wenn du eine Entwicklungsumgebung verwendest, dann werden Kommentare immer speziell angezeigt, sodass diese sich vom eigentlichen Quellcode abheben.
MicroPython - Kommentare
Du kannst auch hinter dem Quellcode Kommentare setzen und so platzsparend Informationen hinterlassen.
MicroPython - Kommentar und Code in einer Zeile
Ausgaben auf der Kommandozeile
Zur Fehlersuche und für die Ausgabe von Sensordaten können wir den einfachen aber trotzdem mächtigen Befehl "print" nutzen.
Diesem Befehl können wir einfach einen Text übergeben, welcher dann auf der Kommandozeile ausgegeben wird.
print("Hallo Welt!")
print("Test")
In der Kommandozeile siehst du die Ausgabe der beiden Texte, welche jeweils durch einen Zeilenumbruch getrennt sind.
MicroPython - Befehl print
Du kannst diesem Befehl jedoch auch mehrere Werte übergeben, dazu trennst du diese mit einem Komma.
print("Hallo Welt!", "Test")
Die Werte werden mit einem Komma getrennt und auf der Kommandozeile hintereinander (getrennt durch ein Leerzeichen) ausgegeben.
MicroPython - Befehl "print", mehrere Werte
Wenn du statt einem Leerzeichen ein anderes verwenden möchtest, dann kannst du diesen Separator mithilfe des optionalen Parameters "sep=" benennen.
print("Hallo Welt!", "Test", sep="|")
In diesem Fall verwende ich zum Trennen der Werte einen geraden Strich. Du kannst auch beliebig andere Symbole, Buchstaben oder Zahlen verwenden.
Erzeugen von Variablen
In MicroPython bzw. Python gibt es keine Datentypen. Das heißt für uns, wir legen neue Variablen an, indem wir einfach einen Namen für unsere neue Variable schreiben, gefolgt von einem Wert.
Dabei kannst du diesen Wert auch jederzeit mit einem anderen Wert / Datentyp beliebig überschreiben.
MicroPython - Variablen
Du kannst mit den bereits bekannten mathematischen Operatoren Zahlen Addieren, Subtrahieren usw. und natürlich mit dem Befehl print diesen Wert ausgeben.
Verketten von Texten
Wenn du Texte verketten / verbinden möchtest, dann verwendest du das + Symbol. Das funktioniert für Texte sehr einfach.
text1 = "Text1"
text2 = "Text2"
print(text1+text2)
Die beiden Texte werden einfach zusammengefügt und auf der Kommandozeile ausgegeben.
Wenn wir jedoch einen Text und eine Zahl verbinden möchten, dann können wir dieses nicht so einfach machen.
text1 = "Text1"
zahl1 = 2
print(text1+zahl1)
Der Code erzeugt die nebenstehende Fehlermeldung. Diese besagt, dass String & Int nicht mit der Funktion add zusammengefügt werden können.
Traceback (most recent call last):
File "", line 3, in
TypeError: unsupported types for add: 'str', 'int'
Wir müssen also zunächst die Zahl in einen String umwandeln. Um die Zahl 1 umzuwandeln, können wir nun einfach jeweils ein doppeltes Anführungszeichen am Anfang und Ende hinzufügen, oder wir nutzen die Funktion "str".
text1 = "Text1"
zahl1 = 2
print(text1+str(zahl1))
Die Funktion str erwartet einen Zahlenwert (Ganzzahl oder Gleitkommazahl) und wandelt diese in einen Text um und gibt diesen zurück.
Das kannst du zum Beispiel verwenden, wenn du einen Sensorwert auf einem Display mit dem zugehörigen Symbol dahinter anzeigen möchtest.
Schleifen
Wenn du Codeblöcke in einer bestimmten Anzahl wiederholen möchtest, oder dauerhaft wiederholen möchtest, dann benötigst du eine Schleife.
For-Schleifen
Um einen Block 5-mal zu wiederholen, können wir eine For-Schleife verwenden.
for i in range(5):
print("i ist:", i)
Du kannst den Index i innerhalb der For-Schleife verwenden und auf diesen reagieren.
Die Funktion range liefert dir eine Liste von Zahlen, von 0 bis 4 (insgesamt 5). Wenn du die Zahlenfolge 1 bis 6 möchtest, kannst du dieser Funktion wie folgt anpassen.
for i in range(1, 6):
print("i ist:", i)
While-Schleife
Eine While-Schleife wird verwendet, um einen Ausdruck zu prüfen, um diese innerhalb der Schleife abzubrechen.
zahl = 5
while(zahl > 0):
print(zahl)
zahl -=1
Innerhalb der While-Schleife wird die Variable zahl um 1 verringert und im Kopf der Schleife wird geprüft, ob dieser Wert größer 0 ist. Sobald der Wert der Variable zahl den Wert 0 erreicht, wird die Schleife abgebrochen.
Endlosschleife
Mit der While-Schleife kannst du eine Endlosschleife starten, dazu übergibst du dieser lediglich ein True.
while True:
print("Hallo Welt!")
Dieser kleine Code bewirkt nun, dass auf der Kommandozeile der Text "Hallo Welt!" fortlaufend ausgegeben wird.
Abbrechen einer Schleife
Wenn du innerhalb der Schleife diese abbrechen möchtest, dann verwendest du den Befehl break. Mit diesem Aufruf wird dann sofort die Schleife verlassen und der nachfolgende Code ausgeführt (soweit vorhanden).
while True:
print("Hallo Welt!")
break
In diesem Beispiel startet die Endlosschleife, gibt den Text "Hallo Welt!" aus und sofort danach wird diese abgebrochen.
Natürlich ergibt dieser Code wenig Sinn, jedoch mit einem später vorgestellten If-Statement wird etwas mehr Funktion geschaffen.
Überspringen einer Ausführung innerhalb einer Schleife
Wenn du die Schleife nicht abbrechen möchtest, sondern nur die Ausführung der Schleife überspringen möchtest, dann verwendest du den Befehl continue. Damit wird wieder zum Kopf gesprungen und von vorne gestartet.
for i in range(1,6):
if i == 2:
continue
print(i)
In der Ausgabe siehst du das die Zahl 2 übersprungen wurde, das liegt daran das wir im Code prüfen ob der aktuelle Index gleich 2 ist und wenn dieses so ist, soll die Ausführung an dieser Stelle abgebrochen werden.
Anders als bei break wird die Schleife jedoch fortgeführt.
If-Statements
Mit If-Statements kannst du innerhalb deines Quellcodes bedingten Code erzeugen. Du prüfst innerhalb des Statements einen Ausdruck welcher einen Wahrheitswert hat True/False 1/0.
test = True
if test:
print("Der Wert von test ist Wahr!")
Man muss bei boolschen Werten nicht unbedingt mit einem doppelten Gleichheitszeichen prüfen, hier reicht es aus den Wert hineinzuschreiben.
if test == True:
#oder
if test:
Genaus kann man auch prüfen ob ein Wert Falsch ist.
if test == False:
#oder
if !test:
Zahlenwerte kannst du mit den nachfolgenden Symbolen prüfen:
- prüfen ob ein Wert größer ist >
- prüfen ob ein Wert größer gleich ist >=
- prüfen ob ein Wert kleiner ist <
- prüfen ob ein Wert kleiner gleich ist
- prüfen ob ein Wert ungleich ist !=
- prüfen ob ein Wert gleich ist ==
0:
print("Der Wert von test ist größer 0")
else:
print("Der Wert von test ist kleiner 1")
Im rechten Beispiel wird die Variable test geprüft ob die größer 0 ist. Wenn dieses nicht so ist (also der Wert ist kleiner 1) dann wird der Text "Der Wert von test ist kleiner 1" ausgegeben.
weitere Prüfungen mit elif
Wenn du weitere Prüfungen hinzufügen möchtest dann kannst du dieses mit elif machen, jedoch musst du bedenken das wenn einmal ein Statement zu einer Ausführung geführt hat die anderen Prüfungen nicht ausgeführt / geprüft werden!
test = 17
if test > 0 and test < 10:
print("Der Wert von test ist zwischen 1 und 9.")
elif test >= 10 and test < 20:
print("Der Wert von test ist zwischen 10 und 19.")
elif test >= 20:
print("Der Wert von test ist größer gleich 20.")
In diesem Beispiel wird geprüft ob sich der Wert der Variable test zwischen bestimmten Werten befindet oder größer gleich 20 ist.
Ausblick
Mit diesem Beitrag habe ich dir nun einen Überblick über die Programmiersprache MicroPython anhand von Beispielen gegeben. Jedoch ist dieses nur der "normale" Funktionsumfang, bei Mikrocontroller wird es schon etwas spezieller denn hier können wir Schnittstellen, GPIO Pins etc. ansteuern und somit Sensoren / Aktoren bedienen.
Wie du die GPIOs ansteuern kannst zeige ich dir im nächsten Beitrag anhand von einfachen LEDs, Taster usw.
Read the full article
0 notes