Un guide du débutant sur MicroPython avec le Raspberry Pi Pico

23 septembre 2021 Hibou Gourou

Le Raspberry Pi Pico est le nouveau membre de la famille Raspberry Pi. Avant cela, la gamme de produits Raspberry Pi était constituée d'ordinateurs à carte unique capables d'exécuter un système d'exploitation.

Basé sur la nouvelle puce RP2040, le Raspberry Pi Pico prend en charge à la fois MicroPython et C/C++. Avec le Raspberry Pi Pico, les débutants et les passionnés peuvent contrôler le matériel et les appareils connectés. Les broches GPIO du Raspberry Pi Pico peuvent être utilisées pour atténuer les lumières, lire l'état des commutateurs et bien plus encore.

Qu'est-ce que le MicroPython ?

La programmation sur les microcontrôleurs se faisait principalement en langage C, comme on le voit dans les cartes de développement Arduino . Puis, en 2014, un nouveau langage de programmation pour microcontrôleurs, MicroPython, a été publié. MicroPython vous permet d'écrire du code Python sur le métal nu d'un microcontrôleur. Cela signifie que vous pouvez écrire du code Python sans système d'exploitation.

Python est un langage de programmation de haut niveau adapté aux débutants qui permet aux utilisateurs de se concentrer sur l'apprentissage des concepts de programmation. C'est à peu près la même chose avec MicroPython.

Utilisation d'une LED

Pour contrôler le matériel, le Pico parle à la série de broches le long de ses deux bords. Celles-ci sont appelées broches GPIO (General Purpose Input Output) et la LED intégrée se trouve sur le GPIO 25. Pour le contrôler, importez d' abord les bibliothèques nécessaires :

 import machine

 import utime

Appelez ensuite la fonction Pin en utilisant la bibliothèque de la machine pour gérer la broche GPIO de la broche, dans ce cas, nous configurons la broche sur GPIO 25, c'est donc le premier paramètre. Le deuxième paramètre la définit comme une broche de sortie plutôt que comme une broche d'entrée, ce faisant, la broche sait ce qu'elle doit faire :

 onboard_led = machine.Pin(25, machine.Pin.OUT)

Pour continuer, dans le code suivant, nous demandons au Pico de définir ensuite sa valeur de broche sur GPIO 25 sur 1, ou « on ».

 while True:
 onboard_led.value(1)

Cependant, vous pouvez vous rendre compte que rien ne semble se passer. En effet, le Pico fonctionne très rapidement, de sorte que la LED s'allume plus rapidement que vous ne pouvez le percevoir avec l'œil. Pour résoudre ce problème, nous devons ralentir le programme en utilisant la commande sleep de la bibliothèque utime . Le code complet où la LED s'allumera et s'éteindra peut être vu ci-dessous :

 import machine
 import utime
 onboard_led = machine.Pin(25, machine.Pin.OUT)
 while True:
 onboard_led.value(1)
 utime.sleep(5)
 onboard_led.value(0)
 utime.sleep(5)

Allumer et éteindre les LED

Alternativement, il existe un autre moyen d'allumer et d'éteindre les LED, avec la commande toggle :

 import machine
 import utime
 onboard_led = machine.Pin(25, machine.Pin.OUT)
 while True:
 led_onboard.toggle()
 utime.sleep(5)

Dans l'exemple, la commande toggle remplace la nécessité de définir la valeur de la LED sur 1 et plus tard sur 0. Elle s'allumera encore pendant 5 secondes, puis s'éteindra pendant cinq autres, tant que le programme est en cours d'exécution.

Création de fonctions

Au fur et à mesure que les programmes deviennent plus complexes, il est utile de regrouper des morceaux de code afin de maintenir la cohérence. Pour ce faire, MicroPython comme Python permet l'utilisation de fonctions. Les fonctions sont un groupe d'instructions liées qui effectuent une tâche spécifique. Par exemple dans le code suivant, une fonction appelée printNames est définie :

 def printNames:
 print(“Raspberry Pi 1”)
 print(“Raspberry Pi 2”)
 print(“Raspberry Pi 3”)
 print(“Raspberry Pi 4”)
 print(“Raspberry Pi Compute Module”)
 print(“Raspberry Pi 400”)
 print(“Raspberry Pi Pico”)
 printNames()

La dernière ligne du code appelle la fonction pour qu'elle s'exécute réellement.

Boucles

La logique conditionnelle exécute différentes actions selon qu'une contrainte booléenne est évaluée à vrai ou faux. De nombreux projets Raspberry Pi Pico sont basés sur ces déclarations logiques. Dans l'exemple suivant, une instruction if-else est utilisée pour déterminer si une instruction print s'exécutera :

 i = 17
 def printNames():
 if i > 15:
 print("i is greater than 15!")
 else:
 print("i is not greater than 15")
 printNames()

Dans l'exemple suivant, la boucle for est utilisée avec la fonction range . Ces boucles peuvent être utilisées pour répéter un bloc de code plusieurs fois.

Pour cet exemple, la commande print sera exécutée cinq fois avec un délai de cinq secondes entre chacune d'elles avec la commande sleep :

 import utime
 def printNames():
 for i in range(5):
 print("Raspberry Pi Pico")
 utime.sleep(5)
 printNames()

Convertisseur analogique-numérique (ADC)

Bien que vous ne puissiez pas le voir, le Raspberry Pi Pico dispose d'un convertisseur analogique-numérique interne. Dans l'exemple suivant, un potentiomètre est connecté au Raspberry Pi Pico sur GPIO 26, qui est capable de la fonctionnalité ADC :

 import machine
 import utime
 pot = machine.ADC(26)
 while True:
 print(pot.read_u16())
 utime.sleep(1)

Ici, avant de pouvoir utiliser cette broche compatible ADC, elle doit être configurée avec la fonction ADC. Ensuite, pendant l'exécution du programme, la valeur du potentiomètre s'imprimera toutes les secondes. Les autres broches du Raspberry Pi Pico compatibles ADC incluent GPIO27, 28 et 29.

Modulation de largeur d'impulsion (PWM)

La sortie numérique d'un microcontrôleur ne peut être que de 1 ou 0. Pour créer un signal analogique, vous aurez besoin d'un convertisseur numérique-analogique. Cependant, une autre façon consiste à créer artificiellement un signal analogique, en utilisant la modulation de largeur d'impulsion ou PWM en abrégé.

En activant et désactivant un signal numérique, cela s'appelle une impulsion. En modulant la largeur d'une impulsion, cela crée artificiellement un signal analogique comme le montre l'exemple suivant :

 import machine
 import utime
 pot = machine.ADC(26
 led = machine.PWM(machine.Pin(21))
 led.freq(1000)
 while True:
 led.duty_u16(pot.read_u16())

Tout d'abord, les bibliothèques machine et utime ont été importées. Un objet, onboard_led est créé avec une sortie PWM activée sur la broche GPIO 21. Ensuite, à l'aide de la commande freq , cela définit la fréquence pour moduler la largeur d'impulsion. Imaginez que vous tournez le potentiomètre, la LED deviendra plus lumineuse lorsqu'elle est tournée dans un sens.

Cela se produit parce que la valeur analogique du potentiomètre est utilisée comme valeur pour le rapport cyclique du signal PWM, c'est une valeur comprise entre 0 et 65535. Cependant, sans conversion, tourner légèrement le potentiomètre peut déjà amener la LED à atteindre son niveau de luminosité maximum .

Pour résoudre ce problème, afin que le potentiomètre n'atteigne sa pleine luminosité que lorsqu'il est tourné à fond, la valeur est convertie avec la fonction duty_u16 . Cette fonction le transforme en un entier de 16 bits qui est une valeur comprise entre 0 et 1024 qui est la même plage de valeurs que vous recevriez de la broche analogique du Pico.

Créez plus avec Raspberry Pi Pico

Cet article a couvert les commandes de base en MicroPython sur le Raspberry Pi Pico. Pour plus d'informations, consultez la documentation officielle sur la programmation MicroPython avec le Raspberry Pi Pico .

S'il n'est pas déjà configuré sur votre Raspberry Pi Pico, obtenez l' IDE Thonny pour exécuter votre code MicroPython ou consultez l' émulateur de processeur Unicorn pour exécuter un microcontrôleur virtuel directement sur votre ordinateur.