Micro:bit

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

Téléchargez la bibliothèque grove ici
puis 4disgits

Pour utiliser une bibliothèque, vous devez la placer sur la carte, voici comment faire:

Coller les fichiers décompressés ( ici micro_grove et 4digits) dans le répertoire mu_code de votre espace personnel :

    Pour le trouver :
    • taper C: dans l'explorateur de fichier.
    • puis cliquer sur Users ou Utilisateurs
    • puis cliquer sur votre nom d'utilisateur
    • puis cliquer sur mu_code

Pour vérifier , vous pouvez regarder dans l'onglet fichier du logiciel MU, vos librairies devraient apparaitre.

Il suffit maintenant de les glisser de l'ordinateur à la carte

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é 

from microbit import *
from micro_grove import luminosite , affiche_jauge
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. 

from microbit import *
from micro_grove import luminosite
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 microbit import *
from music import *
from micro_grove import bip
# 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 

from microbit import *
from micro_grove import mesure_temps_A_R
from music import play
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. 

from microbit import *
from micro_grove import *
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 

from microbit import *
from micro_grove import *
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.

Pour l'afficheur (code à séparer)

from microbit import *

ASCII_4DD_NUM = bytearray(b'\x3F\x06\x5B\x4F\x66\x6D\x7D\x07\x7F\x6F')

def start4dd(clk,dio):
  dio.write_digital(0)
  clk.write_digital(0)

def stop4dd(clk,dio):
  dio.write_digital(0)
  clk.write_digital(1)
  dio.write_digital(1)

def writeByte4dd(clk,dio,cmd):
  for i in range(8):
    dio.write_digital((cmd>>i)&1)
    clk.write_digital(1)
    clk.write_digital(0)
  clk.write_digital(0)
  clk.write_digital(1)
  clk.write_digital(0)

def command4dd(clk,dio,cmd):
  start4dd(clk,dio)
  writeByte4dd(clk,dio,cmd)
  stop4dd(clk,dio)

def write4dd(clk,dio,s,p=0):
  if not 0<=p<=3:
    raise ValueError('Position out of range')
  command4dd(clk,dio,0x40)
  start4dd(clk,dio)
  writeByte4dd(clk,dio,0xC0|p)
  for i in s:
    writeByte4dd(clk,dio,i)
  stop4dd(clk,dio)
  command4dd(clk,dio,0x88|6)

def tm1637_init(clk,dio):
  command4dd(clk,dio,0x40)
  command4dd(clk,dio,0x88|6)
def tm1637_encodeNum(str):
  s = bytearray(len(str))
  for i in range(len(str)):
    o = ord(str[i])
    if o >= 48 and o <= 57:
      s[i] = ASCII_4DD_NUM[o-48]
  return s
tm1637_init(pin0, pin14)

def tm1637_setNumber(clk, dio, n):
  if not -999 <= n <= 9999:
    raise ValueError('Number out of range')
  write4dd(clk, dio, tm1637_encodeNum('{0: >4d}'.format(int(n))))

tm1637_setNumber(pin0, pin14, 1024)

while True:
  pass

  #temperature
  from microbit import *

ASCII_4DD_NUM = bytearray(b'\x3F\x06\x5B\x4F\x66\x6D\x7D\x07\x7F\x6F')

def start4dd(clk,dio):
  dio.write_digital(0)
  clk.write_digital(0)

def stop4dd(clk,dio):
  dio.write_digital(0)
  clk.write_digital(1)
  dio.write_digital(1)

def writeByte4dd(clk,dio,cmd):
  for i in range(8):
    dio.write_digital((cmd>>i)&1)
    clk.write_digital(1)
    clk.write_digital(0)
  clk.write_digital(0)
  clk.write_digital(1)
  clk.write_digital(0)

def command4dd(clk,dio,cmd):
  start4dd(clk,dio)
  writeByte4dd(clk,dio,cmd)
  stop4dd(clk,dio)

def write4dd(clk,dio,s,p=0):
  if not 0<=p<=3:
    raise ValueError('Position out of range')
  command4dd(clk,dio,0x40)
  start4dd(clk,dio)
  writeByte4dd(clk,dio,0xC0|p)
  for i in s:
    writeByte4dd(clk,dio,i)
  stop4dd(clk,dio)
  command4dd(clk,dio,0x88|6)

def tm1637_init(clk,dio):
  command4dd(clk,dio,0x40)
  command4dd(clk,dio,0x88|6)
def tm1637_encodeNum(str):
  s = bytearray(len(str))
  for i in range(len(str)):
    o = ord(str[i])
    if o >= 48 and o <= 57:
      s[i] = ASCII_4DD_NUM[o-48]
  return s
tm1637_init(pin0, pin14)

def tm1637_setTemp(clk, dio, n):
  if n<-9:
    write4dd(clk, dio, [0x38,0x3F])
  elif n>99:
    write4dd(clk, dio, [0x76,0x06])
  else:
    write4dd(clk, dio, tm1637_encodeNum('{0: >2d}'.format(int(n))))
  write4dd(clk, dio, [0x63,0x39], 2)

tm1637_setTemp(pin0, pin14, int(temperature()))

while True:
  pass
  #horloge

from microbit import *

chrono0 = 0
#Warning, the clock is recovered by browser when micro:bit is flashed.
#If micro:bit is powered off, time will not flow.
MIN_START = 40
HOUR_START = 7
ASCII_4DD_NUM = bytearray(b'\x3F\x06\x5B\x4F\x66\x6D\x7D\x07\x7F\x6F')

def start4dd(clk,dio):
  dio.write_digital(0)
  clk.write_digital(0)

def stop4dd(clk,dio):
  dio.write_digital(0)
  clk.write_digital(1)
  dio.write_digital(1)

def writeByte4dd(clk,dio,cmd):
  for i in range(8):
    dio.write_digital((cmd>>i)&1)
    clk.write_digital(1)
    clk.write_digital(0)
  clk.write_digital(0)
  clk.write_digital(1)
  clk.write_digital(0)

def command4dd(clk,dio,cmd):
  start4dd(clk,dio)
  writeByte4dd(clk,dio,cmd)
  stop4dd(clk,dio)

def write4dd(clk,dio,s,p=0):
  if not 0<=p<=3:
    raise ValueError('Position out of range')
  command4dd(clk,dio,0x40)
  start4dd(clk,dio)
  writeByte4dd(clk,dio,0xC0|p)
  for i in s:
    writeByte4dd(clk,dio,i)
  stop4dd(clk,dio)
  command4dd(clk,dio,0x88|6)

def tm1637_init(clk,dio):
  command4dd(clk,dio,0x40)
  command4dd(clk,dio,0x88|6)
def tm1637_encodeNum(str):
  s = bytearray(len(str))
  for i in range(len(str)):
    o = ord(str[i])
    if o >= 48 and o <= 57:
      s[i] = ASCII_4DD_NUM[o-48]
  return s
def tm1637_setClock(clk, dio, h, mn, colon=True):
  segs = tm1637_encodeNum('{0:0>2d}{1:0>2d}'.format(h, mn))
  segs[1] |= 0x80
  write4dd(clk, dio, segs)
def tm1637_getTime():
  mn=0
  h=0
  min0 = (running_time()-chrono0) / 1000 / 60
  h0 = min0/60
  last_mins = MIN_START + int(min0) - (int(h0)*60)
  if last_mins > 59:
    mn = last_mins-60
    h = HOUR_START + int(h0) + 1
  else:
    mn = last_mins
    h = HOUR_START + int(h0)
    return h,mn
tm1637_init(pin0, pin14)

tm1637_setClock(pin0, pin14, tm1637_getTime()[0], tm1637_getTime()[1])

while True:
  pass

C'est parti pour le projet

Pour rendre compte de votre travail, utilisez l'architecture html (ne modifiez pas le CSS)ici

C'est une base, vous pouvez ajouter des parties.