Aller au contenu

TP sur un objets connecté⚓︎

0. Présentation de la carte BBC micro:bit⚓︎

BBC micro:bit est une carte à microcontrôleur conçue en 2015 au Royaume-Uni pour développer l'apprentissage de l'algorithmique et de la programmation.

La carte micro:bit dispose des spécificités techniques suivantes :

  • 25 LEDs programmables individuellement
  • 2 boutons programmables
  • Broches de connexion
  • Capteurs de lumière et de température
  • Capteurs de mouvements (accéléromètre et boussole)
  • Communication sans fil, via Radio et Bluetooth
  • Interface USB

1. "Hello world !"⚓︎

N'oubliez pas de faire un compte rendu.

Question 1

  1. Dans un navigateur (autre que firefox), aller sur la page https://python.microbit.org/v/3

  2. Effacez le code existant et collez-le code ci-dessous :

    from microbit import *

while True:
    display.scroll('Hello, World!')
    display.show(Image.HEART)
    sleep(2000)

  3. Branchez la carte sur un port USB. Un lecteur MICROBIT apparait dans les périphériques USB.

  4. Cliquer sur le bouton violet Send to micro:bit et suivre la procédure indiquée.

Cette procédure est à répéter à chaque nouveau code.

2. Découverte des fonctionnalités⚓︎

2.1 Commandes de base de l'afficheur, matrice de 5x5 LEDs⚓︎

(optionnel) voir vidéo explicative (en anglais)

LED signifie Light Emitting Diode, Diode électroluminescente. La carte micro:bit en dispose de 25, toutes programmables individuellement, ce qui permet d'afficher du texte, des nombres et des images.

2.1.1 Afficher un texte "défilant" display.scroll(string, delay=400)⚓︎

from microbit import *
display.scroll("SNT")

La première ligne de ce programme importe la bibliothèque de fonctions micro:bit. La deuxième ligne fait défiler un message à l’écran. Cela n'arrive qu'une seule fois.

La vitesse de défilement peut être ralentie ou accélérée à l'aide du paramètre delay. L'unité est la milliseconde.

from microbit import *
display.scroll("Davis", delay=20)

Question 2

Ecrire un programme permettant de faire défiler son prénom.

2.1.2 Afficher une "image" display.show(image)⚓︎

Question 3

Exécuter le programme suivant:

from microbit import *
display.show(Image.SAD)

Que voyez vous ?

Liste des images disponibles 
Image.HEART
Image.HEART_SMALL
Image.HAPPY
Image.SMILE
Image.SAD
Image.CONFUSED
Image.ANGRY
Image.ASLEEP
Image.SURPRISED
Image.SILLY
Image.FABULOUS
Image.MEH
Image.YES
Image.NO
Image.CLOCK12
Image.CLOCK11
Image.CLOCK10
Image.CLOCK9
Image.CLOCK8
Image.CLOCK7
Image.CLOCK6
Image.CLOCK5
Image.CLOCK4
Image.CLOCK3
Image.CLOCK2
Image.CLOCK1
Image.ARROW_N
Image.ARROW_NE
Image.ARROW_E
Image.ARROW_SE
Image.ARROW_S
Image.ARROW_SW
Image.ARROW_W
Image.ARROW_NW
Image.TRIANGLE
Image.TRIANGLE_LEFT
Image.CHESSBOARD
Image.DIAMOND
Image.DIAMOND_SMALL
Image.SQUARE
Image.SQUARE_SMALL
Image.RABBIT
Image.COW
Image.MUSIC_CROTCHET
Image.MUSIC_QUAVER
Image.MUSIC_QUAVERS
Image.PITCHFORK
Image.XMAS
Image.PACMAN
Image.TARGET
Image.TSHIRT
Image.ROLLERSKATE
Image.DUCK
Image.HOUSE
Image.TORTOISE
Image.BUTTERFLY
Image.STICKFIGURE
Image.GHOST
Image.SWORD
Image.GIRAFFE
Image.SKULL
Image.UMBRELLA
Image.SNAKE

2.1.3 Créer sa propre image⚓︎

Chaque pixel LED sur l’affichage physique peut prendre une parmi dix valeurs. Si un pixel prend la valeur 0 c’est qu’il est éteint. Littéralement, il a une luminosité de zéro. En revanche, s’il prend la valeur 9 il est à la luminosité maximale. Les valeurs de 1 à 8 représentent des niveaux de luminosité entre éteint (0) et « au maximum » (9).

Question 4

Exécutez le code suivant:

from microbit import *

image_mystere = Image("05050:"
            "05050:"
            "05050:"
            "99999:"
            "09990")

display.show(image_mystere)

Que voyez vous ?

Comment dessiner une image? Chaque ligne de l’affichage physique est représentée par une ligne de nombres se terminant par : et entourée de guillemets doubles ". Chaque nombre indique une luminosité. Il y a cinq lignes de cinq nombres donc il est possible de spécifier la luminosité individuelle de chacune des cinq LED sur chacune des cinq lignes sur l’affichage physique. C’est ainsi que l'on crée une image.

2.1.4 Les pixels (display.set_pixel(x, y, val))⚓︎

Vous pouvez régler la luminosité des pixels de l'affichage individuellement de 0 (désactivé) à 9 (luminosité maximale). Pour des informations sur les coordonnées de l'affichage, voir le guide pour matrice à LED.

Question 5

Exécutez le code suivant:

from microbit import *
display.set_pixel(1, 4, 9)

Que voyez vous ?

2.2 Boucle while⚓︎

Le programme suivant utilise une boucle while pour faire clignoter le pixel central de manière répétée sur l’écran. La boucle while se répète tant que la condition spécifiée est vraie (True). Dans ce cas, nous avons dit que la condition est vraie. Cela crée une boucle infinie.

L'instruction de veille sleep() provoque la pause du micro:bit pendant un nombre défini de millisecondes choisi entre parenthèses.

L'instruction display.clear() éteint l'affichage.

Question 6

Exécuter le programme ci-dessous:

from microbit import *
while True:
    display.set_pixel(2, 2, 9)
    sleep(500)
    display.clear()
    sleep(500)

Que voyez vous ?

Question 7

Modifier le programme précédent pour faire clignoter les quatre coins du carré.

Avec un peu d'aléatoire (voir documentation sur le hasard)⚓︎

Dans le programme suivant que vous exécuterez, on importe randint du module random de MicroPython et on l'utilise pour afficher un pixel au hasard sur la matrice.

L'instruction randint(0,4) va renvoyer un nombre (pseudo-)aléatoire entre 0 et 4 inclus.

Question 8

Exécuter plusieurs fois le programme ci-dessous:

from microbit import *
from random import randint
n = randint(0,4)
p = randint(0,4)
display.set_pixel(n, p, 9)

Décrivez ce que vous observez.

2.3 Boucle for⚓︎

Le programme suivant utilise une boucle for pour faire défiler un pixel sur une ligne.

Grâce à l'expression for i in range(5):, la variable i va prendre successivement les valeurs 0, 1, 2, 3 et 4. (pas 5 !)

Question 9

Exécutez le programme ci-dessous:

from microbit import *
while True:
    for i in range(5):
        display.set_pixel(i,0,9)
        sleep(200)
        display.clear()

Décrivez et expliquez ce que vous observez.

2.4 Les entrées boutons A, B et A+B - programmation événementielle (vidéo explicative)⚓︎

image

Il y a deux boutons sur la face avant du micro:bit (étiquetés A et B). On peut détecter quand ces boutons sont pressés, ce qui permet de déclencher des instructions sur l'appareil.

Exemples avec le boutton A:

  • button_a.is_pressed(): renvoie True si le bouton spécifié est actuellement enfoncé et False sinon.
  • button_a.was_pressed(): renvoie True ou False pour indiquer si le bouton a été appuyé depuis le démarrage de l'appareil ou la dernière fois que cette méthode a été appelée.

Exemple : Essayer le programme suivant qui fait défiler le texte "SNT" indéfiniment. On introduit l'instruction conditionnelle if qui va tester si le bouton A a été pressé (pendant le défilement du texte ou pendant la pause), auquel cas le programme s'arrête en exécutant la commande break.

from microbit import *
while True:
    display.scroll("SNT")
    sleep(200)
    if button_a.was_pressed():
        break
display.clear()
display.show(Image.SAD)

Question 10

Créer le code permettant de basculer d'un visage triste à un visage heureux suivant qu'on appuie sur A ou sur B. 

from microbit import *
while True:
    if ...:
        ...
    if ...:
        ...

Question 11

On veut créer le code permettant de déplacer un point vers la gauche ou vers la droite en appuyant sur A ou sur B.

1
2
3
4
5
6
7
8
9
from microbit import *
x = ...
while True:
    display.clear()
    display.set_pixel(...)
    if button_a.was_pressed():
        x = ...
    if button_b.was_pressed():
        x = ...

Question 12

Même chose mais en faisant parcourir tout l'écran au pixel :

  • si on sort à droite, on se décale d'une ligne vers le bas et on revient tout à gauche.
  • si on sort à gauche, on se décale d'une ligne vers le haut et on revient tout à droite.

Question 13 un jeu !

On veut créer le jeu suivant :

  • au démarrage, un pixel aléatoire est placé sur l'écran.
  • il faut ensuite se déplacer un point vers la gauche ou vers la droite en appuyant sur A ou sur B.
  • lorsque qu'on a rejoint le point aléatoire, un emoji HAPPY apparait.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
from microbit import *
from random import randint

# choix des coordonnées aléatoires du point à rejoindre
n = ...
p = ...

# point de départ de notre pixel mobile
x = ...
y = ...

while True:
    display.clear()

    # affichage des deux pixels
    display.set_pixel(...)
    display.set_pixel(...)

    # mouvement de notre pixel mobile 
    ...


    # test pour savoir si notre pixel mobile a rejoint la cible
    if ... and ...:
      ...  # affichage de l'image HAPPY
      ...  # sortie de la boucle

Question 14 on rajoute un temps limité

En Python, la fonction tick_ms du module utime renvoie le nombre de millisecondes écoulées depuis le démarrage de la carte. Pour mesurer le temps écoulé dans un programme, on fixe le temps du début du programme dans une variable t0. Il suffit d'observer ensuite la valeur de tick_ms() - t0 pour savoir combien de temps (en millisecondes) s'est écoulé depuis le début du programme.

Exemple (à exécuter pour comprendre !) : 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
from microbit import *
from utime import *

display.show(Image.HAPPY)
t0 = ticks_ms()

while True:
    if ticks_ms() - t0 > 5000:
      display.show(Image.SAD)
      break

➡ Rajouter une difficulté supplémentaire à notre jeu en mettant un temps limité.

2.5 Capteur de lumière (vidéo)⚓︎

En inversant les LEDs d'un écran pour devenir un point d'entrée, l'écran LED devient un capteur de lumière basique, permettant de détecter la luminosité ambiante.

La commande display.read_light_level() retourne un entier compris entre 0 et 255 représentant le niveau de lumière.

Question 16

Exécutez le programme suivant et faire varier la luminosité:

from microbit import *
while True:
    display.show(display.read_light_level() )
Décrivez et expliquez ce que vous observez.

Question 17

Compléter le programme ci-dessous qui affiche une image de lune si on baisse la luminosité et un soleil sinon.

from microbit import *

soleil = Image("90909:"
            "09990:"
            "99999:"
            "09990:"
            "90909:")

lune = Image("00999:"
            "09990:"
            "09900:"
            "09990:"
            "00999:")

while True:
    if display.read_light_level()> ... : #trouver la bonne valeur (entre 0 et 255)
        display.show(soleil)
    else:
        display.show(...) #trouver la bonne variable
    sleep(10)

Question 18 Prolongement:

créer un programme qui affiche le niveau de luminosité et le tester avec la LED d'un téléphone portable ou une lampe-torche par exemple. Plus la luminosité sera élevée, plus il y aura de LEDs affichées sur la matrice.

2.6 Capteur de température (vidéo)⚓︎

Le micro:bit n’a pas un capteur de température dédié. Au lieu de cela, la température fournie est en fait la température de la puce de silicium du processeur principal. Comme le processeur chauffe peu en fonctionnement (c'est un processeur ARM à grande efficacité), sa température est une bonne approximation de la température ambiante. L'instruction temperature() renvoie la température de la carte micro:bit en degrés Celsius.

Question 19

Ecrire un programme qui affiche la température (aide: on pourra utiliser l'instruction display.scroll(); revoir le point 2.1.1).

2.7 Accéléromètre (vidéo)⚓︎

Un accéléromètre mesure l'accélération de la carte micro:bit, ce composant détecte quand la micro:bit est en mouvement. Il peut aussi détecter d'autres actions (gestes), par exemple quand elle est secouée, inclinée ou qu'elle tombe.

La carte micro:bit est munie d’un accéléromètre. Il mesure le mouvement selon trois axes :

  • X - l’inclinaison de gauche à droite.
  • Y - l’inclinaison d’avant en arrière.
  • Z - le mouvement haut et bas.

Question 20

Exécutez le programme suivant

#Exemple
from microbit import *

while True:
    abscisse = accelerometer.get_x()
    if abscisse > 500:
        display.show(Image.ARROW_E)
    elif abscisse < -500:
        display.show(Image.ARROW_W)
    else:
        display.show("-")

Décrivez ce que vous observez.

Question 21: secouer les dés!

Écrire un programme qui simule un dé en affichant une face au hasard lorsque la micro:bit est secouée. On pourra utiliser l'instruction accelerometer.is_gesture(shake) qui teste si la carte est secouée. Plus d'informations sur les gestes ici.

2.8 Boussole⚓︎

La boussole détecte le champ magnétique de la Terre, nous permettant de savoir quelle direction la micro:bit indique. La boussole doit être étalonnée avant de pouvoir être utilisée. Pour cela, on utilise compass.calibrate() qui exécute un petit jeu: au départ, micro:bit fait défiler "Tilt to fill screen". Ensuite, incliner micro:bit pour déplacer le point au centre de l’écran autour jusqu'à ce que vous ayez rempli la totalité de l’écran.

La fonction compass.heading() donne le cap de la boussole sous la forme d'un entier compris entre 0 et 360, représentant l'angle en degrés, dans le sens des aiguilles d'une montre, avec le nord égal à 0.

Question 22: Boussole

Compléter le programme suivant qui indique le Nord.

from microbit import *

compass.calibrate()

while True:
    if compass.heading() < "remplir ici" or compass.heading() > "remplir ici":
        display.show(Image.ARROW_N)
    else:
        display.show(Image.DIAMOND_SMALL)

Prolongement: Améliorer le programme pour que le micro:bit indique "N", "S", "E" et "O" en fonction de l'orientation de la boussole.

Autre prolongement: fabriquer une station météo qui détermine la direction du vent.

Autre prolongement: étudier l'intensité du champ magnétique autour du périphérique (en utilisant la fonction compass.get_field_strength()). Plus d'informations sur les fonctions "boussole" ici.

document basé sur le travail de Thomas Basso, académie de Polynésie