Raspberry Pico

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).

Raspberry Pico recto

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.

Raspberry Pico, Arduino nano et Pybstick26

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.

Choisissez le type la taille ou la couleur des connecteurs à souder

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).

Raspberry Pico recto

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.

Raspberry Pico sur une breadboard

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.

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.

Les ports du Raspberry Pi Pico

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 »).

Configuration de l'IDE Thonny

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.

Installation du firmware sur le Raspberry Pico

A la fin de l’installation, cliquez sur Fermer, puis sur OK pour fermer la fenêtre et valider les nouvelles options.

Mise à jour de MicroPython sur le Raspberry Pico

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 »).

print ('Hello Arduiblog') avec l'IDE Thonny

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)
Contrôle de la LED interne avec Thonny

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.

Utilisation de l'IDE Thonny

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).

Enregistrement du programme directement sur le Raspberry Pi Pico

Renommez le fichier main.py et cliquez sur OK.

Enregistrement du fichier main.py sur le Raspberry Pi Pico

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.

Suppression du fichier main.py

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)
Mesures de température avec la sonde du Raspberry Pico

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).

Branchement d'une LED externe (GP15)

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.

Branchement de la LED RGB au Raspberry Pico
# 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é).

LED RGB reliée au Raspberry Pico

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).

Branchement d'un Buzzer au Raspberry Pico

Attention, j’ai rencontré un bug très gênant !!! Il bloque complètement le Raspberry Pico en l’empêchant d’être reconnu par Windows. Le bug se manifeste aussi bien avec les versions 1.13 que 1.14 de MicroPython, quand on enregistre le code suivant dans la mémoire interne du Raspberry Pico (fichier main.py).
Par contre vous pouvez sans risques, exécuter le programme depuis Thonny en le chargeant depuis le disque dur de votre ordinateur. Apparemment, c’est la fonction time.sleep_us qui pose problème, mais je ne sais pas pourquoi. Espérons qu’une prochaine version de Micropython apportera la solution.
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 (Si vous rencontrez des difficultés downgradez MicroPython en 1.13).

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.

Déblocage de la carte

Sinon, le code fonctionne. 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).

# Attention n'enregistrez pas ce code
# dans le Raspberry Pico si vous utilisez
# la version actuelle de MicroPython (V1.14)
from machine import Pin
import time
# Définition du port du Buzzer
buzzer = Pin(15, Pin.OUT)
# Fréquences des notes
re3 = 293.66
mi3 = 329.63
solb3 = 369.99
sol3 = 392
la3 = 440
si3 = 493.88
do4 = 523.25
re4 = 587.33
temps = 0.3
# Fonction note
def note(frequence, duree):
    for i in range (1, (frequence * duree)):
        buzzer.value(1)
        time.sleep_us(int(1000000 / (frequence * 2)))
        buzzer.value(0)
        time.sleep_us(int(1000000 / (frequence * 2)))
    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)

Conclusion

Pour le moment, le Raspberry Pico est encore un peu jeune. On peut rencontrer des bugs et pour le moment, il manque 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.

Sources et liens utiles


Votre commentaire

Entrez vos coordonnées ci-dessous ou cliquez sur une icône pour vous connecter:

Logo WordPress.com

Vous commentez à l’aide de votre compte WordPress.com. Déconnexion /  Changer )

Photo Google

Vous commentez à l’aide de votre compte Google. Déconnexion /  Changer )

Image Twitter

Vous commentez à l’aide de votre compte Twitter. Déconnexion /  Changer )

Photo Facebook

Vous commentez à l’aide de votre compte Facebook. Déconnexion /  Changer )

Connexion à %s