start:projets:capteurweb [DokuWiki]

Ceci est une ancienne révision du document !

<a href=“/wiki0/doku.php?id=start:projets” class=“wikilink1” title=“start:projets” data-wiki-id=“start:projets”>Les idées & projets</a>

<hr />

<h1>Les données, du capteur au Web</h1>
<div class=“level1”>

</div>

<h4>Aussi appelé “IOT” pour “Internet des Objets” (Internet Of Things)</h4>
<div class=“level4”>
<hr />

Cet atelier va permettre de découvrir toutes les techniques utilisées pour lire une donnée (température, pression, qualité de l'air, puissance consommée, …) et pour l'utiliser et l'afficher sur Internet :

<ul>
<li class=“level1”> Utiliser des capteurs avec Arduino ou RaspberryPi afin d'obtenir des données. Commencer par un capteur de température: le DS18B20. On en utilisera plusieurs sur une même broche Arduino</li>
<li class=“level1”> Enregistrer les données obtenues. L'arduino sera connecté à un Pi (Raspberry ou Orange). Cela permet d'alléger le sketch Arduino qui reste ainsi solide. Il est aussi possible de faire un prétraitement des informations fournies, et éventuellement de servir rapidement une ou plusieurs pages HTML. Il va fallor commencer à apprendre à communiquer avec l'Arduino, en Python, via le port série.</li>
<li class=“level1”> Server MQTT, pour distribuer les données à d'autres appareils, comme par exemple une box domotique</li>
<li class=“level1”> Server de base de données SQL afin de conserver un historique de toutes les données</li>
<li class=“level1”> Traiter éventuellement ces données (moyenne journalière par exemple)</li>
<li class=“level1”> Afficher ces données sous formes graphique, dans un navigateur. Server Web - HTML - EcmaScript (js)</li>
</ul>

</div>

<h4>Plusieurs technologies seront abordées et utilisées :</h4>
<div class=“level4”>
<ul>
<li class=“level1”> Arduino et sa programmation</li>
<li class=“level1”> RaspberryPi et sa programmation en Python</li>
<li class=“level1”> Réseau et transport des données, protocoles TCP IP, MQTT, HTTP</li>
<li class=“level1”> Eventuellement , communication radio</li>
<li class=“level1”> Bases de données, SQL</li>
<li class=“level1”> Serveur Web, HTML, JavaScript</li>
</ul>
<hr />

</div>

<h2>Les ateliers</h2>
<div class=“level2”>

Voici la liste non exhaustive et dans le désordre des ateliers à venir. 
Noter que certains de ces ateliers se feront sans doute en plusieurs séances.

<ul>
<li class=“level1”> Arduino + DS18B20. Envoie des données sur le port série, en <a href=“http://www.json.org/” class=“urlextern” title=“http://www.json.org/” rel=“ugc nofollow”>JSON</a></li>
<li class=“level1”> Installation & Configuration d'un RaspberryPi (<a href=“https://www.raspberrypi.org/downloads/” class=“urlextern” title=“https://www.raspberrypi.org/downloads/” rel=“ugc nofollow”>raspbian</a>) et d'un OrangePi (<a href=“https://www.armbian.com/download/” class=“urlextern” title=“https://www.armbian.com/download/” rel=“ugc nofollow”>armbian</a>)</li>
<li class=“level1”> Programmation en <a href=“https://www.python.org/” class=“urlextern” title=“https://www.python.org/” rel=“ugc nofollow”>Python</a> pour communiquer avec le port série grace à la bibliothèque <a href=“https://pyserial.readthedocs.io/en/latest/” class=“urlextern” title=“https://pyserial.readthedocs.io/en/latest/” rel=“ugc nofollow”>pySerial</a></li>
<li class=“level1”> Programmation en Python avec <a href=“http://bottlepy.org/docs/dev/” class=“urlextern” title=“http://bottlepy.org/docs/dev/” rel=“ugc nofollow”>Bottle</a> pour monter un premier server Web servant des pages statiques. Découverte du HTML.</li>
<li class=“level1”> Ajouter de la dynamique dans les pages, c'est à dire des données vivantes et fraiches. Utilisation de bibliothèques <a href=“https://fr.wikipedia.org/wiki/JavaScript” class=“urlextern” title=“https://fr.wikipedia.org/wiki/JavaScript” rel=“ugc nofollow”>JavaScript</a>.</li>
<li class=“level1”> Installation de Linux sur un PC et initiation</li>
<li class=“level1”> Quelques notions de réseau et du protocole <a href=“https://fr.wikipedia.org/wiki/Transmission_Control_Protocol” class=“urlextern” title=“https://fr.wikipedia.org/wiki/Transmission_Control_Protocol” rel=“ugc nofollow”>TCP</a> <a href=“https://fr.wikipedia.org/wiki/Internet_Protocol” class=“urlextern” title=“https://fr.wikipedia.org/wiki/Internet_Protocol” rel=“ugc nofollow”>IP</a> <a href=“https://fr.wikipedia.org/wiki/IPv4” class=“urlextern” title=“https://fr.wikipedia.org/wiki/IPv4” rel=“ugc nofollow”>v4</a></li>
<li class=“level1”> Server <a href=“https://fr.wikipedia.org/wiki/MQTT” class=“urlextern” title=“https://fr.wikipedia.org/wiki/MQTT” rel=“ugc nofollow”>MQTT</a> <a href=“https://mosquitto.org/” class=“urlextern” title=“https://mosquitto.org/” rel=“ugc nofollow”>Mosquitto</a></li>
<li class=“level1”> Server <a href=“https://fr.wikipedia.org/wiki/Structured_Query_Language” class=“urlextern” title=“https://fr.wikipedia.org/wiki/Structured_Query_Language” rel=“ugc nofollow”>SQL</a> <a href=“https://www.postgresql.org/” class=“urlextern” title=“https://www.postgresql.org/” rel=“ugc nofollow”>PostgreSQL</a> ou <a href=“https://sqlite.org/index.html” class=“urlextern” title=“https://sqlite.org/index.html” rel=“ugc nofollow”>SQLite</a> pour enregistrer toutes les données</li>
<li class=“level1”> Augmentation du server web pour servir des historiques de données.</li>
<li class=“level1”> Server <a href=“https://nodered.org/” class=“urlextern” title=“https://nodered.org/” rel=“ugc nofollow”>Node-RED</a> pour éventuellement faire interagir les différents capteurs et actionneurs : <a href=“https://fr.wikipedia.org/wiki/Internet_des_objets” class=“urlextern” title=“https://fr.wikipedia.org/wiki/Internet_des_objets” rel=“ugc nofollow”>IOT</a></li>
</ul>
<hr />

</div>

<h2>Arduino + DS18B20</h2>
<div class=“level2”>

Découverte du capteur DS18B20. 
Apparence physique du capteur simple (boitier TO92), et du capteur tel qu'on peut le trouver inséré dans un bulbe métallique étanche. 
Connexion du capteur DS18B20 à l'Arduino: 
Le DS18B20 est un capteur numérique qui communique ses données selon le protocole “OneWire”. Il présente l'avantage de pouvoir utiliser une seule broche de l'Arduino pour lire plusieurs capteurs disposés en réseau parallèle ou en étoile. 
Un schéma de montage pour un seul capteur nu est disponible <a href=“https://konkarlab.fr/nextcloud/index.php/s/XfA4AbnSarww89E” class=“urlextern” title=“https://konkarlab.fr/nextcloud/index.php/s/XfA4AbnSarww89E” rel=“ugc nofollow”>ici (image)</a> ou <a href=“https://konkarlab.fr/nextcloud/index.php/s/8xejK9Xk5coCB6M” class=“urlextern” title=“https://konkarlab.fr/nextcloud/index.php/s/8xejK9Xk5coCB6M” rel=“ugc nofollow”>ici (fritzing)</a>. Le fil rouge correspond au +5V, le fil noir à la masse et le fil jaune sera connecté à la broche de lecture, soit la broche 2 en utilisant le sketch ci-dessous. 
A noter qu'il existe des capteurs intégrés dans un bulbe étanche qui utilisent les codes couleur suivant:

Masse	+5V	Data

   <th class="col0">Bulbe Noir Rouge Jaune</th><td class="centeralign">  Noir  </td><td class="centeralign">  Rouge  </td><td class="centeralign">  Jaune  </td>\\

</tr>
<tr class=“row1”>

   <th class="col0">Bulbe Jaune Rouge Vert</th><td class="centeralign">  Jaune  </td><td class="centeralign">  Rouge  </td><td class="centeralign">  Vert  </td>\\

</tr>
<tr class=“row2”>

   <th class="leftalign">Bulbe cable réseau  </th><td class="centeralign">  Orange  </td><td class="centeralign">  Rouge  </td><td class="centeralign">  Vert  </td>\\

</tr>
</table>
 
</div>

Dans le cas de capteurs en réseau, il est nécessaire de découvrir l'adresse unique de chaque capteur. 
Cela se fait par exemple avec ce <a href=“https://konkarlab.fr/nextcloud/index.php/s/eQbbf9xBQzzHosL” class=“urlextern” title=“https://konkarlab.fr/nextcloud/index.php/s/eQbbf9xBQzzHosL” rel=“ugc nofollow”>programme </a>.

<a href=“http://www.fritzing.org” class=“urlextern” title=“http://www.fritzing.org” rel=“ugc nofollow”>Fritzing</a> est un logiciel libre qui permet de faire facilement des schémas électriques simples afin de documenter ses projets.

<hr />

</div>

<h2>Installer Linux</h2>
<div class=“level2”>

La distribution souhaitée est Xubuntu. C'est un Ubuntu, avec une interface XFCE, assez légère et réactive 
Bien entendu, cette distribution existe en 64 bits et 32 bits. Pour des machines anciennes, il est nécessaire de choisir la version 32 bits. 
Une <a href=“/wiki0/doku.php?id=start:howto:installlinux” class=“wikilink1” title=“start:howto:installlinux” data-wiki-id=“start:howto:installlinux”>page est dédiée</a> à cela.

<hr />

</div>

<h2>Découverte du langage Python</h2>
<div class=“level2”>

Le langage de programmation “Python” est le langage officiel du Raspberry Pi. En outre, je trouve que Python est aisément accessible et polyvalent. 
On trouve énormément de documenation et de tutoriels sur Internet, en français qui plus est. Le site <a href=“https://openclassrooms.com/courses/apprenez-a-programmer-en-python” class=“urlextern” title=“https://openclassrooms.com/courses/apprenez-a-programmer-en-python” rel=“ugc nofollow”>OpenClassRoom</a> par exemple propose une bonne porte d'entrée. Il y a aussi un <a href=“https://www.fun-mooc.fr/courses/inria/41001S03/session03/about” class=“urlextern” title=“https://www.fun-mooc.fr/courses/inria/41001S03/session03/about” rel=“ugc nofollow”>MOOC</a> python.

Enfin, José a préparé “<a href=“https://konkarlab.fr/nextcloud/index.php/s/dnHLiGECxBKwdS3” class=“urlextern” title=“https://konkarlab.fr/nextcloud/index.php/s/dnHLiGECxBKwdS3” rel=“ugc nofollow”>Une introduction à l’environnement Linux pour des bricoleuses et bricoleurs</a>”, document qui contient aussi “Une introduction au langage Python pour des bricoleuses et bricoleurs”.

J'ai aussi trouvé une “<a href=“https://konkarlab.fr/nextcloud/index.php/s/y5WkrNd4dD8NYqa” class=“urlextern” title=“https://konkarlab.fr/nextcloud/index.php/s/y5WkrNd4dD8NYqa” rel=“ugc nofollow”>Initiation à Python par l’exemple</a>”.

Avec Python, on découvre aussi ce qui est un peu une curiosité : la simultanéité de 2 versions pas tout à fait compatibles : la 2 et la 3, cette dernière étant disponible depuis plus de 10 ans. Toutefois, les 2 versions ont continué à évoluer. On considère actuellement que la version 2 touche à sa fin et que la majorité des bibliothèques en cours de vie ont actuellement migrées vers la version 3.

Sur la plupart des machines, les 2 versions maintenant sont installées, mais la version 2 reste encore souvent la version par défaut. 
Pour exécuter un code python en version 3, il faut explicitement appeler python3. Par exemple, le script toto.py devra être exécuter avec la commande

<pre class=“code”>python3 toto.py

</pre>

la commande par défaut

<pre class=“code”>python toto.py

</pre>

utiliserait la version 2 de Python.

</div>

<h3>Gestion des versions de Python.</h3>
<div class=“level3”>

Pour commencer, il est possible d'identifier la version par défaut en tapant la commande

<pre class=“code”>python –version

</pre>

Ensuite, il est possible de spécifier la version par défaut à utiliser en utilisant la commande “update-alternatives” 
La version par défaut sera celle pour laquelle il aura été spécifié le plus grand numéro en fin de commande. Il est même possible de gérer ainsi différentes versions 2.x et versions 3.x. 
Voici un exemple de commande mettant une version 3 par défaut :

<pre class=“code”>sudo update-alternatives –install /usr/bin/python python /usr/bin/python3.5 2
sudo update-alternatives –install /usr/bin/python python /usr/bin/python2.7 1

</pre>

Il est maintenant possible de faire un script Python permettant de connaître la version utilisée:

<pre class=“code python”>#!/usr/bin/python
# -*- coding: utf-8 -*-

import sys
print(sys.version)

</pre> 
<hr />

</div>

<h2>Communication Arduino Python</h2>
<div class=“level2”>

Le but est de récupérer les informations envoyées par l'Arduino, éventuellement de les afficher, mais surtout de les traiter. 
Pour cela, on va utiliser le port USB de l'Arduino et on va essayer de faire le tri entre les informations de fonctionnement ou de débuggage, et les informations utiles, qui elles, seront présentées en <a href=“http://www.json.org/” class=“urlextern” title=“http://www.json.org/” rel=“ugc nofollow”>json</a>. 
Il sera aussi intéressant de pouvoir envoyer des commandes à l'Arduino. 
Pour commencer, il est nécessaire d'avoir un sketch Arduino qui va nous servir à tester tout cela. Le sketch <a href=“https://konkarlab.fr/nextcloud/index.php/s/NKLzBQcdstMLnWd” class=“urlextern” title=“https://konkarlab.fr/nextcloud/index.php/s/NKLzBQcdstMLnWd” rel=“ugc nofollow”>testJson1.ino</a> est disponible.

Ce sketch récupère une tension sur une borne analogique de l'Arduino, en prépare 3 valeurs et les envoie sur le port USB formattées en json, parmi d'autres informations de contrôle et de débuggage.

Un site intéressant pour vérifier le bon formattage d'un document json : <a href=“https://jsonchecker.com/” class=“urlextern” title=“https://jsonchecker.com/” rel=“ugc nofollow”>jsonchecker.com</a>.

Coté miniPC, c'est donc le script python <a href=“https://konkarlab.fr/nextcloud/index.php/s/FNyfPYooW9BReLs” class=“urlextern” title=“https://konkarlab.fr/nextcloud/index.php/s/FNyfPYooW9BReLs” rel=“ugc nofollow”>testSerial.py</a> qui sera chargé de communiquer avec l'Arduino, en utilisant la bibliothèque pyserial.

Noter que j'utilise python3. 
La bibliothèque pyserial n'est pas installée par défaut sur Linux. Il est donc nécessaire de l'installer. Cela se fait par la commande :

<pre class=“code”>sudo apt install python3-serial

</pre>

Le fichier testSerial.py est donc un fichier qui s'ouvre avec n'importe que éditeur de texte. Pour l'exécuter, ouvrir une fenêtre de terminal dans le dossier dans le quel se trouve le fichier et lancer la commande

<pre class=“code”>python3 testSerial.py

</pre>

ou simplement

<pre class=“code”>python testSerial.py

</pre>

si python3 est la version de python utilisée par défaut sur votre PC. 
Penser à vérifier le port série utilisé par le code. Comme il s'agit d'une boucle infinie, il est nécessaire d'arrêter le programme manuellement. Cela se fait avec la combinaison de touche “Ctrl + C”

<hr />

</div>

<h2>Bottle, un server web léger, en Python</h2>
<div class=“level2”>

Pour servir les pages web qui nous intéressent, qui affichent notamment des données issues de capteurs locaux, le framework web léger <a href=“http://bottlepy.org/docs/dev/” class=“urlextern” title=“http://bottlepy.org/docs/dev/” rel=“ugc nofollow”>Bottle</a> suffit amplement. Et sans alourdir l'ensemble, il est facile d'utiliser un autre Framework web minimaliste supportant le multitache: <a href=“https://cherrypy.org/” class=“urlextern” title=“https://cherrypy.org/” rel=“ugc nofollow”>CherryPy</a>.

Il est donc nécessaire d'installer Bottle et CherryPy avec la commande suivante:

<pre class=“code”>sudo apt install python3-bottle python3-cherrypy3

</pre>

Et maintenant, un premier exemple, avec le traditionnel “Bonjour le monde !” :

<pre class=“code python”>#!/usr/bin/python
# -*- coding: utf-8 -*-

from bottle import route, run

@route('/hello')
def hello():
return 'Bonjour le monde de Python! '

run(host='localhost', port=8080, server='cherrypy')

</pre>

Pour voir cette page s'afficher dans votre navigateur, exécuter ce script python, puis, aller à l'adresse <a href=“http://locahost:8080/hello” class=“urlextern” title=“http://locahost:8080/hello” rel=“ugc nofollow”>http://locahost:8080/hello</a>.

Noter que les page web sont servies sur le port 8080, qui est spécifié dans la dernière ligne. “localhost” est l'adresse IP de votre machine.

Ensuite, la page s'appelle “hello”. Dans le code, c'est le décorateur “@route” qui spécifie cela.

Mais comment faire pour transmettre des images et d'autres fichier ? 
C'est relativement simple, avec l'exemple suivant :

<pre class=“code python”>#!/usr/bin/python
# -*- coding: utf-8 -*-

from bottle import route, run, static_file

@route('/static/< filename>')
def serverStatic(filename):
return static_file(filename, root='myStaticsFiles')

@route('/hello')
def hello():
return 'Bonjour le monde de Python! '

run(host='0.0.0.0', port=8080, server='cherrypy')

</pre>

La nouvelle fonction “serverStatic” a été ajoutée, avec le décorateur “@route('/static/') ”. Cela signifie que le server pourra répondre aux adresses commençant par <a href=“http://locahost:8080/static/…” class=“urlextern” title=“http://locahost:8080/static/…” rel=“ugc nofollow”>http://locahost:8080/static/…</a> avec un nom de fichier valide à la place des “…”. Ce fichier devra se trouver dans le sous-dossier “myStaticsFiles” du dossier courant. Il est bien entendu possible de spécifier un chemin absolu, du style “/home/user/softs/testBottle/myStaticsFiles”.

Autre nouveauté par rapport au premier exemple, le contenu de “host” dans la dernière ligne. Dans le premier exemple, seul l'ordinateur local, nommé “Localhost” pouvoir interroger le server. Maintenant, “0.0.0.0” signifie que le server web va répondre à toutes les adresse IP. Si vous avez une autre machine sur le réseau local, il lui est maintenant possible d'interroger le server web, une fois celui-ci en cours d'exécution bien sûr.

Avec Linux, pour obtenir l'adresse IP locale de sa machine, c'est la commande:

<pre class=“code”>ip addr

</pre> 
<hr />

</div>

<h2>OrangePi & Raspberry Pi</h2>
<div class=“level2”>

L'installation d'un OrangePi est décrite <a href=“/wiki0/doku.php?id=start:howto:installorangepi” class=“wikilink1” title=“start:howto:installorangepi” data-wiki-id=“start:howto:installorangepi”>sur cette page dédiée</a>.

Un tuto complet est aussi disponible sur le site <a href=“https://herve-troadec.developpez.com/tutoriels/orangepi/install-armbian/” class=“urlextern” title=“https://herve-troadec.developpez.com/tutoriels/orangepi/install-armbian/” rel=“ugc nofollow”>developpez.com</a>. Toujours sur ce même site, et du même auteur, un tutoriel explique <a href=“https://herve-troadec.developpez.com/tutoriels/raspberry/connexion-ssh-vnc/” class=“urlextern” title=“https://herve-troadec.developpez.com/tutoriels/raspberry/connexion-ssh-vnc/” rel=“ugc nofollow”>comment contrôler un RaspberryPi depuis un PC Linux</a>.

<hr />

</div>

<h2>MQTT : pour les réunir tous…</h2>
<div class=“level2”>

MQTT est un protocole de transport particulièrement adapté à véhiculer les données fournies par les capteurs. 
MQTT pourrait être l'abréviation de “Message Queuing Telemetry Transport”. 
Il existe des librairies qui permettent d'utiliser MQTT pour Arduino et pour la plupart des microcontroleurs utilisés pour des capteurs.

Chaque information est assuciée à un sujet, ou “topic”. Les topics sont organisés de façon arborescente, et sont laissé au bon soin des utilisateur. Il n'y a aucune structure prédéfinie.

</div>

<h3>Installation du service MQTT :</h3>
<div class=“level3”>
<ul>
<li class=“level1”> Installation</li>
</ul>
<pre class=“code bash”>sudo apt install mosquitto

</pre> 
<ul>
<li class=“level1”> Lancer le server :</li>
</ul>
<pre class=“code bash”>mosquitto -d

</pre>

Normalement, il se lance automatiquement après l'installation. 
Le port n'a pas besoin d'être précisé si on utilise le port par défaut qui est 1883. C'est l'option “-p” qui permet de spécifier un port différent. Il sera alors nécessaire de toujours spécifier le port à utiliser avec les commandes clients que l'on verra plus bas.

<ul>
<li class=“level1”> modifier le fichier /etc/mosquitto/mosquitto.conf</li>
</ul>
<pre class=“code autoconf”>pid_file /var/run/mosquitto.pid
persistence true
persistence_location /var/lib/mosquitto
listener 1883
listener 8083
protocol websocket
log_dest topic
log_type error
log_type warning
log_type notice
log_type information
connection_messages true
log_timestamp true
include_dir /etc/mosquitto.conf.d

</pre> 
<ul>
<li class=“level1”> Installer les clients mosquitto</li>
</ul>
<pre class=“code batch”>sudo apt-get install mosquitto-clients

</pre>

</div>

<h3>Utilisation du service MQTT :</h3>
<div class=“level3”>

Un fois le client installé, il est possible de :

S'abonner

Par exemple souscrivant aux données du topic “test” et de tout ses enfants:

<pre class=“code bash”>mosquitto_sub -t test/# -v

</pre>

Les options suivantes sont disponibles (entre autres):

<ul>
<li class=“level1”></li>
</ul>

-t : pour spécifier le topic auquel on souhaite souscrire ou s'abonner. Le caractère # est un caractère générique qui signifie, dans l'exemple ci-dessus, que l'on souhaite tous les topics commençant par la racine “test”

<ul>
<li class=“level1”></li>
</ul>

-v : pour afficher le topic. Cela est utile quand on s'abonne en utilisant le caratère générique #.

<ul>
<li class=“level1”></li>
</ul>

-h : pour spécifier l'adresse IP ou le nom d'une autre machine

<ul>
<li class=“level1”></li>
</ul>

-p : pour spécifier un port différent

Publier des données

en alimentant le topic “test/a” :

<pre class=“code bash”>mosquitto_pub -t test/a -m “toto fait du vélo” -r

</pre>

Les options suivantes sont disponibles (entre autres):

<ul>
<li class=“level1”></li>
</ul>

-t : pour spécifier le topic sur lequel on souhaite publier.

<ul>
<li class=“level1”></li>
</ul>

-m : pour spécifier le message ou la valeur à publier. Les guillemets sont nécessaire si le message comporte des espaces.

<ul>
<li class=“level1”></li>
</ul>

-r : pour demander au server de conserver la dernière valeur pour le topic en question

<ul>
<li class=“level1”></li>
</ul>

-h : pour spécifier l'adresse IP ou le nom d'une autre machine

<ul>
<li class=“level1”></li>
</ul>

-p : pour spécifier un port différent.

Enfin, voici quelques liens intéressants :

<ul>
<li class=“level1”> <a href=“https://www.frugalprototype.com/installation-de-votre-propre-broker-mqtt/” class=“urlextern” title=“https://www.frugalprototype.com/installation-de-votre-propre-broker-mqtt/” rel=“ugc nofollow”>Installer votre propre broker MQTT</a></li>
<li class=“level1”> <a href=“https://projetsdiy.fr/mosquitto-broker-mqtt-raspberry-pi/” class=“urlextern” title=“https://projetsdiy.fr/mosquitto-broker-mqtt-raspberry-pi/” rel=“ugc nofollow”>Bien débuter avec le Broker MQTT Mosquitto</a> <= avec pas mal de pub :(</li>
<li class=“level1”> <a href=“https://blog.guiguiabloc.fr/index.php/2014/11/13/mqtt-faites-communiquer-vos-objets-simplement/” class=“urlextern” title=“https://blog.guiguiabloc.fr/index.php/2014/11/13/mqtt-faites-communiquer-vos-objets-simplement/” rel=“ugc nofollow”>MQTT, faites communiquer vos objets simplement</a></li>
</ul>

</div>

<h3>Python</h3>
<div class=“level3”>

Enfin, on va pouvoir interragir avec toutes les données via des scripts écrit en Python. 
Avant cela, il va être nécessaire d'installer la librairie ad-hoc via l'utilitaire PIP :

<pre class=“code bash”>sudo apt install python3-pip
sudo pip3 install paho-mqtt

</pre>

Nous voilà maintenant paré à pouvoir triturer et croiser facilement toutes nos données issues des différents capteurs.

</div>

Il peut être aussi extrèmement intéressant de construire une page web dynamique sans server. ce est possible via des scripts JavaScript utilisant l'interface WebSocket du server MQTT.

Dans le fichier de configuration du server Mosquitto, nous avons ajouter 2 lignes :

<pre class=“code autoconf”>listener 8083
protocol websocket

</pre>

Cela pour spécifier que le protocole WebSocket doit être disponible sur le port 8083.

C'est en effet ce protocole qui sera utilisé par les pages HTML pour souscrire au flux MQTT et récupérer directement les données publiées au fur et à mesure.

Un projet exemple est disponible ici : <a href=“https://konkarlab.fr/nextcloud/index.php/s/fJTy6zGHnW24fJZ” class=“urlextern” title=“https://konkarlab.fr/nextcloud/index.php/s/fJTy6zGHnW24fJZ” rel=“ugc nofollow”>dans ce fichier zip</a>

Ce projet comprend 5 fichiers à déposer dans le même dossier:

<ul>
<li class=“level1”> SteelTemp.html : Le fichier html que nous devons construire, avec un peu de javaScript pour personnaliser les interactions avec le server MQTT.</li>
<li class=“level1”> jquery-1.8.3.min.js : une bibliothèque javaScript très utile</li>
<li class=“level1”> tween-min.js : une autre bibliothèque javaScript</li>
<li class=“level1”> mqttws31.js : la bibliothèque javaScript qui gère tout le code permettant de souscrire à un server MQTT</li>
<li class=“level1”> steelseries.js : une bibliothèque javascript qui permet d'afficher un thermomètre graphique</li>
</ul>

—-

</div>

<h2>MySensors, sans fil</h2>
<div class=“level2”>

Une petite démo d'un capteur de température sans fil en utilisant la bibliothèque <a href=“https://www.mysensors.org” class=“urlextern” title=“https://www.mysensors.org” rel=“ugc nofollow”>MySensors</a>.

Plutôt orienté domotique, le système repose sur le composant radio NRF24L01 et un arduino nano. D'un coté, un ensemble (arduino + radio) doté d'un capteur de température DS18B20, et de l'autre, un ensemble seul faisant office de passerelle via le port série. 
Il est possible de connecter toute une série de capteurs et d'actionneurs. 
Plusieurs box domotiques sont capables d'utiliser ce système.

<hr />

</div>
<!– EDIT{“target”:“table”,“name”:“”,“hid”:“table”,“secid”:1,“range”:“4572-”} –>