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.

Réalisation du système embarqué

Attention

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 actionneur_mb.py puis de le transférer sur la carte.

1
from microbit import *
2
3
#initialisation de la vitesse de transmission en bauds
4
uart.init(baudrate=9600)
5
6
7
while True:
8
    #s'il y a un message dans la file de réception
9
    if uart.any():
10
        #lecture du message qui est en bytes
11
        msg_bytes=uart.read()
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
    display.clear()
Méthode
Lemodule uart permet de communiquer avec l'ordinateur connecté sur le port série USB.
  • uart.init(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 uart.any() puis on lit toute la file de messages avec uart.read() ou le message de tête jusqu'au prochain saut de ligne avec uart.readline(). On peut effacer les caractères invisibles de saut de ligne avec uart.readline().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).
Réalisation de l'IHM
Attention
Dans cette partie, on utilise Mu en mode Python.
Saisir le programme ci-dessous dans l'éditeur avant de l'enregistrer dans un dossier pertinent sous le nom actionneur_python.py.
1
from serial import *
2
from tkinter import *
3
4
#port série à découvrir en ligne de commande avec mode
5
port = "COM3"
6
serie = Serial(port)
7
#même vitesse de transmission que sur la carte
8
serie.baudrate = 9600
9
10
def envoie_message():
11
    """Fonction d'envoi"""
12
    msg = texte_message.get()
13
    message_bytes = bytes(msg, "utf-8")
14
    serie.write(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
23
#positionnement du bouton
24
button_message.pack()
25
26
# Création d'un champ de saisie d'un message
27
texte_message = StringVar()
28
champ_message = Entry(ma_fenetre, textvariable= texte_message, bg ="bisque", fg="maroon", width="20")
29
30
#on donne le focus au champ de saisie
31
champ_message.focus_set()
32
33
#positionnement du champ
34
champ_message.pack()
35
36
#boucle de capture d'événements
37
ma_fenetre.mainloop()
Exploitation
Exécuter le programme en cliquant sur l'icône , une fenêtre graphique comme ci-dessous s'affiche.
É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 dans la barre de menu de Mu.
Explications
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éthodeCommunication 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 serie.baudrate à 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.
  • On lit un message en bytes sur l'entrée série, avec serie.read() ou serie.readline() si on veut s'arrêter au prochain saut de ligne.
  • On écrit un message en bytes sur l'entrée série, avec serie.write(msg_bytes)
Pour aller plus loin
Modifier le programme 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.