MicroPython: Module

Module in Python und MicroPython sind ähnlich wie in anderen Programmiersprachen Sammlungen von Funktionen, Klassen und Variablen, die in einer separaten Datei gespeichert sind und von anderen Dateien importiert werden können. Durch die Verwendung von Modulen kann der Code strukturierter und leichter zu warten sein, da Funktionen und Variablen in thematisch passende Einheiten organisiert werden können.

MicroPython hat einige integrierte Module, die nützliche Funktionen bereitstellen:

machine: zum Zugriff auf Hardware-Ressourcen wie GPIOs und Schnittstellen.
network: zum Konfigurieren und Verwalten von Netzwerkverbindungen.
time: für die Arbeit mit Datum und Zeit.
array: für die Arbeit mit Arrays von numerischen Daten.
json: zum Kodieren und Dekodieren von Daten im JSON-Format.
binascii: für die Konvertierung von Binärdaten in ASCII-Zeichen.
cmath: für komplexe mathematische Funktionen.
gc: für die Verwaltung des Speicherplatzes durch Garbage Collection.
math: für mathematische Funktionen wie Sinus, Cosinus und Quadratwurzeln.
os: für den Zugriff auf Betriebssystemfunktionen wie das Lesen von Dateien und das Arbeiten mit Ordnern.
sys: für den Zugriff auf die Hardware.

Hinweis: Diese Liste ist unvollständig. Je nach MicroPython-Port oder -Version können hier weitere Module dazugehören.

Verwenden von Modulen und deren Funktionen und Methoden

Das Verwenden von Modulen erfolgt mit der import-Anweisung. Auf diese Weise integriert oder bindet man einen Programmcode aus einem externen Programmcode ein, dessen Klassen, Funktionen und Methoden man im eigenen Programmcode nutzen will.

Gib die folgenden Zeilen einzeln in die Kommandozeile ein:

import machine
onboard_led = machine.Pin('LED', machine.Pin.OUT)
onboard_led.on()

Die Onboard-LED auf einem Raspberry Pi Pico wird dann leuchten.

In folgenden Beispiel gehen wir noch einen Schritt weiter und importieren die Funktion „Pin“ aus dem Modul „machine“. Das ist dann sinnvoll, wenn Du nicht jedes Mal den Namen des Moduls schreiben möchtest.

Gib die folgenden Zeilen einzeln in die Kommandozeile ein:

from machine import Pin
onboard_led = Pin('LED', Pin.OUT)
onboard_led.on()

Mit Hilfe von „from“ kann man eine Funktion aus einem Modul direkt importieren.

Hinweis: Zur Lesbarkeit eines umfangreichen Programmcodes ist es empfehlenswert ohne „from“ zu arbeiten. Dadurch muss man zwar mehr schreiben, aber man sieht am Modul-Name vor einer Funktion, woher die Funktion kommt. Das ist auch aus einem zweiten Grund wichtig, weil der Name einer Funktion über mehrere importierte Module mehrfach vorkommen und dann zu Namenskollisionen führen kann.

Module „machine“ und „rp2“

Die Module „machine“ und „rp2“ ermöglichen es, auf die Hardware des Mikrocontrollers RP2040 und damit des Raspberry Pi Pico zuzugreifen. Beispielsweise GPIOs, Timer, ADCs usw.
MicroPython für den Raspberry Pi Pico (Port RP2) importiert die Module „machine“ und „rp2“ automatisch. Das heißt, ein „import machine“ oder „import rp2“ ist nicht notwendig, um deren Funktionen zu nutzen. Die MicroPython-Versionen für andere Mikrocontroller machen das nicht.
Zu beachten ist, dass dies bei neueren MicroPython-Versionen nicht mehr so sein muss. Wenn man möchte, dass ein Programmcode auch zukünftig überall läuft, sollte man immer „import machine“ und „import rp2“ verwenden.

Eigene Module erstellen

Module sind in Python und MicroPython gewöhnliche Dateien. Wir können also unsere eigenen Module schreiben und importieren. Der Name des Moduls ist gleichzeitig der Dateiname ohne die Dateiendung.

Um Module in MicroPython zu erstellen, muss nur eine neue Datei erstellen, die einfach importiert werden kann. Wenn Du ein Modul mit dem Namen „person“ erstellen willst, dann speicherst Du eine Datei mit dem Namen „person.py“. anschließend kannst Du die Datei als Modul mit „import“ importieren.

Speichere folgenden Programmcode in einer Datei mit dem Namen „person.py“.

class Person(object):
    # Klassenattribut, gilt für alle Instanzen
    art = "Homo Sapiens"
    
    # Einfacher Konstruktor der Klasse
    def __init__(self, name, gender):
        # Zuweisung der Argumente zu Attributen der Instanz
        self.name = name
        self.gender = gender
    
    # Instanzmethode, mit self als erstes Argument
    def sagt(self, msg):
        return "{name}: {message}".format(name=self.name, message=msg)
    
    # Instanzmethode, mit self als erstes Argument
    def getName(self):
        return self.name
    
    # Instanzmethode, mit self als erstes Argument
    def getSex(self):
        return self.gender
    
    # Instanzmethode
    def setSex(self, gender):
        self.gender = gender
    
    # Klassenmethode, wird von allen Instanzen geteilt
    @classmethod
    def getArt(cls):
        return cls.art
    
    # Statische Methode, wird ohne Instanz aufgerufen
    @staticmethod
    def hallo():
        return "Hallo"

Speichere folgenden Programmcode im selben Verzeichnis mit einem beliebigen Dateinamen und führe ihn aus.

# Klasse "Person" von Modul "person" laden
from person import Person

# Zwei unterschiedliche Instanzen einer Klasse erstellen
herr = Person(name="Peter", gender="Mann")
dame = Person("Beate", "Frau")

# Klassenmethoden der Instand "herr" aufrufen
print(herr.sagt("Guten Tag"))
print('Geschlecht von', herr.getName(), ':', herr.getSex())
# Gemeinsames Attribut anzeigen
print('Art:', herr.getArt())
print()

# Klassenmethoden der Instand "dame" aufrufen
print(dame.sagt("Hallo"))
print('Geschlecht von', dame.getName(), ':', dame.getSex())
# Gemeinsames Attribut anzeigen
print('Art:', dame.getArt())
print()

# Attribut von Instanz "dame" ändern
dame.setSex("Divers")
print('Neues Geschlecht von', dame.getName(), ':', dame.getSex())
print()

# Gemeinsames Attribut ändern
Person.art = "Mensch"
print('Art:', herr.getArt())
print('Art:', dame.getArt())
print()

# Aufruf einer statischen Methode
print(Person.hallo())

Hinweis: Der Programmcode für das Modul und der Programmcode, der das Modul nutzt stammen aus der Beschreibung der Klassen.

MicroPython: Klassen

Was kann ein Modul alles?

Im Optimalfall sind die Namen von Klassen, Methoden und Attributen in Modulen so gewählt, dass sie selbsterklärend sind. Wenn man also wissen will, was ein Modul alles kann, dann lässt sich das auf der Kommandozeile sehr leicht herausfinden.

import person
dir(person)

Oft ist diese Ausgabe nicht detailliert genug. In diesem Fall enthält das Modul auch nur die Klasse „Person“. Wenn man mehr über diese Klasse, also Methoden und Attribute, erfahren möchte, dann muss man die Klasse explizit angeben.

dir(person.Person)

Weitere verwandte Themen:

Hardware-nahes Programmieren mit dem Raspberry Pi Pico und MicroPython

Das Elektronik-Set Pico Edition ist ein Bauteile-Sortiment mit Anleitung zum Experimentieren und Programmieren mit MicroPython.

LED: Einschalten, ausschalten, blinken und Helligkeit steuern
Taster: Entprellen und Zustände anzeigen
LED mit Taster einschalten und ausschalten
Ampel- und Lauflicht-Steuerung
Elektronischer Würfel
Eigene Steuerungen programmieren

Elektronik-Set jetzt bestellen Online-Workshop buchen

Online-Workshop: Programmieren mit dem Raspberry Pi Pico

Gemeinsam mit anderen und unter Anleitung experimentieren? Wir bieten unterschiedliche Online-Workshops zum Raspberry Pi Pico und MicroPython an. Einführung in die Programmierung, Sensoren programmieren und kalibrieren, sowie Internet of Things und Smart Home über WLAN und MQTT.

Online-Workshop buchen

Für Ihre Fragen zu unseren Online-Workshops mit dem Raspberry Pi Pico besuchen Sie unseren PicoTalk (Online-Meeting). (Headset empfohlen)

Zum PicoTalk