Paketverwaltung¶

Pakete mit `mip` installieren¶

Netzwerkfähige Boards enthalten das mip-Modul, das Pakete aus micropython-lib und von Drittanbieterseiten (einschließlich GitHub, GitLab) installieren kann.

mip („mip installs packages“) ähnelt konzeptionell Pythons pip-Werkzeug, verwendet jedoch nicht den PyPI-Index, sondern standardmäßig micropython-lib als Index. mip ruft beim Herunterladen von micropython-lib automatisch die kompilierte .mpy file ab.

Die gebräuchlichste Art, mip zu verwenden, ist über die REPL:

>>> import mip
>>> mip.install("pkgname")  # Installs the latest version of "pkgname" (and dependencies)
>>> mip.install("pkgname", version="x.y")  # Installs version x.y of "pkgname"
>>> mip.install("pkgname", mpy=False)  # Installs the source version (i.e. .py rather than .mpy files)

mip ermittelt einen geeigneten Ort im Dateisystem, indem es sys.path nach dem ersten Eintrag durchsucht, der auf /lib endet. Sie können das Ziel mit target überschreiben, beachten Sie jedoch, dass sich dieser Pfad in sys.path befinden muss, um ihn anschließend importieren zu können:

>>> mip.install("pkgname", target="third-party")
>>> sys.path.append("third-party")

Neben dem Herunterladen von Paketen aus dem micropython-lib-Index kann mip auch Drittanbieterbibliotheken installieren. Am einfachsten ist es, eine Datei direkt herunterzuladen:

>>> mip.install("http://example.com/x/y/foo.py")
>>> mip.install("http://example.com/x/y/foo.mpy")

Beim direkten Installieren einer Datei wird das Argument target weiterhin unterstützt, um den Zielpfad festzulegen, mpy und version werden jedoch ignoriert.

Die URL kann auch mit github: oder gitlab: beginnen, als einfache Möglichkeit, auf Inhalte zu verweisen, die auf GitHub oder GitLab gehostet werden:

>>> mip.install("github:org/repo/path/foo.py")  # Uses default branch
>>> mip.install("github:org/repo/path/foo.py", version="branch-or-tag")  # Optionally specify the branch or tag
>>> mip.install("gitlab:org/repo/path/foo.py")  # Uses default branch
>>> mip.install("gitlab:org/repo/path/foo.py", version="branch-or-tag")  # Optionally specify the branch or tag

Anspruchsvollere Pakete (d. h. mit mehr als einer Datei oder mit Abhängigkeiten) können heruntergeladen werden, indem der Pfad zu ihrer package.json angegeben wird:

>>> mip.install("http://example.com/x/package.json")
>>> mip.install("github:org/user/path/package.json")
>>> mip.install("gitlab:org/user/path/package.json")

Wenn keine json-Datei angegeben wird, wird implizit „package.json“ hinzugefügt:

>>> mip.install("http://example.com/x/")
>>> mip.install("github:org/repo")  # Uses default branch of that repo
>>> mip.install("github:org/repo", version="branch-or-tag")
>>> mip.install("gitlab:org/repo")  # Uses default branch of that repo
>>> mip.install("gitlab:org/repo", version="branch-or-tag")

`mip` auf dem Unix-Port verwenden¶

Auf dem Unix-Port kann mip wie oben über die REPL verwendet werden und außerdem mit -m:

$ ./micropython -m mip install pkgname-or-url
$ ./micropython -m mip install pkgname-or-url@version

Die Argumente --target path, --no-mpy und --index können gesetzt werden:

$ ./micropython -m mip install --target third-party pkgname
$ ./micropython -m mip install --no-mpy pkgname
$ ./micropython -m mip install --index https://host/pi pkgname

Pakete mit `mpremote` installieren¶

Das mpremote-Werkzeug bietet ebenfalls dieselbe Funktionalität wie mip und kann von einem Host-PC aus verwendet werden, um Pakete auf einem lokal angeschlossenen Gerät zu installieren (z. B. über USB oder UART):

$ mpremote mip install pkgname
$ mpremote mip install [email protected]
$ mpremote mip install http://example.com/x/y/foo.py
$ mpremote mip install github:org/repo
$ mpremote mip install github:org/repo@branch-or-tag
$ mpremote mip install gitlab:org/repo
$ mpremote mip install gitlab:org/repo@branch-or-tag

Die Argumente --target=path, --no-mpy und --index können gesetzt werden:

$ mpremote mip install --target=/flash/third-party pkgname
$ mpremote mip install --no-mpy pkgname
$ mpremote mip install --index https://host/pi pkgname

mpremote kann auch Pakete aus Dateien installieren, die im lokalen Dateisystem des Hosts gespeichert sind:

$ mpremote mip install path/to/pkg.py
$ mpremote mip install path/to/app/package.json
$ mpremote mip install \\path\\to\\pkg.py

Dies ist besonders nützlich zum Testen von Paketen während der Entwicklung und zum Installieren von Paketen aus lokalen Klonen von GitHub-Repositorys. Beachten Sie, dass URLs in package.json-Dateien als Verzeichnistrenner Schrägstriche („/“) verwenden müssen, auch unter Windows, damit sie mit der Installation aus dem Web kompatibel sind.

Pakete manuell installieren¶

Pakete können auch (entweder in .py- oder .mpy-Form) installiert werden, indem die Dateien manuell auf das Gerät kopiert werden. Je nach Board kann dies über USB-Massenspeicher, das mpremote-Werkzeug (z. B. mpremote fs cp path/to/package.py :package.py), webrepl usw. erfolgen.

Pakete schreiben und veröffentlichen¶

Die Veröffentlichung in micropython-lib ist der einfachste Weg, Ihr Paket für MicroPython-Benutzer breit zugänglich zu machen und es automatisch über mip und mpremote verfügbar zu machen sowie zu Bytecode zu kompilieren. Weitere Informationen finden Sie unter https://github.com/micropython/micropython-lib.

Um ein „selbst gehostetes“ Paket zu schreiben, das von mip oder mpremote heruntergeladen werden kann, benötigen Sie einen statischen Webserver (oder GitHub), um entweder eine einzelne .py-Datei oder eine package.json-Datei zusammen mit Ihren .py-Dateien zu hosten.

Eine auf GitHub gehostete Beispielbibliothek mlx90640 könnte folgendermaßen installiert werden:

$ mpremote mip install github:org/micropython-mlx90640

Das Layout für das Paket auf GitHub könnte folgendermaßen aussehen:

https://github.com/org/micropython-mlx90640/
    package.json
    mlx90640/
        __init__.py
        utils.py

Die package.json gibt den Speicherort der zu installierenden Dateien sowie weitere Abhängigkeiten an:

{
  "urls": [
    ["mlx90640/__init__.py", "mlx90640/__init__.py"],
    ["mlx90640/utils.py", "mlx90640/utils.py"]
  ],
  "deps": [
    ["collections-defaultdict", "latest"],
    ["os-path", "latest"],
    ["github:org/micropython-additions", "main"],
    ["gitlab:org/micropython-otheradditions", "main"]
  ],
  "version": "0.2"
}

Die urls-Liste gibt die zu installierenden Dateien folgendermaßen an:

"urls": [
    [destination_path, source_url]
    ...

wobei destination_path der Speicherort und Name der auf dem Gerät zu installierenden Datei ist und source_url die URL der zu installierenden Datei. Die Quell-URL würde normalerweise relativ zum Verzeichnis angegeben, das die package.json-Datei enthält, kann aber auch eine absolute URL sein, z. B.:

["mlx90640/utils.py", "github:org/micropython-mlx90640/mlx90640/utils.py"]

Das Paket hängt von collections-defaultdict und os-path ab, die automatisch aus micropython-lib installiert werden. Die dritte Abhängigkeit installiert den Inhalt, wie er durch die package.json-Datei des Branches main des GitHub-Repos org/micropython-additions definiert ist.

Pakete einfrieren¶

Wenn ein Python-Modul oder -Paket aus dem Dateisystem des Geräts importiert wird, wird es im RAM zu bytecode kompiliert, bereit zur Ausführung durch die VM. Bei einer .mpy file ist diese Umwandlung bereits erfolgt, der Bytecode landet jedoch trotzdem im RAM.

Bei Geräten mit wenig Speicher oder bei großen Anwendungen kann es vorteilhaft sein, den Bytecode stattdessen aus dem ROM (d. h. dem Flash-Speicher) auszuführen. Dies lässt sich durch „Einfrieren“ des Bytecodes in die MicroPython-Firmware erreichen, die anschließend auf das Gerät geflasht wird. Die Laufzeitleistung ist dieselbe (wenngleich das Importieren schneller ist), aber es kann erhebliche Mengen an RAM für Ihr Programm freigeben.

Der Nachteil dieses Ansatzes ist, dass die Entwicklung wesentlich langsamer ist, da Sie jedes Mal die Firmware flashen müssen, aber es kann dennoch nützlich sein, Abhängigkeiten einzufrieren, die sich nicht oft ändern.

Das Einfrieren erfolgt durch das Schreiben einer Manifest-Datei und deren Verwendung im Build, oft als Teil einer benutzerdefinierten Board-Definition. Weitere Informationen finden Sie im Leitfaden MicroPython-Manifest-Dateien.