Programmer le microcontrôleur Pico de Raspberry Pi avec MicroPython

Temps de lecture: 9 minutes

February 06, 2021

Rédigé par

Miguel Grinberg

Twilion

Révisé par

Ashley Boucher

Twilion

Programmer le microcontrôleur Pico de Raspberry Pi avec MicroPython

Avec la sortie du Raspberry Pi Pico, la fondation Raspberry Pi a étendu son offre de produits au-delà de sa gamme de mini-ordinateurs au succès fou, pour se lancer dans l'encore plus petit en se positionnant sur le marché des microcontrôleurs.

Contrairement au Raspberry Pi, qui fonctionne comme un ordinateur universel et exécute le très apprécié système d'exploitation Linux, le Pico est un appareil beaucoup plus primitif qui ne dispose pas d'un système d'exploitation central. Il ne peut être programmé que pour effectuer des tâches spécifiques ou contrôler des périphériques connectés, généralement dans le cadre d'un système intégré ou d'un appareil issu de l'Internet des objets.

Alors que la plupart des microcontrôleurs ne peuvent être programmés qu'en langage C ou C++, le Pico est également compatible avec le langage MicroPython, une version allégée de Python conçue spécifiquement pour les petits appareils. C'est un excellent choix pour les débutants qui souhaitent concevoir leurs propres appareils, mais qui n'ont pas le temps ou l'intérêt d'apprendre la programmation de bas niveau.

Dans cet article, vous allez apprendre à configurer et programmer votre Pico avec MicroPython. Vous n'avez pas encore le vôtre ? Les moins chers coûtent environ 4 EUR, alors achetez-en un (ou deux !) avant de poursuivre.

Prérequis

Pour suivre ce tutoriel, vous aurez besoin des éléments suivants :

Un microcontrôleur Raspberry Pi Pico. Vous trouverez ici les points de vente dans votre région.
Un ordinateur avec un port USB ou USB-C libre. Windows, Mac et Linux : peu importe le système d'exploitation !
Un câble USB vers micro-USB. Ils sont utilisés comme câbles de chargement pour de nombreux téléphones portables, vous en avez d'ailleurs peut-être déjà un. Voici un lien si vous avez besoin d'en acheter un ou de voir une photo. Si votre ordinateur est équipé de ports USB-C, vous aurez également besoin d'un adaptateur USB vers USB-C.
Python 3.6 installé sur votre ordinateur ou une version ultérieure. Si vous ne l'avez pas, vous pouvez télécharger un programme d'installation.

Installer MicroPython sur votre Pico

Avant de pouvoir programmer le Pico avec MicroPython, ce langage doit être installé sur la carte du microcontrôleur. Vous pouvez consulter la page de téléchargements MicroPython pour Pico pour trouver la version actuelle. Vous y trouverez une liste de versions stables et instables. Dans la liste, recherchez la version stable la plus récente et téléchargez-la sur votre ordinateur. Il s'agit d'un fichier avec une extension .uf2.

Version de MicroPython pour Pico (.uf2) à télécharger

C'est là que la partie commence. Prenez le câble USB vers micro-USB et branchez l'extrémité USB sur votre ordinateur.

Prenez ensuite votre Pico et trouvez le bouton BOOTSEL.

Appuyez sur le bouton et, tout en maintenant le bouton enfoncé, branchez l'extrémité micro-USB de votre câble sur votre Pico (le connecteur micro-USB est présenté sur le côté droit de l'image ci-dessus). Après quelques secondes, un nouveau lecteur de disque s'affiche sur votre ordinateur. Vous pouvez relâcher le bouton lorsqu'il apparaît.

Pour installer MicroPython, glissez et déposez le fichier .uf2 que vous avez téléchargé précédemment dans ce lecteur de disque. Une fois le fichier transféré, le lecteur disparaît et l'appareil redémarre automatiquement. Sur certains ordinateurs, vous pouvez recevoir un avertissement concernant la déconnexion du lecteur s'il n'est pas éjecté correctement. Vous pouvez ignorer cet avertissement.

Félicitations ! Vous avez installé MicroPython sur votre Pico !

Accès au REPL MicroPython

Tout comme le langage Python standard, MicroPython est fourni avec un REPL, où vous pouvez saisir des instructions et les faire évaluer de manière interactive. Le REPL MicroPython est accessible depuis votre ordinateur lorsqu'il est connecté à l'aide du câble USB.

Le Pico doit apparaître comme un appareil avec port de série sur votre ordinateur. La tâche suivante consiste donc à identifier le port de série parmi ceux éventuellement installés sur votre ordinateur qui est connecté à votre microcontrôleur. Cela peut dépendre du système d'exploitation que vous utilisez :

Si vous utilisez un Mac, le nom de l'appareil avec port de série PICO est /dev/tty.usbmodem0000000000001.
Sur un ordinateur Linux, le nom de l'appareil peut varier, mais il est généralement au format /dev/ttyACM<n>, où <n> est un nombre, probablement 0. Vous pouvez utiliser la commande lsusb pour répertorier tous les appareils connectés par USB. Si vous ne parvenez pas à identifier l'appareil associé au Pico, vous pouvez le débrancher de l'ordinateur et exécuter lsusb à nouveau. Vous verrez ainsi l'appareil qui manque à l'appel.
Sur un ordinateur Windows, le nom de l'appareil est au format COM<n>, où <n> est un nombre. Vous pouvez ouvrir le Gestionnaire de périphériques du panneau de configuration et rechercher la liste des appareils de série sous « Ports (COM et LPT) ». Si vous ne parvenez pas à identifier l'appareil contenant votre Pico parmi ceux répertoriés, débranchez-le du port USB et vérifiez à nouveau la liste pour trouver celui qui manque à l'appel.

Très bien, vous connaissez maintenant l'appareil de série utilisé par votre ordinateur pour se connecter au microcontrôleur Pico.

Le Pico se comporte comme un appareil de série standard : il est accessible avec n'importe quel programme de terminal de série disponible pour votre système d'exploitation. Dans cet article, vous allez utiliser rshell, un outil écrit en Python conçu pour se connecter aux cartes de microcontrôleur MicroPython et les gérer.

Ouvrez une fenêtre de terminal sur votre ordinateur et créez un nouveau répertoire dans lequel vous stockerez vos expériences Pico :

mkdir pico-tests
cd pico-tests

Créez et activez un environnement virtuel Python. Si vous utilisez un ordinateur Mac ou Linux, procédez comme suit :

python3 -m venv venv
source venv/bin/activate

Sur un ordinateur Windows, utilisez les commandes suivantes :

python -m venv venv
venv\Scripts\activate

Assurez-vous que l'environnement virtuel Python est activé en vérifiant que votre invite de commande inclut maintenant un préfixe (venv).

Installez ensuite l'outil rshell dans votre environnement virtuel :

pip install rshell

Assurez-vous que le Pico est toujours connecté à votre ordinateur à l'aide du câble USB (vous ne verrez pas de lecteur de disque maintenant), puis exécutez la commande suivante pour vous y connecter à partir de votre ordinateur :

rshell -p <your-pico-serial-device> --buffer-size 512

Pensez à remplacer <your-pico-serial-device> par le nom de l'appareil de série attribué à votre Pico dans la commande ci-dessus. Par exemple, sur un ordinateur Mac, la commande réelle est la suivante :

rshell -p /dev/tty.usbmodem0000000000001 --buffer-size 512

Sous Windows, en supposant que le Pico est connecté à COM3, la commande serait la suivante :

rshell -p COM3 --buffer-size 512

Le résultat de rshell doit se présenter comme suit :

Using buffer-size of 512
Connecting to /dev/tty.usbmodem0000000000001 (buffer-size 512)...
Trying to connect to REPL  connected
Testing if ubinascii.unhexlify exists ... Y
Retrieving root directories ...
Setting time ... Feb 04, 2021 14:33:07
Evaluating board_name ... pyboard
Retrieving time epoch ... Jan 01, 1970
Welcome to rshell. Use Control-D (or the exit command) to exit rshell.
/Users/miguel/pico-tests>

La commande doit se terminer par une nouvelle invite. Saisissez help (aide) dans cette invite pour voir toutes les commandes compatibles avec rshell :

/Users/miguel/pico-tests> help

Documented commands (type help <topic>):
========================================
args    cat  connect  date  edit  filesize  help  mkdir  rm     shell
boards  cd   cp       echo  exit  filetype  ls    repl   rsync

Use Control-D (or the exit command) to exit rshell.
/Users/miguel/pico-tests>

Pour le moment, concentrons-nous sur la commande repl, qui démarre un shell interactif MicroPython sur votre appareil Pico :

/Users/miguel/pico-tests> repl
Entering REPL. Use Control-X to exit.
>
MicroPython v1.14 on 2021-02-02; Raspberry Pi Pico with RP2040
Type "help()" for more information.
>>>

Cela vous dit quelque chose ? Si vous avez déjà utilisé un REPL Python, vous reconnaîtrez certainement l'invite >>>. Vous pouvez désormais saisir des instructions Python, exactement comme vous le feriez dans un shell Python exécuté sur votre ordinateur. Mais n'oubliez pas que MicroPython s'exécute sur la carte Pico et que votre ordinateur agit comme un terminal passif.

Pour quitter le shell MicroPython, appuyez sur les touches Ctrl-X pour retourner à l'invite rshell. Appuyez ensuite sur les touches Ctrl-D à l'invite rshell pour revenir dans votre terminal.

Si vous souhaitez seulement accéder au REPL MicroPython, vous pouvez ignorer l'étape intermédiaire de l'invite rshell en ajoutant repl à la fin de la commande rshell :

rshell -p <your-pico-serial-device> --buffer-size 512 repl

Programmation de Pico

Pour travailler avec un microcontrôleur comme le Pico, vous devez émettre des requêtes de lecture ou d'écriture sur l'une de ses broches E/S. Certaines broches du Pico sont disponibles pour connecter des appareils externes, alors que d'autres sont connectées en interne. Vous trouverez ci-dessous un schéma présentant les fonctions de toutes les broches E/S de la carte :

Schéma de disposition des broches du Pico

Vous trouverez une version en plus haute résolution de ce schéma au format PDF ici. Comme vous pouvez le voir, la plupart des broches ont plusieurs fonctions.

Dans cette section, vous allez apprendre à travailler avec deux composants inclus dans la carte Pico : la LED, désignée par le libellé GP25 en haut du schéma ci-dessus, et un capteur de température, qui n'a pas été inclus dans ce diagramme pour une raison obscure.

Accéder à la LED intégrée

La LED fournie avec la carte Pico est connectée à une broche libellée GP25. Il s'agit de l'une des broches GPIO, « General Purpose Input/Output » (ou Entrée/sortie à usage général), disponibles sur la carte Pico. Elles sont facilement reconnaissables grâce à leur libellé GP suivi d'un chiffre.

MicroPython inclut le module machine, et plus particulièrement la classe machine.Pin permettant d'accéder aux broches GPIO et de les utiliser.

Entrez dans le REPL MicroPython, puis saisissez les commandes Python suivantes pour allumer la LED :

from machine import Pin
led = Pin(25, Pin.OUT)
led.on()

Ici, vous créez un objet Pin attaché à la broche GPIO 25 et vous spécifiez que cette broche sera utilisée comme broche de sortie. La méthode on() définit une valeur « haut » sur la broche, ce qui déclenche l'allumage de la LED intégrée.

Vous pouvez probablement deviner ce qui se passe si vous appelez led.off(). Vous pouvez également essayer d'appeler led.toggle().

Obtenir une lecture de température

Le capteur de température fourni avec le Pico est connecté à l'une des quelques broches spéciales appelées ADC, Analog-to-Digital Conversion ou conversion analogique-numérique. À la différence d'une broche GPIO standard qui ne prend en charge que deux états, haut et bas, une broche ADC prend en charge une plage de valeurs, déterminée par la tension d'entrée appliquée à la broche.

Dans le Pico, les broches ADC prennent en charge 12 bits, ce qui signifie que leur valeur peut aller de 0 à 4 095. Toutefois, MicroPython met à l'échelle les valeurs ADC sur une plage de 16 bits : la plage va ainsi de 0 à 65 535. Le microcontrôleur fonctionne en 3,3 V : une broche ADC renvoie donc une valeur de 65 535 lorsqu'elle reçoit 3,3 V, et de 0 lorsqu'il n'y a pas de tension. Toutes les valeurs intermédiaires sont obtenues lorsque la tension appliquée à la broche est comprise entre 0 et 3,3 V.

Les broches ADC de la carte Pico utilisent leur propre schéma de numérotation à la place de leur numéro de broche GPIO. Dans le schéma de broches ci-dessus, vous pouvez voir les broches intitulées ADC0, ADC1, ADC2 et ADC_VREF (techniquementADC3), qui sont les quatre broches ADC accessibles de l'extérieur. Le capteur de température n'a pas de broche physique sur la carte, mais il est accessible avec ADC4.

Le module machine fournit la classe ADC() pour fonctionner avec les broches ADC.

Vous pouvez utiliser le code suivant pour lire le capteur de température à partir du shell MicroPython :

from machine import ADC
temp_sensor = ADC(4)
temperature = temp_sensor.read_u16()

Si vous imprimez la valeur temperature (température), vous obtiendrez un nombre entier compris entre 0 et 65 535, comme indiqué ci-dessus. Ce nombre n'est pas très utile pour mesurer la température. Vous voudrez ainsi sûrement convertir cette valeur en degrés Celsius ou Fahrenheit.

Le capteur de température fonctionne en fournissant une tension à la broche ADC4 proportionnelle à la température. Selon les caractéristiques de ce capteur, une température de 27 degrés Celsius fournit une tension de 0,706 V. Chaque degré supplémentaire réduit la tension de 1,721 mV ou 0,001721 V. Inversement, chaque degré inférieur à 27 degrés Celsius augmente la tension de la même manière. La première étape de conversion de la température 16 bits consiste à la reconvertir en volts. Pour ce faire, la carte Pico utilise la fonction de la tension maximale de 3,3 V :

to_volts = 3.3 / 65535
temperature = temperature * to_volts

Avec cette conversion, la valeur temperature est comprise entre 0 et 3,3. Une deuxième conversion est désormais nécessaire pour amener la température à l'échelle des degrés Celsius :

celsius_degrees = 27 - (temperature - 0.706) / 0.001721

Enfin, si vous souhaitez utiliser l'échelle des degrés Fahrenheit, il faut appliquer une conversion supplémentaire à la température en Celsius :

fahrenheit_degrees = celsius_degrees * 9 / 5 + 32

Coder une application complète

En plus de l'exécution de petits tests, le Pico peut être programmé pour exécuter une application MicroPython complète à son démarrage.

À titre d'exemple, construisons une courte application qui fait clignoter la LED intégrée cinq fois. Voici le code que vous pouvez copier et coller dans un nouveau fichier sur votre ordinateur nommé led_blink.py :

from machine import Pin
from utime import sleep

led = Pin(25, Pin.OUT)
for i in range(5):
    led.on()
    sleep(1)
    led.off()
    sleep(1)

L'une des nombreuses fonctions exécutables par la commande rshell pour vous aider à gérer votre carte MicroPython consiste à copier des fichiers entre votre ordinateur et le système de fichiers de la carte. Pour installer l'application ci-dessus sur votre carte Pico, de sorte qu'elle s'exécute automatiquement lorsque la carte est mise sous tension, vous devez la copier avec le nom main.py, qui est automatiquement importé à la fin de la séquence de démarrage.

Pour ce faire, commencez par saisir l'invite rshell :

rshell -p <your-pico-serial-device> --buffer-size 512

Ensuite, dans l'invite rshell, utilisez la commande cp pour copier le fichier sur la carte Pico :

cp led_blink.py /pyboard/main.py

La commande cp, ainsi que d'autres commandes basées sur le système de fichiers, utilise la convention selon laquelle tous les chemins qui commencent par /pyboard/ font référence au système de fichiers virtuel configuré par MicroPython à l'intérieur de la carte du microcontrôleur. Tout chemin ou nom de fichier ne comportant pas ce préfixe est supposé faire référence au système de fichiers de votre ordinateur.

La commande cpci-dessus copie le fichier led_blink.py local de votre ordinateur dans le répertoire racine du système de fichiers Pico portant le nom main.py.

Après avoir copié le fichier, quittez rshell, puis éteignez votre Pico en le débranchant du port USB et rallumez-le en le rebranchant. Vous devriez maintenant voir la LED clignoter cinq fois ! Le fichier main.py fait désormais partie de la séquence de démarrage de la carte. Il s'exécutera donc également si vous déclenchez un redémarrage logiciel en appuyant sur les touches Ctrl-D dans une session REPL.

N'hésitez pas à faire des expériences en modifiant l'application ci-dessus pour faire clignoter la LED de différentes manières. Après avoir modifié le code sur votre ordinateur, n'oubliez pas d'utiliser la commande cp dans rshell pour mettre à jour la copie stockée dans le Pico.

Lorsque vous avez fini vos expériences avec l'application, vous pouvez supprimer le fichier du système de fichiers de la carte à l'aide de la commande rm :

rm /pyboard/main.py

Vous vous demandez pourquoi j'ai nommé le fichier local led_blink.py au lieu d'utiliser le nom main.py qui doit être utilisé dans le système de fichiers de Pico ? Pour une raison très simple : dans rshell, il est très (trop) facile de commettre une erreur et d'exécuter rm main.py au lieu de rm /pyboard/main.py. En utilisant des noms différents, vous éviterez de supprimer accidentellement votre fichier local.

Conclusion

J'espère que vous avez trouvé cette introduction à la programmation du microcontrôleur Pico avec MicroPython amusante et facile !

Vous souhaitez lire d'autres articles sur le Raspberry Pi Pico ? J'ai également rédigé un tutoriel amusant pour y ajouter un bouton physique d'activation et de désactivation du micro, que vous pouvez utiliser pendant vos appels de visioconférence !

Dans cet article, nous n'avons exploré qu'une infime partie de la large gamme d'applications que vous pouvez construire avec ce microcontrôleur. Il existe plusieurs appareils compatibles, comme des écrans, des LED, des boutons et des capteurs qui peuvent être connectés au Pico par le biais de ses broches GPIO pour vous aider à en tirer le meilleur parti. Afin de trouver des accessoires pour votre Pico, il peut être judicieux de commencer par chercher dans la catégorie “Pico” de Pimoroni.

J'ai hâte de voir ce que vous allez construire !

Miguel Grinberg est développeur Python pour le contenu technique chez Twilio. Contactez-le à mgrinberg [at] twilio [dot] com si vous avez un projet Python que vous souhaitez partager sur ce blog !