Le mode interpréteur interactif de MicroPython (alias REPL)

Cette section couvre certaines caractéristiques du mode interpréteur interactif de MicroPython. Un terme couramment utilisé pour le désigner est REPL (read-eval-print-loop), qui servira à faire référence à cette invite interactive.

Note

Les OpenMV Cam exposent ce REPL via leur port série USB (CDC). Il n’est pertinent que lorsque vous vous connectez directement à la caméra avec un émulateur de terminal série (ou un outil tel que Contrôle à distance de MicroPython : mpremote). OpenMV IDE n’utilise pas le REPL — il communique avec la caméra via un protocole de débogage distinct pour exécuter des scripts, transférer des fichiers et diffuser le tampon d’image. Tout ce qui est décrit sur cette page s’applique uniquement aux sessions de terminal directes.

Indentation automatique

Lorsque vous saisissez des instructions Python qui se terminent par deux-points (par exemple if, for, while), l’invite passe à trois points (…) et le curseur est indenté de 4 espaces. Lorsque vous appuyez sur Entrée, la ligne suivante continue au même niveau d’indentation pour les instructions ordinaires, ou à un niveau d’indentation supplémentaire lorsque c’est approprié. Si vous appuyez sur la touche Retour arrière, un niveau d’indentation est annulé.

Si votre curseur se trouve tout au début de la ligne, appuyer sur ENTRÉE exécutera alors le code que vous avez saisi. Voici ce que vous verriez après avoir saisi une instruction for (le tiret bas indique l’endroit où le curseur se retrouve) :

>>> for i in range(30):
...     _

Si vous saisissez ensuite une instruction if, un niveau d’indentation supplémentaire est fourni :

>>> for i in range(30):
...     if i > 3:
...         _

Saisissez maintenant break suivi d’ENTRÉE, puis appuyez sur RETOUR ARRIÈRE :

>>> for i in range(30):
...     if i > 3:
...         break
...     _

Saisissez enfin print(i), appuyez sur ENTRÉE, appuyez sur RETOUR ARRIÈRE puis appuyez à nouveau sur ENTRÉE :

>>> for i in range(30):
...     if i > 3:
...         break
...     print(i)
...
0
1
2
3
>>>

L’indentation automatique n’est pas appliquée si les deux lignes précédentes étaient entièrement composées d’espaces. Cela signifie que vous pouvez terminer la saisie d’une instruction composée en appuyant deux fois sur ENTRÉE, et qu’un troisième appui terminera et exécutera.

Auto-complétion

Pendant la saisie d’une commande dans le REPL, si la ligne saisie jusqu’ici correspond au début du nom de quelque chose, appuyer sur TAB affichera les éléments possibles qui pourraient être saisis. Par exemple, importez d’abord le module machine en saisissant import machine puis en appuyant sur ENTRÉE. Saisissez ensuite m et appuyez sur TAB ; cela devrait se développer en machine. Saisissez un point . et appuyez à nouveau sur TAB. Vous devriez voir quelque chose comme :

>>> machine.
__name__        info            unique_id       reset
bootloader      freq            rng             idle
sleep           deepsleep       disable_irq     enable_irq
Pin

Le mot est développé autant que possible jusqu’à ce que plusieurs possibilités existent. Par exemple, saisissez machine.Pin.PULL et appuyez sur TAB ; cela se développera en machine.Pin.PULL_. Un second appui sur TAB affichera les développements possibles :

>>> machine.Pin.PULL_
PULL_DOWN       PULL_UP
>>> machine.Pin.PULL_

Interrompre un programme en cours d’exécution

Vous pouvez interrompre un programme en cours d’exécution en appuyant sur Ctrl-C. Cela lèvera une KeyboardInterrupt qui vous ramènera au REPL, à condition que votre programme n’intercepte pas l’exception KeyboardInterrupt.

Par exemple :

>>> for i in range(1000000):
...     print(i)
...
0
1
2
3
...
6466
6467
6468
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
KeyboardInterrupt:
>>>

Mode collage

Si vous souhaitez coller du code dans la fenêtre de votre terminal, la fonction d’indentation automatique perturbera tout. Par exemple, si vous aviez le code Python suivant :

def foo():
    print('This is a test to show paste mode')
    print('Here is a second line')
foo()

et que vous essayez de le coller dans le REPL normal, vous verrez alors quelque chose comme ceci :

>>> def foo():
...         print('This is a test to show paste mode')
...             print('Here is a second line')
...             foo()
...
Traceback (most recent call last):
  File "<stdin>", line 3
IndentationError: unexpected indent

Si vous appuyez sur Ctrl-E, vous entrerez en mode collage, qui désactive essentiellement la fonction d’indentation automatique et change l’invite de >>> à ===. Par exemple :

>>>
paste mode; Ctrl-C to cancel, Ctrl-D to finish
=== def foo():
===     print('This is a test to show paste mode')
===     print('Here is a second line')
=== foo()
===
This is a test to show paste mode
Here is a second line
>>>

Le mode collage permet de coller des lignes vides. Le texte collé est compilé comme s’il s’agissait d’un fichier. Appuyer sur Ctrl-D quitte le mode collage et lance la compilation.

Réinitialisation logicielle

Une Réinitialisation logicielle (soft reset) réinitialisera l’interpréteur Python, mais tente de ne pas réinitialiser le moyen par lequel vous êtes connecté à l’OpenMV Cam (USB).

Vous pouvez effectuer une réinitialisation logicielle depuis le REPL en appuyant sur Ctrl-D, ou depuis votre code Python en exécutant :

machine.soft_reset()

Par exemple, si vous réinitialisez votre OpenMV Cam et exécutez une commande dir(), vous verriez quelque chose comme ceci :

>>> dir()
['__name__']

Créez maintenant quelques variables et répétez la commande dir() :

>>> i = 1
>>> j = 23
>>> x = 'abc'
>>> dir()
['j', 'x', '__name__', 'i']
>>>

Maintenant, si vous saisissez Ctrl-D et répétez la commande dir(), vous constaterez que vos variables n’existent plus :

MPY: sync filesystems
MPY: soft reboot
MicroPython v1.25.0 on 2025-05-15; OpenMV Cam H7 with STM32H743
Type "help()" for more information.
>>> dir()
['__name__']
>>>

Pour plus d’informations sur les types de réinitialisation et le processus de démarrage, consultez Séquence de réinitialisation et de démarrage.

La variable spéciale _ (tiret bas)

Lorsque vous utilisez le REPL, vous pouvez effectuer des calculs et voir les résultats. MicroPython stocke le résultat de l’instruction précédente dans la variable _ (tiret bas). Vous pouvez donc utiliser le tiret bas pour enregistrer le résultat dans une variable. Par exemple :

>>> 1 + 2 + 3 + 4 + 5
15
>>> x = _
>>> x
15
>>>

Mode brut et mode collage brut

Le mode brut (aussi appelé REPL brut) n’est pas quelque chose qu’une personne utiliserait normalement. Il est destiné à un usage programmatique et se comporte essentiellement comme le mode collage avec l’écho désactivé, et avec un contrôle de flux facultatif.

On entre en mode brut à l’aide de Ctrl-A. Vous envoyez ensuite votre code Python, suivi d’un Ctrl-D. Le Ctrl-D sera confirmé par « OK », puis le code Python sera compilé et exécuté. Toute sortie (ou erreur) sera renvoyée. Saisir Ctrl-B quittera le mode brut et reviendra au REPL ordinaire (alias convivial).

Le mode collage brut est un mode supplémentaire au sein du REPL brut qui inclut le contrôle de flux et qui compile le code au fur et à mesure de sa réception. Cela le rend plus robuste pour le transfert à grande vitesse de code vers l’appareil, et il utilise également moins de RAM lors de la réception, car il n’a pas besoin de stocker une copie textuelle du code avant la compilation (contrairement au mode brut standard).

Le mode collage brut utilise le protocole suivant :

  1. Entrer dans le REPL brut comme d’habitude via Ctrl-A.

  2. Écrire 3 octets : b"\x05A\x01" (c.-à-d. Ctrl-E puis « A » puis Ctrl-A).

  3. Lire 2 octets pour déterminer si l’appareil est entré en mode collage brut :

    • Si le résultat est b"R\x00", alors l’appareil comprend la commande mais ne prend pas en charge le collage brut.

    • Si le résultat est b"R\x01", alors l’appareil prend bien en charge le collage brut et est entré dans ce mode.

    • Sinon, le résultat devrait être b"ra" et l’appareil ne prend pas en charge le collage brut ; la chaîne b"w REPL; CTRL-B to exit\r\n>" devrait être lue et ignorée.

  4. Si l’appareil est en mode collage brut, alors continuez, sinon repliez-vous sur le mode brut standard.

  5. Lire 2 octets : il s’agit de l’incrément de taille de fenêtre du contrôle de flux (en octets), stocké sous forme d’entier non signé little endian de 16 bits. La valeur initiale de la variable taille-de-fenêtre-restante doit être définie à ce nombre.

  6. Écrire le code vers l’appareil :

    • Tant qu’il reste des octets à envoyer, écrire jusqu’à l’équivalent de la taille-de-fenêtre-restante en octets, et diminuer la taille-de-fenêtre-restante du nombre d’octets écrits.

    • Si la taille-de-fenêtre-restante est 0, ou s’il y a un octet en attente de lecture, lire 1 octet. Si cet octet est b"\x01", alors augmenter la taille-de-fenêtre-restante de l’incrément de taille de fenêtre de l’étape 5. Si cet octet est b"\x04", alors l’appareil souhaite mettre fin à la réception des données, et b"\x04" doit être écrit vers l’appareil et plus aucun code ne doit être envoyé après cela. (Remarque : s’il y a un octet en attente de lecture en provenance de l’appareil, il n’a pas besoin d’être lu et traité immédiatement ; l’appareil continuera de consommer les octets entrants tant que la taille-de-fenêtre-restante est supérieure à 0.)

  7. Lorsque tout le code a été écrit vers l’appareil, écrire b"\x04" pour indiquer la fin des données.

  8. Lire depuis l’appareil jusqu’à ce que b"\x04" soit reçu. À ce stade, l’appareil a reçu et compilé tout le code qui a été envoyé et l’exécute.

  9. L’appareil émet tous les caractères produits par le code en cours d’exécution. Lorsque (si) le code se termine, b"\x04" sera émis, suivi de toute exception non interceptée, suivie à nouveau de b"\x04". Il revient ensuite au REPL brut standard et émet b">".

Par exemple, en partant d’une nouvelle ligne au REPL normal (convivial), si vous écrivez

b"\x01\x05A\x01print(123)\x04"

Alors l’appareil répondra par quelque chose comme

b"\r\nraw REPL; CTRL-B to exit\r\n>R\x01\x80\x00\x01\x04123\r\n\x04\x04>"

Décomposé dans le temps, cela ressemble à

# Step 1: enter raw REPL
write: b"\x01"
read: b"\r\nraw REPL; CTRL-B to exit\r\n>"

# Step 2-5: enter raw-paste mode
write: b"\x05A\x01"
read: b"R\x01\x80\x00\x01"

# Step 6-8: write out code
write: b"print(123)\x04"
read: b"\x04"

# Step 9: code executes and result is read
read: b"123\r\n\x04\x04>"

Dans ce cas, l’incrément de taille de fenêtre du contrôle de flux est de 128 et il y a deux fenêtres de données immédiatement disponibles au départ, une provenant de la valeur initiale de l’incrément de taille de fenêtre et une provenant de la valeur explicite b"\x01" qui est envoyée. Cela signifie donc que jusqu’à 256 octets peuvent être écrits au début avant d’attendre ou de vérifier l’arrivée d’autres caractères de contrôle de flux.

L’outil Contrôle à distance de MicroPython : mpremote utilise le REPL brut, y compris le mode collage brut, pour exécuter du code Python sur les OpenMV Cam.