Accueil » Apprendre le microPython avec la carte Raspberry Pi Pico

Mise à jour : 9/11/23

Ce tutoriel a pour objectif d’apprendre la programmation en langage microPython en utilisant la carte Raspberry Pi Pico. Cette carte est équipé d’un microcontrôleur RP2040. Le langage microPython est le portage du langage Python adapté aux microcontrôleurs.

MicroPython :

  • Écrit en langage C (C99)
  • Langage Open Source et libre (MIT Licence)

Matériels & Logiciel nécessaire

  • Une carte Raspberry Pi Pico
  • Un câble micro-usb
  • Un PC avec le logiciel Thonny (thonny.org)

Présentation de la carte Raspberry Pi Pico

Voici le pinout de la carte Pico :

Dimensions de la carte

Les dimensions mécanique de la carte Raspberry Pi Pico :

Le schéma de la carte PICO

Voici le schéma électronique de la carte :

  • Port micro-usb : programmation, alimentation
  • Régulateur à découpage de type buck : tension +3.3V pour le microcontrôleur
  • Mémoire flash : pour le stockage du programme, connecté en bus SPI au microcontrôleur
  • Led : une led est présente sur la carte Pico, relié sur le port GPIO25

Le microcontrôleur RP2040

Voici l’architecture du microcontrôleur RP2040 :

  • 2 cœur ARM Cortex M0+ à 48 Mhz (32 bits)
  • 264 KB RAM
  • 2MB de mémoire flash, pas de EEPROM
  • 26 GPIO, PWM, SPI, I2C, UART
  • ADC : 3×12 bits
  • USB 1.1 (Device et Host)

Installation du logiciel IDE Thonny

Voir la page : thonny.org

Premier programme, Hello avec le shell

Un premier exemple très simple d’affichage de texte avec la fonction print() :

Gestion d’une led avec le shell

Un exemple de programmer pour allumer une led.

  • La led est connecté sur la pin n°2 (GP2)

Vous pouvez essayer de taper ces lignes de code dans le shell :

Et la lumière fut, allumer et éteindre une led !

Un exemple très simple de programme pour allumer une led :

  • La led doit être connectée sur la GPIO n°2

[code language= »python »]
from machine import Pin
led = Pin(2, Pin.OUT) # configuration de la pin 2 en sortie
led.value(1) # mise à l’état haut de la pin 2, la led s’allume !
[/code]

Un exemple simple de programme pour allumer une led pendant 2 secondes et ensuite l’éteindre :

[code language= »python »]
from machine import Pin
import time

led = Pin(2, Pin.OUT) # configuration de la pin 2 en sortie

while True: # boucle infini
led.value(1)
time.sleep(2) # pause de 2 secondes
led.value(0)
time.sleep(1) # pause de 1 seconde
[/code]

Un autre exemple avec l’utilisation de la fonction toggle():

  • La led va clignoter toutes les 2 secondes

[code language= »python »]
from machine import Pin
import time

led = Pin(2, Pin.OUT)

while True:
led.toggle()
time.sleep(2)
[/code]

Notions de classe et d’objet

Un exemple de création d’un objet pour gérer une led :

[code language= »python »]
import time
from machine import Pin

# Classe appelée ici LED
class LED:

def __init__(self, numero):
self.nom = ""
self.led = Pin(numero, Pin.OUT)

# méthodes allumer la led
def Allumer(self):
self.led.value(1)

# méthodes éteindre la led
def Eteindre(self):
self.led.value(0)
#######################

ma_led = LED(2) # création de l’objet LED

while True :
ma_led.Allumer()
time.sleep(2)
ma_led.Eteindre()
time.sleep(1.5)
[/code]

Utilisation du shell, print

Utilisation de la fonction print() pour afficher du texte dans le shell :

[code language= »python »]
from machine import Pin
import time

print("Hello Raspberry Pi Pico ! ")
[/code]

Le résultat dans le shell :

Gestion d’un bouton poussoir

Un exemple pour lire le manière continue l’état d’un bouton poussoir connecter sur la pin 3 de la carte Raspberry Pi Pico :

[code language= »python »]
from machine import Pin, ADC, PWM
import time

bouton = Pin(3, Pin.IN, Pin.PULL_UP) # configuration pin 3 en entrée

while True:
valeur = bouton.value() #Lecture de l’état du bouton
print(valeur)
time.sleep(1)
[/code]

Résultat sur le shell de l’appuie sur le bouton poussoir, passage de l’état haut à l’état bas :

  • Bouton non appuyé : état haut (1)
  • Bouton appuyé : état haut (0)

Un autre exemple pour gérer l’allumage de la led avec le bouton :

[code language= »python »]
from machine import Pin, ADC, PWM
import time

led = Pin(2, Pin.OUT)
bouton = Pin(3, Pin.IN, Pin.PULL_UP)

while True:
valeur = bouton.value()

if valeur == 1:
led.value(1)
print("Bouton OFF")
else:
print("Bouton ON")
led.value(0)
time.sleep(0.5)
[/code]

Gestion d’une entrée analogique

Un exemple pour lire une entrée analogique :

[code language= »python »]

from machine import Pin, ADC
import time

adc = ADC(Pin(26)) # configuration pin 26 en entrée analogique

while 1:
print("Valeur adc = ", adc.read_u16())
time.sleep(0.2)

[/code]

Le résultat de la lecture de l’entrée analogique avec le Plotter :

Écriture/lecture d’un fichier texte

Un exemple très simple d’écriture dans un  fichier :

[code language= »python »]
import time

file = open("test.txt", "w") # Ouverture du fichier texte.txt en mode ecriture

file.write("Ecriture dans le fichier") # ecriture dans le fichier

file.close() # fermeture du fichier
[/code]

Écriture en boucle d’une variable :

  • str() : permet de convertir en chaine de caractère
  • ‘\n’ : permet le saut d’une ligne

[code language= »python »]
import time

file = open("test.txt", "w")

compteur = 0

while compteur < 10:
file.write("Bonjour, compteur = ")
file.write(str(compteur) + "\n")
print(compteur)
compteur+=1

file.close()
[/code]

Gestion d’un signal PWM

  • PWM : Pulse With Modulation ou modulation de la largeur d’impulsion

C’est quoi un signal PWM ?

 

 

 

This file is licensed under the Creative Commons Attribution-Share Alike 4.0 International license. (https://en.wikipedia.org/wiki/Pulse-width_modulation)

 

Caractéristiques des signaux PWM sur la carte Pico :

  • 7.5Hz à 125Mhz
  • Résolution 16 bits  (0 à 65535)

Un exemple sur la pin 4, d’un signal PWM. Ce signal PWM permet par exemple de contrôler l’intensité lumineuse d’une led ou encore la commande en vitesse d’un moteur à courant continu.

[code language= »python »]
from machine import Pin, ADC, PWM
import time

signal = Pin(4, mode=Pin.OUT)
signal = PWM(Pin(4))

signal.freq(500) # fréquence de 500 Hz
signal.duty_u16(32000) # rapport cyclique
[/code]

Un autre exemple de génération d’un signal PWM :

[code language= »python »]
from machine import Pin, ADC, PWM
import time

signal = Pin(4, mode=Pin.OUT)
signal = PWM(Pin(4))

signal.freq(500)

for rapport in range(0,65_536):
signal.duty_u16(rapport)
print(rapport)
time.sleep(0.001)
[/code]

Contrôle d’un servomoteur

Maintenant, passons au contrôle d’un servomoteur en microPython.

Connexion du servomoteur :

  • Fil rouge : +5V
  • Fil noir : GND
  • Fil orange : GPIO 4

Un exemple de programme pour le contrôle d’un servomoteur :

  • Configuration de la GPIO 4 en signal PWM
  • Pour le contrôle d’un servomoteur la fréquence doit être de 50 Hz
  • Le contrôle angulaire d’un servomoteur varie en fonction du rapport cyclique (entre 1 et 2 ms environ, dépends du type de servomoteurs)

[code language= »python »]
from machine import Pin, PWM
import time

servo = Pin(4, mode=Pin.OUT)
servo = PWM(Pin(4))

servo.freq(50)

while True:
servo.duty_u16(2314)
time.sleep(2)
servo.duty_u16(7600)
time.sleep(2)
[/code]

Allumer une led avec un timer !

Un exemple d’utilisation d’un timer pour faire clignoter la led interne de la carte Raspberry Pi PICO toutes les secondes :

[code language= »python »]
from machine import Pin, Timer

led = Pin("LED", Pin.OUT)

timer_led = Timer()

def mon_timer_led(timer):
global led
led.toggle()

timer_led.init(freq=1, mode=Timer.PERIODIC, callback=mon_timer_led)
[/code]

Interruption matérielle avec un bouton poussoir

Un exemple de programme pour gérer l’appui d’un bouton poussoir avec une interruption matérielle (IRQ). Une interruption matérielle est déclenchée par une entrée (GPIO) du microcontrôleur. Dans cet exemple, l’entrée 3 est configurée en interruption.

[code language= »python »]
from machine import Pin
import time

def mon_interruption(pin):
print("Bouton ON")

bouton = Pin(3, Pin.IN, Pin.PULL_UP) # configuration du bouton sur l’entée 3

bouton.irq(trigger=Pin.IRQ_FALLING,handler=mon_interruption)

# boucle infini
while True:
print("Boucle infini, attendre …") # attendre l’appuie sur le bouton
time.sleep(1)
[/code]

Programmation multicore

Le microcontrôleur RP2040 possédé 2 cœurs de processeur (ARM Cortex M0+)  de 133 Mhz:

  • Core0 : cœur par défaut
  • Core

Ceci permet donc d’exécuter deux taches en parallèle. La communication entre les deux cœurs est possible via une FIFO.

[code language= »python »]
from time import sleep
import _thread

def core0_thread():
compteur= 0
while True:
print("Hello, Je suis le core0 : ", compteur)
compteur+= 1
sleep(1)

def core1_thread():
compteur= 1
while True:
print("Hello, Je suis le core1 : ", compteur)
compteur+= 1
sleep(3)

thread_core1 = _thread.start_new_thread(core1_thread, ())

core0_thread()

[/code]

 

Fin du Tuto !