Valise Grove pour Micro:Bit

Valise grove pour Micro:Bit

La valise Grove m’a été envoyé par la boutique Technologie Services.

Je précise que je l’ai reçu gratuitement, mais, je ne suis pas payé pour en parler (ou en faire la publicité). Je n’ai pas non plus de lien d’affiliation (si vous cliquez sur un lien ou si vous achetez ce produit, je ne touche aucune commission). Je parlerai, évidement des points positifs. Mais je n’hésiterai pas non plus à vous parler aussi des points négatifs.

Contenu de la valise

Elle contient un câble USB/Micro USB, d’une carte d’extension (shield) équipée d’un connecteur Micro:Bit, de câbles équipé de pinces crocodiles et de quelques modules Grove :

  • LED rouge
  • Potentiomètre
  • Capteur de luminosité
  • Ruban de LED RGB adressables (Neopixel)
  • Haut parleur (avec amplificateur)
  • Afficheur 7 segments
  • Capteur à ultrasons
  • Détecteur de gestes
Contenu de la valise grove pour Micro:Bit

Carte shield

Le Micro:Bit se glisse très facilement dans sa carte d’extension. Elle ajoute quelques anneaux, permettant de connecter les ports P8, P12 et P13 (en plus des ports P0, P1, P2, GND et 3V3).

Shield grove pour Micro:Bit

Les anneaux permettent de relier directement des modules ou des composants électroniques au ports du Micro:Bit avec des pinces crocodiles ou des vis M3. Pour plus d’informations, vous pouvez lire cet article.

Branchement de pince crocodiles sur le shield grove pour Micro:Bit

Connecteurs Grove

Ils possèdent 2 câbles pour les données (jaune et blanc) et 2 câbles d’alimentation (rouge et noir). La carte possède 3 connecteurs Grove permettant d’accéder directement aux ports P0/P14, P1/P15, P2/P16 ou au bus de donnée I2C du Micro:Bit.

Le bus I2C est un protocole qui organise la communication entre différents modules compatibles.

Les connecteurs de ce type sont extrêmement pratiques en milieu scolaire. Ils sont solides, fiables et le risque d’erreur est vraiment réduit puisse qu’un détrompeur empêche d’inverser le connecteur.

Connexion d'un module au shield grove pour Micro:Bit

LED

Le module n’utilise qu’un seul port de donnée (relié au fil jaune). Le branchement est très simple. Reliez le module au connecteur Grove de votre choix (sauf le connecteur I2C). Ensuite il suffit de programmer le Micro:Bit.

Branchement du module LED au shield grove pour Micro:Bit

Dans les exemples suivants, la LED rouge est reliée au port P0, mais rien ne vous interdit d’utiliser un autre port (il faudra seulement adapter le programme pour en tenir compte).

MakeCode

Code MakeCode pour faire clignoter une LED

MicroPython

# Bibliothèque microbit
from microbit import *
# Boucle infinie
while True:
    # Mets la broche P0 à 1
    pin0.write_digital(1)
    # Attends 1 seconde
    sleep(1000)
    # Mets la broche P0 à 0
    pin0.write_digital(0)
    # Attends 1 seconde
    sleep(1000)

Vittascience

Le site Vittascience permet une transition en douceur entre la programmation par blocs et le langage MicroPython (je vous l’avais présenté dans un précédent article). Il suffit de placer les blocs pour générer automatiquement le code MicroPython correspondant.

Code Vittascience pour faire clignoter une LED

Potentiomètre

C’est une résistance variable qui retourne une valeur comprise entre 0 et 1023 (que l’on peut modifier en tournant le bouton).

Vous pouvez par exemple vous en servir pour modifier l’intensité lumineuse de la LED. Pour cela reliez la LED au port P0 et le potentiomètre au port P1.

Branchement d'une LED et d'un potentiomètre au shield grove pour Micro:Bit

MakeCode

Code MakeCode pour programmer le potentiomètre

MicroPython

# Appel de la bibliothèque "microbit"
from microbit import *
# Boucle infinie
while True :
    pin0.write_analog(pin1.read_analog())
    sleep(100)

Vittascience

Code Vittascience pour programmer le potentiomètre

Capteur de luminosité

Le capteur lumineux est constitué d’un photo-transistor. Lorsqu’il est relié à une entrée analogique, il renvoie une valeur comprise entre 0 (obscurité) et 1023 (éclairage intense). Je vous en ai déjà parlé en détail lors de mon test du LAMP:bit.

LAMP:bit de Kitronik

Vous pouvez très facilement reproduire le branchement du LAMP:bit en reliant la LED au port P0 et le photo-transistor au port P1.

Branchement d'une LED et d'un photo-transistor au shield grove pour Micro:Bit

Ensuite vous pouvez utiliser le même code. Par exemple, pour allumer la LED, quand la luminosité baisse :

Test du module photo-transistor

MakeCode

Code MakeCode pour programmer le capteur de luminosité

MicroPython

# Code MicroPython pour Micro:Bit
# Appel de la bibliothèque "microbit"
from microbit import *
# Boucle infinie
while True:
    # Si la luminosite est inferieure a 350 (sur 1023)
    if pin1.read_analog() <= 350:
        # Allume la LED reliee a la broche P0
        pin0.write_digital(1)
    # Sinon
    else:
        # Eteint la LED reliee a la broche P0
        pin0.write_digital(0)
    # Pause (1/10 de seconde)
    sleep(100)

Vittascience

Code Vittascience pour programmer le capteur de luminosité

Vous trouverez d’autres exemples de code dans cet article consacré au LAMP:bit.

LED Neopixel

Le ruban de LED mesure 1m et possède 30 LED Neopixel. Je ne reviendrai pas sur le principe des LED adressables, puisse que je l’ai déjà abordé dans cet article.

Branchement de LED Noepixels au shield grove pour Micro:Bit

MakeCode

Code MakeCode pour programmer les LED Neopixel

MicroPython

# Appel des bibliothèques
from microbit import *
from neopixel import NeoPixel
import random
# Indique le nombre de LED du module
nombre_de_LED = 30
# Crée l'objet "strip" pour piloter les LED
strip = NeoPixel(pin0, nombre_de_LED)
# Boucle infinie
while True:
    # Choisir une couleur au hasard
    r = random.randint(0, 50)
    g = random.randint(0, 50)
    b = random.randint(0, 50)
    # boucle correspondant au nombre de LED
    for index in range(0, nombre_de_LED):
        # Programme la couleur de la LED
        strip[index] = [r, g, b]
        # Affiche toutes les LED
        strip.show()
        # Attends 100 millisecondes (1/10 de seconde)
        sleep(100)
        # Éteins toutes les LED
        strip.clear()
    # boucle correspondant au nombre de LED 
    for index in range(0, nombre_de_LED):
        # Programme la couleur de la LED  
        strip[index] = [r, g, b]
    # Affiche toutes les LED 
    strip.show()
    # Attends 1 seconde
    sleep(1000)
    # Éteins toutes les LED 
    strip.clear()

Vittascience

Code Vittascience pour programmer les LED Neopixel

Haut parleur

Le haut parleur permet de jouer de la musique avec le Micro:Bit. Le port P0 est utilisé par défaut pour les fonctions musicales (même s’il est possible d’en utiliser un autre en MicroPython ou avec Vittascience).

Branchement du haut parleur au shield grove pour Micro:Bit

Avec un minimum de connaissances musicales, vous pouvez par exemple jouer « Au clair de la Lune » :

MakeCode

Code MakeCode pour programmer le haut parleur

MicroPython

# Musique
# Appel des bibliothèques
from microbit import *
import music
# Joue les notes
music.play("C4:4")
music.play("C4:4")
music.play("C4:4")
music.play("D4:4")
music.play("E4:8")
music.play("D4:8")
music.play("C4:4")
music.play("E4:4")
music.play("D4:4")
music.play("D4:4")
music.play("C4:8")

Vittascience

Je suis très surpris de constater que le résultat obtenu sur le site Vittascience n’est pas aussi bon qu’avec MakeCode ou MicroPython. Cependant, le site est en constante évolution et il est fort possible que ce soit amélioré à l’avenir.

Code Vittascience pour programmer le haut parleur

Pour info, voilà le code MicroPython généré par Vittascience :

from microbit import *
import time

def beep (pin, noteFrequency, noteDuration, sleepDuration = 100):
  microsecondsPerWave = 1e6/noteFrequency
  millisecondsPerCycle = 1000/(microsecondsPerWave * 2)
  loopTime = noteDuration * millisecondsPerCycle
  for x in range(loopTime):
    pin.write_digital(1)
    time.sleep_us(int(microsecondsPerWave))
    pin.write_digital(0)
    time.sleep_us(int(microsecondsPerWave))
  sleep(sleepDuration)

beep(pin0, 262, 200)
beep(pin0, 262, 200)
beep(pin0, 262, 200)
beep(pin0, 294, 200)
beep(pin0, 330, 400)
beep(pin0, 294, 400)
beep(pin0, 262, 200)
beep(pin0, 330, 200)
beep(pin0, 294, 200)
beep(pin0, 294, 200)
beep(pin0, 262, 400)

while True:
  pass

Afficheur 7 segments

Ce module est plus pratique que la matrice de LED 5 X 5 du Micro:Bit pour restituer un nombre, puisse qu’il est capable d’afficher 4 chiffres en même temps. Il nécessite 2 ports du Micro:Bit, vous avez donc le choix entre les couples P0/P14, P1/P15 et P2/P16.

Branchement de l'afficheur 7 segments au shield grove pour Micro:Bit

MakeCode

Pour utiliser le module, vous devez installer la bibliothèque grove correspondante. Pour cela, cliquez sur Avancé dans le volet des menus (pour développer les menus avancés), puis sur Extensions. Ensuite, tapez « grove » dans la barre de recherche, cliquez sur la petite loupe (à droite) et sélectionnez la bibliothèque grove.

Installation de la bibliothèque grove pour MakeCode

Vous disposez maintenant de nouveaux bloc spécialement adaptés aux modules de la valise Grove Micro:Bit.

Les blocs de la bibliothèque grove (MakeCode)

Créez une variable en indiquant les Ports connectés à l’afficheur 7 segments, puis utilisez là pour visualiser vos données, comme par exemple, la température (rafraîchie toutes les secondes).

Code MakeCode pour programmer l'afficheur 7 segments

Vittascience

Le site ne nécessite pas l’installation de bibliothèques supplémentaires, il reconnait nativement de nombreux modules, ce qui est extrêmement pratique.

Code Vittascience pour programmer l'afficheur 7 segments

MicroPython

Si vous ne trouvez pas de bibliothèque MicroPython, vous pouvez même utiliser le code généré par Vittascience en faisant un simple copier/coller dans votre éditeur MicroPython. Bien sûr, vous pouvez en profiter pour analyser et éventuellement modifier ce programme obtenu automatiquement.

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 init4dd(clk,dio):
  command4dd(clk,dio,0x40)
  command4dd(clk,dio,0x88|6)

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 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 setNumber(clk,dio,n):
  if not -999<=n<=9999:
    raise ValueError('Number out of range')
  write4dd(clk,dio,encodeNum('{0: >4d}'.format(int(n))))

init4dd(pin0, pin14)

Afficheur = None

while True:
  Afficheur = temperature()
  setNumber(pin0, pin14, Afficheur)
  sleep(1000)

Capteur à ultrasons

Le capteur à ultrason calcule la distance le séparant d’un obstacle. Le principe est très simple :

  • Il envoie dans un premier temps une onde sonore inaudible pour l’oreille humaine (ultrason).
  • Puis il mesure le temps qui s’écoule avant que l’écho du son ne lui parvienne (plus l’obstacle est proche et plus c’est rapide).

En connaissant la vitesse du son (environ 340 mètres par seconde), il est possible de calculer la distance entre le capteur et l’obstacle.

Il est bien sûr possible d’utiliser l’afficheur 7 segments pour visualiser la distance obtenue par le capteur à ultrason. Dans ce test le l’afficheur 7 segment est relié aux ports P0/P14 et le capteur à ultrason au port P1 (le même port est utilisé pour l’émission et la réception).

Branchement de l'afficheur 7 segments et du capteur à ultrasons au shield grove pour Micro:Bit

MakeCode

Une fois la bibliothèque grove installée, le programme est assez simple.

Code MakeCode pour programmer le capteur à ultrasons

Vittascience

Code Vittascience pour programmer le capteur à ultrasons

MicroPython

Voilà le code « brut » généré par Vittascience :

from microbit import *
from machine import time_pulse_us

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

def getUltrasonicData(trig, echo, data='distance', timeout_us=30000):
  trig.write_digital(0)
  sleep(2)
  trig.write_digital(1)
  sleep(10)
  trig.write_digital(0)
  echo.read_digital()
  duration = time_pulse_us(echo, 1, timeout_us)
  if data=='distance': return 340*duration/2e4
  elif data == 'duration': return duration
  else:
    print(str(data) + " n'est pas une option")
    return 0

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 init4dd(clk,dio):
  command4dd(clk,dio,0x40)
  command4dd(clk,dio,0x88|6)

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 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 setNumber(clk,dio,n):
  if not -999<=n<=9999:
    raise ValueError('Number out of range')
  write4dd(clk,dio,encodeNum('{0: >4d}'.format(int(n))))

init4dd(pin0, pin14)

Afficheur = None


while True:
  Afficheur = getUltrasonicData(pin1, pin1, 'distance')
  setNumber(pin0, pin14, Afficheur)
  sleep(1000)

Détecteur de gestes

Je suis un peu déçu, car je n’arrive pas à faire fonctionner ce module (censé détecter les gestes).

Je l’ai pourtant branché au port I2C.

Branchement du module détecteur de gestes au shield grove pour Micro:Bit

Et j’ai envoyé le code (MakeCode) suivant dans le Micro:Bit.

Code MakeCode pour programmer le détecteur de gestes

Mais j’ai beau passer ma main au dessus du module, pourtant rien ne se passe. C’est la 1ère fois que j’utilise ce type de module, je suis certainement passé à coté de quelque chose…

Mais nous sommes dimanche soir et je n’ai pas envie de retarder de quelques jours la parution de cet article. Je vais donc laisser tomber ce module (pour l’instant).

Cependant, si vous avez des conseils ou des explications à me donner, n’hésitez pas me contacter ou à le noter dans les commentaires, pour que je puisse modifier cet article.

Conclusion

À part le problème rencontré avec le détecteur de gestes je suis très satisfait de la Valise Grove Micro:Bit. Et bien sûr, j’en parle dans mon prochain livre.

Si cela vous intéresse, elle est disponible dans la boutique Technologie Services.

Edition du 19/03/20 : Larajtekno m’informe qu’il existe aussi une clé USB pédagogique pour cette valise (mais je ne l’ai pas encore testé).


2 réflexions sur “Valise Grove pour Micro:Bit

Votre commentaire

Entrez vos coordonnées ci-dessous ou cliquez sur une icône pour vous connecter:

Logo WordPress.com

Vous commentez à l’aide de votre compte WordPress.com. Déconnexion /  Changer )

Photo Google

Vous commentez à l’aide de votre compte Google. Déconnexion /  Changer )

Image Twitter

Vous commentez à l’aide de votre compte Twitter. Déconnexion /  Changer )

Photo Facebook

Vous commentez à l’aide de votre compte Facebook. Déconnexion /  Changer )

Connexion à %s