Le REPL

Le REPL (Read-Eval-Print Loop, « boucle lire-évaluer-afficher ») est le shell interactif de MicroPython : un interpréteur qui tourne sur la carte et exécute chaque ligne dès qu’on la tape. C’est le panneau Shell de Thonny, avec son invite >>>. C’est l’atout majeur de l’approche scriptée : avant d’écrire un programme complet, on teste une ligne et on voit l’effet immédiatement, idéal pour explorer un capteur, vérifier un branchement, ou inspecter une valeur.

Lire–évaluer–afficher

On tape, MicroPython exécute, et affiche le résultat d’une expression :

>>> 2 + 3
5
>>> "Pico" * 2
'PicoPico'

Une affectation ne renvoie rien (donc rien ne s’affiche), mais la variable existe ensuite :

>>> x = 10
>>> x * 2
20

Et surtout, on agit sur le matériel en direct :

>>> from machine import Pin
>>> led = Pin("LED", Pin.OUT)
>>> led.on()          # la LED s'allume tout de suite
>>> led.value()       # on lit son état
1

Saisir plusieurs lignes

Quand une ligne ouvre un bloc (elle se termine par :), le REPL passe à l’invite de continuation ... et attend le corps indenté. Une ligne vide termine le bloc :

>>> for i in range(3):
...     print("tour", i)
...
tour 0
tour 1
tour 2

Explorer et reprendre la main

Le REPL est aussi un outil de découverte et de contrôle :

• dir(machine) liste ce qu’offre un module, et help(Pin) en donne l’aide ;
• Ctrl-C interrompt un programme en cours (par exemple une boucle while True: qui tourne) et rend la main ;
• Ctrl-D fait un soft reboot : il redémarre l’interpréteur (et relance main.py) — pratique pour repartir propre, mais les variables tapées au REPL sont alors effacées ;
• Ctrl-E ouvre le mode collage, pour coller un bloc de plusieurs lignes sans que l’indentation automatique ne gêne.

Le flux de travail typique : on bricole au REPL jusqu’à ce qu’une séquence marche, puis on la recopie dans un fichier .py (voir prise en main, main.py).

Tracer une grandeur dans Thonny

Thonny embarque un traceur (la vue Plotter, View → Plotter) qui porte sur un graphique les nombres imprimés au Shell, au fil du temps, l’équivalent du traceur série de l’IDE Arduino. Une valeur numérique par ligne, et la courbe se dessine : pratique pour observer un capteur qui évolue ou caler un seuil, sans rien câbler de plus.

from machine import ADC, Pin
import time
 
capteur = ADC(Pin(26))           # entrée analogique (Pico : GP26 = ADC0)
 
while True:
    valeur = capteur.read_u16()  # 0..65535
    print(valeur)                # une valeur par ligne -> une courbe
    time.sleep_ms(50)            # ~20 Hz, lisible à l'œil

Prendre capture d’écran de la vue Plotter de Thonny traçant une grandeur qui varie, la courbe ondulant au fil des print.

Pour superposer plusieurs grandeurs, par exemple pour comparer une consigne et une mesure, on les imprime sur la même ligne, séparées par un espace :

print(consigne, mesure)          # deux nombres -> deux courbes

Le traceur attend des nombres : une ligne qui mêle texte et valeur (print("capteur", valeur)) se trace mal. Pour tracer, imprimer le(s) nombre(s) seul(s) et garder les print() annotés pour la lecture au Shell. Comme le traceur lit le Shell, une boucle qui imprime trop vite le sature : garder une cadence raisonnable (sleep_ms).

Pièges

Une affectation n’affiche rien. x = 10 ne renvoie pas de valeur. Pour voir le contenu, taper x. C’est normal, pas un bug.

Une boucle infinie « bloque » le REPL. Tant qu’un while True: tourne, l’invite ne revient pas : Ctrl-C pour reprendre la main.

Le soft reboot efface les variables. Après Ctrl-D (ou un branchement/débranchement), les variables définies au REPL n’existent plus : il faut les redéfinir. Ce qui persiste, ce sont les fichiers enregistrés sur la carte.

Exercices

Exercice 1 — Piloter et lire au REPL

Au REPL, allumez la LED intégrée, lisez son état, puis éteignez-la et relisez. Quelle méthode bascule l’état d’un seul coup ?

Corrigé

>>> from machine import Pin
>>> led = Pin("LED", Pin.OUT)
>>> led.on()
>>> led.value()
1
>>> led.off()
>>> led.value()
0
>>> led.toggle()   # bascule l'état

toggle() inverse l’état courant, pratique pour un clignotement écrit en une ligne.

Exercice 2 — Explorer un module

Sans documentation sous les yeux, découvrez au REPL ce que contient le module time. Quelle commande ? Repérez une fonction de pause.

Corrigé

>>> import time
>>> dir(time)
[..., 'sleep', 'sleep_ms', 'sleep_us', 'ticks_ms', 'ticks_us', ...]
>>> help(time.sleep)

dir() liste les noms d’un module. sleep (en secondes) et sleep_ms (en millisecondes) sont les pauses. dir() + help() sont les deux réflexes pour explorer une bibliothèque inconnue directement sur la carte.

Voir aussi

• Le langage MicroPython — hub du parcours langage
• Prise en main — où le REPL apparaît pour la première fois
• Modules et import — dir()/import pour explorer et charger du code
• Débugger un programme — le REPL comme outil de diagnostic (transverse)