arduiblog

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

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).

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.

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.

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.

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

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.

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.

MakeCode

MicroPython

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

Vittascience

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.

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.

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

MakeCode

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

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.

MakeCode

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

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).

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

MakeCode

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.

Edit du 30/06/20 : Léo BRIAND (cofondateur du site) m’a prévenu par mail que Vittascience avaient : « complètement revu la musique sur micro:bit, avec notamment la librairie musique ainsi que le simulateur qui joue la musique directement ».

Et effectivement cela fonctionne désormais parfaitement. Et en plus, le site intègre maintenant un simulateur (comme MakeCode). Cela prouve que Vittascience tient compte des remarques de ses utilisateurs et cherche toujours à s’améliorer (une raison de plus pour l’essayer). Merci beaucoup Léo.

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

from microbit import *
import music

music.play(['c:4', 'c:4', 'c:4', 'd:4', 'e:8', 'd:8', 'c:4', 'e:4', 'd:4', 'd:4', 'c:8'], pin=pin0)

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.

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.

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

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).

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.

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).

MakeCode

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

Vittascience

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.

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

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.

Edition du 10/01/2022 : Jean-Luc ARTUSO signale que les commentaires que chez lui, ça fonctionne très bien.

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 livre.

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

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