Faculté des sciences de Monastir Année Universitaire 2020-21

Niveau LFI3

Applications IOT via Arduino & ESP32

LM35
Temperature Sensor

RC522 RFID sensor

Proposé par Mr Samir Belaid

1. Initiation Arduino Uno

Arduino est une plate-forme de prototypage électronique open source basée
sur du matériel et des logiciels flexibles et faciles à utiliser. SS: Slave Select
Ports GPIO: General Purpose Input/Output Bus I²C: Inter-Integrated Circuit
Bus SPI: Serial Peripheral Interface ICSP: In Circuit Serial Programming
PWM: Modulation de largeur d'impulsion MISO: Master In/Slave Out

1
1. Initiation Arduino
• Il existe plusieurs versions de cartes Arduino:
– Cartes: UNO, Mega2560, Mini, Nano, LilyPad, Fio, Pro, …
– Microcontrôleurs de Atmel AVR: Mega328, Mega1280, Mega4809,…
• Modules disponibles (Shields) avec les cartes Arduino

Module Ethernet Module Dragino LoRa Shield Module Moteur

• En plus de ces 3 modules, il existe d'autres modules, notamment :
– Module GPS (Sparkfun)
– Module SIM900 GSM GPRS Shield pour Arduino
– Module Bluetooth HC05
– etc...

1. Initiation Arduino
Environnement de développement – Arduino IDE
(https://www.arduino.cc/en/Main/Software)
• Permet d’éditer, vérifier, compiler (verify/compile) et charger (upload) le
firmware dans la mémoire du microcontrôleur,
• De dialoguer avec la carte lors de son fonctionnement (serial monitor)
• Il fournit des bibliothèques de code pour étendre les fonctionnalités.
• Sélectionner la liaison série COM_XX (menu Tools\serial_port)
Programme Arduino:
Le programme est au moins constitué de 2 fonctions:
• La fonction void setup() qui assure l’initialisation des E/S du microcontroleur.
• La fonction void loop() (qui contient les instructions) est indéfiniment
exécuté.

2
2. Téléverser votre premier programme !
• Le matériel nécessaire : PC+Carte Arduino+cable USB.
• Le programme Blink (clignoter) fait clignoter une LED sur la carte Arduino !
(reliée au pin digital 13).
• Cette LED permet de vérifier qu’une carte Arduino fonctionne bien.
• Voici le programme :
void setup()
{ //On initilise le pin 13 qui est associé à la LED en sortie
pinMode(13, OUTPUT);
} //Fin de la fonction setup()
void loop()
{ //La fonction loop() se répète à l'infini une fois la fonction setup() exécutée
digitalWrite(13,HIGH); //Place le pin digital 13 à l'état HAUT (5V) -> Led allumée
delay(500); //Met en pause le programme pendant la valeur de 500 en ms
digitalWrite(13,LOW); //Place le pin digital 13 à l'état BAS (0V) -> Led éteinte
delay(500); //Met en pause le programme pendant la valeur de 500 en ms
} // Fin de la fonction loop() => on retourne au début de la fonction loop()

Faire communiquer le PC et la carte Arduino:

Liaison série
• La liaison Série est un protocole de communication entre le PC et la carte
Arduino via le câble USB permettant un échange d’informations via un
moniteur série !
• Le moniteur série est accessible depuis le logiciel Arduino en cliquant sur
la loupe en haut à droite de la fenêtre :
• Pour activer et configurer la liaison série.
Ajouter dans la fonction setup() la ligne:
Serial.begin(9600);
• Pour que la carte Arduino envoie un message
sur le moniteur série on a cette fonction : 9600 baud: Fréquence de
transmission du moniteur série.
Serial.print("Hello les makers ");

3
Faire communiquer le PC et la carte Arduino:
Liaison série
Voilà ce que donne le code complet :
void setup() {
// mettre ici le code qui sera répété qu'une fois:
Serial.begin(9600); // Permet d'initialiser le moniteur série à 9600 bauds
Serial.print("Hello les makers "); //Permet d'afficher Hello les makers sur le moniteur série
Serial.println(" j'espère que ce tutoriel vous plaît: ");
Serial.print(" signé : " );
void loop() {
Serial.println(« IoT-LFI3" );
// mettre ici le code qui sera répété en boucle:
}
if (Serial.available() )
void loop() {
{
// On ne fait strictement rien !
//Si un message a été reçu faire ceci
}
Serial.println(Serial.readString()); // Lit le message reçu
} //et l'affiche sur le moniteur
else
{
// Si rien n'est reçu faire cela
}
}

3. Objet IOT 1: Capteur de température

Float temp;
Acquisition de température : LM35 void setup()
Présentation du capteur : { Serial.begin(9600);
• Alimenter les pattes VCC et GND. }
• Brancher la patte void loop()
• centrale à une entrée analogique. { temp =
Lecture du capteur : analogRead(A0)*(5.0*1023)/100;
Serial.println(temp);
• 10mV
1C°
delay(1000);
• 1V
100 C°
}
• La lecture analogique d’un signal de 0 à 5V étant codée de 0 à 1023.
• Temp = Volt*(5/1023)*100
• Volt est entre 0 et 1023
Fonctionnement de la plaque d'essaie (breadboard)

• Permet de relier facilement les composants entre eux.

• La plaque est composée de deux zones :
– Les bandes de chaque côté : On branche le VCC et le GND.
– La zone centrale : On branche les composants entre eux.
– Sur le schéma, chaque trait de couleur représente un ensemble de trous reliés entre eux.

4
4. Introduction à l'interface série pour périphérique (SPI)
• SPI est un protocole de communication série synchrone (en mode full-duplex)
utilisé par les microcontrôleurs pour communiquer avec un ou plusieurs
composants périphériques sur de courtes distances.
• Elle peut être utilisé entre deux microcontrôleurs.

• il y a 3 lignes communes qui relient les composants:

o MISO "Master In Slave Out": utilisée pour envoyer des données depuis le(s)
périphérique(s) vers le maître,
o MOSI "Master Out Slave In": utilisée pour envoyer des données du maître
vers le(s) périphérique(s).
o SCLK "Serial Clock": transmet les impulsions de signal d'horloge générées
par le maître et qui synchronisent la transmission des données

4. Introduction à l'interface série pour périphérique (SPI)

• Aux 3 lignes communes, s'ajoutent une ligne de sélection SS "Slave Select":
o Active en niveau BAS, quand cette broche est mise au niveau HAUT, l’esclave
ignore ce qui se passe sur le bus SPI.
o Le maître peut l’utiliser pour activer ou désactiver le(s) esclave(s)
périphérique(s) voulu(s).

5
 4. Introduction à l'interface série pour périphérique (SPI)
Le tableau suivant compare les protocoles de communication I2C, SPI et UART en
fonction de différentes catégories.
Description I2C SPI UART
Inventé par 1982 -Philips Semi- 1970 -Motorola 1960 -Gordon Bell -Digital
conducteur Equipment Corporation
Transfert de données Une ligne d'horloge est nécessaire pour Vrai Vrai Faux
synchrone synchroniser la communication
Au lieu d'un signal d'horloge, le flux de
Transfert de données données
asynchrone lui-même contient des signaux de Faux Faux Vrai
démarrage et d'arrêt
Débit (bits/s) 10 000 à 1 000 000 Jusqu’à 10 000 000 Jusqu'à 115 200
L'esclave a besoin Vrai Faux Faux
d'une adresse unique
Nombre de broches 2 4+ 2
requises
Protocole de
vérification des Vrai Faux Vrai
erreurs
Multi-master On peut avoir plusieurs maîtres contrôlant Vrai Faux Faux
un ou plusieurs esclaves
Multi-slave On peut connecter plusieurs esclaves à un Vrai Vrai Faux
seul maître
Commutation par Les données transférées sont regroupées en
packages / messages, constitués d'un en- Vrai Faux Faux
paquets tête et d'une charge utile
Asymétrique Les données sont transférées par un seul fil Vrai Serial Data Faux Master in Slave
Out (MISO)/ Master Faux
(SDA) Out Slave In (MOSI)
Connexion série Les données sont transférées petit à petit Vrai Vrai Vrai
le long d'un seul fil

Principe de mise en œuvre de la communication SPI

Pour écrire un programme pour un nouveau composant SPI, il faut prendre en
compte plusieurs éléments :
• Les données série sont-elles envoyées avec le bit de poids fort (MSB) ou
avec le bit de poids faible (LSB) en premier ? Ceci est contrôlé par la
fonction SPI.setBitOrder().
• Le signal d'horloge est-il inactif sur le niveau HAUT ou BAS? (appelé la
polarité d'horloge)
• Les données sont-elles prises en compte sur le front montant (FM) ou
descendant (FD) de l'impulsion d'horloge ? (appelé la phase d'horloge) Ceci
et la polarité l'horloge sont contrôlées par la fonction SPI.setDataMode()
• A quelle vitesse le bus SPI fonctionne-t-il ? Ceci est contrôlé par la
fonction SPI.setClockDivider().
Le standard SPI est libre et chaque composant l'implémente de façon légèrement
différente. Cela signifie qu’il faut donner une attention spéciale à la fiche
technique (datasheet) du composant utilisé avant d’écrire le code.

6
Principe de mise en œuvre de la communication SPI
Il y a 4 modes de transmission qui combinent la polarité et la
phase d'horloge. La fonction SPI.setDataMode() est défini en
accord avec ce tableau:
Mode Clock Polarity (CPOL) Clock Phase (CPHA)
0 0 0
1 0 1
2 1 0
3 1 1
• Une fois que les paramètres SPI sont configurés, il ne reste
plus qu'à déterminer quels registres (32 registres internes 8
bits, R0 à R31) à utiliser.
• Pour inclure la librairie SPI dans un programme, on ajoutera au
programme la ligne : #include <SPI.h> ou le menu du logiciel
Arduino Programme > Importer Librairie > Nom_librairie
• Les fonctions de la librairie SPI: begin(), end(), setBitOrder(),
setClockDivider(), setDataMode() et transfer().

Tag
5. Objet IOT 2: Contrôle d'accès avec RFID
Connecter le module MFRC522
• Branchez le module LCD aux broches de l’Arduino comme
Radio Frequency
représenté ci-dessous : IDentification
• Table de correspondance

RFID-RC522 Arduino
VCC 3.3V
RST 9
GND GND
MISO 12
MOSI 11
SCK 13
NSS 10
IRC /

7
 5. Objet IOT 2: Contrôle d'accès avec RFID
Installation de la bibliothèque
Pour pouvoir utiliser ce module, la
bibliothèque MFRC522 doit être installée:
• Ouvrez l’IDE Arduino et aller dans
Croquis
Inclure une bibliothèque

Gérer les bibliothèques
• Dans le gestionnaire de bibliothèques,
recherchez « MFRC522 » et installez MFRC522:

Fermer la fenêtre une fois l’installation terminée

Exemple de programme #include <SPI.h>

#include<MFRC522.h>
L’exemple de code suivant (à copier dans // Affectation des broches
#define RST_PIN 9
l’IDE Arduino) initialise le module RFID et #define SS_PIN 10
affiche les données de la carte ou du badge MFRC522 mfrc522(SS_PIN, RST_PIN);
void setup() {
présenté sur le moniteur série (CTRL+MAJ+M // Initialisation du Module RFID
Serial.begin(9600);
pour ouvrir le moniteur série) : while(!Serial);
SPI.begin();
mfrc522.PCD_Init();
mfrc522.PCD_DumpVersionToSerial(); // Affichage des
données de la bibliothèque
Serial.println(F("Scan PICC to see UID, type, and data
blocks...")); }
void loop() {
// Attente d'une carte RFID
if( ! mfrc522.PICC_IsNewCardPresent()) {
return; }
// Récupération des informations de la carte RFID
if( ! mfrc522.PICC_ReadCardSerial()) {
return; }
// Affichage des informations de la carte RFID
mfrc522.PICC_DumpToSerial(&(mfrc522.uid)); }

8
5. Objet IOT 2: Contrôle d'accès avec RFID
Nous allons tester le module RFID en assemblant un contrôle d'accès qui vérifie
le droit d’accès (ou non) à travers une porte contrôlée par un servomoteur
(microservo 9G):

servomoteur

RFID LED’s d’accès

ou non

5. Objet IOT 2: Contrôle d'accès avec RFID

Contrôle d'un servomoteur
• Un servomoteur est un moteur qui peut tourner avec une liberté de 180° et
garder de manière précise l'angle de rotation que l'on souhaite obtenir.
• Il est utilisé pour contrôler des systèmes mécaniques (gouverne d'avion,
accélérateur, mini-robots, des actionneurs, etc.).
• Il existe divers types de taille, poids et couple (force) différents.
Fonctionnement Servomoteur chinois
"9 grammes"
• Un circuit électronique contrôle un moteur à courant continu en fonction de la
position d'un potentiomètre intégré au servomoteur.
• Quand le moteur tourne, il entraine avec lui le potentiomètre. Le circuit
électronique ajuste continuellement la vitesse du moteur pour que le
potentiomètre (et par extension le bras) reste au même endroit.
• Il suffit de donner une consigne au servomoteur ("reste à 45°" par exemple) et le
servomoteur fera son maximum pour rester au plus près de cette consigne.

9
 Fonctionnement et contrôle d'un servomoteur
• Cette consigne est transmise au moyen d'une impulsion
numérique (PWM).
• Pour que le servomoteur reste à une position donnée, il faut
transmettre toutes les 20 millisecondes (50Hz) une impulsion
d'une longueur comprise entre 1 et 2 millisecondes.
– Une impulsion de 1 milliseconde correspond à 0°.
– Une impulsion de 2 millisecondes correspond à 180.
– En envoyant une impulsion d'une longueur intermédiaire,
on obtient des angles différents.

Fonctionnement et contrôle d'un servomoteur

Montage
• Attention: à la consommation électrique du servomoteur
• solution: câbler les servomoteurs à une alimentation 5 volts
dédiée.
Code
• La bibliothèque de code à utiliser est nommée Servo.
• Elle permet de contrôler jusqu'à 12 servomoteurs simultanément.
• Elle rend inutilisable les broches D9 et D10 en PWM avec analogWrite().
#include <Servo.h>
Servo monServomoteur; //créer un objet Servo
void setup() { monServomoteur.attach(9); } //numéro de broche sur
// laquelle le servomoteur est câblé
void loop() {
// Fait bouger le bras de 0° à 180°
for (int position = 0; position <= 180; position++) {
monServomoteur.write(position);
delay(15); }
// Fait bouger le bras de 180° à 10°
for (int position = 180; position >= 0; position--) {
monServomoteur.write(position);
delay(15); }}

10
#include <SPI.h>Contrôle d'accès avec RFID
for (byte i = 0; i < mfrc522.uid.size; i++) {
#include <MFRC522.h> Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ");
#include <Servo.h> Serial.print(mfrc522.uid.uidByte[i], HEX);
Servo microservo9g; contenu.concat(String(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " "));
#define SS_PIN 10 contenu.concat(String(mfrc522.uid.uidByte[i], HEX)); }
#define RST_PIN 9 Serial.println();
MFRC522 mfrc522(SS_PIN, RST_PIN); Serial.print(" Publier : ");
int led_libéré = 5; contenu.toUpperCase();
int led_refusé = 6; if (contenu.substring(1) == "D8 4B 12 22") {
char st[20]; microservo9g.write(-90);
void setup() { digitalWrite(led_libéré, HIGH);
pinMode(led_libéré, OUTPUT); Serial.println(" Carte 1 - Accès débloqué !");
pinMode(led_refusé, OUTPUT); Serial.println(); delay(3000);
microservo9g.attach(3); microservo9g.write(90);
microservo9g.write(90); digitalWrite(led_libéré, LOW); }
Serial.begin(9600); if (contenu.substring(1) == "87 4B DC 8A") {
SPI.begin(); Serial.println(" Carte 2 - Accès refusé !!");
mfrc522.PCD_Init(); Serial.println();
Serial.println(" Rapprochez votre carte du lecteur..."); for (int i= 1; i<5 ; i++) {
Serial.println(); } digitalWrite(led_refusé, HIGH);
void loop() { delay(200);
if ( ! mfrc522.PICC_IsNewCardPresent()) { digitalWrite(led_refusé, LOW);
return; } delay(200); }
if ( ! mfrc522.PICC_ReadCardSerial()) { return; } }
Serial.print(" Numéro d'identification UID:"); delay(1000);
String contenu= ""; }
byte lettre;

6. Objets IOT connectés

Connecter Arduino à l’Internet en utilisant le module WiFi ESP8266
• Le module Wifi ESP8266 est un réseau WiFi Commandes Description Type
complet où on peut facilement nous connecter, AT+RST Restart module basic
en tant qu'adaptateur Wi-Fi de service, grâce à AT+CWMODE Wifi mode wifi
AT+CWJAP Join AP wifi
sa connectivité via la communication série ou AT+CWLAP List AP wifi
l'interface UART (Universal Asynchronous AT+CWQAP Quit AP wifi
Receiver Transmitter). AT+CIPSTATUS Get status TCP/IP
• Il peut être programmé en utilisant directement AT+CIPSTART Set up TCP or UDP TCP/IP
AT+CIPSEND Send data TCP/IP
les commandes AT, le code Arduino ou encore AT+CIPCLOSE Close TCP or UDP TCP/IP
le micrologiciel python, AT+CIFSR Get IP TCP/IP
AT+CIPMUX Set multiple TCP/IP
connections
• Des nombreuses informations sur le web sont
AT+CIPSERVER Set as server TCP/IP
périmées ou tout simplement fausses.

11
Application 1
ESP8266 Arduino
Étape 1: parler au module manuellement
GND GND
• L'ESP8266 n'est strictement alimenté VIN 3.3v
qu'en 3,3 V. ENABLE 3.3v
• Téléverser le Sketch Blink pour TX RX
allouer la liaison série, RX TX
• Régler le terminal pour envoyer Schéma pour initialiser
manuellement l'ESP8266
CR et LF en caractère de fin de avec les commandes AT
ligne et le débit à 115200 baud.
Puis envoyer la commande AT
(suivie d'un retour à la ligne).

AT+RST // remise à zéro

AT+CWMODE=3 // 3:mode Client/Serveur, 2:mode AP
115200 baud
AT+CWLAP // lister les point d’accès AP
AT+CWJAP="nom du réseau",mot de passe" //connecter au wifi
AT+CIFSR //connaitre l’adresse IP de l’ESP

Application 2 ESP8266 Arduino

GND GND
Étape 2: parler au module VIN 3.3v
automatiquement ENABLE 3.3v
• Il nous faut au minimum deux serials
TX GPIO10
hardware (un pour le pc, et un pour
l'ESP). La Uno n'en propose qu'un seul, il RX GPIO11
est conseillé d'opter pour une Arduino Schéma pour initialiser
Leonardo ou une Arduino Méga. automatiquement l'ESP8266
SoftwareSerial ESP8266(10, 11); // configurer les Pin 10 et 11 comme un second bus série
Serial.begin(115200);
ESP8266.begin(115200); // activation de la 2ième communication série
WiFi.begin("network-name", "pass-to-network"); //connecter le module ESP au Wi-Fi
Serial.println(WiFi.localIP());
svr=net.createServer(net.TCP) // création d’un serveur web
srv:listen(80,function(conn)
Conn:on("receive",function(client,request)
….
ESP8266.println("AT+RST"); // envoie d’une commande AT à l’ESP
Serial.print(ESP8266.read()); // lecture (par caractères) de la réponse du ESP

Nous sommes maintenant prêts à démarrer le WIFI avec Arduino UNO.

12
Application 2
Réglage du téléphone Android:
1. Téléverser le code ci-après dans l’Arduino UNO
(esp8266Sample.ino).
2. Télécharger le client Telnet pour Android
3. Connecter au ESP8266 Wifi
4. Une fois connecté, obtenir l'adresse IP
5. Ouvrir le client Telnet sur le téléphone Android.
6. Créer une connexion en cliquant sur se connecter,
sur Ajouter IP et sur le port 80.
Une fois connecté, envoyez une demande en tapant:
esp8266: <any AT Commands>

LEDON // commande pour allumer la LED intégrée

LEDOFF // commande pour éteindre la LED intégrée

HELLO // commande pour dire bonjour

Application 2
Étape 3: À propos du code
Toutes les requêtes lues et analysées sont dans la fonction loop()
if(wifiSerial.available()>0){
String message = readWifiSerialMessage();
if(find(message,"esp8266:")){
String result = sendToWifi(message.substring(8,message.length()),responseTime,DEBUG);
if(find(result,"OK"))
sendData("\n"+result);
else
sendData("\nErrRead"); //At command ERROR CODE for Failed Executing statement
}else
if(find(message,"HELLO")){ //receives HELLO from wifi
sendData("\\nHI!"); //arduino says HI
}else if(find(message,"LEDON")){
digitalWrite(13,HIGH);
}else if(find(message,"LEDOFF")){
digitalWrite(13,LOW);
} else{
sendData("\nErrRead"); //Command ERROR CODE for UNABLE TO READ
} }

13
Application 2
• Pour communiquer avec Arduino UNO on ajoute cette condition
if(find(message,""))
{ //something to do here
}
Lit dans le flux jusqu'à ce que le target donné soit trouvé (rep. vrai ou faux).

• On ajoute la fonction suivante pour communiquer avec l’ESP8266.

https://www.instructables.com/id/Add-WiFi-to-Arduino-UNO/
String readSerialMessage(){…}//lire à partir de la liaison série de Arduino
String readWifiSerialMessage(){…}// lire à partir de la liaison série de ESP8266
String sendToWifi(String command, const int timeout, boolean debug){…} //écrire dans esp8266
String sendToUno(String command, const int timeout, boolean debug){…} // écrire dans la UNO

• Une fois on a réussit à communiquer avec l’ESP8266, Il nous devient

possible d’explorer toute sorte de projets Internet des objets.

Application 3
• L’ESP démarre en mode Point d’Accès, on peut donc s’y connecter à l'aide
d'un smartphone pour un contrôle à distance.
• Séquence vidéo (https://www.youtube.com/watch?v=2cjufbgOBYo) illustre
les étapes à réaliser de l’application.
• Environnement de développement utilisé est Remotexy.
• Code voir: https://goo.gl/cxptgA#stay_creative #nothing_impossible

14
7. Diagrammes fonctionnels
Rappels
• Les appareils qui se connectent aux réseaux WiFi sont appelés stations (STA).
• La connexion au WiFi est assurée par un point d'accès (AP), qui fait office de
concentrateur pour une ou plusieurs stations.
• L’AP est connecté de l'autre extrémité à un réseau câblé.
• Un AP est généralement intégré à un routeur pour fournir l'accès d'un réseau
WiFi à l’Internet.
• Chaque AP est reconnu par un SSID (Service Set IDentifier), qui est
essentiellement le nom du réseau qu’on sélectionne lors de la connexion d'un
appareil (station) au WiFi.

Diagrammes fonctionnels
• L’ESP8266 peut fonctionner comme une station, nous pouvons donc le connecter
au réseau WiFi.
• Il peut également fonctionner comme un AP logiciel (soft-AP), pour établir son
propre réseau WiFi.
• Lorsque le module ESP8266 fonctionne comme un soft-AP, nous pouvons
connecter d'autres stations au module ESP.
• L'ESP8266 peut également fonctionner à la fois comme une station et un soft-
AP. Cela offre la possibilité de construire un réseaux maillés.

L’ESP8266 fonctionner comme

station + AP logiciel

15
Diagrammes fonctionnels: Station
• Le mode Station (ST) est utilisé pour connecter le
module ESP à un réseau WiFi établi par un AP.

L’ESP8266 fonctionner en mode station

• En cas de perte de connexion, l'ESP8266 se reconnectera automatiquement

au dernier AP utilisé même lors du redémarrage (les informations sont
enregistrées dans la mémoire flash).

Diagrammes fonctionnels: Point d'accès logiciel

• L'ESP8266 peut fournir des fonctionnalités similaires à un AP, sauf qu'il n'a
pas d'interface avec un réseau câblé ( mode soft-AP).
• Le nombre maximum de ST pouvant être connectées simultanément au
soft-AP peut être réglé de 0 à 8, mais par défaut à 4.

L’ESP8266 fonctionner
en mode soft-AP

• L’ESP démarre d'abord en mode soft-AP, pour nous y connecter à l'aide

d'un ordinateur ou téléphone mobile. Ensuite, nous pouvons fournir des
informations d'identification au réseau cible. Ensuite, l'ESP passe en mode
ST et peut se connecter au WiFi cible.
• L'ESP peut agir comme nœud d'un réseau maillé.

16
Diagrammes fonctionnels: Client
La classe Client crée des clients qui peuvent accéder aux services fournis
par les serveurs afin d'envoyer, de recevoir et de traiter des données.

L’ESP8266 fonctionner comme un Client

Diagrammes fonctionnels: Serveur

• La classe de serveur crée des serveurs qui fournissent des fonctionnalités
à d'autres programmes ou périphériques, appelés clients.

L’ESP8266 fonctionner
comme un Serveur

• Les clients se connectent au serveur pour envoyer et recevoir

des données et accéder aux fonctionnalités fournies.
La connexion entre modules Wi-Fi ESP8266
offre une solution pour les applications IoT

17
8. Ajouter un Shield GSM/GPRS à Arduino UNO
//Programme d'envoi d'un sms toutes les heures
//Shield GSM/GRPRS ITEA //Arduino uno //Pin 2 : TX //Pin 3 : RX
//Carte sim sans code pin
#include "SIM900.h"
#include <SoftwareSerial.h>
#include "sms.h"
SMSGSM sms;
int numdata;
boolean started=false;
char smsbuffer[160];
char n[20];
char num_tph[] = "+21698600000";
void setup(){
//Serial connection.
Serial.begin(9600);
Serial.println("GSM Shield testing.");
//Start configuration of shield with baudrate 2400(pour le shield ITEA)
if (gsm.begin(2400)) {
Serial.println("\nstatus=READY");
started=true;
} else Serial.println("\nstatus=IDLE");

if(started) {
if (sms.SendSMS(num_tph, "start"))
Serial.println("\nSMS sent OK"); }};
void loop(){
if(started) {
sms.SendSMS(num_tph, "message");
delay(3600000); }};

9. Application IOT-1
Problème
Un agriculteur, qui cultive des légumes sur un champ de 5
kilomètres carrés, cherche à mettre en œuvre un système Wi-Fi
de surveillance de la température et de l'humidité entièrement
indépendant, autonome et sans utiliser des fils.
Solution: Création d'un réseau Wi-Fi ESP8266
• Diviser le champ en 4 parties de zones,
• Dans chaque zone, on construit un sous-réseau de 9 ESP8266,
• Au centre du terrain, on place un boîtier central (central Box) contenant
– 1 module ESP8266,
– 1 Arduino uno,
– 1 module compatible GPRS Arduino.
• Dans chaque sous-réseau, on dispose :
– 3 ESP comme répéteurs de signaux (middleman)
– 6 autres ESP pour les lectures des capteurs (workers).

18
9. Application IOT-1

Création d'un réseau

WiFi ESP8266 en
topologie hybride
(étoile –maillé)

9. Application IOT-1
• Les 6 workers sont, la plupart du temps, en DEEP_SLEEP et se
réveillent à 1 heure d'intervalle pour lire les capteurs,
• Les 3 middleman sont à la fois en AP et ST avec un serveur Web
démarré, en attente des requêtes à venir des workers.
Comment programmer les modules?
• Chaque worker est programmé pour se réveiller de DEEP_SLEEP, lire les
capteurs, se connecter à l'AP ESP le plus proche et envoyer une requête
HTTP à son serveur avec les données,
• Si l'AP middleman le plus proche n'était pas disponible, les workers sont
programmés pour conserver jusqu'à 10 lectures dans leurs mémoires
internes, et les envoyer chaque fois que l'AP est réveillé,
• Les workers peuvent être alimentés par 4 piles Li-Ion 3,3 V, branchés en
parallèle et chargés par des panneaux solaires de 15 V,
• Les capteurs à utiliser sont à 1 fil.

19
9. Application IOT-1
• Chaque middleman est programmé pour écouter et recevoir les lectures des
workers, puis les envoyer au prochain middleman jusqu'à l'ESP du central Box,
• Les middlemans sont configurés à la fois en AP/ST.
• Les workers (client) utilisent des adresses IP statiques afin de réduire le
temps nécessaire pour se connecter à l'AP.
• Le central Box est chargé de recevoir et de traiter les données des
middlemans les plus proches, et de les envoyer dans une base de données
MySQL via le module GPRS au format JSON / XML, une fois par jour.
• Les données reçues (toutes les heures) peuvent être stockées (en format CSV)
sur un module de carte SD, attaché au module Arduino UNO.
• Les ESP central et middlemans sont programmés comme un agent de
découverte, en envoyant des requêtes PING vers les AP à proximité pour
vérifier la disponibilité et envoyer l'état et les mesures à la base de données.

9. Application IOT-1
Il existe de nombreux arrangements possibles à concevoir
pour le projet.

20
10. Application IOT-2
• Station météo à distance (humidité et température) en utilisant ThingSpeak,
• ThingSpeak est un service Cloud gratuit de surveillance et de contrôle des
systèmes à distance.
• Les composants à utiliser: Carte Arduino, capteur d'humidité et de
température DHT11 et le ESP8266 WIFI ,

• Le module DHT11 est connecté au GPIO 12,

• L’Arduino recueille les données en deux
parties: l'humidité puis la température,
• Les broches Tx et Rx de l'ESP8266 sont
directement connectées aux GPIO 2 et 3,
• La bibliothèque “Software Serial Library” est
utilisée pour permettre la communication
série sur les GPIO 2 et 3 d'Arduino.

10. Application IOT-2

• Coté ThingSpeak.com, on doit créer un compte pour se connecter et cliquer
sur l'option "New Channel” dans le menu "Channels".
• Dans le formulaire et avant d’enregistrer la chaîne, cocher les cases champs
1 et 2 (Field 1 et 2), remplir «Humidity» et «Temprature» dans les deux
étiquettes et cocher la case «Rendre public» (Make public).
• Maintenant, notre nouvelle chaîne est créée.
• Cliquer sur l'onglet «API Key» et récupérer la clé API d'écriture pour
l’utiliser après, dans le champ char * api_key du code.
• Ensuite, cliquer sur « Data Import/Export » et copier l'URL dans « Update
Channel Feed GET Request », qui est:
https://api.thingspeak.com/update?api_key=SIWOYBX26OXQ1WMS&field1=0
• Coté code, on ouvre «api.thingspeak.com» à l'aide de la fonction httpGet
avec postUrl pour envoyer les données via la requête GET au serveur.
• Pour recevoir les données, sous forme de graphique, sur le smartphone via
ThingSpeak, on utilise l'application Virtuino, disponible sur Google Play.

21
 11. Application IOT-3 avec la technologie LoRa
• Envoyer des valeurs prélevées par des capteurs vers une plateforme Web/IoT
publique en utilisant le kit LoRa de Dragino.

LoRa Node
with Sensors
WiFi
Ethernet 3G/4G LoRa
/WiFi Communication
Cloud
Ethernet
Server

LoRa Gateway

Architecture type de LoRa-IoT

11. Application IOT-3 avec la technologie LoRa

Configuration de la passerelle

Intérieur de la passerelle LoRa

Dragino gateway LG01-P Passerelle en mode client WiFi
• Le type de connexion locale utilisé définit la configuration que doit avoir la passerelle,
• La passerelle se connecte à l’Internet via le réseau local (configurée comme client LAN ou WiFi),
• Par défaut, la passerelle est configurée en point d’accès WiFi.
• Pour l’utiliser en client WiFi, allumer la passerelle et suivre les étapes suivantes :
1.Rejoindre le réseau dragino2-xxxxxx (sans mot de passe)
2.Accéder son interface Web via l’adresse 10.130.1.1 (username: root, password: dragino)
3.Aller dans Network --> Internet Access, et choisir Access Internet via WiFi Client, puis mettre Way
to Get IP à DHCP. Entrer ensuite le SSID du réseau local, le mot de passe et le type de sécurité.
4.Dans Network --> Access Point, Désactiver le point d’accès WiFi.

22
11. Application IOT-3 avec la technologie LoRa
Installation de l’environnement et des bibliothèques
Ajouter et installer le gestionnaire de carte correspondant :
1. Aller dans File --> Preference, de l’Arduino IDE
2. Dans la partie Additional Boards Manager URLs, ajouter le lien:
http://www.dragino.com/downloads/downloads/YunShield/package_dragino_
yun_test_index.json
3. Aller dans Tools --> Board --> Boards Manager, chercher la carte Dragino et
l’installer.
4. Aller dans Tools --> Board et vérifier la présence de la carte Dragino Yun-UNO or
LG01/OLG01
La bibliothèque Radiohead permet au MCU de communiquer et contrôler le module
LoRa pour envoyer et recevoir des paquets :
1. Télécharger la bibliothèque sur
https://github.com/dragino/RadioHead/archive/master.zip et la décompresser
dans le répertoire libraries de Arduino.
2. Redémarrer l’IDE et vérifier que les exemples de la bibliothèque Radiohead sont
bien présents dans File --> Examples.

Le noeud LoRa
1. Brancher le capteur DHT11 à une Arduino UNO selon le schéma donné.
2. Créer un nouveau sketch et copier le code client_lora_dht11.
3. Dans Tools --> Board, sélectionner la carte Arduino/Genuino UNO
4. Brancher la carte à un port USB, sélectionner le port correspondant (dans Tools
--> Port) puis téléverser le programme.
5. Ouvrir le moniteur série (Ctrl+Shift+M)
La passerelle
Afin d’accéder à un autre moniteur série
pour la passerelle, il faut lancer une
nouvelle instance de l’IDE Arduino.
1. Créer un nouveau sketch et copier le code
gateway_lora_local.
2. Dans Tools --> Board, sélectionner la Montage complet et branchement du
carte Dragino Yun-UNO or LG01/OLG01.capteur DHT11 avec la carte Arduino UNO
3. Dans Tools --> Port, sélectionner le port de la passerelle et téléverser le
programme.
4. Ouvrir le moniteur série.

23
Code client_lora_dht11 byte i = 0; Serial.println("C ");
#include <SPI.h> byte result = 0; break;
#include <RH_RF95.h> for(i = 0; i < 8; i++) case 1:
RH_RF95 rf95; // instancier l'objet pour communiquer { Serial.println("Error 1: DHT start condition 1 not met.");
#define dht_dpin XXX // broche de lecture du capteur while(digitalRead(dht_dpin) == LOW); break;
byte bGlobalErr; delayMicroseconds(30); case 2:
char dht_dat[5]; // stocker les données du capteur if (digitalRead(dht_dpin) == HIGH) Serial.println("Error 2: DHT start condition 2 not met.");
float frequency = XXX; // Fréquence du module result |=(1<<(7-i)); break;
void setup() while (digitalRead(dht_dpin) == HIGH); case 3:
{ } Serial.println("Error 3: DHT checksum error.");
InitDHT(); return result; break;
Serial.begin(9600); } default:
if (!rf95.init()) uint16_t calcByte(uint16_t crc, uint8_t b) Serial.println("Error: Unrecognized code encountered.");
Serial.println("init failed"); { break; }
// Paramétrer la fréquence ISM uint32_t i; // calcul de la longueur des données à envoyer
rf95.setFrequency(frequency); crc = crc ^ (uint32_t)b << 8; int dataLength = XXX;
// Paramétrer la puissance de transmission for ( i = 0; i < 8; i++) // calcul du CRC
rf95.setTxPower(13); { uint16_t crcData = XXX;
Serial.println("Humidity and temperature\n\n"); if ((crc & 0x8000) == 0x8000) unsigned char sendBuf[50] = {0}; // buffer d'envoie
} crc = crc << 1 ^ 0x1021; int i;
void InitDHT() // Initialise le capteur DHT11 else for(i = 0; i < dataLength; i++)
{ crc = crc << 1; XXX;
pinMode(dht_dpin,OUTPUT); } // Ajout de la première partie du CRC au paquet paquet LoRa
digitalWrite(dht_dpin,HIGH); } return crc & 0xffff; sendBuf[dataLength] = (unsigned char)crcData;
void ReadDHT() // Lit les valeur de température et d'humidité } // Ajout de la deuxième partie du CRC au paquet paquet LoRa
{ uint16_t CRC16(uint8_t *pBuffer,uint32_t length) sendBuf[dataLength+1] = (unsigned char)(crcData>>8);
bGlobalErr = 0; { rf95.send(XXX, XXX); // envoyer le paquet LoRa
byte dht_in; uint16_t wCRC16 = 0; uint8_t buf[RH_RF95_MAX_MESSAGE_LEN]; // buffer de la réponse
byte i; uint32_t i; uint8_t len = sizeof(buf); // longueur de la réponse
digitalWrite(dht_dpin,LOW); if (( pBuffer == 0 )||( length == 0 )) // attendre une reponse durant 3s
delay(30); { if (rf95.waitAvailableTimeout(3000))
digitalWrite(dht_dpin,HIGH); return 0; } {
delayMicroseconds(40); for ( i = 0; i < length; i++) if (rf95.recv(XXX, &len)) // vérifier si le message est correcte
pinMode(dht_dpin,INPUT); { {
dht_in = digitalRead(dht_dpin); wCRC16 = calcByte(wCRC16, pBuffer[i]); } // vérifier si le message est pour le noeud
if( dht_in ){ return wCRC16; if(buf[0] == X||buf[1] == X||buf[2] == X)
bGlobalErr = 1; } {
return; void loop() pinMode(4, OUTPUT);
} { digitalWrite(4, HIGH);
delayMicroseconds(80); ReadDHT(); Serial.print("got reply: "); // afficher la réponse
dht_in = digitalRead(dht_dpin); char data[50] = {0} ; Serial.println((char*)buf);
if( !dht_in ){ // Utiliser Data[0]. Data[1], Data[2] pour exprimer le deviceID. delay(400);
bGlobalErr = 2; data[0] = X ; digitalWrite(4, LOW);
return; data[1] = X ; Serial.print("RSSI: "); // afficher le RSSI
} data[2] = X ; Serial.println(rf95.lastRssi(), DEC);
delayMicroseconds(80); data[3] = dht_dat[0]; // ajouter la valeur de l'humidité }
for (i = 0; i < 5; i++) data[4] = dht_dat[2]; // ajouter la valeur de température }else{
dht_dat[i] = read_dht_dat(); switch (bGlobalErr) // traiter le retour de lecture Serial.println("recv failed");
pinMode(dht_dpin,OUTPUT); { XXX; // renvoyer le paquet
digitalWrite(dht_dpin,HIGH); case 0: }
byte dht_check_sum = dht_dat[0]+dht_dat[1]+dht_dat[2]+dht_dat[3]; Serial.print("Humdity = "); }else{
if(dht_dat[4]!= dht_check_sum) Serial.print(data[3], DEC); Serial.println("No reply, is rf95_server running?");
bGlobalErr = 3; } Serial.print("% "); XXX; // renvoyer le paquet }
byte read_dht_dat(){ Serial.print("Temperature = "); delay(30000); // Lire le capteur toutes les 30 secondes }
Serial.print(data[4], DEC);

Code gateway_lora_local return crc & 0xffff; uint8_t len = sizeof(buf);

#include <SPI.h> } if (rf95.recv(XXX, XXX)) // Vérifier si un paquet
#include <RH_RF95.h> uint16_t CRC16(uint8_t *pBuffer, uint32_t length) est arrivé
#include <Console.h> { {
#define BAUDRATE 115200 uint16_t wCRC16 = 0; recdata(XXX, len);
RH_RF95 rf95; uint32_t i; Console.print("Get LoRa Packet: ");
uint16_t crcdata = 0; if (( pBuffer == 0 ) || ( length == 0 )) for (int i = 0; i < len; i++)
uint16_t recCRCData = 0; return 0; {
float frequency = XXX; for ( i = 0; i < length; i++) Console.print(buf[i],HEX);
void setup() { Console.print(" ");
{ wCRC16 = calcByte(wCRC16, pBuffer[i]); }
Bridge.begin(BAUDRATE); } Console.println();
Console.begin(); return wCRC16; if(XXX == XXX) // Vérifier le CRC
if (!rf95.init()) } {
Console.println("init failed"); uint16_t recdata(unsigned char* recbuf, int // Vérifier si c'est le noeud attendu
rf95.setFrequency(frequency); Length) if(buf[0] == X||buf[1] == X||buf[2] == X)
rf95.setTxPower(13); { {
Console.println("LoRa Local Gateway Example"); crcdata = CRC16(recbuf, XXX); // calculer le CRC uint8_t data[] = “XXX”; // ACK de la passerelle
} du paquet data[0] = X;
uint16_t calcByte(uint16_t crc, uint8_t b) recCRCData = recbuf[XXX]; // récupérer le CRC data[1] = X;
{ reçu data[2] = X;
uint32_t i; recCRCData = recCRCData << 8; rf95.send(XXX, XXX); // Send Reply to LoRa Node
crc = crc ^ (uint32_t)b << 8; recCRCData |= recbuf[XXX]; rf95.waitPacketSent();
for ( i = 0; i < 8; i++) } }
{ void loop() }else
if ((crc & 0x8000) == 0x8000) { Console.println(" CRC Fail");
crc = crc << 1 ^ 0x1021; if (rf95.waitAvailableTimeout(2000)) // écouter si }
else un noeud transmet }
crc = crc << 1; { }
} uint8_t buf[RH_RF95_MAX_MESSAGE_LEN]; //
buffer de reception

24
Connexion à un serveur IoT
• La deuxième phase consiste à connecter la passerelle à Internet afin d’envoyer les données
collectées à une plateforme Web, ou serveur IoT, ou Cloud.
• Nous optons ici pour ThingSpeak comme serveur IoT.
• Généralement, l’envoie et l’accès aux données se fait avec une API RESTFul. Cette API utilise des
requêtes HTTP (GET, PUT, POST, DELETE) pour envoyer des données au serveur et réaliser ensuite
différentes opérations.
Configuration du serveur
1. Créer un compte sur https://thingspeak.com/users/sign_up
2. Créer un nouveau canal pour contenir les données collectées (New channel).
3. Renseigner les champs nécessaires et cocher une nouvelle case Field pour chaque type de donnée
contenu dans le projet (ici, température et humidité).
4. Dans l’onglet API Keys, copier la clé d’écriture (Write API Key) qui servira à sécuriser les requêtes
d’envoie de données au serveur.
5. Dans la section API Requests, le format des liens à utiliser sont donnés pour chaque opération. Nous
nous intéressons à la première.
6. Les données de chaque champ crée sont accessibles dans l’onglet Private View. Pour tester le
fonctionnement des liens, utiliser un navigateur et lancer par exemple le lien suivant :
https://api.thingspeak.com/update?api_key=XXXXX&field1=31 en remplaçant XXXXX par la clé
d’écriture copiée précédemment. Dans l’onglet Private View la valeur 31 s'affiche dans le graphe
quelques secondes après avoir lancé le lien.

Interface principale ThingSpeak

25
 Interface de visualisation des données reçues

Intégration du montage local au serveur IoT

• Pour envoyer des données, la passerelle effectue la même opération que la
vérification de l’API réalisée sur le navigateur précédemment. La seule différence
est que le lien est lancé par une commande grâce au programme curl. Cependant,
les données envoyées par le noeud LoRa sont reçues par la partie MCU de la
passerelle. Il faut donc lancer la commande curl qui se trouve dans la partie de la
passerelle à partir de la partie MCU. Pour cela, la bibliothèque Process permet de
faire des appels systèmes à partir d’un programme Arduino.
• L’exemple précédent est exécuté avec la commande curl comme suit :
curl -k “https://api.thingspeak.com/update?api_key=XXXXX&field1=31”
• Dans le montage réalisé dans la première phase, remplacer le programme de la
passerelle par le code gateway_lora_iot_server, puis téléverser les sketchs.

Etapes de
communication
du noeud LoRa
au serveur IoT

26
Code gateway_lora_iot_server
Pour obtenir le programme correspondant, il faut compléter les blocs d’instructions suivants et les placer au
bon endroit dans le code donné par le code gateway_lora_local.

1: #include <Process.h> d'ecriture API ");

2: String myWriteAPIString = "XXX";
3: String dataString = "";
4: Console.println("LoRa Gateway to
ThinkSpeak");
5: int humidity = newData[0];
int temperature = newData[1];
6: dataString ="XXX";
dataString += XXX;
uploadData();
dataString = "";
7: void uploadData()
{ l’URL
String upload_url = "XXX";
upload_url += XXX; // ajouter la clé
upload_url += "XXX"; // afficher la réponse de Linux
upload_url += XXX; // ajouter les while (p.available() > 0)
données {
Console.println("Call Linux Command char c = p.read();
to Send Data"); Console.write(c);
Process p; // utiliser la class Process }
p.begin("XXX"); // préparer la Console.println("");
commande cURL Console.println("Call Finished");
p.addParameter("XXX"); // ajouter le Console.println("##################
paramètre ##################");
p.addParameter(XXX); // ajouter Console.println("");
}
p.run(); // lancer la commande cURL
Console.print("Feedback from Linux:

Interface de visualisation des données

après quelques minutes d’exécution

27
Aller plus loin
À partir de la configuration réalisée, deux pistes intéressantes peuvent être envisagées pour rendre le
scénario plus complexe :
 Exécuter une commande sur le noeud LoRa à partir du serveur IoT : En plus de visualiser et traiter
les données, ThingSpeak propose un autre service permettant de créer une file de commandes côté
serveur qui seront exécutées par le noeud LoRa. Le noeud jouera dans ce cas le rôle d’un actionneur,
pour allumer/éteindre une lampe par exemple. Le principe de fonctionnement est similaire à celui de
l’envoie de données vue précédemment.
 Réaliser une topologie maillée avec plusieurs passerelles LoRa : Pour couvrir des surfaces plus larges,
les données collectées par le noeud LoRa peuvent être envoyées sur plusieurs sauts. Pour cela, un
ensemble de passerelles (clients maillés) sont placées entre la passerelle principale (passerelle maillée
connectée à Internet) et les noeuds LoRa. Les clients maillés communiquent entre eux et avec la
passerelle principale. Les détails de configuration sont disponibles dans la documentation du kit
(http://www.dragino.com/)

Exécution de
commandes sur
le noeud LoRa

Topologie LoRa maillée

28
12. Autres outils à explorer
Microcontrôleur
• ESP32: Système à faible coût et consommation
d'énergie avec WiFi et Bluetooth à deux modes!
• La famille comprend les puces ESP32-D0WDQ6,
ESP32-D2WD, ESP32-S0WD, ESP-WROOM-32, etc…
• L'ESP32 est hautement intégré avec des
commutateurs d'antenne intégrés, un balun RF,
un amplificateur de puissance, un amplificateur
de réception à faible bruit, des filtres et des
modules de gestion de l'alimentation.
• Conçu pour les applications IoT,
Développement
• Esplorer: ESP-IDF (Espressif IoT Development Framework)),
• Ardublock ESP: (Programmer des objets connectés),
• Mblock: logiciel qui intègre les briques pour piloter toutes les cartes compatibles Arduino,
• MIT App Inventor : Environnement de développement d'applications pour Android.

12. Programmer ESP32 en utilisant IDE Arduino

• ESP32 est une évolution
de l'ESP8266, intégrant
la gestion du Wi-Fi et du
Bluetooth, apprécié
dans le domaine de
l'internet des objets.

• Connecter l'ESP32-WROOM à l'ordinateur avec un câble micro-usb et Valider le

port COM utilisé sur l'IDE Arduino en sélectionnant Outils/Port Com
• Ajouter dans <URL de gestionnaire de carte supplémentaires> de
Fichier/Préférences : https://dl.espressif.com/dl/package_esp32_index.json

29
12. Programmer ESP32 en utilisant IDE Arduino
• Vérifier et/ou modifier les paramètres de la carte Esp32 comme indiqué
ci-dessous
– Type de carte: ESP32 Dev Module
– Upload Speed: 115200 # Vitesse de transfert
– CPU Frequency: 240MHz (WIFI/BT)
– Flash Frequency: 80MHz
– Flash Mode: QIO
– Flash Sizes 4MB(32Mb)
– Partition scheme: Default 4MB with spiffs (1.2MB APP/1.5MB SPIFFS)
– Core Debug Level: Rien
– PSRAM: Disabled
– Port: COM4 # Votre n° de port COM - Windows

12. Programmer ESP32 en utilisant IDE Arduino

• Pour vérifier le bon fonctionnement du int Led=1; # Ajouter int Led=1; (pin1)
void setup() {
ESP32-WROOM, nous pouvons exécuter pinMode(Led, OUTPUT); # Modifier la variable
le code pour faire clignoter la led de la }
carte ESP32 (Led interne = pin1) void loop() {
digitalWrite(Led, HIGH); # Modifier la variable
• Téleverser le code dans l'EPS32-WROOM delay(1000);
• Lorsque l'IDE Arduino affiche "Connecting digitalWrite(Led, LOW); # Modifier la variable
delay(1000);
....« appuyer durant 2 à 3 secondes sur le }
bouton [BOOT] de l'esp32 pour démarrer le
téléversement,
Vérification du Wifi de la carte ESP32-WROOM
• Téleverser le code « Fichier/Exemples (Exemples pour ESP32 Dev Modules)
/Wifi/WifiScan », ouvrir le Moniteur Série et vérifier la vitesse du moniteur
série pour un affichage correct,

30
 12. Programmer ESP32 en utilisant IDE Arduino
Vérification du Wifi avec la carte ESP32-WROOM
#include "WiFi.h" } else {
void setup() Serial.print(n);
{ Serial.println(" networks found");
Serial.begin(115200); for (int i = 0; i < n; ++i) {
// Set WiFi to station mode and disconnect from an AP if it // Print SSID and RSSI for each network found
// was previously connected Serial.print(i + 1);
WiFi.mode(WIFI_STA); Serial.print(": ");
WiFi.disconnect(); Serial.print(WiFi.SSID(i));
delay(100); Serial.print(" (");
Serial.println("Setup done"); Serial.print(WiFi.RSSI(i));
} Serial.print(")");
void loop() Serial.println((WiFi.encryptionType(i) ==
{ WIFI_AUTH_OPEN)?" ":"*");
Serial.println("scan start"); delay(10);
// WiFi.scanNetworks will return the number of networks }
found }
int n = WiFi.scanNetworks(); Serial.println("");
Serial.println("scan done"); // Wait a bit before scanning again
if (n == 0) { delay(5000);
Serial.println("no networks found"); }

12. Programmer ESP32 en utilisant IDE Arduino

Se connecter au réseau WiFi
• Le sketch suivant est utilisé pour installer et vérifier la connexion à notre
réseau WiFi. Il faudra indiquer le nom de son routeur WiFi (la variable ssid)
et le mot de passe (la variable pwd).
#include "WiFi.h" }
const char* ssid = "..."; void loop() {
const char* pwd = "..."; delay(1000);
void setup() { if (WiFi.status() == WL_CONNECTED) {
Serial.begin(9600); Serial.print("Est connecté au réseau avec ");
Serial.println("Configuration du WiFi"); Serial.println(WiFi.localIP());
WiFi.begin(ssid, pwd); }
while (WiFi.status() != WL_CONNECTED) { else {
delay(500); Serial.println("N'est pas connecté au réseau");
Serial.println("Connexion au WiFi.."); }
} }
Serial.println("Connecté au réseau WiFi");

31
 12. Programmer ESP32 en utilisant IDE Arduino
Un serveur Web simple
• L'accès se fait avec par exemple http://192.168.1.7/test. Ce script ne marche pas trop bien, il
faut attendre plusieurs secondes avant de pouvoir rafraichir la page ou entrer cette adresse avec
un autre explorateur Internet, comme Chrome qui semble donner plus de difficulté.
#include <WiFi.h> } content=\"width=device-width, initial-scale=1.0,
#include <WebServer.h> void deal_onConnect() { user-scalable=no\">\n";
const char* ssid = "..."; Serial.println("onConnect"); ptr += "<title>ESP32 Web Server</title>\n";
const char* pwd = "..."; server.send(200, "text/html", ptr += "<style>html { font-family: Helvetica;
WebServer server(80); SendHTML("Connect sur root")); display: inline-block; margin: 0px auto; text-
void setup() { } align: center;}\n";
Serial.begin(9600); void deal_aTest() { ptr += "body{margin-top: 50px;} h1 {color:
Serial.print("Connexion à "); Serial.println("aTest"); #444444;margin: 50px auto 30px;} h3 {color:
Serial.println(ssid); server.send(200, "text/html", SendHTML("Juste #4444FF;margin-bottom: 50px;}\n";
WiFi.begin(ssid, pwd); un test")); ptr += "p {font-size: 14px;color: #888;margin-
while (WiFi.status() != WL_CONNECTED) { } bottom: 10px;}\n";
delay(200); void deal_temperatures() { ptr += "</style>\n</head>\n";
Serial.print("."); Serial.println("The temperatures"); ptr += "<body>\n";
} server.send(200, "text/html", "C: 20.6 17.8 ptr += "<h1>ESP32 Web Server</h1>\n";
//Montre l'adresse IP et démarre le serveur Web22.5"); ptr += "<h3>" + content + "</h3>\n";
Serial.println(""); } ptr +="</body>\n";
Serial.println("WiFi connecté!"); void deal_notFound() { ptr +="</html>\n";
Serial.println("Adresse IP: "); Serial.println("notFound"); return ptr;
Serial.println(WiFi.localIP()); server.send(200, "text/html", SendHTML("Not }
server.on("/", deal_onConnect); found")); void loop() {
server.on("/test", deal_aTest); } server.handleClient();
server.on("/temps", deal_temperatures); String SendHTML(String content){ delay(1000);
server.onNotFound(deal_notFound); String ptr = "<!DOCTYPE html> <html>\n"; }
server.begin(); ptr += "<head><meta name=\"viewport\"

12. Programmer ESP32 en Python en utilisant MicroPython

• Il est possible d'installer MicroPython (applique Python au champ embarqué) en
utilisant toutes les fonctionnalités qu'offre ce langage.
• uPyCraft est un IDE de programmation efficace qui permet de sauvegarder le
firmware sur ESP32.
Installation du micrologiciel MicroPython sur ESP32
• Pour que uPyCraft fonctionne, il faut avoir une version de Python installée sur
machine. On peut trouver la version la plus récente sur ce lien
(https://www.python.org/downloads/).
• Télécharger le firmware MicroPython pour ESP32 (https://micropython.org/download/).
sélectionner Generic ESP32 module puis le fichier image (.bin) à utiliser.
• Télécharger uPyCraft, disponible sur ce lien
(https://randomnerdtutorials.com/uPyCraftWindows).
• Pour enregistrer le micrologiciel, sélectionner le menu Outils et choisir l'option
BurnFirmware:

32
 12. Programmer ESP32 en Python en utilisant MicroPython
• Choisir la carte ESP32, sélectionnez l'option Effacer Flash (pour effacer
complètement la mémoire ESP32) et dans le champ Firmware Choose, entrez le
chemin du micrologiciel MicroPython téléchargé précédemment. Faites attention à
l'adresse d'enregistrement, qui doit être 0x1000. l’écran ressemblera à ceci:
• Cliquez sur OK et attendez le processus d'enregistrement. Il fallait appuyer sur le
bouton BOOT pour démarrer. Après l'enregistrement, n'oubliez pas de redémarrer
NodeMCU pour que le nouveau firmware déjà avec MicroPython soit chargé.
• Pour vérifier si tout va bien, sélectionnez le port COM
de votre ESP32 NodeMCU dans le menu Outils et dans
ce même menu sélectionnez la carte ESP32.
• Pour vous connecter à l'ESP32, cliquez sur l'icône
«chaîne» sur le côté droit de l'IDE. Vous pouvez voir
sur le côté gauche les fichiers qui se trouvent dans le
module (boot.py) et en bas une invite de commande.

13. Application IOT-4: Envoi d’un messages MQTT

• Il s’agit d’envoyer un message MQTT en utilisant le module ESP32,
• Le message est envoyé à un smartphone Android en utilisant le cloud,
• A la place de l’ESP32, on peut également utiliser la carte Arduino+ ESP8266.
Comment fonctionne le MQTT
• MQTT (Message Queue Telemetry Transport) est un protocole de
communication simple à utiliser et ne nécessite pas beaucoup de puissance
de traitement ou de grandes ressources de bande passante réseau.
• Fondamentalement, il y’a un
– Editeur (Publisher), qui envoie des messages;
– Serveur MQTT (Broker), à mi-chemin, responsable
de la gestion des échanges de messages, Broker
– Abonné (Subscriber), qui lit des messages envoyés
par Publisher. Subscriber
Publisher

33
13. Application IOT-4
MQTT en utilisant Arduino IDE
Le Broker MQTT utilisé est
iot.eclipse.org, qui est gratuit. Il
Subscriber existe également des Brokers
payants sur Internet et on peut
Message
même créer un Broker en
Publisher
interne, en utilisant une carte
Subscriber Raspberry Pi, par exemple.

• Installer la carte ESP32 dans l'IDE Arduino. Dans le menu Fichier-

>Préférences, mettre l'adresse ci-dessous dans le champ URL pour les
gestionnaires de cartes:
https://dl.espressif.com/dl/package_esp32_index.json
• Accéder au menu Outils -> Carte -> Gestionnaire de carte et installer
le module ESP32,

13. Application IOT-4

• La bibliothèque de client MQTT utilisée ici fait partie du projet Eclipse
Paho qui fournit des API pour l’utilisation de MQTT sur plusieurs moyens
de transport.
• Installer la bibliothèque PubSubClient (communication MQTT), en
sélectionnant Croquis -> Ajouter une bibliothèque -> Gérer les
bibliothèques puis Installer.
• Sélectionner la carte du module de développement ESP32 dans le menu
Outils,
• Charger le programme ci-dessous, pour se connecter au réseau wifi et
au serveur MQTT (iot.eclipse.org) et envoyer des messages à des
intervalles de 30 secondes,
• Modifier les lignes 4 et 5 du programme avec le nom et le mot de passe
du réseau wifi, à travers lequel l’ESP32 communique avec le Broker
MQTT pour envoyer des données.

34
//Programme: module ESP32 Wifi avec MQTT
#include <WiFi.h>
#include <PubSubClient.h>
const char* ssid = "WIFI-FSM";
const char* password = « 12457894";
//Envoyez le message au broker
const char* mqttServer = "mqtt.eclipse.org";
client.publish(« LFI3IOT", message);
const int mqttPort = 1883;
Serial.println("Message envoyé avec succès...");
const char* mqttUser = "abcdefg";
compteur++;
const char* mqttPassword = "123456";
delay(30000);}
WiFiClient espClient;
void reconnectbroker()
PubSubClient client(espClient);
{ // Connexion au broker MQTT
int compteur = 1;
client.setServer(mqttServer, mqttPort);
char message[30];
while (!client.connected())
void setup()
{ Serial.println(" Connexion au broker MQTT...");
{ Serial.begin(115200);
if (client.connect("ESP32Client", mqttUser, mqttPassword ))
WiFi.begin(ssid, password);
{ Serial.println(" Connexion au broker!"); }
while (WiFi.status() != WL_CONNECTED)
else
{ delay(500);
{ Serial.print("Échec de la connexion au Broker- État:");
Serial.println("Démarrage de la connexion WiFi..");}
Serial.print(client.state());
Serial.println("Connecté au réseau WiFi!");}
delay(2000);}
void loop()
}}
{ //Se connecte au Broker MQTT
reconnectbroker();
sprintf(message, "MQTT ESP32-message no. %d", compteur);
Serial.print(« Message envoyé: ");
Serial.println(message);

13. Application IOT-4

Réception de données MQTT sur le smartphone
• Pour recevoir sur le smartphone, les données envoyées par
le module ESP32 via MQTT, on utilise l'application MyMQTT,
disponible sur Google Play,
• Sélectionner l'icône de l'application pour accéder au menu
puis Settings et entrer iot.eclipse.org, puis Save. Il n'est pas
nécessaire de modifier les autres paramètres,
• De retour au menu, sélectionner Subscribe et entrer le topic
auquel on souhaite s’abonner. Dans notre cas, le nom du
topic est LFI3IOT. Cliquez sur Add pour enregistrer les
informations,
• Revenir à l'écran principal (Dashboard) et suivre la réception
des messages MQTT envoyés par ESP32,
• A noter, qu'il est possible d'envoyer des commandes à partir
du smartphone à l'ESP32.

35
 Principaux Brokers MQTT open-source
Les principaux projets de brokers Open Source
• ActiveMQ qui permet d’ajouter MQTT à un serveur Web Apache,
• JoramMQ pour l’intégration de MQTT en Java,
• Mosquitto, le plus utilisé dans les projets DIY soutenu par la fondation
eclipse.org,
• RabbitMQ, disponible également avec un support commercial,
• EMQTT, conçu pour recevoir de nombreuses connexions (jusqu’à 1 million
par serveur). Il est possible de créer un cluster (réseau de serveur) pour
accroitre le nombres de connexions simultanées.
ActiveMQ et JoramMQ sont des brokers assez spécifiques. RabbitMQ est
plus orienté entreprise.
Mosquitto est un très bon choix. Il est disponible sur toutes les plateformes
et s’installe en quelques minutes.

Services MQTT Broker gratuits

Les brokers accessibles au public, utiles pour les tests et le prototypage, sont:
adresse port type info
iot.eclipse.org 1883 , 80 (WebSockets) mosquitto web page, Xively statistics, topics and HTTP bridge
test.mosquitto.org 1883 , 8883 (SSL), 8884 mosquitto web page, Xively statistics, topics and HTTP bridge
(SSL), 80 (WebSockets)
dev.rabbitmq.com 1883 rabbitmq admin dashboard
broker.mqttdashboard.com 1883 , 8000 (WebSockets) HiveMQ information page, stastistics and dashboard
q.m2m.io 1883 m2m.io requires signup/username and password, connecting to
m2m.io
q.m2m.io 1883 m2m.io requires signup/username and password, connecting to
m2m.io
www.cloudmqtt.com (Rmq: 18443 , 28443 (SSL) mosquitto nécessite inscription / nom d'utilisateur et mot de
l'hôte réel varie) passe, prix (plan gratuit disponible), documentation
mqtt.simpleml.com 1883 (MQTT), 8883 SimpleML Service MQTT gratuit pour évaluer les modèles Machine
(MQTT+SSL), 80 (REST), 80 Learning, la documentation
(WebSockets), 5683 (CoAP)
mqtt.kgbvax.net 1883 (MQTT) mosquitto Instance partagée gratuite, prend actuellement en
charge la persistance

36