Comme à son habitude, la fondation Raspberry a surpris tout le monde en lançant sa nouvelle carte de développement. Mais cette fois ci, il ne s’agit pas d’un ordinateur, comme c’était le cas des modèles précédents, mais d’une carte utilisant un microcontrôleur (comme l’Arduino).
Il existe 2 grande familles de cartes de développement :
Si vous vous intéressez depuis peu au monde merveilleux des cartes de développement, peut être que la différence n’est pas extrêmement claire. Je vais donc faire un petit rappel.
Les cartes à base de microprocesseur (comme les Raspberry Pi 1, 2, 3 et 4). Ce sont de véritables ordinateurs miniatures sur lesquels on peut brancher un clavier, une souris, un écran etc…
Comme n’importe quel ordinateur, elles peuvent se connecter à internet, faire de la bureautique, visionner un film, jouer à un jeu. Mais elles nécessitent l’installation (et la mise à jour) d’un système d’exploitation. C’est généralement une version de linux spécialement optimisée pour la carte. Ce petit ordinateur est moins puissant qu’un modèle classique, mais il possède des connecteurs d’entrées/sorties programmables (GPIO) pour connecter des LED, des capteurs, des moteurs, des relais…
Les cartes à bases de microcontrôleurs (comme l’Arduino, le micro:bit, la Pyboard ou la Pybstick) sont beaucoup moins puissantes. Elles sont plus fiables et plus faciles à utiliser (puisse qu’il n’y a pas de système d’exploitation à gérer). Mais elles ne peuvent pas servir d’ordinateur d’appoint et nécessitent d’être connectées à un ordinateur pour être programmées.
Le Raspberry Pico (la nouvelle carte de la fondation) appartient à cette seconde catégorie. Son format très compact s’approche de l’Arduino nano ou de la Pybstick.
Je ne détaillerai pas ici les caractéristiques techniques du Raspberry Pico, parce que vous trouverez facilement ces informations sur de nombreux autres sites (comme l’article de François MOCQ, dont le lien est en bas de la page). Mais dans le cadre d’une utilisation pédagogique ou dans la plupart des projets Maker, la puissance de calcul ou la mémoire embarquée ne change finalement pas grand chose.
Le Raspberry Pico est disponible avec ou sans connecteurs soudés. Si vous possédez un fer à souder, je vous conseille de le faire vous-même. Ce n’est pas très difficile et vous pouvez choisir le type (Mâle ou Femelle), la taille ou même la couleur.
Cela dit, pour utiliser une breadboard (ou une carte d’extension classique), vous n’avez pas vraiment le choix. Il faudra forcement ajouter des connecteurs mâles (j’ai quand même choisi la couleur Rouge-Framboise).
Saperlipopette !!! Mais pourquoi le nom des ports est seulement inscrits sous la carte ?
Forcement, quand la carte est insérée dans la breadboard, on ne peut donc plus les voir.
Ben oui, c’est ballot, surtout que j’ai l’impression que c’est devenu la norme sur les nouvelles cartes de développement. Souvenez-vous, c’était exactement pareil avec l’Arduino Nano Every.
Oui, je sais, on ne peut pas tout avoir. Si on met tous les composants au dessus de la carte et qu’on veut garder une taille réduite au maximum, il ne reste plus la place pour écrire des indications. Et c’est vrai que si la carte était plus large, il n’y aurait moins de place sur la breadboard (pour brancher des fils). Evidement, il est possible de souder les connecteurs au dessus de la carte et de l’insérer à l’envers, mais dans ce cas impossible d’utiliser les cartes d’extensions du Raspberry Pico.
En ce qui concerne l’équipement de la carte, il est réduit au strict minimum : un port micro SD (pour l’alimentation et le transfert des données), 1 bouton (non programmable), une LED, un capteur de température et c’est tout. Mais pour environ 4 €, difficile d’exiger beaucoup plus. Heureusement, vous pouvez compter sur de nombreux ports d’entrées/sorties (GPIO) pour connecter des cartes d’extension (ou les modules) qui vous manqueraient.
Le Raspberry Pico impose un tout nouveau format. Je me demande pourquoi les concepteurs de la carte n’ont pas simplement repris la disposition classique sur 2 rangées des GPIO au format Raspberry Pi. Pour l’instant, les cartes d’extension compatibles ne sont donc pas encore très nombreuses. Mais bien sûr, cela devrait rapidement changer et il existera certainement aussi des adaptateurs pour les Shields Arduino et les Hat Raspberry Pi, ainsi que des cartes Grove, Boson, Gravity, UEXT…
Programmation (en MicroPython)
François Mocq et Dominique Meurisse ont traduit la documentation officielle en Français (voir les liens à la fin de la page). Je me suis inspiré de leur travail pour écrire cet article, mais j’ai utilisé Windows 10 (au lieu de Raspberry OS).
Installation du langage MicroPython.
Vous pouvez télécharger l’IDE Thonny ici. Installez le logiciel, lancez le (sélectionnez le Mode Standard). Allez dans Outils – Options sélectionnez MicroPython (Raspberry Pi Pico) dans l’onglet Interpréteu (oui, il manque le « r »).
Maintenez appuyé le bouton BOOTSEL du Raspberry Pico (vous ne pouvez pas vous tromper, il n’y en a qu’un seul) et connectez la carte à l’ordinateur (sans relâcher le bouton). Cliquez sur Installer ou mettre à jour le firmware et ensuite sur Installer.
A la fin de l’installation, cliquez sur Fermer, puis sur OK pour fermer la fenêtre et valider les nouvelles options.
Vous pouvez taper vos instructions directement dans la console, par exemple tapez :
print ('Hello Arduiblog')Et le programme écrit le texte entre les apostrophes. Ça ne sert pas à grand chose mais c’est un 1er test et c’est une tradition, enfin presque (normalement il aurait fallut écrire « Hello World »).
Contrôle de la LED interne
Pour Allumer la LED interne tapez le code suivant (ligne par ligne) :
from machine import Pin
led = Pin(25, Pin.OUT)
led.value(1)
Pour l’éteindre tapez seulement :
led.value(0)Maintenant, pour la rallumer il suffit de taper :
led.value(1)Bon évidement, on ne va pas utiliser cette méthode pour faire clignoter la LED (parce que c’est quand même un peu contraignant). Copiez le programme suivant dans la fenêtre du haut :
from machine import Pin
import time
led = Pin(25, Pin.OUT)
while True:
led.value(1)
time.sleep(1)
led.value(0)
time.sleep(1)Vous pouvez enregistrer vos programmes sur l’ordinateur et les exécuter en laissant la carte connectée à l’ordinateur. Cela permet de tester ou modifier très facilement le code en jouant avec les boutons Exécuter le script courant et Arrêter/redémarrer l’interpréteur.
Mais dans ce cas, le programme n’est pas stocké sur la carte, vous avez toujours besoin de l’ordinateur pour l’exécuter. Pour rendre la carte de développement autonome allez dans Fichier – Enregistrer sous…, cliquez sur Raspberry Pi Pico (au lieu de Cet ordinateur).
Renommez le fichier main.py et cliquez sur OK.
Débranchez et rebranchez (ou alimentez) la carte pour la redémarrer et que le programme s’exécute. Toujours avec Thonny, cliquez sur le bouton Arrêter/redémarrer l’interpréteur pour vous reconnecter et arrêter l’exécution du programme. Ensuite vous pouvez modifier le programme, le tester et enregistrer les modifications directement dans la carte. Maintenant le Raspberry Pico est autonome, il suffira simplement d’une alimentation pour le faire fonctionner.
Si vous le souhaitez, vous pouvez désactiver l’exécution automatique du programme main.py en le renommant. Pour cela allez dans Fichier – Move / Rename. Vous pouvez également supprimer le fichier. Pour cela, faites un clic droit sur le fichier et sélectionnez Supprimer.
Température
Le Raspberry Pico possède une sonde de température interne. Le code suivant affiche la température toutes les 2 secondes. Vous pouvez vous amuser à la faire monter en posant un doigt sur le microcontrôleur.
from machine import ADC
import time
while True:
# Calcul de la température
adc = ADC(ADC.CORE_TEMP)
vadc = adc.read_u16() * 3.3 / 65535
temp = int (27 - (vadc - 0.706) / 0.001721)
# Affichage de la température toutes les 2 secondes
print( "Temperature : %s°" % temp )
time.sleep(2)
Faire clignoter une LED externe
Maintenant nous allons faire clignoter une LED externe. Choisissez l’un des ports de la carte et branchez une LED avec en série, une résistance (d’environ 220 Ω). Dans cet exemple, j’ai choisi le port GP15, mais vous pouvez en choisir un autre (à condition d’en tenir compte dans le code).
Le programme est quasiment le même que pour la LED interne (il n’y a que le numéro du port qui change, mais vous pouvez aussi vous amuser à modifier la vitesse). Pour comprendre son fonctionnement il est nécessaire de connaitre les principes de bases du langage MicroPython :
- Les instructions sont exécutées ligne par ligne dans l’ordre (1ère ligne, 2ème ligne, 3ème ligne…)
- Les lignes précédées du symbole # sont ignorées par le programme. Vous pouvez écrire ce que vous voulez, ça ne changera rien. Elles servent généralement à ajouter des commentaire pour expliquer le fonctionnent du programme ou désactiver certaines parties du programme (pour rechercher un bug ou faire des tests).
- Les instructions exécutées à l’intérieur d’une boucle ou d’une condition doivent être décalées de quelques espaces ou d’une tabulation. On appelle ça l’indentation et contrairement au langage C, en MicroPython, l’indentation est obligatoire.
- Le langage MicroPython est modulaire, il faut indiquer au début du programme les bibliothèques dont vous avez besoin. Si vous oubliez, le programme ne peut pas fonctionner parce que le microcontrôleur ne comprend pas certaines instructions.
# Appel des bibliothèques
from machine import Pin
import time
# Création de la variable "led"
led = Pin(15, Pin.OUT)
# Boucle infinie
while True:
# Allume la LED
led.value(1)
# Attends 0,5 secondes
time.sleep(0.5)
# Eteins la LED
led.value(0)
# Attend 0,5 secondes
time.sleep(0.5)Attention, avec la version 1.13 de MicroPython, j’ai rencontré un bug qui m’a empêché de faire clignoter une LED reliée au port GP19. Heureusement, la mise à jour vers la version 1.14 (depuis Thonny) a réglé le problème.
LED RGB
Une LED RGB est constituée de 3 LED (Rouge, verte et bleue) reliées ensembles par une patte. Elle possède donc 4 pattes (1 par LED + 1 commune). Dans cet exemple j’utilise une LED RGB dont la patte commune est la cathode (borne négative).
Je ne vais pas trop m’étendre sur le principe de fonctionnement d’une LED RGB, parce que c’est un composant électronique extrêmement courant et que ce n’est pas vraiment le sujet principal de cet article, mais si cela vous intéresse, vous trouverez plus de détails sur internet (ou dans mes livres).
Dans cet exemple, j’ai relié la LED RGB aux ports GP16, GP17, PG18 et GND. Comme d’habitude, vous pouvez en choisir d’autres, mais il faudra en tenir compte dans le code.
# Appel des bibliothèques
from machine import Pin
import time
# Création des variables
ledBleue = Pin(16, Pin.OUT)
ledVerte = Pin(17, Pin.OUT)
ledRouge = Pin(18, Pin.OUT)
# Boucle infinie
while True:
# Allume les LED
ledBleue.value(1)
ledVerte.value(1)
ledRouge.value(1)
# Attends 0,5 secondes
time.sleep(0.5)
# Eteins les LED
ledBleue.value(0)
ledVerte.value(0)
ledRouge.value(0)
# Attend 0,5 secondes
time.sleep(0.5)Quand on allume les 3 LED en même temps on obtient un blanc (un peu bleuté).
En allumant ou éteignant les 3 LED, il est possible d’obtenir différentes couleurs, mais les combinaisons sont plutôt limitées.
# Appel des bibliothèques
from machine import Pin
import time
# Création des variables
ledBleue = Pin(16, Pin.OUT)
ledVerte = Pin(17, Pin.OUT)
ledRouge = Pin(18, Pin.OUT)
# Boucle infinie
while True:
# Blanc
ledBleue.value(1)
ledVerte.value(1)
ledRouge.value(1)
# Attends 0,5 secondes
time.sleep(0.5)
# Bleu Foncé
ledBleue.value(1)
ledVerte.value(0)
ledRouge.value(0)
# Attends 0,5 secondes
time.sleep(0.5)
# Vert
ledBleue.value(0)
ledVerte.value(1)
ledRouge.value(0)
time.sleep(0.5)
# Rouge
ledBleue.value(0)
ledVerte.value(0)
ledRouge.value(1)
time.sleep(0.5)
# Bleu clair
ledBleue.value(1)
ledVerte.value(1)
ledRouge.value(0)
time.sleep(0.5)
# Jaune-vert clair
ledBleue.value(0)
ledVerte.value(1)
ledRouge.value(1)
time.sleep(0.5)
# Rose
ledBleue.value(1)
ledVerte.value(0)
ledRouge.value(1)
time.sleep(0.5)
# LED éteintes
ledBleue.value(0)
ledVerte.value(0)
ledRouge.value(0)
time.sleep(2)
Par contre, avec le mode PWM, il est possible de varier l’intensité lumineuse de chaque LED de 0 à 65025. Et là, les possibilités sont énormes puisse théoriquement, il est possible d’obtenir des milliards couleurs différentes. Avec le programme suivant, vous affichez une couleur différente toutes les secondes (elle est définie aléatoirement).
# Appel des bibliothèques
from machine import Pin, PWM
import time
import random
# Construction des objets PWM
ledBleue = PWM(Pin(16))
ledVerte = PWM(Pin(17))
ledRouge = PWM(Pin(18))
# Boucle infinie
while True:
# Affiche une couleur aléatoire
ledBleue.duty_u16(random.randint(0, 65025))
ledVerte.duty_u16(random.randint(0, 65025))
ledRouge.duty_u16(random.randint(0, 65025))
time.sleep(1)Buzzer
Vous pouvez relier un des ports du Raspberry Pico à un Buzzer (avec une résistance de 100 Ω) et jouer de la musique. Dans cet exemple, j’utilise le port GP15, mais bien sûr, vous pouvez tout à fait utiliser un autre port (oui, je sais je me répète un peu, mais c’est pour ceux qui lisent en diagonale).
Définissez les fréquences des notes dont vous aurez besoin (ainsi que la vitesse) au début du programme. Et ensuite utilisez la fonction note pour les jouer. Je n’ai pas inclus le morceau de musique dans une boucle infinie parce que ça peut vite devenir énervant (surtout pour votre entourage). Mais évidement, rien ne vous empêche de le faire chez vous (vous pouvez aussi ajouter un bouton pour lancer la musique à la demande).
# Appel des bibliothèques
from machine import Pin, PWM
import time
# Définition du port du Buzzer
buzzer = PWM(Pin(15))
# Fréquences des notes
re3 = 294
mi3 = 330
solb3 = 370
sol3 = 392
la3 = 440
si3 = 494
do4 = 523
re4 = 587
temps = 0.3
# Fonction note
def note(frequence, duree):
buzzer.duty_u16(1000)
buzzer.freq(frequence)
time.sleep(duree)
buzzer.duty_u16(0)
time.sleep(temps/16)
# Morceau de musique
note(re3, temps / 2)
note(re3, temps)
note(re3, temps / 2)
note(sol3, temps)
note(sol3, temps)
note(la3, temps)
note(la3, temps)
note(re4, temps * 2)
note(si3, temps / 2)
note(sol3, temps)
time.sleep(temps / 2)
note(sol3, temps / 2)
note(si3, temps)
note(sol3, temps / 2)
note(mi3, temps)
note(do4, temps * 2)
note(la3, temps)
note(solb3, temps / 2)
note(sol3, temps * 2)
En cas de problème…
Lors de mes essais, j’ai rencontré un bug très gênant qui a complètement bloqué le Raspberry Pico en l’empêchant d’être reconnu par Windows. J’ai quand même galéré quelques heures avant de trouver une solution pour débloquer mon Raspberry Pico. J’ai réussi à supprimer le fichier main.py depuis la version Raspberry OS de Thonny.
Mais j’ai découvert plus tard qu’il existe une méthode beaucoup plus simple pour récupérer l’usage de la carte. Il suffit de télécharger le fichier flash_nuke.uf2, de brancher le Raspberry Pico en maintenant le bouton BOOTSEL et de faire glisser le fichier flash_nuke.uf2 dans le nouveau lecteur qui est apparu.
Conclusion
Pour le moment, le Raspberry Pico est encore un peu jeune. On peut rencontrer des bugs et il manque encore un langage de bloc. On peut également regretter que le système de fichier ne soit pas directement accessible (comme avec d’autres cartes MicroPython). Mais je me suis quand même bien amusé en testant cette nouvelle carte de développement et comme le disais très justement François Mocq dans son article « nous sommes en train d’essuyer les plâtres« .
La carte est prometteuse et peut compter sur une énorme grosse communauté, je vous conseille donc de la tester. De toute façon, à 4,50 €, vous n’avez pas grand chose à perdre. Vous trouverez le Raspberry Pico chez McHobby.
arduiblog 
3 réflexions sur “Raspberry Pico”