Last month, I told you that we would build a GUI client for our sensor project, so let’s get started. If you set the wayback machine for February 2012 and open Full Circle Magazine issue 58, you will find an article written by me about Page a Tkinter GUI designer for Python. It was a two part article finished the next month in issue 59. Well, Page is still around and still being actively maintained and has gone through many changes since then. Page runs on Linux, Microsoft Windows, MacOS and the Raspberry Pi. The current version is 4.14 and can be found on his sourceforge website at https://sourceforge.net/projects/page/ . You will need to download the latest version to continue this project so head up there and pull it down. I’ll wait for you. Hmmm humm hummmmm. Laaa ti daaaa ti daaa. See, it didn’t take very long. Now, before we start talking about installation, you need to decide if you are going to put Page on your local computer, your Raspberry Pi or both. The reason for this is that the RPi needs some extra steps (not too many and not very hard, but extra steps nonetheless). I’ll assume that you will be using Linux (rather than Windows or MacOS) for this install. If not, there are plenty of instructions included in the Page package for the other operating systems.
Le mois dernier, je vous disais que nous construirions un client GUI (interface utilisateur graphique) pour notre projet de capteur ; aussi, allons-y.
Si vous réglez la machine à voyager dans le temps pour février 2012 et ouvrez le n° 58 du magazine Full Circle, vous trouverez un article que j'ai écrit sur Page, un concepteur graphique pour Python basé sur Tkinter. C'était un article en deux parties, terminé le mois suivant dans le n° 59. Bon, Page est toujours là, toujours maintenu activement, et il a reçu de nombreux changements depuis cette époque. Page tourne sous Linux, Microsoft Windows, MacOS et Raspberry Pi. La version actuelle est la 4.14 et peut être trouvée sur le site Web de Sourceforge : https://sourceforge.net/projects/page/. Vous devrez télécharger la dernière version pour continuer ce projet ; aussi, allez-y et récupérez-la. Je vous attends.
Hmmm humm hummmmm. Laaa ti daaaa ti daaa.
Vous voyez, ça n'a pas pris longtemps. Maintenant, avant de parler de l'installation, vous devez décider si vous allez mettre Page sur votre ordinateur local, sur votre Raspberry ou sur les deux, car le RPi nécessite quelques étapes supplémentaires (pas trop nombreuses et pas trop difficiles, mais des étapes en plus quand même). Je présume que vous utilisez Linux (plutôt que Windows ou MacOS) pour cette installation. Sinon, il y a plein d'instructions incluses dans le paquet Page pour les autres systèmes d'exploitation.
Page uses the Tcl and the Tk Tkinter toolkit to make the GUI. Most Linux distros come with Tcl and Tk already installed. That being said, it is a good idea to get the latest and greatest ActiveTcl, a free community Tck/Tk that you can download from https://www.activestate.com/activetcl. In a terminal, type: tar zxf /path/to/ActiveTcl-download.tar.gz Change to the folder you extracted the files to and run the installer script. You should do this as root, since the installation goes into the opt folder. In the terminal type: sudo ./install.sh Finally, you need to ensure that your PATH variable includes the directory that contains the installed executable files. In the terminal type: export PATH=“/opt/ActiveTcl-8.6/bin:$PATH” That’s it for Tcl and Tk. Now we can unpack the Page distribution. (I use the file manager to unpack Page. You can put it wherever you want. The Page program will run from this folder, so make sure that it is easy to get to.
Page utilise Tcl et la boîte à outils Tk Tkinter pour faire l'interface graphique (UI). La plupart des distrib. Linux arrivent avec Tcl et Tk déjà installés. Cela dit, c'est une bonne idée de prendre la dernière et la meilleure version d'ActiveTcl, un Tcl/Tk gratuit, fait par la communauté, que vous pouvez télécharger à partir de https://www.activestate.com/activetcl.
Dans un terminal, tapez :
tar zxf /path/to/ActiveTcl-download.tar.gz
Placez-vous dans le dossier dans lequel vous avez extrait les fichiers et lancez le script de l'installeur. Vous devrez le faire en tant que root, car l'installation entre dans le dossier opt. Dans le terminal, tapez :
sudo ./install.sh
Enfin, vous aurez besoin de vérifier que votre variable PATH comprend le répertoire qui contient les fichiers exécutables installés. Dans le terminal, tapez :
export PATH=“/opt/ActiveTcl-8.6/bin:$PATH”
C'est tout pour Tcl et Tk. Maintenant, nous pouvons dépaqueter la distribution Page. J'utilise le gestionnaire de fichiers pour dépaqueter Page. Vous pouvez le mettre où vous voulez. Le programme Page sera lancé à partir de ce dossier ; aussi, assurez-vous qu'il est facile d'accès.
Now in a terminal, change to your Page folder. It is named ‘page’. Type: ./configure within the page folder that will create the script that will invoke Page. Finally, check to see if there are any ‘.pagerc’ files in the main folder and remove them if there are. If you are running Page on the Raspberry Pi, Tcl and Tk are not installed by default in the latest Raspbian distribution. However they are available in the repository. In a terminal, you will need to type: sudo apt-get install tcl tk Once you’ve done this, install Page as above. One thing worth mentioning here. There is a wonderful PDF tutorial that comes with Page. It is located in the ‘docs/tutorial/’ folder and is called ‘Learning Page - A Python GUI Designer’ (shameless self promotion written by me).
Maintenant, dans un terminal, passez dans le dossier de Page. Il est nommé « page ». Tapez :
./configure
dans le dossier de page, ce qui créera le script qui invoquera Page. Enfin, vérifiez qu'il n'y a aucun fichier « .pagerc » dans le dossier principal ; enlevez-les s'il y en a.
Si vous lancez Page sur un Raspberry Pi, Tcl et Tk ne sont pas installés par défaut dans la distribution Rasbian la plus récente. Cependant, ils sont disponibles dans le dépôt. Dans un terminal, vous aurez besoin de saisir :
sudo apt-get install tcl tk
Ensuite, installez Page comme ci-dessus.
Une chose intéressante à mentionner ici. Il y a un merveilleux tutoriel en PDF qui est livré avec Page. Il est situé dans le dossier « docs/tutorial/ » et s'appelle « Learning Page - A Python GUI Dsigner » (Apprendre Page - un concepteur de GUI en Python) (honteuse auto-promotion car écrit par moi).
Starting Page In a terminal, change to your Page folder and type: ./page This will bring up the Page system and open five windows on your desktop. From the top left, clockwise, these windows are: • The main Page control window • The Attribute Editor • The Widget Tree • The Toolbox • And finally, in the center, is the blank topmost widget. If you don’t remember the original articles on Page, you basically click on a widget in the toolbox, then place it by clicking on the topmost widget. You can move the new widget, resize it, set its attributes in the attributes editor, and then do it again until you have your UI looking the way you want. When you are finished designing the UI, you use the main control window to save the three files generated by Page. The first file is the .tcl file, the second is the Python GUI definition and the third file is the Python Support module. This changed a number of versions back, to allow the majority of the code to be put into the support module and not have to make many changes to the base UI file. I will walk you through the process, so don’t worry. I’ll go really quickly, so hold on. If you have any problems, you can run through the Page tutorial to get up to speed, then come back to this project.
Commencer avec Page
Dans un terminal, changez pour le dossier Page et tapez :
./page
Ceci va lancer le système Page et ouvrir cinq fenêtres sur votre bureau. À partir du haut à gauche, dans le sens horaire, ces fenêtres sont : • La fenêtre de contrôle principale de Page • L'éditeur d'attributs (Attribute Editor) • L'arborescence des gadgets (Widget Tree) • La boîte à outils • Et enfin, au centre, le gadget vierge supérieur.
Si vous ne vous souvenez pas des articles d'origine sur Page, vous cliquez sur un gadget de la boîte à outils, puis le placez en cliquant sur le gadget supérieur. Vous pouvez déplacer votre nouveau gadget, le redimensionner, paramétrer ses attributs dans l'éditeur d'attributs et continuer ainsi jusqu'à ce que l'interface graphique ressemble à ce que vous voulez. Quand la création de l'interface est terminée, vous utilisez la fenêtre de contrôle principale pour sauvegarder les trois fichiers générés par Page. Le premier fichier est le fichier .tcl, le second est la définition de l'interface graphique en Python et le troisième est le module de support de Python. Ceci a changé depuis pas mal de versions, pour permettre à la majorité du code d'être placé dans le module de support et ne pas avoir à faire beaucoup de changements dans le fichier de base de l'interface. Je vais vous guider dans le processus, aussi, ne vous inquiétez pas. Puisque j'irai vraiment vite, accrochez-vous. Si vous avez des problèmes, vous pouvez parcourir le tutoriel de Page pour le maîtriser, puis revenez à notre projet.
We will be creating a very simple UI for our client. When it’s launched, it will connect to the MQTT broker, subscribe to the Temperature and Humidity topics and when those messages are received, display the Temperature and Humidity values, as well as the time and date of the last message in label widgets. So there will be 6 total labels, three static as prompts and three active that will provide the visual data from the sensors. The three active labels have the relief, or outline, set to sunken to make them stand out from the static labels. There will also be a single button that will close our client. All of the widgets reside on a frame to group them. The topmost widget in this example is about 500 pixels by 255 pixels. The finished UI should look something like the one shown above.
Nous allons créer une interface utilisateur très simple pour notre client. Quand il sera lancé, il se connectera à l'intermédiaire (broker) MQTT, souscrira au sujets Température et Humidité et, quand ces messages seront reçus, il affichera les valeurs de Température et d'Humidité, ainsi que l'heure et la date du dernier message dans des gadgets étiquettes. Ainsi, il y aura 6 étiquettes au total, trois statiques comme titres et trois actives qui fourniront les données visuelles venant des capteurs. Le relief ou contour des trois étiquettes actives est réglé comme enfoncé pour les faire ressortir des étiquettes statiques. Un seul bouton qui fermera notre client y figure aussi. Tout ces gadgets sont logés dans un cadre qui les regroupe. Le gadget supérieur dans cet exemple fait environ 500 pixels par 255 pixels.
L'interface utilisateur finie ressemblerait à quelque chose comme celle présentée ci-dessus.
Once you have Page up and running, move the topmost widget somewhere close to the centre of the screen and resize it using the resize handles on the corners and sides. Next, using the Attribute Editor, set the Alias to “mqttclient” and the title to “MQTT Client”. Now add a frame widget to hold all of our other widgets and make it look something like the image. Now put the six label widgets organized into three rows of two labels each, again making the layout look something like our finished image above. Now here is the part that is a bit tedious. We need to set the attributes for each label. The three static labels are pretty easy. We will not set an alias for them, since they are just static. We do, however, need to set the text. Select the top left label and then in the Attribute Editor, scroll down until you see the ‘text’ attribute. It should read ‘label’ right now. Change it (click on the entry box) to ‘Last Message Received:’. Now move to the next one down, click it to select it and change it’s text attribute to ‘Humidity:’ and finally change the text attribute of the bottom left label to ‘Temperature:’.
Une fois que Page est lancé, déplacez le gadget supérieur quelque part près du centre de l'écran et redimensionnez-le en utilisant les poignées des angles et des côtés. Ensuite, en utilisant l'éditeur d'attributs, donnez à l'Alias la valeur « mqttclient » et, au Titre, « MQTT Client ». Maintenant, ajoutez un gadget cadre pour contenir tous les autres gadgets et faites-le ressembler quelque peu à l'image.
À présent, organisez les six gadgets en trois lignes de deux gadgets chacune, à nouveau en les faisant ressembler à l'image terminée ci-dessus. Arrive ensuite la partie un peu ennuyeuse. Nous devons régler les attributs de chaque gadget. Les trois étiquettes statiques sont plutôt faciles. Nous ne leur attribuerons pas d'alias, car elles sont statiques. Cependant, nous devons leur donner un texte. Sélectionnez l'étiquette en haut à gauche, puis, dans l'éditeur d'attributs, descendez la liste jusqu'à trouver l'attribut « text » (texte). Vous devriez y lire « label » (étiquette). Changez-le pour « Dernier message reçu ». Passez maintenant à celui du dessous, cliquez-le pour le sélectionner et modifiez son attribut text pour « Humidité : » ; enfin, modifiez l'attribut text de l'étiquette en bas à gauche pour « Température : ».
Move to the top right label and select it. We have a number of attributes to set for these. First, we need to set the alias to ‘lblLastMessage’. This names the label widget for easy identification. Next scroll down a bit in the Attribute Editor until you find ‘relief’. Clicking on the entry field will provide you a set of options. Select ‘sunken’. Finally, scroll down a bit more and find the text variable attribute. Put ‘LastMessage’ into the entry box. This will allow us to dynamically change the data in this label. The next label down will have the alias set to ‘lblHumidity’, the relief set to ‘sunken’ and the text variable to ‘HumidityValue’ (one word). Finally do the bottom right label and set the alias to ‘lblTemp’, the relief to ‘sunken’ and the text var to ‘TempValue’. The last thing we need to put in our GUI is the button. Set the alias to ‘btnQuit’. Look down just a little bit in the Attribute Editor for the ‘command’ attribute. This is where we will put the name of the function that will be called when the button is clicked. Enter ‘on_btnQuit’. Finally set the text attribute to ‘Quit’.
Passez à l'étiquette en haut à droite et sélectionnez-la. Pour celles-ci, nous avons un certain nombre d'attributs à régler. D'abord, nous devons changer l'alias pour « lblLastMessage ». Ce nom permet une identification rapide de ce gadget. Ensuite, descendez un peu dans l'éditeur d'attributs jusqu'à ce que vous trouviez « relief ». Un clic sur le champ de saisie vous fournira un jeu d'options. Sélectionnez « sunken » (enfoncé). Enfin, descendez encore un peu et trouvez l'attribut text variable (variable texte). Mettez « Lastmessage » (DernierMessage) dans le champ de saisie. Ceci nous permettra de modifier dynamiquement les données dans cette étiquette.
L'étiquette en dessous verra son alias modifié en « lblHumidity », le relief changé pour « sunken » et la variable texte en « HumidityValue’ (ValeurHumidité, en un seul mot). Enfin, passez à l'étiquette du bas à droite et réglez l'alias à « lblTemp », le relief à « sunken » et la variable texte à « TempValue » (ValeurTempérature).
La dernière chose que nous devons placer dans notre interface est le bouton. Réglez l'alias à « btnQuit ». Cherchez l'attribut « command » un tout petit peu plus bas dans l'éditeur d'attributs. C'est ici que nous mettrons le nom de la fonction qui sera appelée quand le bouton sera cliqué. Entrez « on_btnQuit ». Enfin, réglez l'attribut text à « Quitter ».
Now we are ready to save our UI code. First, on the main Page window, select ‘File|Save’ from the menu. Select a folder to save the file into and save the file as ‘mqttclient.tcl’. Once you have the .tcl file saved, find the ‘Gen_Python’ menu item and click it. Select the first option ‘Generate Python UI’. It will show you the python UI code in a simple editor. Click on the ‘Save’ button. Again, select the ‘Gen_Python’ menu item, but this time, select the second option ‘Generate Support Module’. Again, the simple code editor is shown, this time with our support code. Click save. All three code files are now in the same folder. You won’t have to mess with the .tcl or the mqttclient.py file unless you need to change something in the main UI. The file we will be working with will be mqttclient_support.py. Open this in your favorite code editor. Page has done a lot of the work for us when it comes to the GUI itself. If you were to run the ‘mqttclient.py’ file right now, everything should look like the sample image I showed you earlier. Our code will be providing the glue that binds all the widgets with the data coming from the broker. However, if you click on the ‘Quit’ button right now, nothing will happen, since we haven’t written any code of our own to control what happens when the button is clicked. So you have to click on the ‘X’ in the top of the window.
Maintenant, nous sommes prêts à sauvegarder notre code. En premier, dans la fenêtre principale de Page, sélectionnez « File|Save » (Fichier|Sauvegarder) dans le menu. Sélectionnez un dossier où sauvegarder le fichier et sauvegardez-le sous le nom « mqttclient.tcl ». Une fois que le fichier .tcl est sauvegardé, trouvez la ligne « Gen_Python » du menu et cliquez dessus. Sélectionnez la première option, « Generate Python UI ». Ceci vous montrera le code de l'interface en python dans un simple éditeur. Cliquez sur le bouton « Save ». À nouveau, sélectionnez la ligne « Gen_Python » du menu, mais, cette fois, sélectionnez la seconde option, « Generate Support Module » (Générer le module de support). À nouveau, l'éditeur simple est affiché, cette fois-ci avec notre code de support. Cliquez sur sauvegarder. Les trois fichiers de code sont maintenant dans le même dossier. Nous n'aurons pas à nous battre avec les fichiers .tcl ou mqttclient.py à moins que nous ayons besoin de changer quelque chose dans l'interface principale. Le fichier avec lequel nous allons travailler sera mqttclient_support.py. Ouvrez-le dans votre éditeur de code favori.
Page a fait beaucoup de travail à notre place pour ce qui est de l'interface utilisateur elle-même. Si vous lanciez le fichier « mqttclient.py » maintenant, tout ressemblerait à ce je vous ai montré dans l'image exemple ci-dessus. Notre code fournira le ciment qui relie tous les gadgets avec les données venant du broker. Cependant, si, actuellement, vous cliquez sur le bouton « Quitter », rien ne se passera, car nous n'avons encore écrit aucun code pour contrôler ce qui se passe lors d'un appui sur le bouton. Aussi, vous devez cliquer sur le « X » en haut de la fenêtre.
The Code Now we’ll start dealing with our code. The first thing is to expand the import section to include the paho library, the datetime library and the locale library for printing the date/time properly. Page has already entered the sys library import for us. Below that, put in the following lines. import paho.mqtt.client as mqtt import datetime Import locale Now scroll down a bit until you see a function called ‘set_Tk_var()’. This function, put in by Page sets up the global variables that we will be using to control our dynamic labels. Notice that these are all defined as ‘StringVar()’ which is a special type of string defined by Tkinter. Now find the function ‘on_btnQuit()’. This is a CALLBACK function that is used when the Quit button is clicked. There are already two lines of code there from Page. Add the following lines below them: # client.loop_stop() destroy_window() The first line is currently commented out since we haven’t defined the client yet. We’ll uncomment this in a few minutes but will allow you to run the UI and use the Quit button. The destroy_window() function is written for us (again by Page) to properly close and dispose of the UI.
Le code
Maintenant, nous allons commencer à nous occuper du code. La première chose est d'agrandir la section import pour inclure la bibliothèque paho, la bibliothèque datetime et la bibliothèque locale pour imprimer l'horodatage correctement. Page a déjà fait l'import de la bibliothèque sys pour nous. Sous celle-ci, mettez les lignes suivantes :
import paho.mqtt.client as mqtt
import datetime
import locale
Maintenant, descendez un peu jusqu'à ce que vous voyiez une fonction nommée « set_Tk_var() ». Cette fonction, entrée par Page, paramètre les variables globales qui seront utilisées pour contrôler nos étiquettes dynamiques. Notez qu'elles sont toutes définies comme « StringVar() » qui est un type spécial de chaîne défini par Tkinter. Maintenant, trouvez la fonction « on_btnQuit() ». C'est une fonction de retour (callback) qui est utilisée quand le bouton Quitter est enclenché. Il y a aussi ici deux lignes de code venant de Page. Ajoutez-y les deux lignes suivantes :
# client.loop_stop()
destroy_window()
La première ligne est actuellement commentée car nous n'avons pas encore défini le client. Nous la décommenterons dans quelques minutes, ce qui vous permettra de lancer l'interface utilisateur et d'utiliser le bouton Quitter. La fonction destroy_window() est écrite pour nous (une fois encore par Page) pour fermer et supprimer l'UI comme il faut.
Now in the init() function that Page set up for us, add the following four lines at the bottom of the routine. lang = “en_US.utf8” # Put your locale here locale.setlocale(locale.LC_ALL, lang) set_our_globals() start_up() The init() function is run right before the UI is shown to the user, so any code that we need to run to set up variables and widgets, or calls to startup functions should be put here. We want to make sure that our code is the last thing to run. We set ‘lang’ to whatever your locale settings should be. For example, in the line above, I use “en_US.utf8” since I live and think “U.S. English”. If however, I were able to wrap my old brain around the date/time format in the UK, I could use “en_GB.utf8”. (I tested it and it worked but started causing me to get confused). If, on the other hand, I lived in Norway, I would use “nb_NO.utf8”.
Dans la fonction init() que Page a paramétrée pour nous, ajoutez les quatre lignes suivantes en bas de la routine.
lang = “fr_FR.utf8” # mettez ici votre langue locale
locale.setlocale(locale.LC_ALL, lang)
set_our_globals()
start_up()
La fonction init() est lancée juste avant que l'UI soit présentée à l'utilisateur ; aussi, tout code qui a besoin d'être lancé pour paramétrer les variables et les gadgets, ou les appels pour démarrer les fonctions, doit être mis ici. Nous voulons être sûrs que notre code s'exécute en dernier. Nous paramétrons « lang » à ce que doivent être nos paramètres locaux. Par exemple, dans la ligne du dessus, j'utilise « fr_FR.utf8 » car je vis et pense « Français de France ». Si, cependant, j'étais capable d'enrouler mon vieux cerveau dans le format d'horodatage anglais, je pourrais utiliser « en_GB.utf8 ». (Je l'ai testé et il marche, mais j'ai commencé à faire des confusions). Si, à l'inverse, j'habitais en Norvège, j'utiliserais « nb_NO.utf8 ».
The set_our_globals() function defines the ip address of the broker (I assume it is running on your RPi, so you will use the RPi’s address) and the two topics that we will subscribe to. If, when you programmed your DHTXX code last month you changed these topics to something else, make sure that the topic names match what your sensor program is publishing. Put this code (shown top right) right after the init() function. Next, we will write our start_up() function (shown middle right). This is the code that gets everything going. Notice that we instantiate the mqtt client and set two callbacks as we did in our RPi code. After that, we connect to the broker and call the subscribe_to_topics() function. Finally we start the client into a loop. Unlike a console program, we don’t call client.loop_forever(). This is because the loop_forever() function creates a blocking call which will not allow our GUI to ever update or respond to the mouse. The loop_start() call, however, does not create a blocking call, so we can use it to create the client listen loop (shown bottom right). However, we need to use the loop_stop() call before we end the program to stop the client.
La fonction set_our_globals() définit l'adresse ip du broker (je présume qu'il tourne sur votre RPi ; aussi, vous utiliserez l'adresse du RPi) et les deux sujets auxquels nous nous abonnerons. Si, quand vous avez programmé votre code du DHTXX le mois dernier, vous avez modifié ces sujets pour autre chose, assurez-vous que les noms des sujets correspondent à ce que votre programme des capteurs va publier. Mettez ce code (présenté en haut à droite) juste après la fonction init().
Ensuite, nous écrirons notre fonction start_up() (présentée au milieu à droite). C'est le code qui démarre tout.
Notez que nous instancions le client mqtt et paramétrons deux callbacks comme nous l'avons fait dans le code du RPi. Après cela, nous nous connectons au broker et appelons la fonction subscribe_to_topics(). Enfin, nous démarrons le client dans une boucle. Contrairement à un programme de console, nous n'appelons pas client.loop_forever(). Ceci parce que la fonction loop_forever() crée un appel bloquant qui n'autorisera pas notre UI à se mettre à jour ou à répondre à la souris. L'appel loop_start(), quant à lui, ne crée pas d'appel bloquant, de sorte que nous pouvons l'utiliser pour créer la boucle d'écoute du client (présentée en bas à droite). Cependant, nous devons utiliser l'appel loop_stop() avant la fin du programme pour arrêter le client.
In the subscribe_to_topics() function, we simply send a client.subscribe() call to the broker to make sure we get the messages. Here we use the client.subscribe(topic,qos) method to include the QOS value of 1, since the RPi is publishing the messages with a QOS of 1. Our next function is the on_connect() callback function (shown bottom left). Once we get a connect ACK back from the broker, this routine is called. We simply print that we are connected to the terminal. Now this is where the “magic” happens. The on_message() callback function (shown next page, top right)is run whenever a message comes in from the broker. We will handle any messages coming from the broker to us. We use an if/elif/else tree to handle the messages. First we get the time and format it into a U.S. date/time format, then first check to see if the word ‘humidity’ is in the message topic. If it is, we take the data (message.payload) and use the .set() method of the humidity label text variable to put the data into the label. Next we use a similar scheme to check to see if ‘temperature’ is in the message topic and put that data into the label. Finally, if we get a topic that we aren’t set up for (which should not happen, but can) we print the topic and message to the terminal window. Finally, we place the message date/time string into the proper label. I can only be sure that the datetime format shows as a U.S. datetime format. According to the research that I have been able to do, it should work in whatever language you use based on your locale setting. However, it might require you to use locale.setlocale(locale.LC_ALL, lang) before the tim = datetime… line, but seems to be discouraged by the majority of Python programmers.
Dans la fonction subscribe_to_topics(), nous envoyons juste un appel client.subscribe() à l'intermédiaire pour être sûrs de recevoir les messages. Ici, nous utilisons la méthode client.subscribe(topic,qos) pour inclure une valeur de QOS à 1, car le RPi publie les messages avec QOS à 1.
Notre prochaine fonction est la fonction de callback on_connect() (présentée en bas à gauche). Une fois que nous recevons en retour un « connect ACK » (accusé de connexion) de la part du broker, la routine est appelée. Nous imprimons simplement que nous sommes connectés au terminal.
C'est maintenant que commence la magie. La fonction de rappel on_message() (présentée sur la page suivante, en haut à droite), est lancée si un message du broker arrive. Nous traiterons tous les messages nous arrivant du broker. Nous utilisons une arborescence if/elif/else pour traiter les messages. D'abord, nous recevons l'horodatage et nous le formatons dans un format d'horodatage local, puis, nous vérifions d'abord si le mot « humidity » est dans le sujet du message. Si c'est le cas, nous prenons la donnée (message.payload) et utilisons la méthode .set() de la variable texte de l'étiquette d'humidité pour mettre la donnée dans l'étiquette. Ensuite, nous utilisons une structure similaire pour vérifier si « température » est dans le sujet du message et mettre sa donnée dans l'étiquette. Enfin, si nous recevons un message pour lequel nous ne sommes pas paramétré (ce qui ne devrait pas arriver, mais est possible), nous imprimons le sujet et le message dans la fenêtre du terminal. Pour finir, nous plaçons la chaîne d'horodatage du message dans la bonne étiquette. Je peux seulement être sûr que le format d'horodatage est présenté dans le format local. D'après les recherches que j'ai pu faire, il pourrait être nécessaire que vous utilisiez locale.setlocale(locale.LC_ALL, lang) avant la ligne tim = datetime…, mais cela semble être déconseillé par la majorité des programmeurs en Python.
That is all the code we need to do. Remember to uncomment the line client.loop_stop() in the on_btnClick() function so the program can shut down properly and then run your program. If your RPi is still publishing at a rate of one update every 5 seconds, you should see your data come through. All three code files (*.tcl, *.py and *_support.py) have been placed on pastebin. The addresses are: mqttclient.tcl file - https://pastebin.com/1e41SpNc mqttclient.py - https://pastebin.com/xiUPwaJu mqttclient_support.py - https://pastebin.com/byBuHPyX I’m not sure what we’ll be presenting next month, but hopefully it will be fun for all of us. Until then, HAVE FUN!
C'est tout le code que vous avez à faire. Souvenez-vous de décommenter la ligne client.loop_stop() dans la fonction on_btnClick() pour que le programme puisse se fermer proprement, avant de lancer votre programme. Si votre RPi est toujours sur un rythme de publication d'environ 5 secondes, vous devriez voir arriver les données.
Les trois fichiers de codes (*.tcl, *.py and *_support.py) ont été placés sur pastebin. Les adresses sont : mqttclient.tcl file - https://pastebin.com/1e41SpNc
mqttclient.py - https://pastebin.com/xiUPwaJu
mqttclient_support.py - https://pastebin.com/byBuHPyX
Je ne sais pas encore de quoi je vais parler le mois prochain, mais j'espère que le sujet nous amusera tous. Jusque là, AMUSEZ-VOUS BIEN !