Installation - teuler/robotling GitHub Wiki

Im Folgenden wird die Installation von MicroPython auf einem ESP32 beschrieben. Alle Tests wurden mit einem HUZZAH32 "feather"-Modul von Adafruit und MicroPython durchgeführt.

Hinweis: Derzeit ist CircuitPython - Adafruit's "fork" von MicroPython - noch nicht für das HUZZAH32-Modul verfügbar, weshalb hier die ESP32-Portierung von MicroPython verwendet wurde. Alternativ gibt es noch von Boris Lovosevic einen expliziten MicroPython-"fork" für den ESP32; dieser kann alternativ eingesetzt werden; ggf. sind kleinere Änderungen am Code notwendig.

1. Zunächst muss der USB-Serial-Treibers für den ESP32 installiert und anschließend der PC neu gestartet werden.

2. Von der Kommandozeile (z.B. Powershell) aus müssen mit dem aktuellen pip folgende Werkzeuge installiert werden:

   python -m pip install --upgrade pip
   pip install msgpack
   pip install esptool
   pip install adafruit-ampy
   

3. Die aktuelle Version von Micropython für den ESP32 findet man hier.

4. Nun muss der ESP32 über ein USB-Kabel an den PC angeschlossen und der Name der Schnittstelle (z.B. COM5) bestimmt werden (Windows-Gerätemanager).

5. Von der Kommandozeile (z.B. Powershell) aus wird der ESP32 mit den folgenden Befehlen zunächst komplett gelöscht und dann die MicroPython-Software übertragen. Dafür ersetzt man <xx> durch dem Namen der unter 4) bestimmten Schnittstelle und <yyy> durch den Namen (inkl. Pfad, wenn nötig) der Micropython-Software.

   python -m esptool --port COM<xx> erase_flash
   python -m esptool --port COM<xx> --baud 460800 write_flash --flash_mode dio --flash_size=detect 0x1000 <yyy>.bin
   

6. Der ESP32 sollte nun bereit sein. Das testet man am besten gleich mit einem Terminal-Programm (e.g. PuTTY), das man mit der oben bestimmten Schnittstelle (z.B. COM6, mit 115200 BAUD) verbindet. Das Erscheinen der MicroPython- Eingabeaufforderung (>>>) zeigt an, dass der ESP32 bereit ist. Mit Hilfe dieses sogenannten "REPL prompts" ("Read Evaluate Print Loop" kann man mit Python auf dem ESP32 interagieren.

Adafruit's ampy-Software erlaubt, Dateien auf den ESP32 zu laden, die geladenen Dateien aufzulisten und Programme dort auszuführen. Um z.B. eine Python-Datei in den FLASH-Speicher des Mikroprozessors zu schreiben, reicht folgender Befehl:

ampy --port COM<xx> put <pythonfilename>.py

Hiermit listet man die Dateien im FLASH des ESP32:

ampy --port COM<xx> ls

Um eine Datei zu entfernen, verwendet man:

ampy --port COM<xx> rm <filename>

Um eine einfachere Syntax zu verwenden, kann man die Schnittstelle festlegen:

$env:AMPY_PORT = 'COM<xx>'
ampy ls

Das pymakr Plugin macht aus Atom eine bequeme Entwicklungsumgebung für MicroPython auf dem ESP32.

Man kann über eine USB-Verbindung via REPL mit dem ESP32 interagieren, Dateien und/oder ganze Verzeichnisse hochladen, und .py Skripte direkt ausführen. Dabei kann man genau definieren, welche Arten von Dateien hochgeladen werden.

Weitere nützliche Pakete für Atom sind:

• "Syntax Highlighter" MagicPython
• Falls man mit CircuitPython experimentiert und Atom als Editor verwenden möchte, empfiehlt es sich, Adafruits "CircuitPython Force to Drive" zu installieren, um etwaige Probleme mit dem CircuitPython-Laufwerk des Moduls zu vermeiden (nicht notwendig für den hier hauptsächlich verwendeten HUZZAH32 mit dem Standard MicroPython).

Ein kleines Beispiel für ein jupyter notebook, das mit dem MikroPython Kernel auf dem ESP32 über eine USB-Verbindung interagiert, findet man hier.

Anders als bei den älteren Arduino-Boards, wo ein üblicherweise in C++ geschriebenes Programm in Maschinencode kompiliert quasi als Firmware auf dem Mikrocontroller läuft, muss bei MicroPython ein in den Flash-Speicher geladenes .py-Skript zunächst in einen Bytecode übersetzt werden, den anschließend eine Laufzeitumgebung ausführt (d.h. interpretiert). Manchmal läuft diese Laufzeitumgebung noch unter einem Betriebssystem wie FreeTOS. Dieser Overhead ist erstmal nicht spürbar, da die 32-Bit Mikrocontroller, auf die MicroPython portiert wurde, deutlich leistungsfähiger sind als jene auf den einfachen 8-Bit Arduino-Boards. Doch spätestens, wenn es um zeitkritische Programme geht (z.B. die Steuerung eines Roboters in „Echtzeit“) oder man allzu freizügig mit Pythons bequemen, dynamischen, aber speicherfressenden Datenstrukturen (list, dict) umgeht und dem Programm zur Laufzeit der Speicher ausgeht, ist es Zeit, sich die MicroPython-spezifischen Möglichkeiten der Code-Optimierung anzusehen. Natürlich sollte man nicht generell auf die mächtigen und flexiblen Sprachkonstrukte verzichten, die Python bietet – sonst braucht man ja kein Python einzusetzen. Eine sinnvolle Vorgehensweise ist vielmehr, ein Programm zunächst zum Laufen zu bringen, und dann zeitkritische Teile gezielt zu optimieren.

Um Speicherplatz zu sparen, sollte man numerische ganzzahlige Konstanten über const (Modul micropython) definieren und wo möglich und sinnvoll, anstatt Listen (list) eher Datenstrukturen fester Größe wie bytearray für Bytes oder array (Modul array) für andere numerische Datentypen einsetzen. Dies beschleunigt auch die Ausführung von häufig aufgerufenen Funktionen, die mit der Hardware kommunizieren. Programmteile, die stabil sind, können mit dem Cross-Compiler mpy bereits vor dem Hochladen auf das Board in Bytecode übersetzt, also „eingefroren“ werden („frozen byte code“). Die so erzeugten .mpy-Dateien können anschließend ganz normal hochgeladen und über import eingebunden werden. Ein Vorteil ist hier die Platzersparnis im Flash-Speicher – .mpy-Dateien sind kompakter als .py-Skripte. Ein weiterer Vorteil ist, dass weniger RAM ausreicht, um die übrigen .py-Skripte auf dem Board zu übersetzen. Um die Performance zu verbessern, kann man zu Beginn einer zeitkritischen Funktion die dort oft verwendete Objekte und Unterfunktionen in lokalen Variablen zwischenspeichern. Die MicroPython-Versionen mancher Boards bieten zudem die Möglichkeit, Funktionen zu beschleunigen, in dem man sie mit speziellen „decorators“ (z.B. @micropython.native) markiert, was zur Folge hat, dass diese Funktionen direkt in Maschinencode anstatt in Bytecode übersetzt werden. In solchen Funktionen sind dann allerdings einige Python-Sprachkonstrukte und -Datentypen nicht erlaubt.

Genügen diese Maßnahmen nicht, kann man auch zeitkritische Teile des Programms als eigenständige Softwarebibliotheken in MicroPython zu integrieren, in dem man eine auf den eigenen Zweck zugeschnittene MicroPython-Version erstellt. Hierbei besteht natürlich auch die Gelegenheit, nicht benötigte Bibliotheken zu entfernen (z.B. Netzwerkunterstützung). Idealerweise schreibt man dann die neuen Teile dann in C++; als Teil von MicroPython können .py-Skripte dann auf diese Funktionalität ganz normal über import zugreifen. Informationen dazu findet man u.a. auf der MicroPython-Seite.

Alternativ sei auf die Seite von Boris Lovosevic verwiesen, dessen ESP32-spezifischer "fork" viele Möglichkeiten bietet, MikroPython an die Benutzerwünsche anzupassen. Unter Windows 10 ist es mir die Neu-Kompilierung von MicroPython bislang nur über die "MINGW32 tool chain" gelungen (siehe entsprechendes Kapitel in "building the firmware under Windows"). Dazu folgende Anmerkungen:

• Die Installation der ESP Tools (mit pip install esptool) in der MINGW32 Shell klappte erst, nachdem ./BUILD.sh menuconfig ausgeführt worden war und der PC neu gestartet wurde.
• Wie immer unter Windows, die Schnittstelle für den ESP32 wird einfach als COMx ohne Pfad angegeben.
• Die MINGW32 Shell eignet sich auch sehr gut dafür, die vor-kompilierten Versionen auf einen ESP32 zu laden.

Die Seite von Boris Lovosevic hält unterschiedliche vor-kompilierte Versionen der Software vorrätig, die sich u.a. in der Zusammensetzung der eingebundenen Bibliotheken unterscheiden, z.B. auch eine Version, die TFT-Displays unterstützt. Außerdem erklärt er die Möglichkeit, die Software so zu konfigurieren, dass beide ESP32-Kerne verwendet werden.

Hinweis: Die Syntax der Hardware-nahen Befehle und Objekte bei Boris Lovosevics MicroPython kann sich von der offiziellen Mikropython-Distribution erheblich unterscheiden.

Um mit Micropython auf einem ESP32 zu beginnen, sind die Installationsanleitung und Tipps von Mauro Riva und Philip van Allen sehr hilfreich.

Jupyter notebooks für MicroPython werden von auf den Seiten von Julian Todd und Marcelo Rovai ausgiebig beschrieben.

Andere nützliche Quellen sind:

• https://github.com/espressif/esptool
• https://learn.adafruit.com/micropython-hardware-ili9341-tft-and-featherwing/micropython
• https://github.com/loboris/MicroPython_ESP32_psRAM_LoBo/wiki

Weiter zu Zusammenbau - Übersicht