Micro:bit

Maintenant que vous maitrisez, choisissez les mini-projets que vous voulez

Programmation micropython

copier coller le code ci-dessous dans l'éditeur Mu 

from microbit import *
from machine import time_pulse_us
from math import log
from music import play
from time import sleep_ms
from math import ceil


analogiq_in = [pin0, pin1, pin2, pin3, pin4, pin10]

# Module Grove - Temperature Sensor
# Retourne la température en degrés Celcius
# Paramètres :   nom de la broche utilisée
#               version du modèle de capteur : 0, 1 ou 2

def mesure_temperature(broche = pin2, model = 0):
    if broche in analogiq_in:
	    # each of the sensor revisions use different thermistors, each with their own B value constant
        if model == 2:
            bValue = 4250  # sensor v1.2 uses thermistor ??? (assuming NCP18WF104F03RC until SeeedStudio clarifies)
        elif model == 1:
            bValue = 4250  # sensor v1.1 uses thermistor NCP18WF104F03RC
        else:
            bValue = 3975  # sensor v1.0 uses thermistor TTC3A103*39H
        a = broche.read_analog()
        resistance = (float)(1023 - a) * 10000 / a
        temperature = (float)(1 / (log(resistance / 10000) / bValue + 1 / 298.15) - 273.15)
        return temperature
    else:
        return 'Erreur de broche'
# ###

# Module Grove - Ultrasonic Ranger
# Retourne la durée d'un aller/retour des ultra_sons en microsecondes
# Paramètre : Nom de la broche utilisée

def mesure_temps_A_R(broche = pin1):
    broche.write_digital(0)
    sleep_ms(2)
    broche.write_digital(1)
    sleep_ms(10)
    broche.write_digital(0)
    broche.read_digital()
    dt = time_pulse_us(broche, 1)
    return dt

# ###

# Module Grove - Speaker
# Emet un beep
# Paramètre : Nom de la broche utilisée

def bip(broche = pin0):
    play(['e5:3'], broche)
    return 'Erreur de broche'
# ###

# Module Grove - ligth-sensor
# its_dark retourne True si la luminosité < 10 lux ~
# Paramètre : Nom de la broche utilisée

def it_s_dark(broche = pin0):
    if broche in analogiq_in:
        return (broche.read_analog() < 50)
    else:
        return 'Erreur de broche'
# ###

# Module Grove - ligth-sensor
# retourne un entier (0 -> 100%) ( 100% correspond à ~ 60 lux)
# Paramètre : Nom de la broche utilisée

def luminosite(broche = pin0):
    if broche in analogiq_in:
        return int(broche.read_analog() / 612 *100) -1
    else:
        return 'Erreur de broche'
# ###

# Module Grove - Rotary angle sensor
# retourne la position du bouton ( 0 -> 100% )
# Paramètre : Nom de la broche utilisée

def position_curseur(broche = pin0):
    if broche in analogiq_in:
        return int(broche.read_analog() / 1021 *100)
    else:
        return 'Erreur de broche'

# Affiche une valeur sous forme de jauge (bargraph) sur la matrice à leds
# Paramètres : val -> valeur à afficher , val_max -> la plus grande valeur que peut prendre val

def affiche_jauge(val,val_max=100):
    display.clear()
    n = ceil(5 * val / val_max)
    nl = min(5, n)
    if nl >= 0 and nl <= 5:
        for i in range(nl):
            for j in range(5):
                display.set_pixel(j, 4-i, 9)

# Module Grove - Grove-Servo
# positionne le servomoteur à un  0 < angle < 180 degrés
# Paramètre : Nom de la broche utilisée, angle

def angle_servomoteur(broche = pin0, angle = 0):
    if broche in analogiq_in:
        broche.write_analog(28 + max(0, min(angle, 180)) * 94 / 180)
    else:
        return 'Erreur de broche'
Pour la suite, vous copierez le code proposé à la suite.

Avancez à votre rythme et faite appel au professeur pour vérifier chaque fin de projet.

Pour aller plus loin, vous pouvez imaginer d'autre situation simulant d'autres fonctionnements ou utilisations

Contrôle la lumière

Description Dans cette démo, tu vas apprendre à utiliser les boutons de la micro:bit pour allumer ou éteindre une Led 

from microbit import *
# on definit une variable
etat_led = 0
while True:
 if button_a.is_pressed():
     # on met la led à l'état 1 (5V)
     etat_led = 1
 if button_b.is_pressed():
     # on met la led à l'état 0 (0V)
     etat_led = 0
 # on recopie l'état de la led sur la broche P0
 pin0.write_digital(etat_led)
 sleep(100)
Appuie sur le bouton A puis sur le bouton B pour vérifier que le programme fonctionne. Défi : Quand on appuie simultanément sur les 2 boutons, la led est éteinte. On dit que B est prioritaire. Comment faut-il modifier le programme pour que A soit prioritaire ? Saurais-tu modifier le programme afin de n’utiliser que le bouton A pour allumer et éteindre la Led ? Petit conseil : utilise was-pressed() à la place de is_pressed() !

Contrôle la luminosté

Description Dans cette démo, tu vas apprendre à utiliser les leds de la micro:bit pour indiquer le niveau de luminosité 


while True:
 # on récupère la valeur fournie par le capteur
 mesure = luminosite(pin0)
 # on affiche le niveau de luminosité sur les leds
 affiche_jauge(mesure, 100)
 sleep(50)
Observe les leds lorsque tu montes et descends ta main au dessus du capteur. Que se passe t-il quand tu modifies la valeur 100 dans la fonction “affiche _jauge” ? (essaie avec 10 puis 200)

Éclairage automatique

Description Dans cette démo, tu vas apprendre à allumer une led lorsque la nuit tombe. 


while True:
 # le capteur est branché sur la broche P1
 if luminosite(pin1) < 10:
     etat_led = 1
 else:
     etat_led = 0
 # on recopie l'état de la led sur la broche P0
 pin0.write_digital(etat_led)
 sleep(100)
Vérifie que la led s’allume si tu recouvres le capteur, ou si tu l’enfermes dans ta main. Défi Modifie le programme pour que la led s’allume plus tôt quand la nuit tombe, donc quand il fait moins sombre.

Un peu de musique

Description Dans cette démo, tu vas apprendre à utiliser les 2 boutons de la micro:bit pour jouer de la musique 


from music import *

# les notes sont définies en Scientific Pitch Notation (SPN).
maNote = "c4:1" # c’est un DO
while True:
     if button_a.is_pressed() and not(button_b.is_pressed()):
         # on joue une note
         play(maNote)
     elif button_b.is_pressed()and not(button_a.is_pressed()):
         # on joue une mélodie pré-enregistrée
         play(PUNCHLINE)
     elif button_a.is_pressed() and button_b.is_pressed():
         # on emet un beep
         bip()
         sleep(500)
Tu dois entendre des sons différents quand tu appuies seulement sur le bouton A, ou seulement sur le bouton B puis sur les 2 boutons en même temps Défi Après une recherche sur internet modifie le programme pour jouer la note “LA” à la place du DO Ajoute la définition de la mélodie maMelodie = [“C4:4”, "D", "E", "C", "C", "D", "E", "C", "E", “F”], puis modifie le programme pour jouer cette mélodie quand on appuie sur le bouton B.

Gardien des secrets

Description Dans cette démo, tu vas apprendre à créer une alarme. Si quelqu’un rentre dans ta chambre, une led s’allumera et une “sirène” retentira 



maNote = "F6:1"
while True:
 # Valeur fournie par le capteur ultra-sons
 t = mesure_temps_A_R(pin1)
 distance = t * 0.034328 / 2 # cm
 if distance < 100:
     # on detecte une présence
     for i in range(5):
         pin2.write_digital(1)
         play(maNote)
         sleep(150)
         pin2.write_digital(0)
         sleep(150)
 sleep(500)
Vérifie que quand tu passes ta main lentement devant le capteur à ultra-sons, l’alarme s’enclenche et s’arrête au bout d’un certain temps Défi : Modifie le code pour que l’alarme dure 2 fois plus longtemps, sans changer la fréquence du clignotement de la led. Modifie de nouveau le code pour que la led clignote 3 fois plus vite.

De toutes les couleurs

Description Dans cette démo, tu vas apprendre à utiliser un ruban à leds.Il faut alimenter la carte micro:bit avec des piles pour avoir suffisamment de puissance. 


import neopixel
np = neopixel.NeoPixel(pin1, 30)
np.clear()
rouge = (255, 0, 0)
vert = (64, 255, 12)
magenta = (219, 0, 115)
while True:
 if button_a.is_pressed():
     couleur = rouge
 elif button_b.is_pressed():
     couleur = vert
 else:
     couleur = magenta
 # on calcule le nbre de leds à allumer
 potentiometre = position_curseur(pin0)
 nombre_de_leds = (int)(potentiometre / 3.3)
 #on eteint tout
 for x in range(30):
     np[x] = (0, 0, 0)
 # on allume le nombre de leds calculé
 for x in range(nombre_de_leds):
     np[x] = couleur
 # on applique les changements sur le ruban
 np.show()
 sleep(100)
Observe l’effet d’une action sur le potentiomètre, puis le bouton A et enfin le bouton B Défi : Recherche sur Internet le code RVB de la couleur BLEU, et modifie le programme pour allumer les leds en bleu quand on appuie sur le bouton B

Commande à distance.

Description Dans cette démo, tu vas apprendre à utiliser une deuxième carte microbit pour agir à distance.

Code : carte émettrice

from microbit import *
import radio
#on choisit un canal
radio.config(channel=22)
radio.on()
while True:
 if button_a.was_pressed():
     radio.send("Allume")
 if button_b.was_pressed():
     radio.send("Eteint")
 sleep(100)

Code : carte réceptrice

from microbit import *
import radio
#on choisit un canal
radio.config(channel=22)
radio.on()
etat_led = 0
while True:
 message = radio.receive()
 if message == "Allume":
     etat_led = 1
 if message == "Eteint":
     etat_led = 0
 pin0.write_digital(etat_led)
 sleep(100)
S’il y a d’autres cartes microbit qui utilisent a radio à proximité, choisit un autre canal entre 0 et 83. Vérifie que ta télécommande fonctionne bien. Essaie de trouver par expérience la portée maximale de la radio. Défi : Ajoute un feedback ! Pour faire ça, affiche l’état de la led (A ou E) sur la matrice à led de la carte émettrice

Éclairage automatique économique

Description Dans cette démo, tu vas apprendre à allumer un éclairage extérieur quand il fait nuit, mais uniquement si on détecte la présence de quelqu’un. Ça permet d’économiser l’énergie 


etat_led = 0
while True:
 # Valeur fournie par le capteur ultra-sons
 t = mesure_temps_A_R(pin1)
 distance = t * 0.034328 / 2 # cm
 # Valeur fournie par le capteur de luminosité
 mesure_lum = luminosite(pin2)
 if mesure_lum < 10:
     # il fait nuit
     if distance < 100:
         # on detecte une présence
         etat_led = 1
     else:
         # il n'y a personne
         if etat_led == 1:
             sleep(5000)
             etat_led = 0
 else:
     # il ne fait pas nuit
     etat_led = 0
 pin0.write_digital(etat_led)
 sleep(1000)
Vérifie que la led s’allume quand on recouvre le capteur de luminosité et qu’on passe sa main devant le capteur à ultra-sons. Défi : En passant ta main plus ou moins vite devant le capteur à ultra-sons, peux tu expliquer à quoi sert la dernière ligne ? Peux tu modifier le code pour que la led reste allumée 10 secondes après qu’on s’est éloigné du capteur à ultra-sons.