© ecco/Shutterstock.com
MicroPython auf der STM32-Plattform

Python, preiswert


Wer von Embedded Python spricht, denkt normalerweise an den Raspberry Pi oder den ESP32. Weniger bekannt ist, dass es auch preiswerter (und leichter zertifizierbar) geht.

Man kann von SGS Thomson bzw. nun ja STMicroelectronics halten, was man möchte: in den letzten Jahren haben die Franco-Italiener aufgeräumt. Statt einer Vielzahl verschiedener integrierter Entwicklungsumgebungen gibt es nur noch eine einzige (mit Ausnahmen); eine 10-Jahres-Lebensgarantie für Mikrocontroller macht die auf den ersten Blick unübersichtlich erscheinende Controller-Familie zu einem wahren Buffet der Freude. Man kann argumentieren, dass der hohe Spezialisierungsgrad dabei hilft, für jede Situation den optimalen Controller zu finden.

Im Rahmen dieser Aufräumarbeiten hat STM das Kind nicht mit dem Bade ausgeschüttet – Teile des Ökosystems wie die von MicroEJ entwickelte Java Runtime, aber auch eine quelloffene Python Runtime sind nach wie vor mit von der Partie. In diesem Artikel möchte ich das Experimentieren mit MicroPython auf der STM32-Plattform vorstellen.

Wieso ausgerechnet Python?

Das Design von Embedded-Systemen gilt als letztes Refugium der Alten. Harte Echtzeitanforderungen lassen sich nun mal nicht oder nur sehr schwer mit Sprache realisieren, die einen Garbage Collector und ähnliches Eigenleben mitbringen. Ehrlich gesagt muss man als Entwickler allerdings zugeben, dass die Aufgaben, wo es auf harte Echtzeit ankommt, heute sehr selten sind. Ob eine Steuerung für eine Heizung sofort oder in einer halben Sekunde auf einen Sensor reagiert, ist egal. Das gilt in den meisten Fällen auch für Türklinken und andere Lustigkeiten. STM-Mikrocontroller sind heute bei geringen Preisen extrem leistungsfähig. Die Anforderungen von MicroPython lassen sich quasi nebenbei befriedigen.

Wer die unter [1] bereitstehende Projektseite aufruft, stellt fest, dass das Pyboard als offizielles Referenzboard der Community auf einem STM32F405-Controller basiert. Nebenbei gibt es auch Unterstützungen für die F0-, F4-, L0- und L4-Familie; Unterstützung für den F7 liegt im Moment als Betaversion vor. Um Anfängern und Einsteigern einen schnellen Start zu ermöglichen, unterstützt MicroPython ein gutes Dutzend verschiedener Nucleo-Boards. Ich werde in den folgenden Schritten mit einem Nucleo-F401RE arbeiten, das ich im Unternehmen aus einem anderen Projekt herumliegen habe. MicroPython ist – wie so ziemlich jede andere Open-Source-Runtime – ein Produkt, dem man bei der Verwendung zumindest bis zu einem gewissen Grad Wartung zugestehen muss. Aus diesem Grund wollen wir das für unser Board unter [2] zum Download bereitstehende Firmware-Image nicht verwenden, und stattdessen die Quellen in ein lokales Arbeitsverzeichnis herunterladen:

t@T18:~$ mkdir stmpython t@T18:~/stmpython$ git clone https://github.com/micropython/micropython.git

MicroPython integriert sich weder in Atollic noch in STM32Cube. In Bezug auf die Voraussetzungen für die Kompilation findet sich in der Dokumentation nur die lapidare Feststellung: „The „stm32“ port requires an ARM compiler, arm-none-eabi-gcc, and associated bin-utils.“

Erfreulicherweise lässt sich der nach der Installation rund 1 GB an Speicherplatz belegende Compiler unter Ubuntu 18.04 LTS direkt aus den Paketquellen beziehen:

sudo apt-get install gcc-arm-none-eabi

Nach getaner Arbeit müssen wir das GitHub Repository bearbeiten, um danach die Kompilation der Module und zu guter Letzt des eigentlichen Firmware-Image zu befehlen:

t@T18:~/stmpython/micropython$ git submodule update --init t@T18:~/stmpython/micropython/ports/stm32$ make submodules t@T18:~/stmpython/micropython/ports/stm32$ make BOARD=NUCLEO_F401RE

Die Kompilation einer spezifischen Variante der Firmware erfolgt prinzipiell im zu ihr gehörenden Ports-Ordner. Durch Angabe des Parameters BOARD legen Sie fest, welche Controller-Architektur anzuzielen ist. Bei einem jungfräulichen MicroPython-Environment bekommen wir an dieser Stelle den Fehler mpy-cross not found at /home/tamhan/stmpython/micropython/mpy-cross/mpy-cross, please build it first angeliefert. Er entsteht, weil der für die Auslieferung bzw. Kompilation erforderliche hauseigene Cross-Compiler noch nicht einsatzbereit ist. Erfreulicherweise lässt sich dies mit wenigen Maschinensekunden beheben:

t@T18:~/stmpython/micropython/mpy-cross$ make -j 8

An dieser Stelle können wir wieder in ports/stm32 zurückkehren, um das eigentliche Firmware-File zu erzeugen (Listing 1).

Listing 1

t@T18:~/stmpython/micropython/ports/stm32$ make BOARD=NUCLEO_F401RE -j 8 LINK build-NUCLEO_F401RE/firmware.elf text data bss dec hex filename 300596 24 37356 337976 52838 build-NUCLEO_F401RE/firmware.elf GEN build-NUCLEO_F401RE/firmware.dfu GEN build-NUCLEO_F401RE/firmware.hex

Mit STM32 erfahrene Entwickler sehen hier die Ausgabe des bekannten Linkers, der unter anderem über die Größe der erzeugten Firmware informiert. Die .DFU- und .txt-Dateien lassen sich danach (in der Theorie) auf den Controller brennen.

Wieso Nucleo?

STM hat mit der Nucleo-Serie ein Entwicklungsboard geschaffen, das sich immenser Popularität erfreut....

Neugierig geworden? Wir haben diese Angebote für dich:

Angebote für Gewinner-Teams

Wir bieten Lizenz-Lösungen für Teams jeder Größe: Finden Sie heraus, welche Lösung am besten zu Ihnen passt.

Das Library-Modell:
IP-Zugang

Das Company-Modell:
Domain-Zugang