TheSkillCodex

Prise en main de MicroPython

7 min de lecture

La prise en main de MicroPython consiste à installer l’éditeur Thonny, à déposer une fois le firmware MicroPython sur la carte (un Raspberry Pi Pico 2 ici), puis à exécuter un premier programme. La différence avec l’Arduino est de fond : on ne compile pas un binaire à chaque fois, mais on installe un interpréteur sur la carte, après quoi on lui envoie du Python — au clavier dans le REPL, ou sous forme de fichiers .py. Le programme cible reste le Blink, l’équivalent embarqué du « Hello World ».

À quoi ça sert ?

La prise en main valide toute la chaîne : éditeur, firmware sur la carte, liaison USB, REPL. Si un maillon manque, le Blink ne clignote pas, et on le sait tout de suite, sur du code trivial.

Au-delà du premier programme, elle installe deux réflexes propres à MicroPython :

  • Le REPL comme bac à sable. Une fois le firmware en place, on peut taper une commande (led.on()) et voir l’effet immédiatement, sans téléverser quoi que ce soit. C’est l’atout majeur de l’approche scriptée pour explorer un capteur ou un module.
  • Le modèle « fichiers sur la carte ». Un programme MicroPython est un fichier .py enregistré sur la carte. Le fichier nommé main.py se lance tout seul à la mise sous tension. La carte devient autonome, sans ordinateur.

Procédure pas à pas

Cinq étapes : installer Thonny, flasher le firmware, se connecter, écrire (au REPL puis en fichier), rendre autonome.

1. Installer Thonny

Téléchargez Thonny depuis thonny.org et installez-le (Windows / macOS / Linux). C’est l’IDE débutant de référence pour MicroPython : il sait flasher le firmware, ouvre le REPL, et gère les fichiers de la carte.

Prendre capture d’écran de la page de téléchargement de Thonny sur thonny.org, avec les liens par système d’exploitation.

2. Flasher le firmware MicroPython sur le Pico 2

C’est l’étape propre à MicroPython, à faire une seule fois par carte. Le plus simple passe par Thonny :

  • branchez le Pico 2, puis, en bas à droite de Thonny, cliquez sur le sélecteur d’interpréteur → « Installer MicroPython… » (ou Outils → Options → Interpréteur) ;
  • choisissez la variante Raspberry Pi Pico / Pico 2, et suivez l’invite : Thonny demande de maintenir le bouton BOOTSEL en rebranchant la carte, puis installe le firmware.

Tip

Méthode manuelle (sans Thonny). Maintenez le bouton BOOTSEL du Pico enfoncé en branchant l’USB : la carte apparaît comme une clé USB nommée RP2350 (ou RPI-RP2). Glissez-y le fichier .uf2 du firmware Pico 2, téléchargé sur micropython.org (rubrique Download, carte Pico 2) ou raspberrypi.com. La carte redémarre en exécutant MicroPython.

Prendre capture d’écran de la boîte de dialogue « Installer MicroPython » de Thonny, avec la variante Raspberry Pi Pico 2 sélectionnée.

3. Se connecter à la carte (le REPL)

Dans Outils → Options → Interpréteur, choisissez « MicroPython (Raspberry Pi Pico) » et le port de la carte. En bas de Thonny, le panneau Shell affiche l’invite du REPL :

>>>

C’est l’interpréteur qui tourne sur le Pico. Tapez pour vérifier :

>>> print("Bonjour depuis le Pico")
Bonjour depuis le Pico

Prendre capture d’écran de Thonny avec l’interpréteur réglé sur « MicroPython (Raspberry Pi Pico) » et le Shell affichant l’invite puis le résultat d’un print.

4. Allumer la LED… au REPL, puis en programme

D’abord en direct, ligne à ligne. C’est là que l’approche scriptée brille :

>>> from machine import Pin
>>> led = Pin("LED", Pin.OUT)   # LED intégrée (GP25 sur Pico 2 ; "LED" marche aussi sur Pico 2 W)
>>> led.on()                    # la LED s'allume IMMÉDIATEMENT
>>> led.off()

Puis le Blink comme programme. Dans l’éditeur de Thonny, saisissez :

from machine import Pin
from time import sleep
 
led = Pin("LED", Pin.OUT)
 
while True:
    led.on()
    sleep(1)
    led.off()
    sleep(1)

Notez la différence avec Arduino : pas de setup()/loop(), mais du code qui s’exécute de haut en bas, et une boucle while True: pour répéter. Les blocs sont délimités par l’indentation, pas par des accolades (voir le langage).

Cliquez sur Exécuter (le bouton vert) : Thonny envoie le script au Pico et le lance. La LED clignote. Le programme tourne. La prise en main est validée. Pour l’arrêter, le bouton Stop (rouge), ou Ctrl-C dans le Shell.

Si rien ne clignote, reprenez le choix de l’interpréteur à l’étape 3, puis voyez les Pièges.

5. Rendre la carte autonome (main.py)

Tant que le script est lancé depuis Thonny, il s’arrête si l’on débranche. Pour qu’il tourne seul à la mise sous tension, enregistrez-le sur la carte sous le nom main.py (Fichier → Enregistrer sous… → Raspberry Pi Pico). Débranchez/rebranchez : la LED clignote sans ordinateur.

Prendre capture d’écran de la boîte « Enregistrer sous » de Thonny proposant « Raspberry Pi Pico » comme destination, le fichier nommé main.py.

Exemple — Blink modifié

Pour vérifier qu’on contrôle réellement le comportement, changez le rythme :

from machine import Pin
from time import sleep
 
led = Pin("LED", Pin.OUT)
 
while True:
    led.on()
    sleep(0.1)    # éclair court
    led.off()
    sleep(0.9)

Relancez : un éclair court toutes les secondes. Ce petit pas — modifier, relancer, observer — est le geste de base de tous les tutoriels suivants. (On peut aussi tester led.toggle() au REPL pour basculer l’état d’un coup.)

Pièges

Interpréteur resté sur le PC. Si Thonny pointe sur le Python local (et non « MicroPython (Raspberry Pi Pico) »), le code s’exécute sur l’ordinateur, pas sur la carte, et from machine import Pin échoue. Vérifier l’interpréteur en bas à droite.

Firmware non installé. Sans l’étape 2, la carte n’est pas un interpréteur MicroPython : Thonny ne s’y connecte pas. Le BOOTSEL ne sert qu’à flasher le firmware, pas à chaque exécution.

Script lancé depuis Thonny ≠ autonome. Un programme exécuté par Thonny s’arrête au débranchement. Pour l’autonomie, l’enregistrer sur la carte sous main.py (étape 5).

Boucle infinie qui « bloque » la carte. Un while True: occupe l’interpréteur : pour reprendre la main au REPL, Stop ou Ctrl-C. Si main.py boucle dès le démarrage et empêche toute connexion, rebrancher en BOOTSEL et re-flasher (ou supprimer main.py).

Réflexe 5 V. Le Pico 2 est en 3,3 V, non tolérant 5 V : ne pas appliquer 5 V sur une broche (voir niveaux de tension).

Câble « charge seule ». Carte alimentée mais aucun port : changer pour un câble de données.

Cas particulier — Autres éditeurs et autres cartes

  • Ligne de commande — mpremote (officiel) et rshell pilotent la carte et copient des fichiers depuis un terminal, pratiques pour scripter ou pour l’intégration continue.
  • VS Code — l’extension MicroPico (ou Pico-W-Go) apporte REPL et envoi de fichiers dans VS Code, pour un projet plus structuré.
  • Autres cartes — le même Thonny + le firmware adapté programment un ESP32 ou une Pyboard en MicroPython. Seuls le firmware et quelques broches changent.

Raccrochage projet

  • Étape 4 de la phase de preuve de concept — flasher le firmware et lancer un premier programme est l’acte fondateur de la PoC logicielle en MicroPython. Tant que le Blink ne clignote pas, rien en aval n’est crédible.
  • Tous les tutoriels MicroPython aval — faites le Blink (et essayez le REPL) au moins une fois, sur le matériel cible, le plus tôt possible.

Le REPL change la façon de déboguer : avant d’écrire un programme complet, on teste une ligne sur la carte. Prendre ce réflexe dès la prise en main fait gagner un temps considérable sur tout le reste du module.

Aller plus loin

Voir aussi

Signaler une erreur

Si vous trouvez une erreur, un lien qui ne mène nulle part, une image manquante ou une explication bancale, dites-le à votre enseignant : la correction profite à la promotion suivante.

Vue Graphique

Liens retour