MSXFAQ MeetNow aktiv: Komm doch einfach dazu.

MicroPython/CircuitPython

Die Entwicklung mit Arduino Studio, Visual Studio Code  ist gängige Praxis. Für einfache Aufgaben oder Schulungszwecke kann es aber auch durchaus interessant sein, den Mikroprozessor mit einem Interpreter auszustatten und einfach per Terminal zu steuern. Genau das verbirgt sich hinter MicroPython und funktioniert auch mit dem ESP8266 und ESP32. Ein ähnlicher Ansatz verfolgt LUA (NodeMCU / LUA).

Hinweis: MicroPython funktioniert auch wunderbar mit ESP8266 und ESP32 und Raspberry Pi Pico

Warum Python?

Kleinprozessoren wie Arduino, ESP8266 etc. werden meist in einer sehr hardwarenahen Sprache wie C programmiert. Die Entwickler schreiben dazu Code, kompilieren diesen, flashen diesen auf das Board und starten den Code und warten auf den ersten Fehler. Das kostet viel Zeit und Erfolge sind mühsam. Mit Python auf so einen Board kann man interaktiv auf dem Board direkt die Zeilen eingeben und ausführen. Gerade für Einsteiger werden Fehler direkt erkannt und lösbar.

Zudem wird Python auch gerne als "Schweizer Messer" für Automatisierung, Datenauswertung u.a. bezeichnet.

MicroPython und pyboard

Die erste Umsetzung von Python auf einem Mikroprozessor erfolgte auf den eigens dafür gebauten pyboards, von denen es Mitte 2019 zwei Serien mit je drei Varianten gibt und auf https://store.micropython.org/ vorgestellt werden:

  • pyboard D-Serie
    Das kleinere kompakte Modell mit WLAN und BT
  • pyboard Serie
    Die Vorgängerversion ohne WLAN/BT und ca. 30€

Natürlich gibt es für die Boards auch entsprechende Gehäuse und weitere Sensoren, die aufgesteckt werden können. Es gibt auch günstigere Nachbauten im Internet, die aber immer noch über den bekannten ESP32 und ESP8266:Boards sind.

ESP32/ESP8266 und MicroPython

Interessant ist die MicroPython-Firmware aber dennoch, denn es gibt sie auch mittlerweile für den ESP8266 und den ESP32. Diese Plattform ist natürlich schon allein vom Preis her deutlich interessanter, da es die entsprechenden Module für unter 10€ und in vielen Varianten gibt.

MicroPython für ESP8266/ESP32 u.a.
https://micropython.org/download/all/

Lobo MicroPython for ESP32
https://GitHub.com/loboris/MicroPython_ESP32_psRAM_LoBo

Precompiled Micropython ESPNow Images for the ESP32 and ESP8266
https://GitHub.com/glenn20/micropython-espnow-images

Anders als bei Arduino, bei der ein lokal geschriebener Code kompiliert und dann auf den ESP übertragen wird, müssen wir die vorgefertigte Firmware  auf das Modul übertragen.

Wenn Sie den ESP8266 per USB anschließen, müssen Sie natürlich erst einmal den COM-Port ermitteln Ich nutze dazu meist folgende PowerShell

[System.IO.Ports.SerialPort]::getportnames()

Ohne PowerShell geht es auch in einer CMD-Shell

change port /query

Den Port brauche ich später immer wieder.

Ich zeige hier den Upload der MicroPython-Firmware mit dem esptool. Wenn Sie eine Entwicklungsumgebung wie Thonny oder PyCraft nutzen, dann können sie auch dort die Firmware einfach installieren und diesen Teil überspringen. Hier am Beispiel von Thonny:

REM Installation es ESPTOOL auf Windows 
pip install esptool 

REM Wechsel in das Verzeichnis
cd C:\\AppData\Roaming\Python\Python39\site-packages\

REM Flash leeren
esptool.py --port com3 erase_flash

RAM Aktuelle Firmware auf den ESP8266 flashen
esptool.py --port com3 --baud 460800 write_flash --flash_size=detect 0 esp8266-20210202-v1.14.bin

REM Oder fuer den ESP32 / M5Lite / M5ATOM
esptool.py --port com3 --chip esp32 write_flash -z 0x1000 esp32-20180511-v1.9.4.bin

Der Bildschirm gibt dann den Flash-Vorgang aus und startetet den ESP8266. Den Erfolg sehen sie auf ihrem Computer, wenn Sie ein WLAN finden, welches dem Namen "MicroPython-xxxxxx" hat und sie sich mit dem Kennwort "micropythoN" verbinden können. "xxxxxx" sind die letzten 3 Bytes der MAC-Adresse des ESP und er hat die IP-Adresse 192.168.4.1. Ihr Client bekommt dann eine IP-Adresse zugewiesen.

Wichtiger ist aber erst einmal der Zugriff über die serielle Schnittstelle, die das Board auch mit Strom versorgt. Ein einfacher Putty reicht, wenn Sie bei der Verbindung auf "Serial" gehen und den richtigen seriellen Port mit Baudrate angeben

Viel mehr als das "schwarze Fenster" zur interaktiven Eingabe von Python-Code sehen sie hier aber nicht:

Danach brauche ich eigentlich nur noch ein Terminal. zum COM-Port denn die Entwicklung erfolgt direkt auf dem ESP über das Termin oder eine kleine GUI wie z.B. Thonny.

Raspberry Pi und Python

Die Raspberry Pi Foundation hat mit dem Raspberry Pico W ebenfalls sehr günstige (6-7€) Boards am Start, die mit MicroPython betrieben werden können. Neben den klassischen Kleinstprozessoren der ESP8266/ESP32/Atmel-Klasse gibt es natürlich noch die Gerät der ARM/RasPi-Klasse, auf denen normalerweise ein Linux für ARM läuft. Natürlich gibt es auch Python für Linux aber das hat mit MicroPython/CircuitPython weniger zu tun. Natürlich kann ich auch mit dem klassischen Python die GPIOs des Raspi ansteuern:

Der Nachteil/Vorteil all dieser Lösungen ist aber das Linux darunter, welches vielleicht etwas mehr Rechenleistung braucht aber vor allem auch aktuell gehalten werden muss, damit es keine Einfallstore bietet. Adafruit hat nun aber Circuitpython als natives System für Raspberry bereitgestellt.

Raspberry Pi Pico und MicroPython

Mit dem Pico geht es sogar noch eine Stufe kleiner und billiger (4-6€) als beim vollen RasPi mit Linux. Das macht den Dauerbetrieb einfacher, da kein "großes" Betriebssystem aktuell zu halten ist.

Programmieren

Sobald die MicroPython-Firmware auf dem Modul ist, können Sie interaktiv über den seriellen Port oder per HTTP über WebREPL (https://GitHub.com/micropython/webrepl) kommunizieren. Wenn Sie MicroPython installiert haben, dann ist der kleine Prozessor auch ein WLAN-AccessPoint und sie können auch ohne seriellen Port z.B. mit einem Smartphone oder Tablet Kontakt aufnehmen. Auf Dauer werden Sie aber nicht per seriellem Terminal" arbeiten, sondern eine IDE nutzen.

IDE Beschreibung und Links

Thonny

Introducing Thonny
https://www.youtube.com/watch?v=nwIgxrXP-X4

uPyCraft

Der Editor kann auch direkt eine Firmware auf das Board laden.

VSCode

Auch für die kostenfreie VisualStudio Code-Umgebung von Microsoft gibt es Anleitungen in Verbindung mit dem Pymakr-Addon

Intro to Programming with MicroPython for ESP8266 Boards [Tutorial]
https://www.youtube.com/watch?v=j0hgKkwmSlw

Wenn ich MicroPython mit Arduino vergleiche, dann ist es faszinierend, wie einfach Dinge umzusetzen sind, zumindest wenn es in MicroPython die passenden Module schon gibt. Das sollten Sie natürlich vorher genau prüfen. Taster, SPI, I2C, Neopixel und Servos per PWM sind an Bord. LCD-Displays etc. sind aber kniffliger.

boot.py und main.py

Ihren Code legen Sie als "Datei" auf dem Mikrocontroller ab und starten diesen über ihren Editor. Wenn Sie Programme automatische beim Einschalten wollen, können Sie eine Datei boot.py oder main.py anlegen. Die beiden Dateien haben eine besondere Funktion und sind quasi wie eine "autoexec.bat" zu DOS-Zeiten oder "Autostart-Ordner" unter Windows.

Achtung:
Der Code wird direkt nach dem Einschalten gestartet. Das Problem dabei ist aber, dass Sie dann den Pico eventuell nicht mehr programmieren können, da er sich gar nicht mehr ansprechen lässt.

Für die serielle Kommunikation muss die MicroPython REPL-Funktion von MicroPython gestartet werden und das gelingt nicht, wenn boot.py bzw. main.py sofort starten und dauerhaft aktiv sind.
Wenn Sie einen Code direkt beim Start laden, dann sollten sie die boot.py nicht nutzen und in der main.py eine "Sicherung" einbauen. Das kann ein "sleep(2)" sein, so dass Sie in den ersten 2 Sekunden den Start mit CTRL-C/CTRL-D unterbrechen können oder sie fragen den Status eines Pin ab und starten aus der main.py das eigentliche Programm nur, wenn der Pin gesteckt ist.

Es gibt eine eigene Firmware, um die "main.py" umzubenennen.

MicroPython_RenameMainDotPy.uf2
https://diyprojectslab.com/how-to-delete-main-py-in-raspberry-pi-pico/

Damit können Sie danach wieder MicroPython installieren und wieder an ihren Code kommen. Die funktioniert nicht, wenn Sie eine boot.py angelegt haben. Dann hilft nur noch ein Rücksetzen auf Werkseinstellungen. (Siehe nächstes Kapitel)

Raspberry Pico komplett zurücksetzen

Ein neu Flashen mit MicroPython löscht nicht das Dateisystem mit ihrem Code. Es gibt aber eine "flash_nuke.uf2"-Firmware, die genau das macht.

flash_nuke.uf2
https://datasheets.raspberrypi.com/soft/flash_nuke.uf2

Der Prozess erfolgt dann wie folgt

  1. Raspberry Pico mit gedrückter BOOTSEL-Taste an den PC anschließen
    Sie sollten den Pico wieder als Massenspeicher sehen
  2. kopieren die flash_nuke.uf2-Datei auf den Stick.
    Der Pico bootet alleine und das Laufwerk verschwindet. Nach einigen Sekunden können Sie den Pico abstecken.
  3. Raspberry Pico erneut mit gedrückter BOOTSEL-Taste an den PC anschließen
    Nun haben wieder das Laufwerk
  4. Gewünschte MicroPython.uf2-Datei auf den Pico kopieren.
    Der Pico startet erneut durch
  5. Pico abstecken und anschließen
    Nun sollten sie einen leeren PICO vorliegen haben.

Es gibt auch andere Firmware

 

Sicherheit = AP Off

Die MicroPython-Firmware konfiguriert das WLAN eines ESP8266/ESP32 automatische als AccessPoint. Sie finden daher sehr schnell einen "MicroPython_xxxxxx"-AccessPoint mit dem Standardkennwort "micropythoN". Das ist gut, wenn Sie über die WebREPL-Schnittstelle "drahtlos" programmieren wollen. Wenn Sie aber klassische per serieller Schnittstelle arbeiten und erst recht später im produktivbetrieb wollen Sie diese Hintertür nicht offen stehen lassen. Sonst könnte jede Person in der Nähe sich ebenfalls verbinden und nicht nur den Code auslesen sondern auch verändern oder ersetzen. Ich habe daher zur Sicherheit bei all meinen Projekten am Anfang folgende Zeilen addieren

print('Disabled WLAN AP-Mode')
import network  # WLAN Support
wlan = network.WLAN(network.AP_IF)     # get AP-Node
wlan.active(False)                     # disable AP-WLAN

Damit schalte ich nur die Funktion "AccessPoint" aus.

Device-Test

Zuerst habe ich mir ein ESP8266 geschnappt und die Basisfunktionen ausprobiert. Quasi das "Hello World" für Mikroprozessoren. In meinem Fall war es ein "Witty Cloud Modul", welches im Grunde ein ESP8266 mit untergeschnalltem USB2Serial-Adapter ist und einen Taster an GPIO4 und eine RBG-LED an GPIO 12/13/15 hat. Der Helligkeitssensor ist am analog-Port angeschlossen.

Zusätzlich habe ich an GPIO5 einen kleinen Servo angeschlossen und damit Ports erst einmal definiert und getestet.

# ESP8266 Witty Cloud Modul  https://www.schatenseite.de/2016/04/22/esp8266-witty-cloud-modul/
#from machine import Pin, ADC, PWM
ledg     = machine.Pin(12, machine.Pin.OUT)
ledb     = machine.Pin(13, machine.Pin.OUT)
ledr     = machine.Pin(15, machine.Pin.OUT)   # Setzen mit ledr.on() und ledr.off()
tast     = machine.Pin(4, machine.Pin.IN)     # Auslesen mit tast.value()   0 = gerueckt
ldr      = machine.ADC(0)                     # Auslesen mit ldr.read()
servopin = machine.Pin(5)                          # GPIO5,14,16 
sind auch verfuegbar auf dem witty cloud modul
servo    = machine.PWM(servopin,freq=50)  # Servo mit
servo.duty(100)   # Bei meinem Servo nutzbare werte sind zwischen 30 - 134

Das hat alles schon mal auf Anhieb geklappt.

WLAN-Test

Gerade mit IoT will man seine Geräte gerne im WLAN haben. Folgender Code versetzt den Controller erst einmal in einen WLAN-Client, der dann nach Netzwerken sucht und diese ausgibt. Danach versucht er sich mit dem angegebenen WLAN zu verbinden. Da die ESP-Chips einen eigenen WLAN-Controller, der sich selbst initialisieren muss, sollten wir immer etwas Zeit vergehen lassen.

import machine
import network
import time

WLANSSID="HierSSIDrein"
WLANPASS="UnddasKennwort"

print("Disable AccessPoint Mode")
wlan = network.WLAN(network.AP_IF)     # get AP-Node
wlan.active(False)     
time.sleep(1)  # etwas warten
print("Interface Status:", wlan.status())
print("Enable Station mode")
wlan = network.WLAN(network.STA_IF)
wlan.active(True)                      # activate WLAN
time.sleep(2)  # etwas warten
print("Interface Status:", wlan.status())
print("Erzwinge aktiven Verbindungsversuch")
wlan.disconnect()
time.sleep(2)  # etwas warten
print("Start WLAN Scan")
networks = wlan.scan()

# Nach Signalstärke (RSSI, Index 3) sortieren
networks.sort(key=lambda x: x[3], reverse=True)

print(f"{'SSID':<30} | {'Kanal':<5} | {'RSSI (dBm)':<10} | {'Sicherheit':<10}")
print("-" * 65)

# Jedes gefundene Netzwerk ausgeben
for net in networks:
    ssid = net[0].decode('utf-8') if isinstance(net[0], bytes) else net[0]
    bssid = net[1]
    channel = net[2]
    rssi = net[3]
    security = net[4]
    hidden = net[5]
    
    # Platzhalter für leere SSIDs (versteckte Netzwerke)
    if not ssid:
        ssid = "<Versteckt>"
    print(f"{ssid:<30} | {channel:<5} | {rssi:<10} | {security:<10}")
    
print("-" * 65)


print("Verbindung mit WLAN ",WLANSSID,"herstellen...")
wlan.connect(WLANSSID,WLANPASS)
print("Waiting for WLAN", end="")
if not wlan.isconnected():
    print("-Connected")
while wlan.ifconfig()[0] == ("0.0.0.0"):
    print(".", end="")
    time.sleep_ms(500)
print("Connected")
print('WLAN:', wlan.ifconfig())

ESP mit >4MB Flash

Es kann passieren, dass Sie einen ESP8266 mit 8MB oder 16 MB Flash mit MicroPython flashen und danach nur wirre Zeichen in der seriellen Konsole erscheinen und die LED panisch blinkt. Wenn Sie dann ein serielles Terminal mit 78400 Baud anschließen, dann sehen Sie folgende Fehler:

 ets Jan  8 2013,rst cause:2, boot mode:(3,7)

load 0x40100000, len 31212, room 16
tail 12
chksum 0xf4
ho 0 tail 12 room 4
load 0x3ffe8000, len 1060, room 12
tail 8
chksum 0x00
load 0x3ffe8430, len 1124, room 0
tail 4
chksum 0x4b
csum 0x4b
rf_cal[0] !=0x05,is 0xFF

Die Zeile "rst cause:2" bedeutet Reset durch den Reset-Pin der wohl immer wieder passiert aber interessante ist die letzte Zeile "rf_cal[0] !=0x05,is 0xFF", welche auf ein Problem mit  den ESP8266-RF-Kalibrierungsdaten im Flash hinweist. Mit den Informationen finden wir dann auch eine Seite bei MicroPython zum Thema:

Anscheinend überschreibt der MicroPython-Flasher auch den Bereich, in dem ein ESP8266 seine WLAN-Kalibrierung ablegt und enthält keinen Code das beim Start ggfls. auf Standardwerte zurückzusetzen. Ursache ist aber einfach die Größe des Flash. Ich habe das derart gelöst, dass ich beim Flasher die Größe des Flash auslesen lasse und nicht plump die Größe der Firmware nutzen:

Danach waren auch diese ESP8266 unter MicroPython nutzbar

 

Tee-Hase

Vielleicht haben Sie das Projekt in der c't gesehen, bei der ein Servo einen Tee-Beutel aus der Tasse zieht, wenn eine gewisse Zeit abgelaufen ist. Die Lösung wurde klassisch mit einem Arduino mit C++ entwickelt. Eine vergleichbare Lösung habe ich als Beispielprojekt mit MicroPython umsetzen wollen.

Meine erste Überlegung war nun eine klassische Programmierung mit einer Endlosschleife, die den Taster ausliest, die Zeit überwacht und den Servo steuert. Klingt einfach aber wenn ich die Tastendrücke erfassen will, muss ich sehr oft die Messung machen. MicroPython und ESP8266 unterstützen aber Interrupts nach Zeiten als auch GPIO-Pins. Daher habe ich den Code so angelegt, dass ein Interrupt beim Drücken des "Buttons" eine Funktion zum Hochzählen bzw. Reset der Laufzeit in Sekunden ausführt.

# Teeodor simple
from machine import Pin, ADC, PWM, Timer
import time

print('Program started')

print('Init LED, Button, ldr')
ledg     = Pin(12, machine.Pin.OUT)
ledb     = Pin(13, machine.Pin.OUT)
ledr     = Pin(15, machine.Pin.OUT)        # Setzen mit ledr.on() und ledr.off()
btn1     = Pin(4,  machine.Pin.IN)         # Auslesen mit btn1.value()   0 = gerueckt

print('Global Variables')
teesekunden=0       # speichert Zeit zum Ziehen des Tees
servoup=100         # Position des Servo im Ruhezustand
servodown=40        # Position des Servo beim Ziehen
servodelayms=100    # bremse beim heben/senken des Servo

print('Init Servo')

servo    = PWM(Pin(5),freq=50)  # Servo an GPIO5. GPIO5,14,16 sind auch verfuegbar auf dem witty cloud modul
servo.duty(servoup)             # Initialisierung auf Ruhezustand

def handlebutton(btn1):
    global teesekunden
    print("ButtonDown")
    ledb.on()
    time.sleep_ms(500)
    teesekunden+=60
    print("teesekunden",teesekunden)
    ledb.off()
    if btn1.value() == 0:
        print("LongPress")
        teesekunden = 0
        print("teesekunden reset",teesekunden)
        ledg.off()
        for _ in range (1,5):
            ledb.on()
            time.sleep_ms(200)
            ledb.off()
            time.sleep_ms(200)

print("Aktiviere Interrupt fuer Button")
btn1.irq(trigger=Pin.IRQ_FALLING, handler=handlebutton)

# Hauptprogramm
while True:
    print("Teesekunden:",teesekunden)
    teesekunden-=1
    ledr.on()
    time.sleep_ms(100) 
    ledr.off()
    if (teesekunden <= 0):
        print("tee raus")
        servo.duty(servoup)
        teesekunden=0
        ledg.off()
    else: 
        print("tee rein")
        servo.duty(servodown)
        ledg.on()
    time.sleep_ms (1000)    

print('Program ended')

Die Endlosschleife prüft dann einfach immer die Restlaufzeit und lässt die rote LED als Zeichen der Aktivität blinken. Die grüne LED leuchtet, wenn der Teebeutel in der Tasse ist. Denkbar wäre auch eine Version, bei der die Endlosschleife auch eine Interrupt-Funktion ist, die ein Timer jede Sekunde aufruft oder ein Timer, der genau am Ende der Laufzeit den Sensor rausholt.

Eine Weiterentwicklung wäre dann eine NeoPixel-Anzeige der Restlaufzeit oder eine Summer als Hinweise am Ende.

Analoge Uhr mit 60 Neopixel-LEDs

Siehe dazu die eigene Seite MicroPython Uhr

Interrupt mit MicroPython

Die Nutzung von Interrupt ist eine sehr leistungsfähige aber auch tückische Möglichkeit, bestimmte Herausforderungen beim Codieren pfiffig zu lösen. Aber dabei sollte man schon auf Details achten, z.B. habe ich gelernt:

  • Nur ein Interrupt gleichzeitig ausgeführt
    Wenn ein Interrupt passiert, führt MicroPython den aktuellen Mikro-Befehl noch aus, sichert dann Variablen und Stack um dann die Funktion auszuführen. Weitere Interrupts finden dann nicht statt. Sie sollten also die eigentlich Funktion "kurz" halten und nur zur Verarbeitung des Events nutzen.
  • Weitere Interrupts werden gequeued
    Ich habe zum Test den Event zur "Tastaturverarbeitung" mit "sleep" angehalten. Weitere Interrupts wurden "gemerkt" und und im Anschluss ausgeführt. Vorsicht, wenn Sie den Status der Taste im Interrupt abfragen, um z.B. die "Drückdauer" zu ermitteln. Es könnte schon der nächste Druck sein. Sie sehen dann keine Zwischenschritte.
  • Variablen-Scope
    MicroPython unterscheidet globale und lokale Variablen. Eine per Interrupt aufgerufene Funktion kann auf globale Objekte lesend zugreifen. Wenn Sie aber z.B. den Wert einer globalen Variable ändern wollen, muss diese am Anfang mit dem Codewort "global" freigegeben werden. Ein Zugriff auf GPIO-Ports o.a. geht aber ohne vorheriges "Global"

Ich habe mir angewöhnt, die Funktion meines Codes immer erst in einem eigenen Programm zu testen.

Wenn Sie zu viele Interrupts haben und durch die Bildschirmausgabe nicht mehr an die "Konsole" kommen, dann helfen Soft-Resets mittels "CTRL-D", um das MicroPython-Board ohne Interrupts zu starten.

M5Stack

Basteleien mit dem ESP32 gelingen auch mit den Geräten von M5Stack sehr elegant. Sie sind kompakt, haben ein Gehäuse und einen Groove/I2C-Connector und preislich attraktiv. Allerdings sind die Pin-Belegungen schon etwas anders. Ich habe daher den kleinsten und billigsten M5Lite einmal mit uPyCraft mit MicroPython bespielt: Das geht direkt aus der GUI

Auf der Seite hhttps://micropython.org/download/esp32/ wird aber ein anderer Weg beschrieben. Für Windows musste ich die Port-Angabe anpassen und die Baudrate etwas senken.

esptool.py --chip esp32 --port COM6 erase_flash
esptool.py --chip esp32 --port COM6  --baud 115200 write_flash -z 0x1000  esp32-20210902-v1.17.bin

Für die ESP32-Devices gibt es eine Firmware ohne und mit SPIRAM. Einige Boards haben zusätzliches RAM, welches aber langsamer angebunden ist. Die Version mit SPI macht also nur dann Sinn, wenn sie mehr RAM für Variablen brauchen, als im ESP32 drin verbaut ist.

Folgende Zeilen haben dann einfach mal die LED mit jedem Tastendruck durchgeschaltet:

print("M5Lite Test")

import machine
import esp      # esp8266 function
import time
from neopixel import NeoPixel

print("Definiere LED und Taster")
led = NeoPixel(machine.Pin(27), 1)
taster = machine.Pin(39, machine.Pin.IN, machine.Pin.PULL_UP)

count = 0
while 1:
    while taster.value() == 1:
        print(".", end='')
        time.sleep_ms(500)
    count+=1

    if count > 3:
        count = 0
    if count == 0:
        led[0]=[0,0,0]
    if count == 1:
        led[0]=[100,0,0]
    if count == 2:
        led[0]=[0,100,0]
    if count == 3:
        led[0]=[0,0,100]
    led.write()

Einschätzung

Ich bin positiv überrascht, wie schnell der Einstieg mit MicroPython auf einem ESP8266 gelingt. Die Programmierung ist viel direkter und einfacher also der C++ mit Arduino zu schreiben, zu kompilieren und auf den Flashspeicher zu schreiben. Vermutlich ist die Aufführung etwas langsamer aber die "Interaktion" erlaubt auch Anfängern den schnellen Einstieg in verschiedene Sensoren. Speziell für kleine Aufgaben und Einsteiger ist MicroPython super geeignet. Da kann man auch schon mal drüber wegschauen, dass es kleine Unstimmigkeiten gibt, z.B. 0.1 +0.2 ergibt 0.30000000000000004.

Ich werde zukünftig wohl immer erst mal mein Prototyping mit MicroPython machen und nur dann auf C++ wechseln, wenn es keine passenden Module für MicroPython gibt. Ich freue mich schon, meine weiteren ESP-Projekte mit Python zu starten, z.B.

  • WLAN-Scanner/Signalstärke-Überwachung
    Regelmäßige Scans im 2,4 GHz-Band könnten Aussetzer im LAN oder fremde APs erkennen. Vielleicht kann man sogar die Beacon-Suche von Clients nutzen, um die Clients zu erkennen?
  • Bluetoothbr> Auch diese Funktechnik finde ich bestechend, um auf der Nahstrecke Daten zu erhalten. Insbesondere von Temperatursensoren wie MI Sensor mit BTLE Gateway
  • Mini-Sensoren
    Ich bin ja immer noch am Thema "Parkplatz-Überwachung" involviert. Wenn ich aber sehe, wie einfach mit MicroPython sein könnte, dann könnte das ein Startpunkt sein.

Es bleibt aber schon noch das ein oder andere zu tun. Viele IP-Funktionen wie z.B. MQTT, PING müssen über weitere Libraries nachgerüstet werden.

Weitere Dokumentationen

YouTube Videos

Weitere Links