Les bases de Micropython pour la Micro:bit

Cet article résume les bases de la programmation d’une carte Micro:bit en langage MicroPython.

IDE de développement

Thonny

Thonny est un environnement de développement assez complet pour MicroPython. Il a l’avantage de gérer la plupart des cartes : PyBoard, ESP32, Micro:bit, …

Trouvez ici une documentation sur l’utilisation de Thonny avec la Micro:bit.

Mu

L’éditeur Mu est un outil très simpliste. Il supporte parfaitement la carte Micro:bit.

Trouvez ici une documentation sur l’utilisation de Mu avec la Micro:bit.

Noms des broches

En résumé :

Broche	MicroPython	Fonction initiale	Autres fonctions
P0	`pin0`	Touch (capacitif)	E/S digitale, Entrée analogique
P1	`pin1`	Touch (capacitif)	E/S digitale, Entrée analogique
P2	`pin2`	Touch (capacitif)	E/S digitale, Entrée analogique
P5	`button_a`	Bouton A
P11	`button_b`	Bouton B
3V		Alimentation 3,3 V
GND		Masse

Afficheur à LED

L’afficheur intégré est composé de 25 LED disposées sur une matrice 5×5.

Etat d’une LED de la matrice

from microbit import *
display.clear()               # Efface l'afficheur
display.set_pixel(2,3,9)      # Allume la LED à la position 2,3
val = display.get_pixel(1,1)  # Retourne l'intensité d'une LED
print(val)                    # Affichage de l'intensité

clear() efface l’écran.
set_pixel(x, y, valeur) fixe l’intensité d’une LED de la matrice aux coordonnées x et y (entier de 0 à 4). La valeur de l’intensité est un nombre entier de 0 à 9.
get_pixel(x, y) retourne l’intensité (entier de 0 à 9) d’une LED à la position x, y.

Afficher un texte

from microbit import *
display.clear()                          # Efface l'afficheur
display.show("Bonjour", delay=1000)      # Affiche lettre par lettre
display.scroll("Bonjour", delay = 500)   # Fait défiler le texte

show(texte, delay=400) affiche un texte caractère par caractère tous les 400 ms.
scroll(texte, delay=150) fait défiler le texte avec une période de 150 ms.

Sorties digitales

from microbit import *
pin0.write_digital(1)   # Met la broche P0 à l'état haut (3,3V)
pin2.write_digital(0)   # Met la broche P0 à l'état bas (0V)

La méthode write_digital(valeur) fixe le niveau logique (0 ou 1) d’une broche (pin0, pin1, pin2, …).

Entrées digitales

Lecture d’un niveau logique

from microbit import *
val = pin0.read_digital()  # Retourne le niveau logique sur P0
print(val)                 # Affichage du niveau logique

La méthode read_digital() renvoie le niveau logique (0 ou 1) d’une broche (pin0, pin1, pin2, …).

Etat d’un bouton intégré

La carte intègre deux boutons poussoir respectivement notés button_a et button_b en langage MicroPython.

from microbit import *
val = button_a.is_pressed()  # Retourne l'état actuel du bouton A (True ou False)
print(val)                   # Affichage de l'état du bouton A

is_pressed() détecte l’état actuel d’un bouton et renvoie True ou False.
was_pressed() retourne True si le bouton a été appuyé depuis la mise sous tension de la carte ou du dernier appel de cette méthode. Retourne False sinon.

Mesurer une durée d’impulsion

Cette possibilité est offerte par le module machine.

from microbit import *
from machine import time_pulse_us
duree = time_pulse_us(pin0,1)      # Durée impulsion état haut sur P0
print(duree)                       # Affichage

time_pulse_us(pinX, 0) mesure la durée (en µs) d’une impulsion sur la broche pinX à l’état bas.
time_pulse_us(pinX, 1) mesure la durée (en µs) d’une impulsion sur la broche pinX à l’état haut.

Entrées analogiques

Six entrées analogiques (de 0 à 3,3 V) sont disponibles sur la carte. La conversion se fait sur 10 bit.

Lecture directe

from microbit import *
N = pin0.read_analog()  # Tension (entier de 0 à 1023) sur P0
print(N)                # Affichage

read_analog() retourne le résultat (entier entre 0 et 1023) de la conversion d’une tension sur les broches pin0, pin1, pin2, pin3, pin4 ou pin10.

Affichage en volt

La tension correspondante s’obtient en théorie par la relation :

$U = N \times\dfrac{ V_{Ref}}{N_{max}}= N \times\dfrac{ 3,3 V}{1023}$

from microbit import *
N = pin0.read_analog()  # Lecture de la tension sur P0
U = N*3.3/1023          # Calcul de la tension en volt
print(N, U)             # Affichage

En pratique, la tension affichée est légèrement supérieure à celle mesurée par un voltmètre ! Ce qui pose problème pour une mesure précise de tension.

Il existe deux origines à ce problème :

La présence d’une diode en série sur l’alimentation 3,3 V du microcontrôleur provoque une faible chute de tension mais non négligeable ici. Pour compliquer encore les choses, cette chute de tension augmente avec le courant consommé par le microcontrôleur (type et nombre de capteurs par exemple). Il est donc nécessaire de mesurer au voltmètre la tension d’alimentation Vcc pour chaque montage !
L’existence d’un décalage (offset) lors de la conversion analogique-numérique. Cet offset est l’entier à soustraire au résultat de la conversion pour une tension égale à 0 V.

Le programme suivant donne un meilleur résultat :

from microbit import *
Vcc = 3.090              # Mesure au voltmètre entre GND et 3V3 (dépend du courant consommé)
No = 3                   # Décalage (entier) obtenu pour une tension de OV sur l'entrée analogique
N = pin1.read_analog()   # Lecture de la tension sur P0
U = (N-No)*Vcc/(1023-No) # Calcul de la tension en volt
print(N, U)              # Affichage

Acquisition d’une série de mesures en fonction du temps

Contrairement à la PyBoard, il n’est pas possible de réaliser une série de mesures directement en mémoire de la Micro:bit à partir d’un timer.

Cependant, pour les faibles fréquences d’échantillonnage (environs 100 Hz), le programme suivant offre une alternative avec une assez bonne précision.

from microbit import *
from time import ticks_ms

N = 10                      # Nombre de points de mesures
Dt = 20                     # Période d'échantillonnage (ms)
tps = [None]*N              # Création d'un tableau vide pour le temps
val = [None]*N              # Création d'un tableau vide pour les mesures
to = ticks_ms()             # Définition de l'instant initial

for i in range(10):
    tps[i] = ticks_ms()-to      # Instant de la mesure
    val[i] = pin0.read_analog() # Mesure tension sur P0
    sleep(Dt) # Attendre Dt

print(tps)
print(val)

La fonction ticks_ms() renvoie une durée (en ms) obtenue par un comptage par rapport à un point de référence arbitraire.

Sorties analogiques

Contrairement à la Pyboard, la carte Micro:bit n’intègre pas de Convertisseur Numérique Analogique (CNA ou ADC).

Sortie PWM

La génération d’une tension Modulée en Largeur d’Impulsion (MLI ou PWM en anglais) sur une sortie digitale est une alternative afin d’obtenir une tension continue dont la valeur moyenne est réglable entre 0 et 3,3 V.

from microbit import *
pin0.set_analog_period(100)  # Fixe une période de 100 ms sur P0
pin0.write_analog(767)       # Fixe le rapport cyclique à 75% sur P0

set_analog_period(value) fixe la période (en ms) du signal MLI.
write_analog(duty) génère la tension MLI sur la broche concernée.
Le paramètre duty est le rapport cyclique (entier sur 12 bits de 0 à 1023 pour un rapport cyclique allant de 0 à 100%).

Port I2C

Le port I2C est accessible sur les broches P19 (SCL) et P20 (SDA).

from microbit import *
i2c.init()              # Initialise le port I2C
rep = i2c.scan()        # Recherche des périphériques I2C
print(rep)              # Affichage des adresses trouvées

Faire une pause

Avec le module microbit, il est possible d’imposer une pause (en ms) dans le programme à l’aide de la fonction sleep(t_ms) .

Un autre module utime dispose de trois fonctions sleep(t_s), sleep_ms(t_ms) et sleep_us(t_µs) pour réaliser une pause respectivement en seconde, milliseconde et microseconde.

# Clignotement d'une LED sur P0
from microbit import *
from utime import sleep_ms

while True:               # Boucle sans fin
    pin0.write_digital(1)     # P0 à l'état haut
    sleep_ms(500)             # Attendre 500 ms
    pin0.write_digital(0)     # P0 à l'état bas
    sleep_ms(500)             # Attendre 500 ms

Liens externes

Documentation du BBC Micro:bit MicroPython

Bases de l’utilisation de la carte Micro:bit