Micropython.fr

Principes généraux REPL / script

Bien que les cartes Micropython soit des cartes à micro-contrôleur, au même titre qu'une carte Arduino, il y a quelques différences de concept qu'il faut bien intégrer dans la façon d'accéder à la carte, d'exécuter un programme.

Python (et Micropython) : un langage interprété !

Fondamentalement, ce qu'il faut comprendre, c'est que Micropython, tout comme le langage Python, est un langage interprété. Les instructions sont exécutées "à la volée" par le "moteur Micropython" qui est le coeur actif que l'on doit avoir installé sur la carte avant toute utilisation.

A partir de là, on comprend aisément qu'il y a 2 modes de fonctionnement possibles :

  • soit en envoie des instructions manuellement à la volée : c'est ce que l'on appelle le mode "interpréteur" ou REPL dans le cas de Micropython. Concrètement, lorsque l'on utilise ce mode, on a l'équivalent d'une ligne de commande avec une invite au format >>> qui caractérise Python.

  • soit on exécute un script, un code Micropython, qui correspond ni plus ni moins à l'exécution automatique successive "à la volée" de toutes les instructions contenue dans le script. Noter que le script MicroPython peut appeler des fonctions placées dans d'autres scripts (que l'on va appeler "librairies" ou "modules"), mais il faut bien comprendre que dans tous les cas, c'est le coeur Microptyhon qui interprète et exécute les instructions.

Note

Le caractère interprété est l'une des grandes forces de Python : la compilation nécessaire a été faite une fois pour toute et c'est celle du "coeur Micropython" que l'on installe initialement dans la carte. A noter que techniquement, le "coeur Micropython", c'est du langage C qui est compilé et qui est un "programme interpréteur Python".

Une fois fait, une fois que le coeur est installé, IL N'EST PLUS NECESSAIRE DE COMPILER QUOI QUE CE SOIT !! Et cela offre une souplesse de codage et de développement qui est très intéressante. On n'est jamais face à des erreurs de compilation contre lesquelles on ne peut parfois pas faire grand chose : on a uniquement affaire à des erreurs de syntaxe facile à corriger directement dans le code.

L'autre point très intéressant, c'est que d'éventuelles "librairies" utilisées sont elles-mêmes du code Micropython qu'il suffit d'ouvrir pour avoir accès au code, le modifier au besoin. Bref, les "boîtes noires" disparaissent.

Le mode interpréteur

REPL

Ecrire et transférer un script vers la carte Micropython

Lorsque l'on écrit des scripts, que l'on peut donc considérer comme un ensemble d'instructions qui seront successivement interprétées automatiquement par le coeur Micropython, on a 2 possibilités :

  • soit on le charge en RAM à partir de l'éditeur (c'est une sorte d'équivalent du "téléverser" Arduino sauf que c'est en RAM...)

  • soit on le place en mémoire Flash et on le lance lancement.

En phase de développement : on charge directement le code en RAM à partir de l'éditeur sur le poste principal

Note

Le code chargé en RAM depuis l'éditeur s'exécutera sans interruption :

  • tant que un autre code n'aura pas été chargé en RAM
  • ou tant que l'on n'aura pas interrompu son exécution depuis interpréteur
  • ou tant que l'on n'aura pas éteint / mis hors tension

Bien comprendre que l'une de ces 3 opérations interrompra l'exécution programme.

En phase d'utilisation : on place les fichiers en mémoire Flash et on boote dessus

Pour qu'un code soit exécuté automatiquement à la mise sous tension de la carte, il faut faire 2 choses :

  • le placer sur la carte Micropython
  • indiquer dans le fichier boot.py de l'exécuter au lancement

Placer le code sur la carte Python

Expliqué séparément. Facile à faire graphiquement, ou bien en mode REPL ou avec un utilitaire tel que RShell ou Ampy.

Lancer le script au boot de la carte Micropython

Au lancement, Micropython lance le fichier boot.py : dans ce fichier est indiqué le /les fichiers à lancer au démarrage.

On a 2 possibilités :

  • soit on modifie le fichier boot.py en l'éditant directement via le gestionnaire de fichier + éditeur comme n'importe quel fichier. On modifie le nom du fichier en conséquence. 
# boot.py -- run on boot-up
# can run arbitrary Python, but best to keep it minimal

import pyb
pyb.main('trans.py') # main script to run after this one
pyb.usb_mode('VPC+MSC') # act as a serial and a storage device
#pyb.usb_mode('VPC+HID') # act as a serial device and a mouse
  • soit, et c'est probablement le plus simple pour éviter d'avoir à éditer boot.py, on change le nom du fichier copier/collé sur la Flash dans le nom du fichier indiqué par défaut. C'est probablement la façon de faire la plus simple.

Note

Encore une fois, pour être tout à fait clair, on ne parle ici QUE du cas où on souhaite une exécution en autonome du code. En phase de développement, ceci n'est pas nécessaire, le programme pouvant être chargé en RAM à partir de l'éditeur directement.

Qu'est-ce qui se passe...

Nous allons voir ici quelques situations concrètes pour bien comprendre le fonctionnement de Micropython, les différences entre le mode interpréteur REPL et l'exécution d'un script.

... si on utilise directement le mode REPL ?

Typiquement dans ce cas de figure on se connecte à l'aide d'un moniteur série, soit par exemple avec screen sous Gnu/Linux en faisant : 

screen /dev/ttyACM0

Et on obtient : 

MicroPython v1.14-80-g75db0b907 on 2021-02-22; PYBv1.1 with STM32F405RG
Type "help()" for more information.
>>>

Si on saisit des commandes Python dans ce contexte après l'inivite, elles sont directement exécutées à la volée par Micropython. 

>>> print("Hello world !")
Hello world !
>>>

Note

Le mode interpréteur REPL est l'idéal pour apprendre les commandes de base du langage Python, faire des tests à tout moment, interagir avec Micropython.

... si on a transféré un programme en mémoire RAM depuis l'éditeur et qu'on se connecte en interpréteur REPL ?

Imaginons ici que l'on ait transféré un programme en mémoire RAM, par exemple le code suivant : 

import pyb 

def hello():
    print ("Hello world !")

A présent, si on se connecte en REPL, le premier programme étant exécuté :

On constate qu'il est possible d'appeler les fonctions du code et que les sorties s'affichent : 

>>> hello()
Hello world !
>>>

Ce mécanisme peut être intéressant pour implémenter facilement un contrôle personnalisé de la carte Micropython.

Noter que si on saisi

  • CTRL+B : reset de la carte et le programme est toujours exécuté
  • CTRL+D : reset de la carte complet et le programme n'est plus exécuté. Il faut le reflasher en RAM ou mettre le fichier en Flash.

.... si programme while(True) ?

.... si programme timer() ?