Comment programmer le Raspberry Pi Pico en micropython, avec Thonny IDE (sous Windows) ?

Saviez-vous qu’il existe un moyen simple et rapide pour programmer son Raspberry Pi Pico en MicroPython ? Il s’agit de Thonny IDE, un environnement de développement léger, 100% gratuit, et disponible sous Windows, Mac, et Linux !

Ici, nous verrons comment installer ce petit logiciel, paramétrer son interpréteur micropython, et enfin, comment faire exécuter du code micropython par son Raspberry Pico, depuis son PC ! Alors en avant !

Si vous êtes débutez en programmation pour Raspberry Pi Pico, je vous conseille vivement le langage de programmation MicroPython et l’IDE Thonny (recommandé par la fondation Raspberry, d’ailleurs). Car ainsi, vous pourrez rapidement développer vos premières applications, et gagner en expérience. Ensuite, libre à vous de passer de passer à la vitesse supérieure, et d’explorer le C/C++ ! Mais chaque chose en son temps, et pour l’heure, découvrons la programmation MicroPython opur Raspberry Pico 😉

Prérequis (logiciel/matériel)

Comme évoqué en intro, il existe plusieurs façons de programmer un Raspberry Pi Pico. Mais le plus simple est, selon moi, d’utiliser le langage de programmation MicroPython, avec l’interface de développement Thonny (en tout cas, si vous débutez, c’est l’idéal !).

Pour ce faire, vous aurez besoin de 3 choses :

• le logiciel « Thonny IDE » (gratuit)
• une carte Raspberry Pi Pico, bien évidemment 😉
• et un câble USB ↔ microUSB, pour faire la liaison entre votre ordi, et la carte Pico !

Voyons d’ailleurs tout cela plus en détail, dès à présent.

Installer l’IDE Thonny (environnement de développement)

La première chose dont vous aurez besoin, est l’environnement de développement Thonny. Il faut donc le télécharger !

Pour cela, il vous suffit de vous rendre sur le site officiel de Thonny (https://thonny.org/), puis, en fonction de votre système d’exploitation (Windows, Mac, ou Linux), de télécharger la version qui vous convient. Pour ma part, j’ai pris la version « Windows 64 bits », car c’est celle qui correspondait à mon PC.

D’ailleurs, pour ceux qui travaillent sous Windows, comme moi, voici quelques images, prises pendant l’installation sur mon ordi (rien de bien compliqué pour l’instant, vous en conviendrez !) :

Une fois l’installation achevée, ne lancez pas cette application pour l’instant, car j’ai plusieurs choses à vous expliquer auparavant !

Nota : vous remarquerez que j’emploie très souvent ici le nom de « Thonny IDE » ou « IDE Thonny ». Comme vous l’avez certainement compris, « Thonny est le nom du logiciel ». Et, pour ceux qui ne le sauraient pas, « IDE » (provenant de l’anglais « Integrated Development Environment) est tout simplement un « environnement de développement intégré » (EDI, en français) ; en clair, il s’agit d’une application (d’un logiciel, si vous préférez) qui nous aide (nous programmeurs) à développer efficacement/rapidement du code logiciel.

Avoir une carte Raspberry Pi Pico

La deuxième chose dont nous aurons besoin, est évidemment une carte Raspberry Pi Pico.

Ici, libre à vous d’utiliser le modèle de Pico qui vous convient ! Pour rappel, il existe actuellement 4 types de RPi Pico différents, à l’heure où je rédige ce guide :

Modèle	Pico « de base »	Pico H	Pico W	Pico WH
Aperçu de la carte
Avec « castellated holes » ?	Oui	Non	Oui	Non
Avec « module WiFi » ?	Non	Non	Oui	Oui
Lien (description/prix)	Raspberry Pico	Raspberry Pico H	Raspberry Pico W	Raspberry Pico WH

À noter que si vous débutez, je vous conseille de travailler sur un Pico en version « de base », plutôt qu’un Pico disposant « d’un module WiFi ». En effet, ces derniers comportent un câblage interne plus spécifique, ce qui peut les rends un poil plus difficile à prendre en main. Mais cela étant dit, encore une fois, libre à vous d’opter pour le modèle qui vous convient ou plaît le plus 😉

Raccorder le Raspberry Pi Pico à son ordinateur

Pour raccorder son Raspberry Pi Pico à son ordinateur, un simple câble USB suffit. Celui-ci doit être de type « micro USB » côté Pico, et USB « normal » côté PC.

Ici, nul besoin de breadboard ou de boitier spécifique, pour contenir ou supporter sa carte Raspberry Pico (pour faire ses premiers pas avec ce tuto, j’entends). Par contre, faites bien attention à ne pas provoquer de court-circuit, si vous n’avez pas de plan de travail isolé !

Remarque : là aussi, attendez que je vous explique deux ou trois choses supplémentaires, avant de brancher ou lancer quoi que ce soit. Ainsi, vous comprendrez mieux tout ce qui va se passer ensuite 😉

[Remarque] Juste un mot sur les Bootloader > Firmware > Programme micropython d’un Pico

Juste avant de vous expliquer comment programmer un Raspberry Pi Pico avec Thonny IDE, je souhaitais vous parler de 3 choses importantes avant tout (pour que vous compreniez mieux la suite, en fait). Ce sont les notions de « Bootloader », de « Firmware », et de « Programme micropython ».

Tout d’abord, il faut savoir que tous les Raspberry Pi Pico disposent d’un « bootloader intégré », dans leur mémoire ROM ; c’est à dire un programme de démarrage « gravé dans le dur », dans la mémoire morte du microcontrôleur. Ce programme permet entre autre :

• la communication entre le Raspberry Pico et un ordi, via le port USB
• et l’exécution de code programme, stocké en mémoire FLASH

La mémoire FLASH, pour parler d’elle, peut contenir :

• un programme (écrit en langage machine, directement compréhensible par le µC)
• et d’éventuelles données

Et c’est là où je voulais en venir !

En fait, pour qu’un Raspberry Pi Pico puisse exécuter des scripts écrits en MicroPython, nous allons utiliser la mémoire FLASH de cette manière là :

• la partie programme hébergera un interpréteur micropython (c’est à dire un micrologiciel, aussi appelé firmware en anglais, permettant de transformer à la volée du code MicroPython, en langage machine, que le microcontrôleur saura comprendre)
• et la partie données hébergera nos fichiers-programmes écrits en MicroPython

Ainsi, le microcontrôleur du Pico exécutera du code machine fournit au fur et à mesure par le firmware (l’interpréteur micropython), en sachant que ce code machine proviendra de nos scripts micropython, interprétés à la volée.

À présent, nous allons pouvoir attaquer la suite, à savoir :

• comment graver un firmware (qui contiendra l’interpréteur de code MicroPython), sur notre Raspberry Pico
• et comment envoyer du code micropython au Pico, qu’il devra exécuter (ou plus exactement, si vous avez bien suivi, comment transmettre du code micropython à l’interpréteur micropython installé sur le Pico, afin qu’il puisse le convertir en code machine à la volée, pour que le µC puisse l’exécuter au fur et à mesure !)

Et vous comprendrez certainement mieux maintenant pourquoi nous installerons qu’une seule fois le firmware au début, et qu’ensuite, on ne s’en occupera plus !

Nota : j’ai particulièrement simplifié cette partie, afin qu’elle soit la plus simple possible à comprendre, dans le principe. Cela étant dit, ça reste quand même délicat à expliquer … du coup, j’espère que mes explications auront été suffisamment claires, et que je ne vous ai pas perdus ! Sinon ne vous inquiétez pas, passez simplement à la suite, et revenez ici plus tard 😉

Implanter le firmware « micropython » dans son Raspberry Pico (à faire uniquement la 1ère fois)

Remarque : ceci est à faire UNIQUEMENT LA PREMIÉRE FOIS, si :
– vous travaillez avec une carte Raspberry Pi Pico neuve (et donc vierge de tout programme)
– vous avez purgé (effacé) la totalité des données de la mémoire flash de votre Pico
– vous souhaitez remplacer un firmware existant (pour simplement l’upgrader, par exemple)

La première chose à faire, si vous souhaitez exécuter du code micropython sur votre Raspberry Pi Pico, c’est de lui transmettre l’interpréteur micropython, sous forme de firmware. Cet interpréteur, pour rappel, permettra de « convertir » le code python pour microcontrôleur, en langage machine, pour que le µC puisse l’exécuter.

À noter que l’interpréteur micropython (le firmware) se présente sous la forme d’un fichier « .UF2 », téléchargeable sur le site https://micropython.org/, et spécifique à chaque « famille » de microcontrôleur.

Pour installer ce micrologiciel dans votre Pico, vous avez 2 manières de faire :

• soit vous le faites « à la main »
• soit vous le faites à l’aide de l’IDE Thonny

Ici, je vais vous montrer les deux façons de faire, et vous choisirez celle que vous préférez ! Perso, l’IDE Thonny a ma préférence, car tout se passe au même endroit (téléchargement sur PC, puis upload vers Pico) ; qui plus est, vous pouvez « immédiatement » vérifier la version du firmware installé, depuis la console de l’IDE Thonny.

Première façon de faire : copier/coller le fichier du firmware micropython, du PC sur son Pico (sous Windows)

Pour installer un firmware manuellement dans son Raspberry Pico, il y a 2 étapes à suivre :

• récupérer la dernière version du firmware correspondant à sa carte Pi Pico
• et copier/coller ce firmware dans « l’espace de stockage » dédié, du Pico

Ainsi, pour commencer, il faut tout d’abord récupérer le firmware correspondant à sa carte. Pour ce faire, le plus simple est d’aller sur le site micropython.org, ou plus exactement, sur sa page download (accessible ici : https://micropython.org/download/). Puis, il faudra descendre dans la page, jusqu’à trouver l’image correspondant à sa carte (ou faire CTRL+F, pour rechercher le nom de sa carte). De cette manière, vous trouverez par exemple :

• pour le Raspberry Pi Pico « de base », le lien suivant : https://micropython.org/download/rp2-pico/
• pour le Raspberry Pi Pico « avec module WiFi », le lien suivant : https://micropython.org/download/rp2-pico-w/

Remarque : comme vous verrez, il y a presque toujours deux catégories de firmware : les « Releases » et les « Nightly builds ». En fait :
– les firmware de type « Releases » sont les versions éprouvées, valides, et « stables » ; il faut donc les choisir en priorité (et de préférence celle qui est notée « lastest », pour bien avoir la dernière version stable).
– les firmware de type « Nightly builds » sont des versions non encore totalement éprouvées, et qui peuvent donc parfois être « instables » ; il vaut mieux les éviter (à moins, bien sûr, que ce soit la seule option disponible, ou que ayez vraiment besoin des « nouvelles » améliorations qu’elles contiennent).

À noter que le firmware que vous allez télécharger se présente sous la forme d’un fichier « .uf2 », qui est un format de fichier développé par Microsoft, particulièrement adapté pour le « flashage » des microcontrôleurs.

Pour envoyer ce fichier UF2 dans votre Pico, il vous suffira de suivre les étapes suivantes :

• vous assurer que votre Raspberry Pi Pico est bien débranché de votre PC
• puis d’appuyer sur le bouton « BOOTSEL » de votre carte Pico (il y a normalement qu’un seul bouton sur la carte, vous ne pouvez donc pas vous tromper !)
• et, tout en maintenant le bouton bootsel appuyé, brancher votre Raspberry Pico à votre PC, par l’intermédiaire d’un câble USB

Ainsi, vous devriez voir votre Raspberry s’afficher sur votre ordinateur, à l’image d’une clef USB (c’est à dire un « périphérique de stockage de masse »).

Nota : la toute première fois où vous branchez un Raspberry Pi Pico sur un PC, vous aurez peut-être un « pilote Windows » qui s’auto-installera. Si c’est le cas, patientez juste quelques secondes, et la fenêtre correspondant à l’espace de stockage du Pico apparaîtra juste après.

   

À partir de là, vous pouvez copier/coller (ou glisser/déposer) votre fichier .UF2, téléchargé sur le site micropython, dans la fenêtre matérialisant l’espace de stockage de votre carte Raspberry Pi Pico, comme imagé ci-dessous (exemple avec un Pico W, ici) :

Une fois fait, la fenêtre doit se fermer au bout de quelques seconde, du fait que le Raspberry Pico effectue un reset, après installation du firmware.

Félicitation ! Votre raspberry est maintenant prêt à exécuter du code micropython 😉

Deuxième façon de faire : utiliser l’IDE Thonny, pour implanter le firmware micropython dans son Pico

Pour commencer, avant de lancer l’IDE Thonny, il va falloir brancher votre carte Raspberry Pi Pico à votre PC, pour qu’elle démarre en mode « stockage de masse ». Pour ce faire, il suffit d’effectuer les 3 opérations suivantes :

• gardez votre Raspberry Pico débranché (il ne doit pas être branché au PC, pour l’instant)
• appuyez sur le bouton BOOTSEL de votre carte Pico (c’est normalement le seul bouton poussoir présent sur la carte, à moins que vous ayez une variante, « non officielle »)
• et, tout en maintenant le bouton poussoir appuyé, branchez le Raspberry Pico sur votre PC

Ainsi, vous devriez voir une fenêtre s’ouvrir sur votre PC, comme si vous aviez branché une clef USB (à noter que Windows devrait automatiquement installer le pilote approprié, si c’est la 1ère fois que vous branchez un Pico sur votre PC). Pour plus d’infos en image, n’hésitez pas à vous rapporter au paragraphe précédent (où il fallait faire la même manip).

Puis fermez la fenêtre ouverte, car à présent, nous allons continuer avec l’IDE Thonny.

Ensuite, ouvrez le logiciel Thonny IDE. Remarque : si c’est la première fois que vous lancez Thonny sur votre PC, il vous demandera de préciser la langue à utiliser (j’ai sélectionné « Français »), et les paramètres initiaux (j’ai laissé sur « Standard »). Du reste, si vous ne connaissez pas encore l’interface Thonny, ne vous inquiétez pas ! Car pour l’heure, nous allons juste faire quelques manips basiques, ne nécessitant pas vraiment de connaître le logiciel.

À présent, regardez attentivement en bas/à droite de l’interface Thonny. Vous devriez voir écrit : « Local Python 3 – Thonny’s Python ». Cliquez dessus, avec le bouton gauche de votre souris. Ainsi, vous devriez voir un menu s’afficher, tel que celui-ci :

Cliquez ensuite sur « Install MicroPython… », pour ouvrir la fenêtre de préparation d’installation de MicroPython. Celle-ci ressemble à ça :

Ici, 3 listes déroulantes figurent à l’écran :

• la 1ère liste déroulante, « Target Volume », doit pointer vers le volume de stockage de votre Raspberry Pico (c’est comme une clé USB, en fait) ; normalement, le « bon » volume est sélectionné par défaut, en automatique (sinon, sachez qu’il s’appelle « RPI-RP2 », et qu’il est donc facile de le retrouver !).
• la 2ème liste déroulante, « MicroPython variant », permet de sélectionner le modèle de carte ; là aussi, Thonny identifie normalement le modèle que vous avez branché (sinon, changez-le manuellement). Faites tout de même bien attention que le bon modèle de carte soit sélectionné, selon si vous avez un Raspberry Pi Pico « en version de base » (noté Pico / Pico H), ou en version « avec module WiFi » (noté Pico W / Pico WH).
• la 3ème liste déroulante, « Version », désigne tout simplement la version du firmware que vous souhaitez installer ; là encore, par défaut, la dernière version « stable » devrait être automatiquement sélectionnée. Sinon, ou si vous souhaitez une autre version, libre à vous de modifier cela, en sélectionnant une autre version, dans la liste proposée.

Une fois les paramètres convenablement sélectionnés, dans ces trois listes déroulantes, cliquez sur « Installer », pour implanter ce firmware (qui est en fait un interpréteur micropython), dans votre Raspberry Pi Pico.

Au bout de quelques instants, vous devriez voir apparaître la mention « Done » sur cette même fenêtre.

Ici, il ne vous reste plus qu’à cliquer sur le bouton « Fermer », pour faire disparaître cette fenêtre.

Enfin, dernière étape (si Thonny n’a pas automatiquement basculé d’interpréteur, en bas) : sélectionnez « MicroPython (Raspberry Pi Pico) » à la place de « Local Python 3 », en bas à droite, comme visible ci-dessous :

Et pour vérifier que tout se soit bien passé, il suffit de lire la version du firmware du Pico, à présent détecté par l’IDE Thonny. Cela apparaît en clair dans la console :

Comme vous pouvez le constater, Thonny indique « MicroPython v1.19.1 », ce qui correspond bien au langage et à la version que j’avais sélectionnés, dans les listes déroulantes, deux images plus haut.

Astuce complémentaire : si jamais vous utilisez un autre logiciel que Thonny IDE, et que vous souhaitez connaître la version du firmware, il suffit d’exécuter les 2 lignes micropython suivantes :
       import os;
       print(os.uname());
Ainsi s’affichera à l’écran la version du firmware installé sur votre Raspberry Pi Pico 😉

À partir de maintenant, vous pouvez faire exécuter du code micropython par votre Raspberry Pi Pico, qui dispose d’un interpréteur micropython opérationnel, pour transformer nos scripts MicroPython en langage machine (en instructions que le microcontrôleur pourra comprendre, si vous préférez !). Alors en avant 😉

Programmer son Raspberry Pi Pico avec Thonny IDE (exemple de code « Blink »)

Si vous êtes débutant en la matière, sachez que l’IDE Thonny est sans conteste l’une des applications les plus simples qui soit, pour programmer un Raspberry Pico en micropython. Enfin … selon moi ! En effet, le fait de pouvoir en un seul et même endroit installer/upgrader un firmware, gérer des fichiers locaux et distants, et exécuter de code MicroPython sur un Pico, rend cet outil idéal, pour débuter. Cela étant dit, rien ne vous empêchera ensuite d’aller creuser du côté de Visual Studio Code ou autre, et vous initier à la programmation C/C++, par exemple ! Mais pour l’heure, faisons « simple » 😉

Pour commencer, ouvrez l’application Thonny.

L’espace de travail de l’IDE Thonny est divisé en 4 grandes parties, comme visible sur l’image ci-dessous :

On y retrouve :

• un explorateur de fichiers locaux, côté PC, donc
• un explorateur de fichiers distants, côté Pico, donc (à noter que cela est seulement visible si un Pico est branché sur son PC)
• une zone pour l’édition de code programme, python/micropython
• et une console interactive, pour récupérer des messages venant du Pico, tout comme envoyer des instructions « manuellement » à l’interpréteur MicroPython (c’est ce qu’on appelle du REPL, pour Read – Evaluate – Print – Loop)

Ici, je vous propose de copier/coller le programme ci-dessous, dans la « zone d’édition programme » de Thonny IDE (il s’agit en fait d’un exemple de « programme blink », permettant de faire clignoter la LED de votre Pico) :

# ======================================================================
# Programme BLINK (faisant clignoter la LED embarquée sur la carte Pico)
# ======================================================================

from machine import Pin
from time import sleep

led = Pin(25, mode=Pin.OUT)          # Si vous utilisez un Raspberry Pi Pico "de base" (modèle Pico ou Pico H)
# led = Pin('LED', mode=Pin.OUT)     # Si vous utilisez un Raspberry Pi Pico "avec module WiFi" (modèle Pico W ou Pico WH)

while True:      # Boucle perpétuelle (celle-ci ne s'arrêtera jamais, car la condition "True" est toujours "vraie")
    led.on()          # Allumage de la LED du Pico
    sleep(1)          # Mise en pause du programme, pendant 1 seconde
    led.off()         # Extinction de la LED du Pico
    sleep(1)          # Nouvelle pause programme d'une seconde, et rebouclage sur le while

# Remarque : avant led.high(), sleep(1), et led.low(), ce sont des tabulations qui sont présentes, et non
#            des espaces (qui seraient faits avec la barre d'espace). Si jamais vous copiez/collez ce code,
#            et qu'il y a des espaces à la place des tabulations, il faudra les remplacer par des tabulations !

Pour faire simple, ce code va piloter l’état de sortie GPIO25 de votre carte Raspberry Pi Pico, et faire changer son état toutes les secondes.

Ceci est permis par la boucle « while », qui prend en paramètre la valeur « True », créant ainsi une boucle infinie (perpétuelle). À l’intérieur de cette boucle, le code va se répéter : allumer la LED du Pico, attendre 1 seconde, éteindre la LED du Pico, réattendre 1 seconde, et recommencer, sans fin !

Juste quelques remarques, concernant ce code, si vous débutez en python ou micropython :

• les textes précédés d’un « # » sont en fait des commentaires ; ils sont uniquement là pour renseigner le code (ils sont donc ignorés, au moment de l’exécution du programme)
• en MicroPython, comme en Python, toutes les tabulations ne sont pas là pour faire « joli » ; elles structurent le code, et sont donc à respecter, pour la bonne interprétation du code (nota : si jamais ces tabulations sont remplacées par des espaces, au moment du copier/coller, il faudra les reremplacer par des tabulations)
• les langages python/micropython sont « sensibles à la casse », c’est à dire que minuscules et majuscules sont importantes à respecter (par exemple, si vous écrivez « true » à la place de « True », vous aurez une erreur en retour)
• les « from » et « import » permettent de faire appel à des librairies (ici inclues de base, dans micropython)
• sur un Raspberry Pi Pico « de base », la LED est branché sur la GPIO25 ; c’est pourquoi il y a un « 25 » dans la ligne « led = Pin(25, mode=Pin.OUT) ». Par contre, si vous utilisez un modèle Pico W (avec module WiFi intégré, donc), il faut remplacer cette ligne de code en « led = Pin(‘LED’, mode=Pin.OUT) » (du fait que la LED n’est pas directement accessible depuis le microcontrôleur avec un PicoW, mais seulement au travers de son module wifi ; ce qui nécessite forcément un peu de code particulier, en arrière plan, d’où le ‘LED’ à la place du 25)
• on aurait respectivement pu remplacer led.on() et led.off() par led.high() et led.low(), dans le cas du Raspberry Pi Pico (pas forcément vrai, avec d’autres microcontrôleurs)
• on aurait pu remplacer les led.on() et led.off() par un seul et unique led.toggle(), afin de simplement faire basculer l’état de la sortie, où la LED du Pico est raccordée

Pour exécuter le code précédemment présenté, sur votre Raspberry Pi Pico, il suffit de cliquer sur l’icône avec la flèche verte (« Exécuter le script courant »), aussi accessible avec la touche F5 du clavier :

À présent, la LED de votre Raspberry Pico devrait clignoter (à raison d’une seconde allumée, une seconde éteinte).

Nota : je ne vous l’ai pas dit, mais à tout moment, vous avez possibilité d’enregistrer ce script, soit en local sur votre PC, soit sur votre Raspberry Pi Pico (en cliquant sur l’icône représentant sur une disquette, ou en faisant CTRL+S sur le clavier, ou en allant dans le menu Fichier > Enregistrer Sous). Pensez juste à mettre l’extension « .py » au nom de fichier enregistré, pour bien indiquer qu’il s’agit d’un code python/micropython.

Pour arrêter ce programme, il vous suffira de cliquer sur l’icône représentant un panneau STOP (« Arrêter/redémarrer l’interpréteur »). Ainsi le « blink » de la LED de votre carte Raspberry Pico s’arrêtera.

Remarque : contrairement à Arduino, si vous débranchez/rebranchez votre carte Pico, le programme ne se mettra pas automatiquement en route, dès la mise sous tension ; à moins que vous ayez donné un nom spécifique à votre fichier micropython, comme nous allons le voir à présent !

[Complément #1] Créer un fichier « spécial » dans son Pico, pour qu’il s’exécute automatiquement à la mise sous tension

Si vous avez l’habitude de développer des programmes sous Arduino, vous savez sûrement que les programmes uploadés sur une carte arduino sont automatiquement exécutés, à la remise sous tension de la carte. Mais dans le cas d’un Raspberry Pi Pico avec firmware micropython intégré, c’est différent d’un Arduino.

En effet, un Raspberry Pico flashé d’un firmware n’exécutera que le code du firmware en lui-même, en automatique, à sa remise sous tension (et « rien d’autre »). Par contre, comme vous vous en doutez, il y a un moyen de « passer outre » 😉

La solution réside dans le firmware en lui-même, en fait. Car celui-ci, lorsqu’il est exécuté au démarrage du Pico, recherche la présence ou non d’un fichier « main.py ». Ainsi :

• si un fichier « main.py » est présent, alors l’interpréteur va l’interpréter (l’exécuter, si vous préférez)
• si aucun fichier « main.py » n’est présent, alors le Raspberry Pi Pico « s’arrête là »

Du coup, si vous souhaitez que votre code micropython soit exécuté à la mise sous tension de votre Raspberry Pico, il faudra tout simplement lui donner le nom « main.py », lorsque vous l’enregistrerez sur la carte Pico (via Thonny IDE, par exemple).

Nota : pour tester cela, prenez simplement l’exemple de code précédent (blink), enregistrez-le sur votre carte Pico (en lui donnant le nom de « main.py »), puis débranchez votre carte Pi Pico de votre PC, et branchez-la sur n’importe quelle prise d’alim USB (même en dehors de votre PC). Ainsi, vous devriez voir la LED de la carte Raspberry clignoter, dès sa mise sous tension !

[Complément #2] Comment retirer le firmware micropython, si souhaité (pour revenir à l’état initial, comme « sorti d’usine »)

Si un jour vous souhaitez retirer le firmware micropython de votre Raspberry Pi Pico, pour une raison ou une autre (pour passer au C/C++, par exemple), et par la même, effacer toutes les données stockées en mémoire flash (comme vos scripts micropython), sachez qu’il existe un moyen vraiment simple pour ce faire.

En fait, il suffit de copier/coller un programme .UF2 particulier dans votre Pico, en mode « stockage de masse », pour que ces opérations se réalisent. Côté mise en œuvre, plus précisément, c’est exactement la même procédure à suivre, que celle que nous avions vu au chapitre 3.1 (pour l’implantation « manuelle » d’un firmware).

En pratique maintenant, le fichier .uf2 dont nous aurons besoin pour vidanger la mémoire FLASH d’un Pico est mis à disposition sur le site Raspberry :

• en base de cette page, du site officiel : https://www.raspberrypi.com/documentation/microcontrollers/raspberry-pi-pico.html#resetting-flash-memory
• ou en téléchargement direct : https://datasheets.raspberrypi.com/soft/flash_nuke.uf2

Ce programme de vidange s’appelle « flash_nuke.uf2 ».

Pour rappel, il vous suffira donc simplement de brancher votre Pico à votre ordi, en mode « périphérique de stockage de masse » (en appuyant et maintenant le bouton BOOTSEL, pendant le branchement au PC), et de faire un copier/coller de ce fichier dans la fenêtre qui s’est ouverte (correspondant au volume de stockage de votre Raspberry Pico). Une fois fait, la vidange mémoire démarrera, puis une fois fait, le Raspberry Pi Pico effectuera un RESET. Ainsi, vous revenez à l’état initial « à neuf », ou « sorti d’usine », comme on dit !

Pour les plus curieux d’entre vous : techniquement, ce programme se logera en mémoire RAM (interne au µC, donc). Il videra « une à une » les cases de la mémoire FLASH (externe au µC), et fera faire un reset à la carte, une fois fini. Ainsi, votre Pico redémarrera, vide de tout programme ou toute donnée, en mémoire flash. Au final, c’est comme ça qu’un programme peut effacer toute une mémoire, sans s’effacer lui-même 😉

Pour résumer / ce qu’il faut retenir

Je vous rassure, programmer un Raspberry Pi Pico en MicroPython avec Thonny IDE est vraiment simple et plaisant, au final (enfin… une fois qu’on a compris ou pris l’habitude !).

Sinon, histoire de résumer l’ensemble des points à retenir (prenez votre temps) :

• le micropython est un langage informatique, dérivé du Python, spécifiquement conçu pour le développement de programmes sur microcontrôleur
• le micropython est un langage interprété (et non compilé) ; les lignes de code écrites en micropython doivent donc passer au travers d’un interpréteur (traducteur, si vous préférez), afin d’être transformées en code machine (ligne après ligne, et pas tout en même temps, contrairement à un compilateur)
• l’interpréteur micropython sera logé « en tête » de mémoire programme (FLASH), du Raspberry Pi Pico ; en quelque sorte, il agira comme une passerelle entre le microcontrôleur lui-même, et notre code micropython. On donnera le nom de firmware (qui signifie micrologiciel) à ce programme-interpréteur.
• ce firmware pourra être installé « à la main », ou à l’aide de l’IDE Thonny, à partir d’un fichier .UF2 (fourni sur le site micropython.org, et spécifique à chaque type/famille de microcontrôleur)
• à noter que l’interpréteur micropython est installé « une fois pour toute », pour ainsi dire, mais qu’il pourra tout du moins être mis à jour plus tard, ou être retiré, si souhaité
• nos scripts micropython (nos programmes, donc) seront eux-aussi stockés en mémoire programme (c’est à dire en mémoire FLASH du Pico), pour y être possiblement lus/exécutés à la demande, ligne après ligne, par l’interpréteur
• sans interpréteur micropython, le Raspberry Pico ne comprendrait pas nos lignes de code, écrites en langage MicroPython ; car son microcontrôleur (le RP2040) ne comprend que son langage à lui, c’est à dire le « langage machine »
• l’IDE Thonny vous permettra aussi bien de faire exécuter du code au Raspberry Pico depuis votre PC, que de sauvegarder des fichiers (scripts) micropython, dans votre ordi ou dans la mémoire de votre Pico (l’un n’excluant pas l’autre !)
• un script micropython, stocké dans la mémoire flash d’un Pi Pico, ne s’exécutera à la mise sous tension de ce dernier que s’il porte le nom « main.py » (ou s’il est appelé par ce fichier)
• et un code MicroPython pour Raspberry Pi Pico « de base » (Pico / Pico H) n’est pas forcément compatible avec un Raspberry Pico intégrant un module WiFi (Pico W / Pico WH) ; comme nous l’avons vu un peu plus haut d’ailleurs, avec le programme blink

Ça vous parait beaucoup de choses à retenir ? Certes ! Mais au fond, ce n’est pas si compliqué que ça, à comprendre ! Alors prenez votre temps, encore une fois, pour tout bien assimiler 😉

Pour aller plus loin …

Voilà ! Pour info, j’ai essayé de simplifier les choses au maximum, et évité d’entrer trop dans les détails. Aussi, j’espère ne pas avoir été trop long, dans mes explications ! Mais je pense qu’il était toutefois nécessaire de faire le tour de tout un tas de notions de base à connaître (langage, firmware, interpréteur, …), pour mieux appréhender la programmation micropython sur Raspberry Pi Pico.

Sur ce, il ne me reste plus qu’à vous souhaiter bon courage, pour vos prochaines tentatives de programmation Pico ! Et de vous dire à très bientôt !
Jérôme.

À découvrir aussi : découvrir le brochage du Raspberry Pi Pico et ses principales caractéristiques

JEROME

Passionné par tout ce qui touche à l'électronique, sans toutefois en être expert, j'ai à coeur de vous partager ici, peu à peu, tout ce que j'ai appris, découvert, réalisé, et testé jusqu'à présent ! En espérant que tout cela puisse vous servir, ainsi qu'au plus grand nombre !

(*) Mis à jour le 25/03/2023