Nous allons nous intéresser à une nouvelle interface Homme-Machine (IHM).

Une IHM permet à un utilisateur d'interagir avec une machine, la souris et le clavier sont des exemples d'IHM, mais il en existe bien d'autres (par exemple les écrans tactiles des smartphones). Par "machine", on entend bien évidemment "ordinateur", comme dans le cas du duo clavier-souris, mais pas seulement. En effet, les "machines" peuvent aussi être des objets connectés, des systèmes embarqués ou encore des robots.

Nous allons justement nous intéresser ici à cette dernière catégorie : les robots.

Qu'est-ce qu'un robot ?

Le mot robot a été utilisé pour la première fois par l’écrivain tchécoslovaque Karel Čapek dans sa pièce de théâtre "Rossum's Universal Robots" en 1920, il a pour origine le mot russe "rabota" qui signifie travail, corvée. La notion de robot a été ensuite développée par l'écrivain américano-russe Isaac Asimov dans son recueil de nouvelles "Les Robots" (1950).

Pour simplifier à l'extrême, un robot est constitué de 2 choses :

• des actionneurs qui lui permettent d'effectuer des actions (se déplacer, saisir des choses, faire de la soudure...)
• des capteurs qui lui permettent de "connaitre" son environnement (détecteurs d'obstacles, capteur de température...)

Au niveau IHM, il est possible d'interagir avec le robot avec une simple télécommande : l'opérateur donne des ordres au robot par l'intermédiaire de cette télécommande ("aller à gauche", "avancer de 3 mètres", "prendre un objet avec une pince"...), par exemple, les robots qui interviennent dans des milieux dangereux (centrale nucléaire) sont télécommandés à distance par des opérateurs.

Il est aussi possible d'interagir avec un robot non pas directement, mais en le programmant afin de lui donner une certaine autonomie. La programmation consiste à donner au robot la marche à suivre en fonction des situations rencontrées : "si le capteur X détecte quelque chose alors arrête les moteurs".

Nous allons nous initier à ce genre de programmation à l'aide de la carte micro:bit.

Introduction à notre objet connecté, la carte 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.

Ce petit appareil intègre beaucoup de fonctionnalités : il a 25 LED rouges qui peuvent afficher des messages, et deux boutons programmables pouvant être utilisés pour contrôler des jeux, ou, par exemple, faire une pause et sauter des chansons sur une liste de lecture ; le BBC micro:bit peut détecter le mouvement, la température, la luminosité, et vous dire dans quelle direction vous vous dirigez ; il peut aussi utiliser une connexion Bluetooth à faible énergie pour interagir avec d'autres appareils et Internet.

Ce petit ordinateur possède la dernière technologie qui équipe les appareils modernes : téléphones mobiles, réfrigérateurs, montres intelligentes, alarmes antivol, robots, etc...

Ainsi, il s'apparente à ce que l'on nomme l'Internet des objets : Internet of Things, abrégé IoT.

Grâce à la connexion à l'IoT, nous pouvons interagir avec un large éventail de capteurs à travers le monde entier en temps réel et nous pouvons maintenant prendre des décisions intelligentes en utilisant nos appareils.

Un micro:bit est à la fois autonome et extensible. En plus d'utiliser ses LED intégrées, boutons et capteurs, nous pouvons élargir sa gamme de fonctions en l'insérant dans un connecteur

D'après le matériel fournis , identifiez au moins 3 capteurs et 3 actionneurs ( qu'ils soient sur la carte ou externe)

Utilisation de la carte Micro:bit

Prise en main de l'éditeur mu

• Les modes
• Où sont les fichiers
• Créer son premier programme
• La console interactive REPL
• Déceler une erreur
• Voir le résultat de la commande print
• Utiliser l'outil Graphique

Les modes

L'éditeur Mu (il en aussi existe aussi online) peut s'adapter à plusieurs contextes en fonction des cartes qu'on lui connecte. Il peut même être utilisé pour coder en Python directement sur l'ordinateur, même si on utilise pas de carte microbit. Les fonctionnalités d'une carte à l'autre peuvent varier donc l'éditeur se met dans un mode spécifique à la carte qui est connectée.

Connectez votre carte sur un port USB et ouvrez Mu.

Ce mode peut se changer en appuyant sur l'icône .

Dans ce tutoriel, nous supposerons que nous sommes en mode BBC microbit. L'environnement Mu va nous permettre de

• taper nos programmes et les envoyer sur la carte pour s'exécuter
• transférer des fichiers vers et depuis la carte
• accéder à la console interactive MicroPython (REPL)
• tracer des graphiques
• vérifier la syntaxe de nos programmes

Où sont les fichiers

Mu stocke ses fichiers dans le dossier nommé mu_code situé dans votre dossier personnel.

La racine de ce dossier apparaît quand vous cliquez sur l'icône

Créer son premier programme

Cliquer sur puis commencer à taper votre programme. Celui ci-dessous sera très bien :)

import microbit as mb
mb.display.show("She's alive!")

• Enregistrer le fichier à l'emplacement de votre choix en choisissant un nom, par exemple testMB.py.
• Flasher le programme sur la carte à l'aide de l'icône . Cela signifie que le programme sera transféré sur la carte - en remplaçant éventuellement celui qui était présent - et sera lancé automatiquement au démarrage.

La console interactive REPL

Le REPL permet un contact direct avec MicroPython installé sur la carte. C'est ce qui correspond à la console Python sur ordinateur ou la calculatrice. Pour lancer REPL, cliquez sur l'icône .

En cliquant sur , le programme en cours d'exécution sur la carte (main.py) est stoppé et vous pouvez taper des commandes qui seront immédiatement exécutées par MicroPython. La capture ci-dessus vous affichera instantanément le message sur la matrice LED. C'est très commode de pouvoir interagir directement avec MicroPython en cours d'élaboration de programme. Cela permet par exemple :

• de tester une ligne de code comme mb.display.show("coucou")
• de se renseigner sur l'usage d'une commande. Essayez help(display.show)
• de connaître les causes d'un plantage du programme
• etc....

Déceler une erreur

Les erreurs de syntaxe peuvent parfois être décelées avant même le flashage grâce au bouton .

Si vous flashez un programme qui provoque une erreur, celle-ci va défiler sur la matrice LED mais il n'est pas du tout évident à lire ! Pour visualiser les retours d'erreur, nous allons utiliser le REPL :

Lancer REPL. L'invite de commande >>> apparaît. Nous allons provoquer un redémarrage de la carte via le bouton reset au dos de la carte. Le programme se lance à nouveau mais cette fois-ci, les erreurs sont affichées dans la console.

Voir le résultat de la commande print

Vous pouvez afficher des informations à l'aide de l'instruction python print, mais la carte ne possède pas d'écran. Elles n'apparaissent pas non plus sur la matrice LED car celle-ci se pilote via la commande display. Essayez le programme ci-dessous qui simule le lancer de 10 dés.

from random import randint
for i in range(10):
    print("lancer ",i," : ",randint(1,6))

Rien ne s'affiche sur la carte. Pour voir le résultat, ouvrez REPL puis redémarrez le programme via le bouton reset. Vous obtiendrez dans la console l'affichage attendu :

>>> lancer  0  :  6
lancer  1  :  3
lancer  2  :  6
lancer  3  :  5
lancer  4  :  4
lancer  5  :  6
lancer  6  :  4
lancer  7  :  5
lancer  8  :  1
lancer  9  :  6

Utiliser l'outil Graphique

L'outil graphique permet de visualiser sous forme de courbe les valeurs affichées via la commande print. Celles-ci doivent être présentées dans un tuple (liste de données délimitées par des parenthèses et séparées par des virgules). A chaque élément du tuple correspondra une courbe. On peut ainsi tracer une ou plusieurs courbe.

Si on ne veut qu'une seule courbe, il faut quand même afficher un print à un seul élément ce qui ressemble à cela (21,). Ne pas oublier la virgule à la fin. Voici un exemple :

import microbit as mb

while True:
    temp = mb.temperature()
    print((temp,))
    mb.sleep(1000)

• La fonction mb.temperature() renvoie la température relevée par e capteur intégré à la carte micro:bit.
• On affiche cette température dans un tuple à un élément selon le format (temp,) décrit ci-dessus.
• On attend 1000 ms soit une seconde afin de de pas saturer la liaison série avec des relevés de température trop fréquents. La fonction mb.sleep permet de mettre le microcontrôleur en pose pendant un temps spécifié en microsecondes.

Maintenant que nous en savons plus sur le fonctionnement, passons à quelques exercices d'application avant un mini projet au choix.

from microbit import *

while True:
    display.show("1")
    sleep(500)
    display.show(" ")
    sleep(500)
    
            

from microbit import *

for x in range(5):
    display.set_pixel(x,0,9)
    sleep(500)
            

		
from microbit import *
while True:
	if button_a.is_pressed():
		break
	display.scroll("Bonjour")
	sleep(5000)
display.show(Image.HAPPY)
		
	

Pour en savoir plus sur les possibilités de la carte, voici des exemples d'utilisation, à vous de les tester et modifier à votre guise.

		from microbit import *
touches = 0
while True:
 if pin0.is_touched():
  touches += 1
  display.scroll(str(touches))



            

		from microbit import *
while True:
 display.scroll(str(temperature()))
 display.scroll(' Celsius')


            

		from microbit import *
while True:
 display.scroll('Cap %s' % compass.heading())


            

		from microbit import *
while True:
 if accelerometer.is_gesture("shake"):
  display.show(Image.SURPRISED)
  sleep(1000)
  display.show(Image.ASLEEP)



            

		from microbit import *
while True:
 display.scroll('X:%s' % accelerometer.get_x())
 display.scroll('Y:%s' % accelerometer.get_y())
 display.scroll('Z:%s' % accelerometer.get_z())



            

		from microbit import *
import radio
radio.config(group=1)
radio.on()
while True:
 if button_a.was_pressed():
  radio.send('Hello de A!')
 if button_b.was_pressed():
  message = radio.receive()
  display.scroll(str(message))


            

                from microbit import *
import radio
radio.config(group=1)
radio.on()
while True:
 if button_a.was_pressed():
  radio.send('Hello de B!')
  
 if button_b.was_pressed():
  message = radio.receive()
  display.scroll(str(message))

        
        
                    

                        from microbit import *
import radio
radio.config(group=1)
radio.on()
while True:
 if button_a.was_pressed():
  radio.send('Hello de C!')
 if button_b.was_pressed():
  message = radio.receive()
  display.scroll(str(message))