#esp32d1r32

[draegerit]

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

[draegerit]

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

[draegerit]

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

[draegerit]

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

[draegerit]

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