République Tunisienne

Ministère de l’Enseignement Supérieur et de la Recherche Scientifique

Université de Tunis El Manar
Ecole Nationale d’Ingénieurs de Tunis

DEPARTEMENT GENIE ELECTRIQUE 
 
 
 
 
 
Cours : Réseaux Locaux et IOT 
 
 
 
Cahier des Charges : Carte STM32L475 IOT Node 
Key Words : WIFI, MQTT, Node‐red, FireBase 

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
http://www.utm.rnu.tn/utm/fr/annuaire-ens-6969-khaled-jelassi
 
 
 
Edition 2020/2021 
 
 
 

Chapitre 1 : Programmation du dispositif IOT Node……………………………………..5

1.1 Introduction…………………………………………………………………………….5
1.2 Le dispositif IOT Node…………………………………………………………………5
1.2.1 Noyau………………………………………………………………………6
1.2.2 Mémoire……………………………………………………………………6
1.3 Configuration graphique à l’aide du logiciel STM32CubeMX ………………………..8
1.4 Génération du code et implémentation du programme sur l’environnement de
programmation STM32CubeIDE……………………………………………………...10
1.4.1 Programmation de la carte et visualisation des données…………………….10
1.4.2 Les protocoles I2C et UART………………………………………………..12
1.4.2.1 L’interface I2C…………………………………………………………….12
1.4.2.2’interface UART ……………………………………………………...……12
Chapitre II : Plateforme Cloud…………………………………………………………….13
2.1 Introduction……………………………………………………………………………14
2.2 Intégration du driver ES-WIFI………………………………………………………...14
2.2.1 Protocole UDP……………………………………………………………..14
2.2.2 Protocole MQTT…………………………………………………………...18
2.3 Installation du Broker MQTT Mosquitto sous Windows ……………………………..20
2.4 La Plateforme de développement Arduino IDE ……………………………………….22
2.5 Node-Red: l'IoT à portée de tous .................................................................................... 28
2.5.1 Installation de Node-red…………………………………………………....28
2.5.2 Ce qu on peut faire avec Node-red ………………………………………...32
Chapitre III : Base de données Cloud …………………………………………………..37
3.1 Introduction ……………………………………………………………………………37
3.2 Base de données ……………………………………………………………………….37
3.2.1 Description ………………………………………………………………….37
3.2.2 Terminologie ………………………………………………………………..38
3.2.3 Solution …………………………………………………………………….………..38
3.3 La base de données Cloud FireBase proposée par Google ……………………………40
3.3.1 Présentation de Firebase …………………………………………………….40
3.3.2 Création d’une Base de données Firebase …………………………………..41
3.3.3 Ecriture en temps réel dans la base de données par un objet connecté ……..43

3.3.3.1 Accès direct à la base de données par microcontrôleur : ………………………………

Cas du microcontrôleur ESP826644
3.3.3.2 Accès Indirect à la base de données par Node-red …………………………………...47
 Travail à Faire …………………………………………………………………………..52

Références bibliographiques .................................................................................................... 54

III
 Table des figures

Figure1 : STM32-L475E-IOT Board ......................................................................................... 5

Figure 2 : Wi-Fi module Inventek ISM43362-M3G-L44 .......................................................... 7
Figure 3 : Module SPBTLE-RF Bluetooth ................................................................................. 7
Figure 4 : Module NFC de série M24SR………………………………………………………8
Figure 5 : Module SPSGRF-868 Sub-GHz RF………………………………………………...8
Figure 6 : Interface de configuration des périphériques………………………………………..9
Figure 7 : Configuration de l'horloge par STM32CubeMX…………………………………..10
Figure 8 : Organigramme de l’algorithme utilisé ..................................................................... 11
Figure 9 : Visualisation des données sur Tera Term ................................................................ 11
Figure 10 : Représentation de la connexion de la carte au server via Wifi .............................. 16
Figure 11 : Etablissement de la connexion ............................................................................... 17
Figure 12 : Communication de la carte via le server ................................................................ 17
Figure 13 : Objets connectés .................................................................................................... 18
Figure 14 : Principe de fonctionnement du protocole MQTT………………………………...19
Figure 15 : Visualisation des données sur la plateforme Arduino ……………………………27
Figure 16 : Etablissement de la connexion (Wifi et Server de MQTT).................................... 27
Figure 17 : Ecran d’accueil de Node-red ……………………………………………………. 31
Figure 18 : Représentation du flow de la température.............................................................. 32
Figure 19 Exemple de flow pour une carte IOT Node ............................................................ 33
Figure 21 : Visualisation des données sur Node-Red .............................................................. 34
Figure 21 Interface Weather ..................................................................................................... 35
Figure 22 : Interface "My Dashboard" ..................................................................................... 36
Figure 23 : Accès simultané à la base de données …………………………………………….37
Figure 24 : Modélisation de la structure de la base de données ………………………………38
Figure 25 : Sous système d’un SGBD ………………………………………………………...38
Figure 26 : Firebase et ses services… ………………………………………………………...38
Figure 27 : Synchronisation des données en temps réel avec firebase …………………….....41
Figure 28 : Création d’un compte firebase … ………………………………………………...41
Figure 29 : Création d’un projet … …………………………………………………………...42
Figure 30 : Autorisations de lecture et d’écriture……………………………………………..42
Figure 31 : SDK de Firebase..…………………………………………………………………43
Figure 32: Kit d'apprentissage NodeMCU IOT..…………………………………..………….43
Figure 33: Initialisation de la palette Firebase………………………………………………...47
Figure 34: Les palettes Firebase (Real Time)..……………………………………..…………43
Figure 35 : Exemple de flow Node-red pour l’acquisition de l’hum, la press, et la temp……...48

4
Chapitre I : Programmation du dispositif IOT
Node

1.1 Introduction

Nous allons présenter ici sur le dispositif IOT Node ainsi que les étapes de programmation des
drivers de ses capteurs et les ressources logicielles utilisées.

1.2 Le dispositif IOT Node

Pour le développement de notre application, nous avons choisi un kit de développement de

STMicroelectronics de la série L4. Plus précisément la carte B-L475E-IOT01A2 présentée
dans figure 1. Ce kit est adapté aux applications médicales et industrielles … en associant sa
technologie ultra-basse consommation aux performances des cœurs ARM® Cortex®-M4. Ce
microcontrôleur affiche une puissance de calcul qui peut atteindre 100 DMIPS pour une
consommation active de seulement 100 μA/MH.

Figure 1: STM32-L475-IOT Board

5
 1.2.1 Noyau :

C’est un processeur 32 bits ARM Cortex™-M4 avec unité à virgule flottante (FPU), un
accélérateur en temps réel adaptatif (ART Accelerator™) qui permet d’atteindre une
exécution de la mémoire Flash sans état d’attente, une fréquence allant jusqu’à 80 MHz, une
unité de protection de la mémoire, 100 DMIPS/1.25DMIPS/MHz (Dhrystone 2.1) et des
instructions de traitement numérique des signaux (DSP).

1.2.2 Mémoire :

 1 Mbyte de mémoire Flash

 128 Kbytes de SRAM (Static Random Access Memory)

La carte B-L475E-IOT est équipée de capteurs environnementaux et de capteurs de

mouvements :

 HTS221 : Capteur numérique capacitif qui mesure l’humidité relative ainsi que la
température.
 LPS22HB : Baromètre numérique.
 LSM6DSL : 3D accéléromètre numérique et 3D gyroscope numérique.
 LIS3MDL : Capteur magnétique sur 3 axes à sortie numérique.
 VL53L0X : Capteur qui permet la détection de gestes et mesure l’intervalle de temps
durant lequel il y a eu une détection.

Le kit de développement intègre aussi les modules sans fils suivant :

• Le module Wi-Fi: Ce module Wi-Fi, Inventek ISM43362-M3G-L44 (802.11 b/g/n), est un

dispositif de sans fil pour la connexion à Internet (ES-WiFi). La partie Hardware du module Wi-Fi
possède un processeur ARM® Cortex® -M3 STM32. Elle contient aussi une antenne intégrée (ou
une antenne externe en option) et une connexion Wi-Fi Broadcom. 802.11 b/g/. Il accepte les
authentication WEP-128, WPA-PSK (TKIP), WPA2-PSK.

6
 Figure 2 : Wi-Fi module Inventek ISM43362-M3G-L44

 Le module Bluetooth :

Le module Bluetooth (SPBTLE-RF) est un module de processeur Maitre/Esclave qui permet

d’utiliser le Bluetooth à basse consommation (Bluetooth Low Energy /BLE) conforme à la
technologie du Bluetooth V4.1.

Figure 3 : Module SPBTLE-RF Bluetooth

 Le module NFC :

Les balises NFC de série M24SR fournissent une interface de type 4RF et prennent en charge
les données d’échange NFC dont le format est NDEF. Ainsi les cas d’utilisation du NFC sans
le couplage Bluetooth, les liens automatiques vers des URLs, le stockage des Vcard et d’autres
types d’informations sont possibles. De plus, le module NFC est utilisé dans une grande
variété d’application comme par exemple les périphériques informatiques, les appareils
électroménagers, l'automatisation industrielle et les produits de santé [9].

7
 Figure 4 : Module NFC de série M24SR (RFID Tag)

 Le module Sub-GHz :

Les SPSGRF-868 et SPSGRF-915 sont des modules sub-GHz basse. Ils sont basés sur le RF
SPIRIT1 en mode émetteur-récepteur, opérant respectivement dans les bandes SRD 868 MHz
et ISM 915 MHz [10].

Figure 5 : Module SPSGRF-868 Sub-GHz RF

1.3 Configuration graphique à l’aide du logiciel STM32CubeMX

STM32CubeMX est un outil de configuration pour la génération automatique du code et des

drivers. Il est fourni avec une couche software HAL (Hardware abstraction Layer :
STM32CubeHAL) et un ensemble de middleware (RTOS, TCP/IP, Graphics, ..)
Le logiciel STM32CubeMX nous permet la configuration de nos périphériques d’une manière
simple et efficace grâce à son interface graphique très utile [11] comme illustré sur les figures
6 et 7 suivantes.

8
 STM32CubeMX

STM32CubeL0

STM32CubeF4
STM32CubeL

STM32CubeF0 STM32CubeF2

STM32CubeF3
STM32CubeF1
Configuration des pattes

Configuration des périphériques

Consommation électrique
Configuration des horloges

Figure 6 : Interface de configuration des périphériques

9
 Figure 7 : Configuration de l'horloge par STM32CubeMX

En outre, le logiciel offre un package d’extension X-CUBE-AI qui fait partie de l’écosystème STM32Cube.AI.
Ainsi STM32CubeMX permet une conversion automatique du réseau de neurones [12].

1.4 Génération du code et implémentation du programme sur

l’environnement de programmation STM32CubeIDE

1.4.1 Programmation de la carte et visualisation des données

STM32CubeIDE est une plate-forme de développement C / C ++ avancée avec configuration

périphérique, génération de code, compilation de code et fonctionnalités de débogage pour les
microcontrôleurs et microprocesseurs STM32. Cette plateforme est basée sur le Framework
ECLIPSE ™ / CDT et la chaîne d'outils GCC pour le développement, et GDB pour le
débogage [13]. Cette partie est basée sur la programmation des différents capteurs. Après avoir
consulté les Data Sheets de chaque composant, extrait les différentes étapes nécessaires au
développement des drivers de chaque capteur, nous avons pu faire fonctionner ces
périphériques.

L’organigramme donné par la figure 8 ci-dessous décrit l’algorithme.

10
 Figure 8 : Organigramme de l’algorithme utilisé

Dans cet algorithme, nous allons tester les capteurs et faire une acquisition des données.
Afin de visualiser ces dernières, nous allons utiliser le terminal « Tera Term ».

Figure 9: Visualisation des données sur Tera Term

11
Comme nous pouvons le constater sur la figure 9 ci-dessus, nous avons récupéré les données
des capteurs en temps réel. Nous avons les valeurs des capteurs environnementaux qui sont la
température en degré Celsius (°C), l’humidité relative en pourcentage (%) et la pression en
millibar (mbar). Quant aux capteurs de mouvement, nous avons l’accélération en mètre
Seconde moins deux (m.s-2), position en degré par seconde (deg/s) et le champ magnétique en
Nano Tesla.

1.4.2 Les protocoles I2C et UART

1.4.2.1 L’interface I2C :

Le bus I2C (Inter-IC-Communication) permet les connexions de circuit intégré à proximité (à

une distance de 1m). En fait, C’est un bus de communication séries synchrones, bidirectionnel.
La fréquence de transfert est comprise entre 100KHz et 400KHz. Le bus est piloté par un maitre
(MASTER) qui génère l’horloge de communication. Les capteurs sont esclaves (SLAVES), ils
reçoivent tous la même horloge issue du maitre qui est le microcontrôleur. Le bus est constitué
de deux fils :

1.4.2.1.1 SCL : Serial Clock qui est l’horloge de cadencement des communications
(unidirectionnel).
1.4.2.1.2 SDA : Serial Data permet les échanges bidirectionnels entre le maitre et un
esclave.

Ainsi, avec ce bus un transfert commence avec la condition de START qui est définit par le
basculement du haut vers le bas du SDIO lorsque SCLK est élevé. Les Transitions des bits de
données doivent se produire lorsque la broche SCLK est faible.

L’octet juste après le bit de Start est le mot de contrôle qui est de huit bits de longueur, constitués
d'une adresse de sept bits et un bit de lecture / écriture (lecture = 1 et écrire = 0). Le dispositif
reste dans l'état de la lecture ou d'écriture jusqu'à ce que la condition d'arrêt soit reçue.

1.4.2.2 L’interface série UART :

UART : Universal Asynchronous Reception and Transmission.

C’est un protocole de communication série simple qui permet à l'hôte de communiquer avec un
périphérique auxiliaire comme dans notre cas le microcontrôleur STM32L475 [14].

12
Avant l’utilisation de l’UART les configurations suivantes sont requises :
- Baud_Rate : le baudrate est la vitesse à laquelle les composants se sont entendus pour
communiquer.
- Word_Length : Il s’agit de la longueur des mots qui vont être transmis, c’est à dire le
nombre de bits lus ou reçus d’un coup. Nous avons le choix entre Length_8 et Length_9
selon que l’on a choisi de transmettre 8 ou 9 bits.
- Stop_Bit : il s’agit de la longueur du bit signalant la fin de la transmission.
- Parity : indique s’il y a un bit de parité et si oui, il signale un nombre pair ou impair. Le
bit de parité indique si le nombre de 1 est pair ou impair ce qui permet rapidement de
détecter certaines erreurs

13
 Chapitre II : Plateforme Cloud

2.1 Introduction

Dans cette partie, nous allons traiter la partie de l’acquisition des données par notre dispositif
IOT Node sur une plateforme Cloud. Nous présenterons dans un premier temps la librairie Wifi
utilisée puis nous définirons les protocoles mis en jeu et enfin nous décrirons l’interface
utilisée. Il est important à ce stade de comprendre que la connectivité Internet ou
éventuellement en réseau local sans fil est indispensable pour pouvoir parler de Cloud. La
connectivité à un réseau WLAN(Wireless Local Area Network) est assurée par un module
WIFI, soit intégré au microcontrôleur (cas du microcontrôleur ESP8266) ou par un module
additionnel à la carte microcontrôleur (cas de STM32L475 IOT Node)

2.2 Intégration du driver ES-WIFI

L’intégration du driver ES-WIFI au programme est la première étape à faire afin d’activer le
module Wifi sur la carte STM32L4. Le module Wifi utilise le protocole SPI (Serial Peripheral
interface) pour communiquer. C’est un protocole similaire à l’I2C. Sa communication série a
une forme différente qui est spécialement conçue pour les microcontrôleurs afin de se
connecter.

2.2.1 Protocole UDP

Le protocole UDP (User Datagram Protocol) est un protocole qui permet d'envoyer des
datagrammes dans des réseaux IP sans connexion. Pour obtenir les services souhaités sur les
hôtes cibles, il utilise des ports répertoriés. Comme tous les autres protocoles réseau, l’UDP
appartient à la bande Internet Protocol, où il est connu comme médiateur au niveau du transport
entre la couche réseau et la couche application. Après l’intégration du driver ES-WIFI, nous
allons utiliser le protocole UDP afin de vérifier la connexion de la carte STM32L4 au réseau
Wifi. Le protocole en question utilise le port 8002. En outre, nous utilisons le Serveur Open
source « Packet Server Portable : https://packetsender.com/ » grâce auquel nous allons
visualiser la communication entre la carte IOT Node et l’Interface utilisateur (PC). De plus,
nous devons nous assurer dans le programme coté Microcontrôleur de bien spécifier l’adresse
du réseau SSID, le mot de passe du réseau et l’adresse du PC sur lequel est installé Packet
14
Server Portable. Nous donnons ci-dessous quelques éléments du programme coté carte
microcontrôleur.
#define SSID " //ssid_du_reseau"
#define PASSWORD " //pass_reseau"
uint8_t RemoteIP[] = {192,168,1,2}; // Adresse du PC qui contient Packet Server Portable
#define RemotePORT 8002 // Port UDP standard
./..
if(WIFI_Init() == WIFI_STATUS_OK) {
snprintf(str1,100,"> WIFI Module Initialized.\n");
HAL_UART_Transmit(&huart2,( uint8_t * )str1,sizeof(str1),1000);
if(WIFI_GetMAC_Address(MAC_Addr) == WIFI_STATUS_OK) {
snprintf(str2,100,"> es-wifi module MAC Address :
%X:%X:%X:%X:%X:%X\n",MAC_Addr[0],MAC_Addr[1],MAC_Addr[2],MAC_Addr[3],
MAC_Addr[4],MAC_Addr[5]);
HAL_UART_Transmit(&huart2,( uint8_t * )str2,sizeof(str2),1000);
} else {
snprintf(str3,100,"> ERROR : CANNOT get MAC address\n");
HAL_UART_Transmit(&huart2,( uint8_t * )str3,sizeof(str3),1000);
}
if( WIFI_Connect(SSID,PASSWORD, WIFI_ECN_WPA2_PSK) == IFI_STATUS_OK) {
snprintf(str4,100,"> es-wifi module connected \n");
HAL_UART_Transmit(&huart2,( uint8_t * )str4,sizeof(str4),1000);
if(WIFI_GetIP_Address(IP_Addr) == WIFI_STATUS_OK) {
snprintf(str5,100,"> es-wifi module got IP Address : %d.%d.%d.%d\n",
IP_Addr[0],IP_Addr[1],IP_Addr[2],IP_Addr[3]);
HAL_UART_Transmit(&huart2,( uint8_t * )str5,sizeof(str5),1000);
snprintf(str6,100,"> Trying to connect to Server: %d.%d.%d.%d:8002 ...\n",RemoteIP[0],
RemoteIP[1],RemoteIP[2],RemoteIP[3]);
HAL_UART_Transmit(&huart2,( uint8_t * )str6,sizeof(str6),1000);
while (Trials--){
if( WIFI_OpenClientConnection(0, WIFI_TCP_PROTOCOL, "TCP_CLIENT", RemoteIP,
8002, 0) == WIFI_STATUS_OK){
snprintf(str7,100,"> TCP Connection opened successfully.\n");
HAL_UART_Transmit(&huart2,( uint8_t * )str7,sizeof(str7),1000);

15
 Socket = 0;
}
}
if(!Trials) {
snprintf(str8,100,"> ERROR : Cannot open Connection\n");
HAL_UART_Transmit(&huart2,( uint8_t * )str8,sizeof(str8),1000);
}
} else {
snprintf(str9,100,"> ERROR : es-wifi module CANNOT get IP address\n");
HAL_UART_Transmit(&huart2,( uint8_t * )str9,sizeof(str9),1000);
}
} else {
snprintf(str10,100,"> ERROR : es-wifi module NOT connected\n");
HAL_UART_Transmit(&huart2,( uint8_t * )str10,sizeof(str10),1000);
}
} else {
snprintf(str11,100,"> ERROR : WIFI Module cannot be initialized.\n");
HAL_UART_Transmit(&huart2,( uint8_t * )str11,sizeof(str11),1000);
}

Dans cette configuration l’affichage est renvoyé vers la liaison série USART1. Donc il suffit
d’avoir un adaptateur USB série connecté aux sorties de l’USART 2 (PA2 : TX et PA3 : RX)
et du coté PC avoir un programme Terminal (Tera Term ou Hyperterminal ou Putty …)

La figure 10 ci-dessous nous résume la démarche.

Figure 10 : Représentation de la connexion de la carte au server via Wifi

16
En outre, le terminal « Tera Term » permettra à l’utilisateur de savoir s’il y a bien eu une
connexion ou s’il y a un problème. Comme nous pouvons le constater sur la figure 11, la
connexion a bien été établie et nous avons récupéré l’adresse IP de carte : 192.168.1.109.

Figure 11 : Etablissement de la connexion

Grâce à cette adresse IP, nous pouvons maintenant communiquer avec la carte via le Server
« Packet Server Portable » comme nous le montre la figure 12.

Figure 12 : Communication de la carte via le server

17
 Le protocole UDP bien qu’il soit simple mais il n’est pas bien adapté pour les objets
connectés. UDP est un protocole orienté "non connexion". Pour faire simple, lorsqu'une
machine A envoie des paquets à destination d'une machine B, ce flux est unidirectionnel. En
effet, la transmission des données se fait sans prévenir le destinataire (la machine B), et le
destinataire reçoit les données sans effectuer d'accusé de réception vers l'émetteur (la machine
A).

2.2.2 Protocole MQTT

MQTT (Message Queuing Telemetry Transport) est un protocole de transfert de données

Machine-to-Machine (M2M) permettant aux systèmes SCADA d’accéder aux données IIoT.
Il est considéré comme l’un des principaux protocoles de messagerie de l’internet des objets
industriel (IIoT).

MQTT : quels sont les avantages de ce protocole ?

Figure 13 : Objets connectés

En effet, même s’il existe de multiples technologies et protocoles IIoT, le MQTT dispose de
plusieurs atouts pour tirer son épingle du jeu. Son header très léger ne pèse que 2 bytes, il
dispose de capacités bidirectionnelles, et repose sur un modèle publish/subscribe permettant de
collecter plus de données que les protocoles de type polling tout en consommant moins de
bande passante. Ce sont toutes ces qualités qui lui permettent de répondre aux exigences de
systèmes de contrôle industriels.

18
 Parmi les autres avantages apportés par le MQTT, on compte l’efficience de la distribution
d’information, la scalabilité, ou encore la réduction de consommation de la bande passante du
réseau. Ainsi, cela permet de maximiser la bande passante.
Ce protocole permet aussi de réduire les taux de mise à jour à quelques secondes seulement, et
de réduire les temps de développement. Il s’adapte parfaitement au sensing et au contrôle à
distance. Son système de sécurité basé sur les permissions est très fiable. L’industrie du gaz et
du pétrole, ainsi que les géants comme Amazon et Facebook utilisent ce protocole.

Le MQTT est un protocole publish/subscribe permettant aux appareils «edge-of-network » de

publier vers un broker. Les clients se connectent à ce broker qui joue ensuite le rôle de
médiateur entre les deux appareils. Chaque appareil peut souscrire à des topics particuliers.
Lorsqu’un autre client publie un message sur un topic, le broker transfère le message à tous
les autres clients qui y ont souscrit.

Figure 14 : Principe de fonctionnement du protocole MQTT

De plus, une autre qualité du protocole MQTT est qu’il peut facilement être mis en œuvre du
côté client. Cette facilité est parfaitement adaptée aux dispositifs contraints ayant des
ressources limitées [21]. En outre, le MQTT utilise le port 1883 et nécessite l’utilisation d’un
Broker. C’est un serveur chargé d’envoyer des informations vers les appareils connectés
(Client). Lorsqu’un appareil (Client) veut envoyer des données vers le Broker, il publie
(Publish) sur un certain thème (Topic) et quand cet appareil veut recevoir des données du
Broker, il s’abonne à un thème précis.
MQTT inclus nativement la notion de QoS « acronyme de Quality of Service – Qualité de
service » permettant de véhiculer des données conformément à certaine exigence en matière de
temps de réponse et de bande passante. MQTT s’appuie sur 3 niveaux de QoS allant du plus
faible au plus élevé. QoS permet de « sélectionner » la qualité des données transmises.

 QoS niveau 0 « At Most Once » l’information n’est transmise qu’une seule fois entre le
« Publisher » et le « Broker » puis « l’utilisateur ». QoS niveau 0 signifie que les informations
seront transmises sans vérification de la bonne réception. Au niveau 0, le Broker n’informera
pas l’utilisateur de la bonne transmission ou non des informations.

19
 QoS niveau 1 « At Least Once » les informations seront transmises au moins une fois.
L’utilisateur n’est pas à l’abri de recevoir plusieurs fois le même message si absence d’accusé
de réception.
 QoS niveau 2 « Exactly Once » niveau le plus sûr, mais aussi le plus lent. Quel que soit le
nombre de tentatives d’envois, les informations seront reçues par l’utilisateur qu’une seule et
unique fois. La QoS de niveau 2 est la plus fiable, mais également la plus énergivore en bande
passante. Elle permet de bénéficier d’une qualité de service à son paroxysme.
La qualité de service se base sur plusieurs facteurs tels le débit, la fluctuation du signal
numérique, la latence (ping), la perte de paquet et le déséquencement (ordre d’arrivée des
paquets). QoS permet d’assurer une bonne réception des informations et l’intégrité de celles-
ci. De très nombreuses bibliothèques sont disponibles pour programmer des clients MQTT,
pour la plupart des langages (C, C++, Java, JavaScript, PHP, Python…) et sur la plupart des
plates-formes (GNU/Linux, Windows, iOS, Android, Arduino…).

Il existe plusieurs types de brokers : ActiveMQ, JoramMQ, Mosquitto ou encore, RabbitMQ.

Mosquitto est le plus souvent utilisé pour les projets ESP8266 (Arduino et Raspberry). Il est
disponible sur toutes les plateformes (MacOS, Windows XP-10, Linux).

Mosquitto est un serveur (Broker) MQTT Open Source (Broker) que l’on peut installer sur un
Raspberry Pi mais aussi sur presque toutes les systèmes d’exploitation (macOS, Windows,
Linux…). Mosquitto est disponible sur toutes les plateformes et s’installe en quelques
minutes.

La version suivante est la plus récente pour un environnement windows (quelque soit la
version de windows)

http://www.eclipse.org/downloads/download.php?file=/mosquitto/binary/win32/mosquitto-1.4.8-install-
win32.exe

2.3. Installation du Broker MQTT Moquitto sous Windows

Pour windows 7 en plus de l’installation de mosquitto il faut télécharger les fichiers suivants :

pThreads: ftp://sources.redhat.com/pub/pthreads-win32/dll-latest/dll/x86/

Il faut également installer OpenSSL :

OpenSSL: https://slproweb.com/products/Win32OpenSSL.html

Le broker Mosquitto est installé dans le répertoire « C:\Program Files (x86)\mosquitto »

20
Pour une installation sous windows seven ou windows 8 vous avez des dependances de mosquitto :

Dependences (windows 7 et windows 8)

DLLs: libeay32.dll ssleay32.dll (ces fichiers se trouvent dans le repertoire OpenSSL-Win32 or

OpenSSL-Win32\Bin)

Required DLLs: pthreadVC2.dll (pThreads: ftp://sources.redhat.com/pub/pthreads-win32/dll-

latest/dll/x86/)

Il faut vérifier par la suite que le service Moquitto est en exécution :

Vous tapez à l’onglet de start de windows : services.msc

Si le service n’est pas en run vous pouvez le lancer manuellement :

1 Appuyez simultanément sur les touches Win + R

2. Une fenêtre intitulée Exécuter s'affiche : tapez cmd puis Entrée

21
Ci-dessous nous donnons la démarche à suivre pour tester le Broker. :

1 Appuyez simultanément sur les touches Win + R

2. Une fenêtre intitulée Exécuter s'affiche : tapez cmd puis Entrée

Lancer la commande suivante :

Ici nous nous inscrivons au topic "/Khaled_test"

Puis Lancer la commande suivante dans une autre fenêtre:

Ici nous publions le massage «Ceci est un test» vesr le topic «khaled_test»

Vous devez avoir sur votre première console :

2.4 La Plateforme de développement Arduino IDE

La plateforme Arduino Ide présente une bonne alternative intéressante pour la mise au point
d’un protocole de communication client-serveur basé sur MQTT. Cet environnement permet
un prototypage rapide et une première validation du travail. Arduino IDE est un
environnement Open- source qui utilise le langage C/C++. L’activation du module Wifi ne
pose pas de problèmes particuliers et l’intégration de la bibliothèque MQTT non plus.
Vous devez préalablement charger votre bibliothèque Arduino :
22
 https://github.com/256dpi/arduino-mqtt

Après le chargement vous devez l’inclure dans votre environnement :

Pour le test avec une carte microcontrôleur équipé de WIFI vous pouvez suivre la démarche
suivante :

1) Sélection de la carte

Pour la carte ESP8266 il faut entrer l’URL suivante dans l’environnement Arduino :

http://arduino.esp8266.com/stable/package_esp8266com_index.json

23
 Pour la carte STM32L475 IOT Node il faut entrer l’URL suivante :

https://github.com/stm32duino/BoardManagerFiles/raw/master/STM32/package_stm_index.js
on

Puis dans l’environnement Arduino il faut sélectionner la bonne carte :

2) Initialisation du WIFI et des périphériques

#include <stm32l475e_iot01.h>
#include <stm32l475e_iot01_accelero.h>
#include <stm32l475e_iot01_gyro.h>
#include <stm32l475e_iot01_hsensor.h>
#include <stm32l475e_iot01_magneto.h>
#include <stm32l475e_iot01_psensor.h>
#include <stm32l475e_iot01_qspi.h>
#include <stm32l475e_iot01_tsensor.h>
#include <SPI.h>
#include <WiFiST.h>
#include <WiFiUdpST.h>
#include <MQTTClient.h>
SPIClass SPI_3(PC12, PC11, PC10);
WiFiClass WiFi (&SPI_3, PE0, PE1, PE8, PB13);

Il faut préalablement installer les librairies de la carte STM32L475

24
Il faut également installer le driver WIFI de la carte :

Ci-dessous l’initialisation des périphériques et le test du module WIFI :

BSP_TSENSOR_Init();
BSP_HSENSOR_Init();
BSP_PSENSOR_Init();
BSP_MAGNETO_Init();
BSP_GYRO_Init();
BSP_ACCELERO_Init();
Serial.begin(115200);
Serial.println("OK");
if (WiFi.status() == WL_NO_SHIELD) {
Serial.println("WiFi module not present");
// don't continue:
while (true);
}

Ci-dessous la connexion à un réseau WIFI (ici mon SSID est « ssid » et mon mot de passe est
« pass ». Il faut les initialiser en début de programme :

25
char ssid[] = "ssid";
char pass[] = "pass";
status = WiFi.begin(ssid, pass);

while (status != WL_CONNECTED) {

Serial.print("Attempting to connect to SSID: ");
Serial.println(ssid);
// Connect to WPA/WPA2 network. Change this line if using open or WEP network:
// wait 10 seconds for connection:
delay(10000);
}

3) Connection à un Broker MQTT

client.begin("10.30.100.253", net); // client MQTT

client.onMessage(messageReceived);
Serial.print("\nconnecting..."); // Mot de passe: always; user: khaled
while (!client.connect("STM32-B-L475-IOT01A2", "Login", "password")) {
Serial.print(".");
delay(1000);
}
Serial.println("\n connected!");
client.subscribe("/Reponse_Serveur"); // Ceci est un essai de souscription au topic
/Reponse_Serveur

Dans cet exemple l’adresse de mon Broker est 10.30.100.253 (Mon PC connecté au CIIP)
Login et password sont les login et mot de passe de Mon PC.

4) Publication d’un topic

sensor_value_T = BSP_TSENSOR_ReadTemp();
Serial.print("\n TEMPERATURE = ");
Serial.print(sensor_value_T);
string_MQTT = String(sensor_value_T, 1);
client.publish("/temperature", string_MQTT);

Dans cet exemple je publie la température sous le topic /temperature. string_MQTT est une
chaine de caractère de type string (String string_MQTT).
Les figures 14 et 15 suivantes nous montrent respectivement les données reçues des capteurs
et la connexion au Wifi.

26
 Figure 15 : Visualisation des données sur la plateforme Arduino

Figure 16 : Etablissement de la connexion (Wifi et Server de MQTT)

27
 2.5 Node-Red: l'IoT à portée de tous

Les objets connectés envahissent progressivement notre paysage, à titre personnel mais aussi
professionnel. Le coût unitaire de capteurs connectés permet à tout un chacun de prototyper et de
construire des systèmes pouvant être assez rapidement complexes. Les informations collectées
peuvent assez rapidement devenir importantes. Mais souvent leur traitement, et donc leur
valorisation, reste un problème épineux. De même, la création de valeur par l’interprétation de
signaux et le déclenchement d’actions dérivées peut se révéler être une tâche assez complexe à
mettre en oeuvre. Offrir une plateforme permettant de tirer profit d’un parc d’objets connectés,
passifs ou actifs, est un challenge que certaines entreprises technologiques ont relevé. Des acteurs
majeurs, comme AT&T ou IBM, proposent de faciliter la construction de plateformes globales
offrant un ensemble de solutions pour gérer cette problématique. Cela couvre la collecte des
données émises, leur transport, la capacité à créer des flux de données et de traiter l’information
reçue, mais aussi de déclencher des actions sur des capteurs actifs… Le fil conducteur de ces
plateformes est de permettre la création rapide de nouvelles applications ou services. IBM a
travaillé autour d’une solution logicielle open sourcée permettant la création de chaînes de
traitement. Cette solution se nomme Node-Red (https://nodered.org/). La vocation de cette solution
est de permettre de lier aisément des sources de données à des composants de traitement, locaux ou
distants, et de créer des chaînes de valeurs en quelques clics. La promesse de cette solution semble
convaincre, puisqu’AT&T utilise aussi ce projet dans son offre M2X en en faisant le socle de son
produit AT&T Flow Designer. IBM l’utilise aussi de façon étendue en l’intégrant à son offre sur
Bluemix et en permettant l’exécution des chaînes de traitement au sein de son environnement cloud.
Alors qu’est-ce que Node-Red plus précisément ? Techniquement, il s’agit d’une application
reposant sur Node.js et permettant le design des chaînes de traitement dans un environnement Web.
Node-Red fonctionne comme un ETL : une palette de connecteurs, des composants de traitement,
des possibilités de wiring entre tout cela. Regardons maintenant un peu plus dans le détail.
Les composants de la palette

La palette des composants vient par défaut avec un ensemble de connecteurs assez complet. On
retrouve assez classiquement des composants permettant de lire (input) et écrire (output) des
données, ainsi que plusieurs autres catégories : des fonctions (split, join, range, delay, …), de
l’analyse (un simple composant d’analyse de sentiment par défaut), du stockage (file), etc. On
trouve facilement en input et output de quoi construire les premières bases d’une chaîne de
traitement. Les types récurrents dans l’IoT sont présents (MQTT, HTTP), néanmoins la liste
28
comporte quelques manques. De même, la section analyse fait office de parent pauvre avec un seul
composant à disposition, qui d’ailleurs est plutôt limité dans son usage.
Heureusement, cette palette n’est qu’une base de départ. Il est possible de l’enrichir de plusieurs
façons :

 en installant de nouveaux composants depuis la liste officielle des composants Node-Red,

 en développant ses propres composants.

Dans le premier cas, le catalogue à disposition permet de rapidement couvrir un spectre très large et
souvent suffisant pour 95% des besoins. Le support des protocoles manquants par défaut est plutôt
large. On trouvera donc des composants XMPP, CoAP, etc. Mais on trouvera aussi des connecteurs
vers des solutions de persistance complémentaires (InfluxDB, Cassandra, etc.), mais aussi Kafka,
etc. Il s’agit ici d’un pool de presque 1000 composants de qualité et/ou maturité variable aussi.
Dans le second cas, il est possible de rapidement wrapper une librairie ou un service avec un
composant custom. La documentation explique assez clairement la démarche à suivre.
L’éditeur

La création de flows est très simple : du drag & drop de composants, de la configuration via un
panneau contextuel et du cablage entre composants. L’organisation par onglet permet de gérer un
grand nombre de flows en les organisant de façon logique en sous-ensembles. Des facilités
permettent aussi des appels entre flows, même s’ils ne sont pas présents sur le même onglet.
Le déploiement d’un flow

Une fois installé, Node-Red expose la UI de design, mais permet aussi l’exécution des flows
définis. L’édition d’un flow se conclut généralement par une action de déploiement. Le déploiement
peut fonctionner selon 3 modes :

 un déploiement global, de type annule et remplace,

 un déploiement pour l’ensemble des composants du flow concerné,
 un déploiement uniquement des composants modifiés.

Un simple clic sur le bouton de déploiement et les flows se trouvent mis à jour et opérationnels.
Simple et efficace.

Installation de Node‐red
Pour installer Node-RED sur Windows, vous aurez besoin dans un premier temps

d'installer NodeJS afin d'activer le gestionnaire de paquet npm en cliquant sur le lien suivant

29

Une fois que NodeJS a été installé, ouvrez votre éditeur de ligne de commande et tapez la commande
suivante :
npm install -g --unsafe-perm node-red

afin d'installer Node-RED sur votre PC. Une fois que vous aurez installé node-RED,démarrez le serveur
Node-red en tapant la commande suivante : node-red

Le lancement de Node-red provoque les exécutions suivantes :

30
Il ne vous reste qu'à copier-coller l'adresse : http://127.0.0.1:1880/ sur votre navigateur internet pour
démarrer Node-RED

Figure 17 : Ecran d’accueil de Node-red

31
Concrètement, que peut‐on vraiment faire ?
Tout cela reste assez abstrait. Voici donc quelques explications pour mettre le pied à l’étrier.Node-
Red est un éditeur de flux basé sur un navigateur qui facilite la liaison de flux à l'aide d'un large
éventail de nœuds dans la palette. Les flux peuvent ensuite être appliqués à l'exécution avec un seul
bouton. De plus, nous pouvons créer des fonctions JavaScript grâce à un éditeur de texte enrichi
Dans l’exemple ci-dessous, nous utilisons cette plateforme afin de recevoir les données grâce au
protocole MQTT et les afficher sur une Dashboard. Le flow de la figure 18 suivante présente les
données acquises du capteur de la température HTS221 via MQTT.

Figure 18: Représentation du flow de la température

Dans l’exemple ci-dessous un peu plus complet nous présentons le flow permettant de suivre en
temps réel l’évolution de la température, de la pression et de l’humidité. Ce flow suppose que le
Broker utilise est un broker cloud et que les valeurs sont publiés par le dispositif IOT comprenant
les capteurs d’humidité, de température et de pression sur ce broker (figure 19)

32
 Figure 19 : Exemple de flow pour une carte IOT Node avec configuration du Broker

Dans le cas où le Broker est installé en local (Cas de Mosquitto) le serveur devient localhost :1883

33
Nous pouvons aussi visualiser nos données sur la fenêtre « debug » de la plateforme Node-red
comme le représente la figure suivante.

Figure 20 : Visualisation des données sur Node-Red

34
Finalement, dans le cas de l’exemple de la figure 19, nous présentons le Dashboard crée sous
Node-red pour la visualisation de certaines grandeurs publiées par la carte IOT Node.

La première interface, figure 19, est l’interface « Home ». Nous pouvons voir le dispositif IOT
utilisé ainsi qu’une photo du concepteur.

Figure 21: Interface « Weather »

35
La deuxième interface, figure 22, est celle de la visualisation de nos données en
temps réel. Nous avons choisi de seulement mettre les capteurs de température,
pression, humidité et accélération.

Figure 22: Interface "My Dashboard »

36
 Chapitre III : Base de données Cloud

3.1 Introduction
Ici nous allons aborder le problème d’archivage de données. Le besoin d’une base de données pour
stocker, organiser et analyser les mesures en temps réel est aujourd’hui indispensable et fait partie
intégrante des cahiers des charges IOT et des systèmes de supervision industrielles.

3.2 Base de Données

3.2.1 Description

BD (base de données) est une entité structurée dans laquelle on stocke un ensemble organisé
d’informations avec un objectif commun [7]. Une base de données est utile pour mettre des
nombreuses données à la disposition des utilisateurs pour une consultation, une saisie ou bien une
mise à jour. La caractéristique la plus importante d’une base de données est le stockage des
informations sur des machines distantes et accessibles par réseau. En plus de cet avantage, une
base de données permet aux plusieurs clients ou utilisateurs d’y accéder simultanément.

Figure 23 – Accès simultané à la base de données

37
3.2.2 Terminologie
La Terminologie décrit le modèle de données et l’organisation des données à l’intérieur de la base
de données. Afin de permettre la récupération des données, un objet nommé "mesure" est créé
contenant la valeur de la Température ainsi que celle de l’Humidité avec la Date et l’Heure de la
prise.

Figure 24 – Modélisation de la structure de la base de données

3.2.3 Solution
Afin de permettre le contrôle des mesures, on a besoin d’un gestionnaire de base de données
appelé SGBD (système de gestion de bases de données).

♦ Le SGBD est un ensemble de services (applications logicielles) permettant de gérer les bases de
données, c’est-à-dire :

— Permettre l’accès aux données de façon simple.

— Autoriser un accès aux informations à de multiples utilisateurs.
— Manipuler les données présentes dans la base de données (insertion, suppression,
modification).

38
♦ Le SGBD peut se décomposer en trois sous-systèmes :

— Le système de gestion de fichiers : il permet le stockage des informations sur un support

physique.
— Le SGBD interne : il gère l’ordonnancement des informations.
— Le SGBD externe : il représente l’interface avec l’utilisateur.

Figure 25 – Sous-système d’un SGBD

♦ Les SGBD connus et utilisés sont :

— PostgreSQL
— MySQL
— Oracle
— IBM DB2
— Microsoft SQL
— MongoDB

Dans cette partie nous allons nous allons vous donner un exemple de création de base de
données à temps réel (Realtime database) afin d’archiver en temps réel les mesures des capteurs.
La plateforme Google Firebase nous permet de développer une base de données NoSQL
utilisée surtout les applications Web en temps réel. La base de données NoSQL dispose d’un
hébergement « in the Cloud » permettant le stockage et la synchronisation des données des
utilisateurs. Dans ce qui suit, une analyse de l’utilité de cette plateforme et la méthodologie de
stockage et de synchronisation des données sera présentée.

39
3.3 La base de données Cloud FireBase proposée par Google
3.3.1 Présentation de Firebase
Firebase est une plateforme mobile de Google offrant un certain nombre de fonctionnalités
adaptées pour les objets connectés et l’IOT. Plus précisément, ces fonctionnalités s’articulent
autour des services Cloud, permettant aux utilisateurs de sauvegarder et de récupérer des données
accessibles depuis n’importe quel appareil ou navigateur. Ceci est utile pour de nombreuses
applications telle que la messagerie Cloud, les rapports d’incidents, les notifications et les
analyses...

Figure 26 – Firebase et ses services

La base de données en temps réel Firebase est une base de données hébergée dans le Cloud dans
laquelle les données sont stockées sous forme d’objet JSON (JavaScript Object Notation). Le format
JSON est un format standard d’échanges de données. C’est un format « TEXT » qui est indépendant du
langage de programmation. Les données stockées (format JSON) sont synchronisées en temps réel
avec chaque client connecté. La synchronisation en temps réel permet aux utilisateurs d’accéder
facilement à leurs données depuis n’importe quel appareil connecté au réseau. La base de données
en temps réel aide les utilisateurs à collaborer les uns avec les autres. Elle est livrée avec le Kit de
développement SDK (Software Development Kit) mobile et web, qui permettent de créer des
applications sans avoir besoin de serveurs. Lorsque les utilisateurs sont hors ligne, les SDK de la
base de données en temps réel utilisent un cache local sur l’appareil pour servir et stocker les
modifications. Les données locales sont automatiquement synchronisées lorsque l’appareil est en

40
ligne.

Figure 27 – Synchronisation des données en temps réel avec firebase

3.3.2 Création d’une base de données dans firebase

• Étape 1 : La création de compte sur https ://firebase.google.com/connecter/ à l’aide des
informations d’identification du compte gmail.

Figure 28 – Création d’un compte firebase

41
• Étape 2 : La création d’un nouveau projet.

Figure 29 – Création d’un projet

• Étape 3 : Activation des autorisations de lecture et d’écriture à partir de l’onglet «Règles»

en spécifiant "true" pour les deux options.

Figure 30 – Autorisations de lecture et d’écriture

42
3.3.3 Ecriture en temps réel dans la base de données par un objet connecté
Il est possible d’écrire directement dans la base de données provenant d’un objet connecté. Ceci
nécessite d’avoir la librairie nécessaire de Firebase pour le microcontrôleur ou le KIT de
développement utilisé. Dans le cas d’un environnement UNIX (PC ou carte microcontrôleur)
ou Windows (dans le cas d’un PC). La librairie nécessaire (SDK clients est disponible :
https://firebase.google.com/docs/libraries ). Pour certains microcontrôleurs cette librairie est
également disponible (cas de ESP8266 et ESP32). Dans ce qui suit nous vous proposons les
deux solutions possibles pour un accès direct à la base de données ou un accès indirect dans le
cas où la librairie n’est pas disponible. La figure ci-dessous résume un peu l’accès à la base de
données Firebase par un équipement connecté.

Figure 31 : SDK de Firebase

43
3.3.3.1 Accès direct à la base de données par microcontrôleur : Cas du
microcontrôleur ESP8266

L’ESP8266 est un circuit intégré à microcontrôleur avec connexion Wi-Fi développé par le
fabricant chinois Espressif. En août 2014, les passionnés d’électronique commencent à
s’intéresser à la version ESP-01 de ce circuit intégré produite par une entreprise tierce, AI-
Thinker. Celui-ci, de taille réduite, permet de connecter un microcontrôleur à un réseau Wi-Fi et
d’établir des connexions TCP/IP. Sa documentation très riche ainsi que son bas prix a motivé
plusieurs passionnés d’électronique et d’objets connectés le développement d'une communauté de
développeurs et de passionnés de l'ESP8266. Fin octobre 2014, Espressif propose un kit de
développement logiciel (SDK) permettant de programmer le circuit sans recourir à l’utilisation
d’un microcontrôleur additionnel. Depuis, Espressif a sorti quantité de nouvelles versions du
SDK ainsi qu’un successeur de ESP8266 plus puissant avec double Core et cadensé à 240 MHz et
avec plus de SRAM et plus de DRAM. La librairie Firebase pour ce Kit à base du
microcontrôleur est disponible : https://github.com/mobizt/Firebase-ESP8266

Figure 32 : Kit d'apprentissage NodeMCU IOT

Nous donnons dans ce qui suit quelques éléments de programmes dans le cas d’un accès direct à
la base de données par un objet connecté (nos essais ont été faite par un kit NodeMCU ESP8266.
Les données doivent être envoyées sous format JSON vers la base de données :
En premier, il faut déclarer un objet de la classe StaticJsonBuffer. Il correspondra à un pool de
44
mémoire pré-alloué pour stocker l’arbre d’objets. Sa taille est spécifiée dans un paramètre de
modèle (la valeur entre <> ci-dessous), en octets .

StaticJsonBuffer<300> mesures ;
Ensuite, il faut faire l’instanciation à une référence « JsonObject » à partir de l’objet
StaticJsonBuffer créé en appelant la méthode "createObject".

JsonObject mesures = JSONbuffer.createOb ject() ;

-Pour créer des tableaux, nous utilisons la méthode "createNestedArray" sur la référence
JsonObject.

JsonArray temps = mesures.createNestedArray("temps") ; JsonArray

temperature = mesures.createNestedArray("Température") ; JsonArray
humidity = mesures.createNestedArray("Humidity") ;
Ici nous avons pris un exemple de deux mesures à archiver (température et
humidite)
Cette méthode renvoie une référence à un tableau Json « JsonArray », que nous utiliserons
pour ajouter les valeurs envoyées par les capteurs.
L’ajout d’une nouvelle valeur se fait par la méthode "add" appliquée au tableau
« JsonArray »
temps.add(time_date.getFormattedDate());
temperature.add((dht13.readTemperature( ))) ;
humidity.add((dht13.readHumidity( ))) ;
La première ligne permet d’avoir le temps format yy/mm/dd. Le temps est ajouté
automatiquement à chaque nouvelle mesure. Tous les mesures sont stockées avec leurs temps
d’arrivé à la base de données. Sans ceci les mesures deviendront insignifiants.
La connexion à la base de données Firebase depend de la plateforme utilisée. Chaque
plateforme a ses propres scripts pour la connexion à Firebase. Nous ne pouvons pas mettre ici
les scripts de toutes plateformes c’est pour cette raison nous nous limitons uniquement à deux
plateformes. La première plateforme qui présente qui présente un avantage par rapport aux
autres de point de vue simplicité et la plateforme Arduino IDE. Nous donnons ci-dessous
quelques éléments de programme correspondant à un stockage temps réel dans Firebase
#include "NTPClient.h" // Serveur Universel de temps (format UDP)
#define FIREBASE_HOST "xxxxxxx-cb8ac.firebaseio.com" //identifiant base de données
#define FIREBASE_AUTH "ZVwLlXbfKezcMVAf7TuYn5Nv0v8lkgsmxxxxxxxx"
#define WIFI_SSID "ssid"
45
 #define WIFI_PASSWORD "pass"
FirebaseData firebaseData;
./..
FirebaseJson json;

json.set("integer", 123); // Ceci est un exemple d’ecriture d’un entier simple

json.set("string", "parent" ); // chaine de caractere
json.set("DAY",dayStamp); // il faut lire préalablement dayStamp (Serveur NTP)
json.set("HOUR",timeStamp); //// il faut lire préalablement timeStamp (Serveur NTP)

if (Firebase.pushJSON(firebaseData, "/test", json)) {

Serial.println(firebaseData.dataPath());
Serial.println(firebaseData.pushName());
Serial.println(firebaseData.dataPath() + "/"+ firebaseData.pushName());
} else {
Serial.println(firebaseData.errorReason());
}

FIREBASE_HOST et FIREBASE_AUTH sont définis dans la console Firebase de Google

https://firebase.google.com/?hl=fr

Lorsque vous accédez à votre console Firebase vous devez avoir les information d’autorisation et de
login dedans :

46
 3.3.3.2 Accès Indirect à la base de données par Node-red : Cas de
STM32L475IOT

Dans le cas ou le Kit de développement (Cas de STM32L475 IOT Node) ne dispose pas des SDK
nécessaires pour un accès direct à la base de données Firebase, nous pouvons le faire
indirectement par Node-red. Pour cela il va falloir en premier lieu publier les données à stocker
vers un Broker MQTT. Par la suite ils faut récupérer ces grandeurs par Node-red et les stocker
dans la base de données Firebase. Vous devez préalablement installer les palettes nécessaires avec
Node-red (§2.5)

Figure 33. Installation de la palette Firebase

Après l’installation vous devez avoir deux palettes supplémentaires.

Figure 34. Les palettes Firebase (Real Time)

)

Ci-dessous nous donnons un exemple de publication de la température, de l’humidité et de la pression

vers la base de données Firebase

47
Figure 35. Exemple de flow Node-red pour l’acquisition de l’humidite et la pression et la température

Sur cette figures les Nœuds firebase ne sont pas encore configurés. Pour la configuration de ces nœuds
vous devez suivre les étapes suivantes :
1) Créer dabord une base de données Firebase (https://firebase.google.com/ )
2) Vous devez ajouter par la suite votre identification au nœud Firebase :

3) Dans votre projet Firebase il faut aller vers parametres :

48
 Puis par la suite, il faut créer une clé d’accès format Json :

Cette clé aura un format JSON et vous permet d’accéder à votre base de données. C’est une clé unique
Elle a la forme suivante :
{ 
  "type": "service_account", 
  "project_id": "votre identifiant de projet", 
  "private_key_id": "dfe8047bd84259e3071e5af9b30f78135b2019e9", 
  "private_key": "‐‐‐‐‐BEGIN PRIVATE KEY‐‐‐‐‐
\nMIIEvwIBADANBgkqhkiG9w0BAQEFAASCBKkwggSlAgEAAoIBAQCg01x6HznhCBDf\nMudIzK9P+hXaFu7h
pSLKRjkk0eryaiBJcAh20woBAMr+cAVX6VTXh1n9YKEGoZeW\nHaUc1k45cYcDPsD6BjYuxJcWKcEdLmnKHU
6PiDTq1WlUlsPFe+Ef8498ZVp65CQF\nzcP1lH8uI3LiYoysgYBKL6DTyO3PScI2ZOU+i2gLuT6YZaA8wuKl
GAp0DAk8Ftyx\nEk4LT80X8AHwYg4n/B7GXzOYRfYJffwGOAxU8ikuMxA7L0wv8+kpgu2O/9YK6MRp\nBneL
kPNgRe4vltbN++iENKSdPhJM62GXvDtuFDwb2M1l0RV8TjZyrf0/Ug743ivU\nzc4SsJoDAgMBAAECggEACN
RslzSKsCJfZsRmiAvbiOJmpmbW7mLrfOaLxvaS1doM\nyWtnaOVfqbwaPmD2ciQDPqLARpXdEWj4J8ubNUZG
MjIw+Ep5kYtGGJ2ThqnRNUxx\n43ZmH0xE94BdvEFbdfFouUvdMgu7LX8Zbot5uaHRtRNI1fQU3CMaC43/iv
vU+VSc\nOL+ZgPddQCykXDIOLVcBV0PbiEDufw2y0tvglKlAusuFj5XgzcAo2oEAhMjNKBkX\n65DD8FTnY0
RHqTlo5iD1MHPgJUJKrwTC49b4pthMOlZEYwaSsa/G24eFaWpatR52\n2rkczCCeaKfAPuH1hGmSGEA//Ca3
49
neP0/qWWjupooQKBgQDW2n1mjEaSFgnEl7wn\nfOv5+3RUlMNWjqNuNrLKPU+YgYfoQIa1pYiRl5YtkZcj6Q
nZ8uhtqvTZRQ3ROWHT\noqqU7R1o0VEYo3lnLgpmgA4DqhunylcAufFUV7HRe4DAOBBPqjKJddJeTIvU+W9A
\npfBWYTCYrDMq1bUAq/CbXNZIYQKBgQC/oBN+UvbtBUMzIK8vM8vzfk75/OVMmBGy\nGXfN2r9+KY6Z7yuh
rOrGcdoV3yA73ui+B+0UlXZ7813ulibSvYLFDuq8JK9HDVSw\nwA1I66ouSbaV2KQvkCv6tgMMXMvuwv0Of9
3ZZFwa+huvJ+Nl2EUCPlv474/v5Ii3\nPcmPBhXs4wKBgQDPBy36mISP0+iJpORK8Ja6BNCth8NKLpvQYaia
M8X04CvDYhns\nApu8HuM4+ac3lSBHAUdyFV9l1KJhzvcy5PWWF31VOQz5vtwGzlh7OD1IzqtjXRfE\nvWeL
rAzOHEGN9vfQq+GSjxOshfnfuJK5KqyRr4kSNCwBxHdrNELekfBxQQKBgQCd\nSKa3aSGEKm2d6ZXhCIK+uU
3ZotoSpD7iEEVlkcbbpwCFGOqXKXcKqyh2C05J1gzy\n7U6LNqKp2nee/V+gWiyb0kKZawLzLt30ta4xzD1D
AP38wHUDFTMD9aFK5F/++cz7\nubg+V0HCYseWXQco8PqzfLvA9+EM5mfQ/8YQvs4AQQKBgQCG0vC/91jDTM
SMBuue\nTKPfEj/QdwQPOQS9Ee7icddswf6NM6g+tCwJ6EJfoi1Caz0xzy3zSXyEEsTUyUFa\nCQxvA4NeCW
euiy76QRtcp8YOuriHqmnzIGqBxglJx6ftJTk0lwIewXWrOeHbQ+Lk\nvY5WBarMxOobayaLniPDeSZG5A==
\n‐‐‐‐‐END PRIVATE KEY‐‐‐‐‐\n", 
  "client_email": "votre compte de service", 
  "client_id": "109319011014876038760", 
  "auth_uri": "https://accounts.google.com/o/oauth2/auth", 
  "token_uri": "https://oauth2.googleapis.com/token", 
  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs", 
  "client_x509_cert_url": 
"https://www.googleapis.com/robot/v1/metadata/x509/khaledjelassi‐
cb8ac%40appspot.gserviceaccount.com" 
} 
Par la suite vous devez coller votre clé JSON comme le montre la figure ci‐dessous de 
configuration du nœud. 
 

Apres il faut ajouter une collection. Si cette collection n’existe pas, elle va etre automatiquement crée. Ici
nous avons ajouté la collection STM32L475_IOT_Node.

50
Enfin vous pouvez visualer vos donnees sur la base de données Firebase.

51
Travail à faire :

4) Il faut préparer les environnements de travail nécessaires (Arduino IDE 1.8.6 ou plus, Keil V5,
Mosquitto, Node-red, Creation compte Firebase ou MongoDb (locale)
5) Programmation de la carte IOT et visualisation sur un terminal (Tera Term ou Hyperterminal
ou putty) des valeurs envoyées par les capteurs (Nous pouvons prendre comme exemple les
capteurs de température, d’humidité et de pression. Cette Partie peut être faite sous un
environnement Keil V5 ou CubeMX ou Attolic True Studio ou IAR ou Arduino IDE ou avec la
plateforme Cloud MBED OS.
6) Dans cette partie vous devez publier les valeurs de température, pression et humidité
(" /temperature" , " /pression" , " /humidite" ) vers un serveur cloud. Je vous propose d’utiliser
broker.hivemq.com. Vu la complexité d’initialisation du WIFI ainsi que l’usage de MQTT
sous l’environnement Keil V5 ou CubeMX ou Attolic True Studio, je vous propose d’utiliser la
plateforme Arduino IDE. Bien évidemment il faut ajouter les librairies nécessaires décrites plus
haut dans le paragraphe 2.2.2.
Il faut s’assurer ici que la carte a une connectivité Internet. Il faut s’assurer que la configuration
du SSID et du mot de passe permettent une connectivité internet. Afin de vérifier les valeurs
publiées il faut télécharger sur Google Play store un client MQTT (Exemple; MyMQTT -
Apps on Google Play ou MQTT Client - Apps on Google Play … Pour un environment
Android (Smart Phone ou Tablette). Dans le cas d’un envronnement IOS (IPAD) ou Iphone, il
faut telecharger MQTT Tools. Dans le cas d’un environnment windows vous pouvez utiliser
Mosquitto.
7) Dans cette etape vous pouvez mettre au point une interface graphique sous Node-red qui
permet la lecture des topics MQTT (" /temperature" , " /pression" , " /humidite" ). Vous pouvez
visualiser vos donnees en mode debug sous node-red.
8) Réaliser un dashboard complet personnalisé permettant un suivi en temps réel de la
temperature, de l’humidite et de la pression (Figure 35)
9) Dans cette partie nous voulons ajouter une base de données pour l’archivage des valeurs. Je
vous propose soit d’utiliser Mongodb (NoSql) ou Firebase ou InfluxDB. Les valeurs envoyées
à la base de données doivent inclure la date (format timestamp ou format DateTime.

Instructions pour les soutenances des mini-projets

 chaque soutenance dure 15 minutes comportant une présentation de 7 minutes ainsi qu'une
démonstration de 5 minutes et 3 à 5 minutes de questions/réponses.
 respectez le temps donc répétez la
 la présentation mettra en avant
 le titre (avec les noms prénoms des binômes)
 les applications IoT cibles/envisagées
 le ou les architectures (successivement) implémentées,
 les composants logiciels et matériels utilisés,
 les métriques (langages de programmation, sloc (Lignes de code source), performance ...),
 les problèmes rencontrés et les solutions élaborées,
 la conclusion
 des perspectives possibles à votre développement.
Le code, le rapport et le PDF de la présentation doivent être livré dans un dépôt Github la veille de
la soutenance. Le rapport qui détaille les éléments de la présentation sera livré dans un
README.md ou README.html dans le dépôt GitHub.
Envoyez le lien vers le dépôt Github (code + présentation) avant la soutenance d’une semaine. Les
dates de soutenances seront annoncées par E-mail. Ils se feront entre la première et la deuxième
semaine de Janvier.
Pensez à répéter vos présentations.
52
Références bibliographiques

[1] www.ncbi.nlm.nih.gov/pmc/articles/PMC6697552/

[2] Wortmann F et Fluchter K. Internet of things (2015). Business and Information

Systems Engineering 57 (3) ,221-224.
[3] Whitmore A., Agarwal A. et Da Xu L. (2014) The Internet of Things—A survey
of topics and trends. Information Systems Frontiers.17 (2) ,261-274.

[4] Embedded Serial-to-Wi-Fi Modules eS-WiFi 802.11 b/g/n, Data Sheet. Inventek Systems

[5] www.st.com/en/wireless-transceivers-mcus-and-modules/spbtle-rf.html

[6] www.st.com/en/nfc/m24sr-series-dynamic-nfc-tags.html

[7] www.st.com/en/wireless-transceivers-mcus-and-modules/spsgrf.html

[8] www.st.com/en/development-tools/stm32cubemx.html

[9] www.st.com/en/embedded-software/x-cube-ai.html#overview
[10] www.st.com/en/development-tools/stm32cubeide.html
[11]www.seeedstudio.com/blog/2019/09/25/uart-vs-i2c-vs-spi-communication-
protocols-and- uses/

53
[15] www.ionos.com/digitalguide/server/know-how/udp-user-datagram-protocol/

[16] www.iot.goffinet.org/iot_protocole_mqtt.html

[17] www.nodered.org/

54