Mode interpréteur (REPL)

Pour comprendre

Le mode interpréteur, avec Micropython est aussi appelé REPL :

• Read (lire) : MicroPython attend que vous saisissiez du texte suivi d'un appui sur entrée.
• Evaluate (évaluer) : Ce que vous avez saisi est interprété comme du code Python et est exécuté immdiatement.
• Print (afficher) : Tout résultat de la dernière ligne saisie sont affichés pour information
• Loop (recommencer): Revient au point de départ et est prêt pour la saisie d'une nouvelle ligne de code.

Ce mode permet de saisir des instructions "à la volée" et de contrôler la carte micropython en conséquence "à la volée".

Accéder à l'interpréteur micropython

Le langage Python est un langage interprété : les instructions sont exécutées "à la volée", sans avoir besoin d'être compilées au préalable.

La première façon d'utiliser micropython est donc logiquement le mode interpréteur. Ceci se fait via un "interpréteur" qui accepte les commandes "à la volée".

Le plus simple, c'est de lancer l'éditeur Thonny précédemment installé et d'utiliser l'interpréteur intégré. On obtient l'interface avec 2 fenêtres et l'interpréteur Micropython correspond à la fenêtre du bas, celle avec l'invite >>>

>>> print("Hello World !")
Hello World !
>>>

Cette fois, tout est OK ! Vous êtes bien connecté à votre carte Pi Pico et vous "discutez" avec (Micro)Python qui vous répond.

Prise en main de l'interpréteur

Bon ben là, on y est ! Et si vous connaissez un peu Python, on peut faire mumuse... et tester la bête. Faîtes-vous plaisir et saisissez quelques commandes pour voir ce que çà donne :

for i in range(10):
 print(i)

ce qui donne :

Yes !

Quelques essais en vrac de langage Python :

>>> 100000000000000000000*200034
20003400000000000000000000

>>> import math
>>> math.sin(math.radians(90))
1.0
>>> math.sin(math.radians(45))
0.7071068

>>> semaine=['Lu', 'Ma', 'Me', 'Je', 'Ve', 'Sa', 'Di']
>>> for jour in semaine:
...  print(jour)
... 
Lu
Ma
Me
Je
Ve
Sa
Di

>>> chaine="Bonjour"
>>> chaine[-1]
'r'
>>> chaine[:-3]
'Bonj'
>>> chaine[::2]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NotImplementedError: only slices with step=1 (aka None) are supported
>>> chaine[2:3]
'n'

>>> x = [1, 2, 3]
>>> y = [4, 5, 6]
>>> zipped = zip(x, y)
>>> list(zipped)
[(1, 4), (2, 5), (3, 6)]
>>> x2, y2 = zip(*zip(x, y))
>>> x2
(1, 2, 3)
>>> y2
(4, 5, 6)

Bref, bien cool tout çà, même si il y a deci-delà quelques (minimes ou contournables) limitations comparativement au langage Python standard.

Franchement, disposer d'un Python sur une carte à micro-contrôleur à 4€... cela fait entrer dans une autre dimension : c'est vraiment cool !

Bon à savoir :

Effacer le contenu courant de la fenêtre de l'interpréteur

Simplement faire clic droit dans la fenêtre et choisir "Effacer"

Obtenir de l'aide en mode interpréteur REPL

En mode interpréteur, dit "REPL", on dispose d'un certain nombre de raccourcis utiles d'une part et on peut également avoir besoin de se mémoriser des informations sur les classes dédiées de la carte. Pour cela, on a la possiblité d'obtenir de l'aide avec la commande :

>>>help()

Ce qui donne :

Welcome to MicroPython!

For online help please visit https://micropython.org/help/.

For access to the hardware use the 'machine' module.  RP2 specific commands
are in the 'rp2' module.

Quick overview of some objects:
  machine.Pin(pin) -- get a pin, eg machine.Pin(0)
  machine.Pin(pin, m, [p]) -- get a pin and configure it for IO mode m, pull mode p
    methods: init(..), value([v]), high(), low(), irq(handler)
  machine.ADC(pin) -- make an analog object from a pin
    methods: read_u16()
  machine.PWM(pin) -- make a PWM object from a pin
    methods: deinit(), freq([f]), duty_u16([d]), duty_ns([d])
  machine.I2C(id) -- create an I2C object (id=0,1)
    methods: readfrom(addr, buf, stop=True), writeto(addr, buf, stop=True)
             readfrom_mem(addr, memaddr, arg), writeto_mem(addr, memaddr, arg)
  machine.SPI(id, baudrate=1000000) -- create an SPI object (id=0,1)
    methods: read(nbytes, write=0x00), write(buf), write_readinto(wr_buf, rd_buf)
  machine.Timer(freq, callback) -- create a software timer object
    eg: machine.Timer(freq=1, callback=lambda t:print(t))

Pins are numbered 0-29, and 26-29 have ADC capabilities
Pin IO modes are: Pin.IN, Pin.OUT, Pin.ALT
Pin pull modes are: Pin.PULL_UP, Pin.PULL_DOWN

Useful control commands:
  CTRL-C -- interrupt a running program
  CTRL-D -- on a blank line, do a soft reset of the board
  CTRL-E -- on a blank line, enter paste mode

For further help on a specific object, type help(obj)
For a list of available modules, type help('modules')