SNT : Activité 2 carte micro:bit
Ce document a été inspiré entre autres par la lecture de l’article http: // tableauxmaths. fr/ spip/ spip.
php? article232 . Il est placé sous licence CC BY-NC-SA 4.0.
1 Interface Homme Machine
Définition 1
Une Interface Homme Machine ou IHM est un ensemble de dispositifs physique (boutons, curseurs) et
logiciels (interface graphique) permettant d’échanger des informations avec une machine.
Exercice 1 Manipulation de diodes et boucle for
L’écran de la carte micro:bit est une grille ou matrice constituée de 25 diodes électroluminescentes ou LED.
Chaque diode est repérée par ses coordonnées x et y variant entre 0 et 4, comme ci-dessous. De plus une diode
peut être émettre un signal lumineux d’intensité variable entre 0, diode éteinte, et 9, intensité maximale.
En Python, l’instruction display.set_pixel(x, y, v) permet d’allumer le diode de coordonnées x et y
avec l’intensité v.
Source : [Link]
1. Ouvrir le logiciel Mu en mode micro:bit, saisir le programme ci-dessous dans l’éditeur avant de l’en-
registrer dans un dossier pertinent sous le nom [Link] puis de le transférer sur la carte.
Programme 1
1 from microbit import *
2
3 for x in range(5):
4 display.set_pixel(x,x,9)
Page 1/10 [Link]
SNT : Activité 2 carte micro:bit
2. Décrire l’effet du programme sur la carte.
..............................................................................................................
Préciser le rôle de chaque instruction.
..............................................................................................................
..............................................................................................................
..............................................................................................................
3. Modifier le programme pour qu’il allume tous les pixels de coordonnées (x,0) avec 0 6 x 6 4.
4. Modifier le programme pour que les diagonales de la matrice de diodes s’allument en forme de croix.
Exercice 2 Commande d’un actionneur par une IHM
L’objectif de cet exercice est de réaliser une IHM simple permettant d’envoyer un code de trois chiffres xyv à
la carte pour qu’elle d’affiche (actionneur) la diode de coordonnées (x,y) avec l’intensité v.
Les systèmes embarqués sont de nos jours souvent connectés à un réseau local ou à l’Internet ce qui permet
de communiquer avec eux à travers des IHM déportées sur le Web ou un smartphone. On va écrire deux
programmes Python : un programme pour l’IHM s’exécutant uniquement sur l’ordinateur et un autre pour le
système informatique embarqué qui sera transféré sur la carte.
Partie A : réalisation du système embarqué
Dans cette partie, on utilise Mu en mode micro:bit.
Ouvrir le logiciel Mu en mode micro:bit, saisir le programme ci-dessous dans l’éditeur avant de l’enregistrer
dans un dossier pertinent sous le nom [Link] puis de le transférer sur la carte.
Programme 2
1 from microbit import *
2
3 #initialisation de la vitesse de transmission en bauds
4 [Link](baudrate=9600)
5
7 while True:
8 #s’il y a un message dans la file de réception
9 if [Link]():
10 #lecture du message qui est en bytes
Page 2/10 [Link]
SNT : Activité 2 carte micro:bit
11 msg_bytes=[Link]()
12 #conversion en chaîne de caractères en précisant l’encodage
13 msg = str(msg_bytes, "utf-8")
14 #conversion en entier du premier caractère du message (x)
15 x = int(msg[0])
16 #conversion en entier du second caractère du message (y)
17 y = int(msg[1])
18 #conversion en entier du troisième caractère du message (v)
19 v = int(msg[2])
20 display.set_pixel(x, y, v)
21 sleep(1000)
22 [Link]()
Méthode Communication série côté micro:bit
Le module uart permet de communiquer avec l’ordinateur connecté sur le port série USB.
+ [Link](baudrate=9600) est nécessaire pour fixer la vitesse de transmission en bauds.
+ Pour lire un message sur l’entrée série, on vérifie s’il reste des messages à lire dans la file d’attente
avec [Link]() puis on lit toute la file de messages avec [Link]() ou le message de tête
jusqu’au prochain saut de ligne avec [Link](). On peut effacer les caractères invisibles
de saut de ligne avec [Link]().strip()
+ Un message reçu msg_bytes est un flux d’octets, de type bytes en Python, avant de le traiter, il
faut le convertir en chaîne de caractères avec str(msg_bytes, ’utf-8’).
+ Pour transmettre un message msg de type chaîne de caractères, on le convertit en bytes avec
msg_bytes = bytes(msg, ’utf-8’) puis on l’écrit sur la sortie série avec print(msg_bytes).
Partie B : réalisation de l’IHM
Dans cette partie, on utilise Mu en mode Python.
1. Récupérer le fichier [Link] dont on donne le code ci-dessous et l’enregistrer dans un dossier per-
tinent.
Page 3/10 [Link]
SNT : Activité 2 carte micro:bit
Programme 3
1 from serial import *
2 from tkinter import *
3
4 #port série à découvrir en ligne de commande avec mode
5 port = "COM4"
6 serie = Serial(port)
7 #même vitesse de transmission que sur la carte
8 [Link] = 9600
9
10 def envoie_message():
11 """Fonction d’envoi"""
12 msg = texte_message.get()
13 message_bytes = bytes(msg, "utf-8")
14 [Link](message_bytes)
15
16 # Fenêtre principale
17 ma_fenetre = Tk()
18 ma_fenetre.title("IHM")
19
20 # Création d’un bouton pour envoyer un message
21 button_message = Button(ma_fenetre, text ="Envoyer", command =
envoie_message)
22 #positionnement du bouton
23 button_message.pack()
24
25 # Création d’un champ de saisie d’un message
26 texte_message = StringVar()
27 champ_message = Entry(ma_fenetre, textvariable= texte_message,
28 bg ="bisque", fg="maroon", width="20")
29 #on donne le focus au champ de saisie
30 champ_message.focus_set()
31 #positionnement du champ
32 champ_message.pack()
33
34 #boucle de capture d’événements
35 ma_fenetre.mainloop()
2. Exécuter le programme en cliquant sur l’icône Lancer, une fenêtre graphique comme ci-dessous s’af-
fiche. Écrire 115 dans le champ de saisie puis cliquer sur le bouton envoyer, le pixel de coordonnées
(1,1) devrait s’allumer avec une intensité moyenne.
Pour arrêter l’IHM, fermer la fenêtre graphique puis cliquer sur Arrêter dans la barre de menu de Mu.
Page 4/10 [Link]
SNT : Activité 2 carte micro:bit
3. Revenons sur le code de l’IHM.
La réalisation de l’interface graphique est commentée dans le code, elle s’appuie sur le module tkinter
qu’on charge avec from tkinter import *.
La communication série avec la carte micro:bit s’appuie sur le module serial qu’on charge avec
from serial import *.
Méthode Communication série côté ordinateur
Le module serial permet de communiquer avec une carte connectée sur le port série USB.
+ serie = Serial(port) permet d’ouvrir une connexion série sur le port de l’ordinateur où
la carte est connectée. Sous Windows ce port peut être découvert avec la commande mode
depuis la console lancée avec cmd dans la barre de recherche. Si l’accès n’est pas autorisé, il
suffit de tester les différentes possibilités : "COM3", "COM4" ou "COM5".
+ On commence par fixer la vitesse de transmission [Link] à la même valeur que
celle choisie sur la carte.
+ Comme sur la carte les messages transmis par communication série sont nécessairement en
bytes, ce qui nécessite une conversion entre chaîne de caractères de type str et bytes avant
transmission ou après réception.
msg_bytes = bytes(msg, "utf-8")
msg de type str msg_bytes de type bytes
msg = str(msg_bytes, "utf-8")
+ On lit un message en bytes sur l’entrée série, avec [Link]() ou [Link]() si
on veut s’arrêter au prochain saut de ligne.
+ On écrit un message en bytes sur l’entrée série, avec [Link](msg_bytes)
Partie C : prolongements
1. Modifier le programme de la carte [Link] et l’enregistrer sous le nom [Link],
pour que la carte allume pendant une seconde :
• la diagonale de diodes de coordonnées (x, x) avec 0 6 x 6 4 si on transmet le message "a" par
l’IHM ;
• l’autre diagonale de diodes si on transmet le message "b" par l’IHM ;
• une croix formée des deux diagonales si on transmet le message "c" par l’IHM.
Page 5/10 [Link]
SNT : Activité 2 carte micro:bit
Exercice 3 Acquisition des données d’un système embarqué par une IHM
L’objectif de cet exercice est de réaliser une IHM simple permettant d’acquérir la composante selon l’axe x de
l’accélération mesurée par la capteur de la carte micro-bit et de l’afficher dans l’interface graphique d’une
IHM.
Partie A : réalisation du système embarqué
Dans cette partie, on utilise Mu en mode micro:bit.
1. Dans un fichier [Link], compléter le programme ci-dessous pour qu’il envoie sur la sortie
série la valeur capturée par accelerometer.get_x() si le caractère "c" est reçu sur l’entrée série.
Programme 4
1 from microbit import *
2
3 [Link](baudrate=9600)
4
5 while True:
6 if [Link]():
7 #à compléter
8 sleep(1000)
2. Enregistrer puis transférer le programme sur la carte.
Partie B : réalisation de l’IHM
Dans cette partie, on utilise Mu en mode Python.
1. Récupérer le fichier [Link] dont le code est donné ci-dessous et l’enregistrer dans un dos-
sier pertinent.
Programme 5
1 from serial import *
2 from tkinter import *
3
4 port = "COM4"
5 serie = Serial(port)
6 [Link] = 9600
7
8 def capture():
9 """Fonction de capture"""
10 [Link](bytes("c", "utf-8"))
11 data = str([Link]().strip(), "utf-8")
12 texte_gx.set("Accélération gx = " + data)
13
14 # Fenêtre principale
Page 6/10 [Link]
SNT : Activité 2 carte micro:bit
15 ma_fenetre = Tk()
16 ma_fenetre.title("IHM")
17
18 # Création d’un bouton pour envoyer un message
19 button_message = Button(ma_fenetre, text ="Capturer", command =
capture)
20 #positionnement du bouton
21 button_message.pack(fill = X)
22
23 # Creation d’un label pour afficher la composante gx de l’accélé
ration
24 texte_gx = StringVar()
25 texte_gx.set("Accélération gx = ")
26 label_gx = Label(ma_fenetre, textvariable = texte_gx , bg ="grey",
width="30", justify = LEFT)
27 label_gx.pack(fill = X)
28
29 #boucle de capture d’événements
30 ma_fenetre.mainloop()
2. Exécuter le programme en cliquant sur l’icône Lancer, une fenêtre graphique comme ci-dessous s’af-
fiche. Vérifier qu’un clic que le bouton capturer permet bien d’afficher la valeur souhaitée dans l’IHM.
Incliner la carte pour faire varier cette valeur.
3. Décrire l’action déclenchée par l’appui sur le bouton capturer.
..............................................................................................................
..............................................................................................................
..............................................................................................................
..............................................................................................................
Partie C : prolongements
a. En mode micro:bit, modifier le programme de la carte [Link] et l’enregistrer sous
le nom [Link], pour que la carte transmette sur sa sortie série un caractère dif-
férent selon l’angle [Link]() avec le nord magnétique mesuré par son capteur bous-
sole :
• "N" pour Nord si l’angle en degrés est supérieur à 315 ou inférieur à 45 ;
• "E" pour Est si l’angle est entre 45 et 135 ;
• "S" pour Sud si l’angle est entre 135 et 225 ;
Page 7/10 [Link]
SNT : Activité 2 carte micro:bit
• "O" pour Ouest sinon.
Ne pas oublier de calibrer la boussole avec [Link]()
b. En mode Python, lancer l’IHM programmée dans [Link] et vérifier que les directions
transmises par la carte sont bien affichées. On peut adapter l’affichage.
En cas d’erreur, relancer uniquement le programme de l’IHM.
2 Objet connecté
Définition 2
Un objet connecté est un système informatique embarqué disposant d’une connexion à un réseau local
ou à L’Internet. Actuellement, il existe plus d’objets que d’humains connectés à Internet et leur nombre va
augmenter fortement dans les prochaines années. On parle d’IOT pour Internet Of Things.
Exercice 4 Transmission de données sur le Web
L’objectif de cet exercice est d’illustrer la transmission de données d’un objet connecté, la carte micro:bit,
vers une IHM en ligne, un canal public de visualisation sur le Web d’URL [Link]
846201. Le site Web thingspeak fournit des outils de visualisation et d’analyse de données transmises par des
objets connectés. Il est aussi possible de récupérer des échantillons de données au format CSV.
Comme on ne dispose pas du module d’extension Wifi pour micro:bit, on utilise un programme sur l’ordi-
nateur connecté pour servir de passerelle entre la carte et l’Internet .
1. Ouvrir Mu en mode micro:bit et compléter dans un fichier [Link] le programme ci-
dessous pour que toutes les 5 secondes il mesure la valeur de la composante en x de l’accélération,
la fasse défiler sur l’écran puis la transmette sur la sortie série. Enregistrer et transférer le fichier sur la
carte.
Programme 6
1 from microbit import *
2 [Link](baudrate=9600)
3 while True:
4 #à compléter
2. Récupérer l’un des 24 fichiers [Link] et l’enregistrer dans un dossier perti-
nent.
Page 8/10 [Link]
SNT : Activité 2 carte micro:bit
Programme 7 [Link]
1 from serial import *
2 from requests import *
3
4 serie = Serial("/dev/ttyACM0", 9600)
5 #Channel Groupe 1 : [Link]
6 #Champ rempli : field2
7 apiKey = "DEMANDERPROFESSEUR"
8
9 while True:
10 #récupération des données sur l’entrée série
11 msg_bytes = [Link]().strip()
12 msg = str(msg_bytes, "utf-8")
13 #transmission des données par requête HTTP
14 r = get("[Link]
15 params = {"field2" : msg , "key" : apiKey})
3. Passer Mu en mode Python et lancer l’exécution du programme [Link], qui
va retransmettre les données acquises par la carte vers une interface Web de visualisation. Dans un na-
vigateur Web, ouvrir la page d’URL [Link] le graphique des
données est celui du du champ fieldX transmis comme paramètre dans l’URL (dernière ligne du pro-
gramme ci-dessus).
4. Incliner la carte pour faire varier la valeur de la composante en x de l’accélération et observer si le gra-
phique en ligne se met à jour.
5. Modifier le programme de la carte pour qu’il transmette les mesures de température du processeur.
Exercice 5 Récupération de données sur le Web
Un objet connecté peut transmettre mais aussi recevoir des informations sur le réseau : des mises à jour logi-
cielles mais aussi des données.
Pour illustrer cet aspect, on va récupérer des données de trafic d’une autoroute du Massachussets , dispo-
nibles sur le canal public [Link] de thingspeak. Le champ field1
Page 9/10 [Link]
SNT : Activité 2 carte micro:bit
représente la densité de véhicules dans un sens et le champ field2 dans l’autre. Ces mesures, prises toutes
les 15 secondes sur certains intervalles de temps fixés, sont transmises par des objets connectés : une caméra
reliée à un nano-ordinateur Raspberry Pi où s’exécute un programme de traitement d’image pour détecter les
véhicules. Plus de détail, sur cette page.
1. Ouvrir Mu en mode Python, récupérer le fichier [Link], l’enregistrer dans un dossier pertinent
puis lancer son exécution.
Programme 8 [Link]
1 from serial import *
2 from requests import *
3 import time
4
5 port = "COM4"
6 serie = Serial(port)
7 [Link] = 9600
8
9 reponse = get("[Link]
json?results=50")
10 data_json = [Link]()
11 #parcours en boucle des mesures
12 for releve in data_json[’feeds’]:
13 # la mesure releve[’field1’] est une chaine de caractères
14 #de la forme ’25.00000’, on la convertit en décimal avec float
15 #puis on tronque à l’entier avec int
16 #avant de reconvertir en chaine avec un saut de lignes
17 traffic = str(int(float(releve[’field1’]))) + ’\r\n’
18 [Link](bytes(traffic, ’utf-8’))
19 [Link](4) #attente de 4 secondes
2. Passer en mode micro:bit et compléter dans un fichier [Link] le programme ci-dessous
pour que toutes les secondes il lise la mesure transmise sur son entrée série puis la fasse défiler sur
l’écran. Enregistrer et transférer le fichier sur la carte. Vérifier que l’écran affiche bien les données de
traffic du field1 du canal public [Link]
Programme 9
1 from microbit import *
2
3 [Link](baudrate=9600)
4 while True:
5 if [Link]():
6 #à compléter
7 [Link]()
8 sleep(2000)
Page 10/10 [Link]
