FEATHER-CHARGER-MODULE-FROZEN

Crédit: AdaFruit Industries www.adafruit.com

Dans la section précédentes, nous avons appris a créer et charger des modules et paquet/package Python sur notre carte MicroPython. C'est une façon facile et rapide de charger des modules, cependant, il y a également des limitations importantes concernant le chargement et l'exécution de module et paquet depuis le système de fichier. La plus grande limitation concerne concerne l'interpréteur Python qui doit charger le code et en faire l'analyse syntaxique (Wikipedia - aussi dit "parsing" en anglais). Cette opération requière du temps mais aussi de la mémoire, mémoire très limitée sur les microcontrôleurs. Vous pourriez même trouver des codes sources tellement grand qu'ils ne pourraient pas être chargé par l'interpréteur de la carte MicroPython!

Il existe une façon de pré-compiler les modules pour qu'ils soient "inclus" dans le firmware MicroPython et qu'ils utilisent moins de mémoire. MicroPython peut comprimer presque tous les éléments du langage Python dans quelques kilooctets de mémoire en "gelant" le code Python. Cela permet de stocker un code sous un format plus efficace appelé byte-code (du Pyhton déja interprété). Une autre approche permet même de compiler ce code en instruction native (pour le microcontrôleur de la carte). Ces deux dernières approches étant beaucoup plus efficace que des fichiers Python.

Une fois le code gelé ("frozen" en anglais), il peut être rapidement chargé et interprété par MicroPython sans besoin de mémoire et temps de traitement supplémentaire.

Avec MicroPython, vous pouvez geler vos propres modules et les ajouter au firmware en réalisant une compilation personnalisée du Firmware MicroPython (pour votre carte). Cela vous permet d'écrire des modules nettement plus complexes que vous pourrez importer directement dans vos fichiers .py (comme nous l'avons fait jusque maintenant).

Sachez que les modules gelés (Frozen Modules) est une technique avancées qui nécessite la compilation d'un firmware MicroPython personalisé. Pour certaines cartes comme l'ESP8266, il est assez facile de compiler le firmware MicroPython mais d'autres cartes nécessiterons des connaissances plus avancées pour préparer et utiliser la chaîne de compilation.

Assurez vous de pouvoir compiler un firmware MicroPython pour votre carte avant de vous lancer dans la technique des modules gelés. Pour l'ESP8266, voyez le tutoriel Adafruit "guide on how to compile MicroPython firmware" qui utilise une machine virtuelle spéciale basée sur Linux (Vagrant). Pour les autres cartes tels que pyboard, WiPy, etc. vous pouvez consulter le GitHub des sources de MicroPython pour voir comment configurer leur chaîne de compilation et compiler leur firmware.

Gardez également à l'esprit que la technique "Frozen Module" est assez récent pour une carte comme l'ESP8266 et que ce processus pourraît changer à l'avenir. Si vous rencontrez un problème avec l'une des étapes ci-dessous alors référez vous ) la documentation officielle, code sur GitHub et les Forums MicroPython pour obtenir des informations plus récentes.

Dans ce guide, nous allons plus particulièrement nous concentrer sur l'ESP8266 et comment ajouter des modules gelés (Frozen Modules) au Firmware de la carte. Nous allons commencer par nous intéresser aux code source du firmware MicroPython pour ESP8266. Si vous utiliser utilisez une machine virtuelle previously mentioned firmware building guide then you'll want to enter the VM with SSH and navigate to the ~/micropython/esp8266 folder. Notice there are two subdirectories, scripts and modules:

Crédit: AdaFruit Industries www.adafruit.com

There's an important difference between these two folders. The scripts folder is for Python code that will be 'baked-in' to the firmware but not frozen into more efficient and smaller code. Everything in the scripts folder is just stored as the raw Python code in the board's flash memory. This saves you from having to copy that code onto the board's filesystem, but doesn't save a lot of memory or processing time.

The modules folder is for Python code that will be frozen into more efficient bytecode. This is where you want to place scripts that you'd like freeze to save memory.

Try adding a new frozen module as a quick test. Inside the modules folder create a test.py file and add the following code to it:

def add(a, b):
        return a + b

def subtract(a, b):
        return a - b

Now rebuild the ESP8266 MicroPython firmware. From inside the VM's ~/micropython/esp8266 folder run:

make

Notice in the output the MPY modules/test.py line, this shows the test.py module was picked up by the build and frozen into bytecode:

Crédit: AdaFruit Industries www.adafruit.com

If you don't see this line for your module then try running the make clean command and then make command again.

Now copy out the newly built firmware and flash it to the ESP8266. Remember you're now using a development build so debug output will be enabled and features like the WebREPL must be manually started.

Connect to the REPL of the board with the new firmware and try using the test module's functions by running:

import test
test.add(1, 1)
test.subtract(1, 1)

Crédit: AdaFruit Industries www.adafruit.com

You should see the module import and functions work just like if the .py file was on the filesystem!

You can also freeze Python packages inside the modules folder. Just create a directory for each package and put inside it an __init__.py and other source files for the package.

Using the scripts folder to save Python module sources in flash memory is just like using the modules folder above. However note with the scripts folder you cannot put packages inside it, only single .py source files will currently work.

Remember the scripts folder is only for scripts that will be saved as-is to flash memory. The modules folder is for freezing modules and packages so they're in flash memory and more efficient to load and store. As you develop your own complex MicroPython scripts and modules consider freezing them in the MicroPython firmware to reduce memory usage and increase performance!

---

Source: MicroPython Basics: Loading Modules
Créé par Tony DiCola pour AdaFruit Industries.

Traduit par Meurisse D. pour MCHobby

Toute référence, mention ou extrait de cette traduction doit être explicitement accompagné du texte suivant : «  Traduction par MCHobby (www.MCHobby.be) - Vente de kit et composants » avec un lien vers la source (donc cette page) et ce quelque soit le média utilisé.

L'utilisation commercial de la traduction (texte) et/ou réalisation, même partielle, pourrait être soumis à redevance. Dans tous les cas de figures, vous devez également obtenir l'accord du(des) détenteur initial des droits. Celui de MC Hobby s'arrêtant au travail de traduction proprement dit.

Traduit avec l'autorisation d'AdaFruit Industries - Translated with the permission from Adafruit Industries - www.adafruit.com