doctor/mini-IOT
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

update

Browse Source
This commit is contained in:
doctor 2023-06-10 21:55:38 +02:00
parent 7a39e09d71
commit 58c7c776fb
1 changed files with 153 additions and 172 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

325
README.md
View File

@ -2,7 +2,6 @@
<img src="./Images/iot-logo.png" align="right" width="50">
Ce document présente le projet de création d'un mini réseau d'objets connectés, réalisé dans le cadre d'un projet universitaire. L'objectif principal de ce projet est de démontrer la faisabilité et les fonctionnalités d'un tel réseau.
## Sommaire
- [Matériels utilisés](#matériels-utilisés)
@ -11,9 +10,19 @@ Ce document présente le projet de création d'un mini réseau d'objets connect
- [Aperçu en vrai](#aperçu-en-vrai)
- [Configuration de la box Wifi](#configuration-de-la-box-wifi)
- [Configuration du Raspberry PI](#configuration-du-raspberry-pi)
- [Flasher l'OS sur une carte SD](#flasher-l'os-sur-une-carte-sd)
- [Configuration Wi-Fi et IP statique](#configuration-wi-fi-et-ip-statique)
- [Connexion au Raspberry Pi](#connexion-au-raspberry-pi)
- [Mise à jour du système](#mise-à-jour-du-système)
- [Installation des services nécessaires](#installation-des-services-nécessaires)
- [Configuration de Mosquitto](#configuration-de-mosquitto)
- [Configuration de MariaDB](#configuration-de-mariadb)
- [Configuration Node-RED](#configuration-node-red)
- [Aperçu interface web généré par Node-RED](#aperçu-interface-web-généré-par-node-red)
- [Installation de modules complémentaires](#installation-de-modules-complémentaires)
- [Connexion au réseau de la box](#connexion-au-réseau-de-la-box)
- [Programmation des ESP32](#programmation-des-esp32)
- [ESP32 Micropython](#esp32-micropython)
- [ESP32 en C](#esp32-en-c)
## Matériels utilisés
@ -49,88 +58,96 @@ La mise en œuvre du mini réseau d'objets connectés comprend les étapes suiva
### Configuration de la box Wifi
Sur la face arrière de la box wifi qui nous a été fournie pour ce projet, nous avons découvert
l’adresse IP de la box (192.168.1.50) ainsi que les identifiants de connections pour accéder
à la page d’administration de cette box (identifiant : admin) et sans mots de passe. Étant
donné que cette box avait une configuration par défaut assez complet pour un réseau, nous
n’avions pas grand-chose à configurer. Ce que nous avons configuré était le mot de passe
wifi du SSID ”PT4ObjConnect” que nous avons remplacé par ”Admin2022” et avons activé
le DHCP avec une plage d’adresse allant de ”192.168.1.30” à ”192.168.1.200” qui était
désactivé par défaut.
Pour la configuration de la box WiFi fournie dans le cadre de ce projet, nous avons suivi les étapes suivantes :
1. Sur la face arrière de la box WiFi, nous avons identifié l'adresse IP de la box, qui était 192.168.1.50. Nous avons également trouvé les identifiants de connexion pour accéder à la page d'administration de la box : l'identifiant était "admin" et il n'y avait pas de mot de passe requis.
2. Étant donné que la box avait une configuration par défaut assez complète pour un réseau, nous n'avions pas besoin de configurer grand-chose. Cependant, nous avons modifié le mot de passe du réseau WiFi du SSID "PT4ObjConnect" en le remplaçant par "Admin2022".
3. Nous avons également activé le service DHCP, qui était désactivé par défaut, en configurant une plage d'adresses allant de "192.168.1.30" à "192.168.1.200". Cette plage d'adresses permettrait au routeur de fournir automatiquement des adresses IP aux appareils connectés à la box WiFi.
### Configuration du Raspberry PI
Afin de configurer le Raspberry PI, nous avons utilisé l’OS DietPi dû à sa légèreté et sa
simplicité d’utilisation. Pour installer Dietpi sur le RPI, il faut d’abord flasher l’OS sur une
carte SD avec le logiciel RPI-Imager :
Afin de configurer le Raspberry Pi, nous avons utilisé l'OS DietPi en raison de sa légèreté et de sa simplicité d'utilisation. Voici les étapes que nous avons suivies :
#### Flasher l'OS sur une carte SD
1. Téléchargez le logiciel RPI-Imager sur le site officiel.
2. Lancez RPI-Imager et sélectionnez l'OS DietPi.
3. Insérez la carte SD dans votre ordinateur.
4. Sélectionnez la carte SD dans RPI-Imager.
5. Cliquez sur "Write" pour flasher l'OS sur la carte SD.
<img src="./Images/rpi-imager.png" width="500" alt="Logiciel RPI-Imager">
Avant de connecter le RPI au wifi de la box, nous avons créé un partage de connexion
à l’aide d’un téléphone portable ayant accès à internet (étant donné que la box n’a pas
accès à internet et que nous en avons besoin afin d’installer des logiciels sur le RPI). Nous
avons également utilisé un PC portable (sous Linux) connecté au téléphone par Wifi afin
de configurer le Raspberry PI par SSH. Sur le PC portable, pour connaitre la passerelle par
défaut de ce réseau créé par le téléphone, nous avons relevé la passerelle par défaut avec
la commande ”ip r” :
Avant de connecter le Raspberry Pi au réseau Wi-Fi, nous avons créé un partage de connexion à l'aide d'un téléphone portable disposant d'un accès Internet. Nous avons également utilisé un PC portable connecté au téléphone par Wi-Fi pour configurer le Raspberry Pi via SSH.
<img src="./Images/ip-r.png" width="500" alt="Passerelle par défaut du PC portable">
1. Connectez-vous au réseau Wi-Fi partagé par le téléphone portable à l'aide du PC portable.
2. Recherchez la passerelle par défaut de ce réseau en exécutant la commande "ip r" sur le PC portable : <img src="./Images/ip-r.png" width="500" alt="Passerelle par défaut du PC portable">
Pour commencer, avant de démarrer le RPI, nous avons créé un fichier ”ssh” vide dans la
partition contenant la racine de l’OS afin d’activer le service ssh au démarrage du RPI.
#### Configuration Wi-Fi et IP statique
Et dans la deuxième partition (en FAT) nous avons modifié le fichier dietpi.txt afin d’activer la carte wifi et configurer le Raspberry PI avec une adresse IP statique. Les lignes que nous
avons modifiées dans le fichier dietpi.txt sont les suivantes :
Avant de démarrer le Raspberry Pi, effectuez les étapes suivantes :
```Bash
AUTO_SETUP_NET_ETHERNET_ENABLED =0
AUTO_SETUP_NET_WIFI_ENABLED =1
AUTO_SETUP_NET_USESTATIC =1
AUTO_SETUP_NET_STATIC_IP =192.168.80.160
AUTO_SETUP_NET_STATIC_MASK =255.255.255.0
AUTO_SETUP_NET_STATIC_GATEWAY =192.168.80.153
AUTO_SETUP_DHCP_TO_STATIC =1
1. Créez un fichier vide nommé "ssh" à la racine de la partition de l'OS pour activer le service SSH au démarrage.
2. Modifiez le fichier "dietpi.txt" dans la deuxième partition (FAT) pour activer la carte Wi-Fi et configurer une adresse IP statique. Voici les lignes à modifier :
```bash
AUTO_SETUP_NET_ETHERNET_ENABLED=0
AUTO_SETUP_NET_WIFI_ENABLED=1
AUTO_SETUP_NET_USESTATIC=1
AUTO_SETUP_NET_STATIC_IP=192.168.80.160
AUTO_SETUP_NET_STATIC_MASK=255.255.255.0
AUTO_SETUP_NET_STATIC_GATEWAY=192.168.80.153
AUTO_SETUP_DHCP_TO_STATIC=1
```
Ensuite, pour que le Raspberry PI se connecte au wifi du téléphone, nous avons modifié le
fichier dietpi-wifi.txt avec les informations suivantes :
3. Modifiez le fichier "dietpi-wifi.txt" avec les informations de votre réseau Wi-Fi :
```Bash
aWIFI_SSID [0]= ' WifiSAE '
aWIFI_KEY [0]= '12345678910 '
```bash
aWIFI_SSID[0]='WifiSAE'
aWIFI_KEY[0]='12345678910'
```
Une fois le Raspberry PI alimenté, il se connecte en quelques secondes au réseau wifi. Nous
pouvons nous y connecter par ssh en utilisant la commande :
#### Connexion au Raspberry Pi
```Bash
1. Alimentez le Raspberry Pi et laissez-le se connecter au réseau Wi-Fi.
2. Sur le PC portable, ouvrez un terminal et utilisez la commande suivante pour vous connecter au Raspberry Pi via SSH :
```bash
ssh dietpi@192.168.80.160
```
Avec le mot de passe par défaut ”dietpi”. Ce qui nous retourne cette interface une fois
connecté :
3. Entrez le mot de passe par défaut "dietpi" pour vous connecter.
Ce qui nous retourne cette interface une fois connecté :
<img src="./Images/ssh.png" width="500" alt="Interface d’accueil de Dietpi">
Afin de mettre à jour le système, nous avons utilisé la commande :
#### Mise à jour du système
```Bash
Pour mettre à jour le système DietPi, exécutez la commande suivante :
```bash
sudo dietpi-update
```
Pour installer les différents services nécessaires pour ce projet sur le Raspberry PI, nous
avons utilisé la commande :
#### Installation des services nécessaires
```Bash
Utilisez la commande suivante pour installer les services requis (MariaDB, Mosquitto et Node-RED) :
```bash
sudo dietpi-software
```
Et avons sélectionné l’option ”search software” pour rechercher les logiciels MariaDB, Mosquitto et Node-RED, et les avons ensuite sélectionnés pour les installer :
Sélectionnez les logiciels MariaDB, Mosquitto et Node-RED dans l'interface de DietPi-Software et installez-les.
<img src="./Images/software.png" width="500" alt=" Interface de Dietpi-Software">
Pour configurer le serveur MQTT, nous avons modifié le fichier ”/etc/mosquitto/mosquitto.conf” pour supprimer tout son contenu et le remplacer par :
#### Configuration de Mosquitto
Modifiez le fichier "/etc/mosquitto/mosquitto.conf" pour configurer Mosquitto. Remplacez tout le contenu par les lignes suivantes :
```Bash
allow_anonymous false
@ -138,9 +155,19 @@ password_file /etc/ mosquitto /passwd
listener 1883
```
Nous avons ensuite ajouté un utilisateur en utilisant la commande ”sudo mosquitto_passwd
-c /etc/mosquitto/passwd patate” et avons redémarré le service MQTT avec ”sudo systemctl restart mosquitto”. Si jamais un utilisateur a été créer par erreur et que vous voulez
le supprimer, par exemple l’utilisateur ”username” il suffit d’exécuter la commande suivante : ”sudo mosquitto_passwd -d /etc/mosquitto/passwd username”.
Créez un utilisateur en utilisant la commande suivante :
```bash
sudo mosquitto_passwd -c /etc/mosquitto/passwd patate
```
Redémarrez le service Mosquitto avec la commande :
```bash
sudo systemctl restart mosquitto
```
Afin de configurer la base de données MariaDB, nous avons utilisé la commande permettant
de configurer l’utilisateur root et d’assurer la sécurité de la base de données :
@ -149,51 +176,47 @@ de configurer l’utilisateur root et d’assurer la sécurité de la base de do
sudo mysql_secure_installation
```
Pour se connecter à la base de données, nous avons en utilisé la commande ”mysql -u root
-p” puis avons ajouté l’utilisateur ”patate” en utilisant la commande afin de lui donner tous
les privilèges :
#### Configuration de MariaDB
```Bash
GRANT ALL PRIVILEGES ON . TO 'patate '@'localhost ' IDENTIFIED BY 'patate ';
Utilisez la commande suivante pour configurer l'utilisateur root et sécuriser la base de données MariaDB :
```bash
sudo mysql_secure_installation
```
Nous avons ensuite utilisé la commande ”FLUSH PRIVILEGES” pour prendre en compte les
nouveaux privilèges.
Connectez-vous à la base de données en utilisant la commande "mysql -u root -p" et ajoutez l'utilisateur "patate" avec tous les privilèges :
```bash
GRANT ALL PRIVILEGES ON *.* TO 'patate'@'localhost' IDENTIFIED BY 'patate';
```
Exécutez la commande "FLUSH PRIVILEGES" pour prendre en compte les nouveaux privilèges.
#### Configuration Node-RED
Pour configurer Node-RED, nous avons dans un premier temps utilisé la commande
”sudo systemctl enable nodered.service” afin d’activer le service Node-RED au démarrage.
À la suite de son installation, Node-RED était disponible à l’adresse IP de notre Raspberry
Pour configurer Node-RED, effectuez les étapes suivantes :
PI sur le port 1880. Concernant Node-RED, c’est un environnement de programmation visuel open-source basé sur Node.js qui permet de créer des flux de données et des applications IoT en utilisant des blocs graphiques. Il facilite la création de protocoles de communication, la manipulation de données et la création d’interfaces utilisateur en utilisant des nœuds prédéfinis ou personnalisés. Il est souvent utilisé pour connecter des périphériques IoT, des services en nuage et des applications web. Il est également possible d’ajouter des
fonctionnalités supplémentaires en utilisant des modules additionnels.
1. Activez le service Node-RED au démarrage en utilisant la commande suivante :
Pour ajouter des fonctionnalités supplémentaires à Node-RED, nous avons installé les modules node-red-dashboard et node-red-node-mysql en utilisant le gestionnaire de paquets
de Node-RED. Pour installer les modules Node-RED Dashboard et Node-RED Node-MySQL,
nous avons utilisé les commandes suivantes dans le terminal de notre Raspberry PI :
```Bash
cd /mnt/ dietpi_userdata /node -red/
npm install node -red - dashboard
npm install node -red -node -mysql
```bash
sudo systemctl enable nodered.service
```
2. Ouvrez un navigateur Web et accédez à l'adresse IP de votre Raspberry Pi sur le port 1880 pour utiliser l'interface Node-RED.
La première commande permet de se rendre dans le répertoire de Node-RED, et la seconde
et la troisième commandes permettent respectivement d’installer les modules Node-RED
Dashboard et Node-RED Node-MySQL. Une fois les modules installés, ils deviennent disponibles dans les palettes de nœuds de Node-RED et peuvent être utilisés pour créer des
tableaux de bord et des requêtes SQL directement depuis Node-RED. Le module node-red-
dashboard a été utilisé pour créer des tableaux de bord pour afficher les données des capteurs en temps réel. Le module node-red-node-mysql a été utilisé pour stocker les données
des capteurs dans une base de données MySQL sur le Raspberry PI. Ces modules ont été
installés en utilisant les commandes npm depuis le terminal.
#### Installation de modules complémentaires
En utilisant ces modules, nous avons pu créer des flux de données pour collecter les données
des capteurs, les stocker dans une base de données MySQL et les afficher sur des tableaux
de bord en utilisant Node-RED. Cela nous a permis de visualiser les données des capteurs
en temps réel et de stocker les données pour une analyse ultérieure.
Pour vous donner une idée de notre flux final sur Node-RED, voici une image de notre flow
final :
Pour ajouter des fonctionnalités supplémentaires à Node-RED, installez les modules Node-RED Dashboard et Node-RED Node-MySQL en utilisant les commandes suivantes :
```bash
cd /mnt/dietpi_userdata/node-red/
npm install node-red-dashboard
npm install node-red-node-mysql
```
Ces commandes vous permettront d'installer les modules nécessaires et de les utiliser dans Node-RED pour créer des tableaux de bord et effectuer des requêtes SQL.
Pour vous donner une idée du flux final sur Node-RED, voici une image :
<img src="./Images/flow-nodered.png" width="500">
@ -201,77 +224,44 @@ final :
<img src="./Images/web-1.png" width="250"> <img src="./Images/web-2.png" width="250">
#### Connexion au réseau de la box
Pour connecter le Raspberry Pi au réseau de la box "PT4ObjConnect", utilisez la commande suivante :
Une fois tous les services installés et configurés, nous avons connecté le Raspberry PI au
réseau de la box ”PT4ObjConnect” en utilisant la commande
```Bash
sudo dietpi-config
```
Et en spécifiant le mot de passe ”Admin2022”. Pour cela utiliser la commande
```Bash
```bash
sudo dietpi-config
```
Puis aller dans ”Network Options” :
<img src="./Images/dietpi-config.png" width="500">
Ensuite choisir l’option :
```Bash
WiFi : Available | [On] | Connected
```
Puis mettre l’adresse IP en DHCP avec l’option ”Change mode” afin que le RPI se connecte
au réseau automatiquement.
Sélectionnez "Network Options" et choisissez l'option "WiFi: Available | [On] | Connected". Modifiez le mode pour utiliser le DHCP et connectez-vous au réseau en spécifiant le mot de passe "Admin2022".
### Programmation des ESP32
Nous avions à notre disposition deux ESP32, l’un faisant tourner des programmes en Micropython à l’aide de l’IDE Thonny et l’autre faisant tourner des programmes en C à l’aide
de l’IDE Arduino.
Dans le cadre de ce projet, nous disposions de deux modules ESP32. L'un était programmé en Micropython à l'aide de l'IDE Thonny, tandis que l'autre était programmé en langage C à l'aide de l'IDE Arduino.
L’image ci-dessous montre les différents pins des deux ESP32 utilisés dans ce projet. Il est
important de noter que certains des pins indiqués sur cette image ne correspondent pas exactement à leur emplacement réel sur le module ESP32 utilisé dans ce projet. Cependant, cette image fournit une vue d’ensemble des fonctions des différents pins et permet
de comprendre comment ils ont été utilisés dans notre projet.
L'image ci-dessous présente les différents broches (pins) des deux modules ESP32 utilisés dans ce projet. Il est important de noter que certains des broches indiquées sur cette image peuvent ne pas correspondre exactement à leur emplacement réel sur le module ESP32 utilisé dans notre projet. Cependant, cette image offre une vue d'ensemble des fonctions des différentes broches et permet de comprendre comment elles ont été utilisées dans notre projet.
<img src="./Images/shema-esp32.jpg" width="500">
#### ESP32 Micropython
Sur l’ESP32 sous Micropython, nous avons utilisé les capteurs BME680, Oled, Servo
FS90R ainsi qu’une LED. Nous avons utilisé l’IDE Thonny pour écrire et téléverser les
codes sur l’ESP32. Pour configurer Thonny afin d’utiliser MicroPython sur l’ESP32, nous
avons suivi les étapes suivantes :
Sur l'ESP32 sous Micropython, nous avons utilisé les capteurs BME680, Oled, Servo FS90R ainsi qu'une LED. Nous avons utilisé l'IDE Thonny pour écrire et téléverser les codes sur l'ESP32. Voici les étapes que nous avons suivies pour configurer Thonny afin d'utiliser MicroPython sur l'ESP32 :
- Aller dans le menu Outils > Options > Interpréteur
- Sélectionner MicroPython (ESP32)
1. Aller dans le menu Outils > Options > Interpréteur
2. Sélectionner MicroPython (ESP32)
Avant de pouvoir téléverser nos codes sur l’ESP32, il a fallu installer le firmware. Pour ce
faire, nous avons utilisé les étapes suivantes :
Avant de pouvoir téléverser nos codes sur l'ESP32, nous devions installer le firmware. Voici les étapes que nous avons suivies :
- Sélectionner le port série connecté à l’ESP32
- Sélectionner le firmware approprié (dans notre cas, esp32-idf3-20191220-v1.12.bin)
- Cliquer sur installer pour téléverser le firmware sur l’ESP32
1. Sélectionner le port série connecté à l'ESP32
2. Sélectionner le firmware approprié (dans notre cas, esp32-idf3-20191220-v1.12.bin)
3. Cliquer sur "Installer" pour téléverser le firmware sur l'ESP32
Une fois ces étapes effectuées, nous étions prêts à écrire et à téléverser notre code sur
l’ESP32.
Une fois ces étapes effectuées, nous étions prêts à écrire et à téléverser notre code sur l'ESP32.
L’image ci-dessous est un schéma qui montre comment les différents composants utilisés
dans le projet ont été connectés à l’ESP32 ([fichier .fzz](fritzing/micropython.fzz)). On peut voir sur l’image comment les broches de l’ESP32 sont connectées aux broches des différents capteurs pour établir les communications I2C. Cette image donne une vue d’ensemble visuelle de la configuration des différents composants.
Le schéma ci-dessous montre comment les différents composants utilisés dans le projet ont été connectés à l'ESP32. Vous pouvez consulter le fichier .fzz pour obtenir le schéma complet ([fichier .fzz](fritzing/micropython.fzz)). Cette image offre une vue d'ensemble visuelle de la configuration des différents composants.
<img src="./Images/micropython.png" width="500">
Le tableau suivant montre les connections des différents capteurs (BME280, LED, OLED
et Servo FS90R) sur l’ESP32. Les broches GND et 3.3 V sont connectées respectivement
aux broches GND et VCC des capteurs. Les broches SCL et SDA (GPIO22 et GPIO21) sont
connectées respectivement aux broches SCL et SDA des capteurs pour la communication
I2C. La broche GPIO14 est connectée à l’anode (+) de la LED. La broche VIN (5V) est
connectée à la source d’alimentation. La broche RX2 (GPIO16) est connectée entre S et
G pour le servo moteur.
Le tableau suivant présente les connexions des différents capteurs (BME280, LED, OLED et Servo FS90R) sur l'ESP32. Les broches GND et 3.3V sont connectées respectivement aux broches GND et VCC des capteurs. Les broches SCL et SDA (GPIO22 et GPIO21) sont connectées respectivement aux broches SCL et SDA des capteurs pour la communication I2C. La broche GPIO14 est connectée à l'anode (+) de la LED. La broche VIN (5V) est connectée à la source d'alimentation. La broche RX2 (GPIO16) est connectée entre S et G pour le servo moteur.
| ESP32 | BME680 | LED | Oled | Servo FS90R |
|--------------|--------|-------------|-------------|-------------|
@ -283,59 +273,50 @@ G pour le servo moteur.
| VIN (5V) | X | X | X | entre S et G |
| RX2 (GPIO16) | X | X | X | S |
Codes utilisés pour programmer l’ESP32 en utilisant Thonny (MicroPython) :
Les codes suivants ont été utilisés pour programmer l'ESP32 en utilisant Thonny (MicroPython) :
Boot : [boot.py](ESP-codes/MicroPython/boot.py) Ce fichier est responsable de l'initialisation et de la configuration initiale de l'ESP32 au démarrage.
- Boot : [boot.py](ESP-codes/MicroPython/boot.py) Ce fichier est responsable de l'initialisation et de la configuration initiale de l'ESP32 au démarrage.
Librairies :
- [bme680.py](ESP-codes/MicroPython/bme680.py) Cette bibliothèque contient les fonctions et les classes nécessaires pour interagir avec le capteur BME680.
- [ssd1306.py](ESP-codes/MicroPython/ssd1306.py) Cette bibliothèque contient les fonctions et les classes nécessaires pour interagir avec l'écran OLED.
- Bibliothèques :
- [bme680.py](ESP-codes/MicroPython/bme680.py) Cette bibliothèque contient les fonctions et les classes nécessaires pour interagir avec le capteur BME680.
- [ssd1306.py](ESP-codes/MicroPython/ssd1306.py) Cette bibliothèque contient les fonctions et les classes nécessaires pour interagir avec l'écran OLED.
Connection WIFI :
- [wifi.py](ESP-codes/MicroPython/wifi.py) Ce fichier gère la connexion à un réseau WiFi en configurant les paramètres de connexion.
- [ssid_connect.py](ESP-codes/MicroPython/ssid_connect.py) Ce fichier contient les identifiants (SSID et mot de passe) du réseau WiFi auquel l'ESP32 doit se connecter.
- Connexion WIFI :
- [wifi.py](ESP-codes/MicroPython/wifi.py) Ce fichier gère la connexion à un réseau WiFi en configurant les paramètres de connexion.
- [ssid_connect.py](ESP-codes/MicroPython/ssid_connect.py) Ce fichier contient les identifiants (SSID et mot de passe) du réseau WiFi auquel l'ESP32 doit se connecter.
Main : [main.py](ESP-codes/MicroPython/main.py) Ce fichier contient le code principal du programme, qui coordonne les différentes fonctionnalités et le comportement de l'ESP32.
- Main : [main.py](ESP-codes/MicroPython/main.py) Ce fichier contient le code principal du programme, qui coordonne les différentes fonctionnalités et le comportement de l'ESP32.
Les librairies utilisées incluent ”Pin, SoftI2C, time, bme680, ssd1306, machine, network, umqtt.robust, sys” qui ont été utilisées pour gérer les capteurs, l’affichage, la
communication réseau et la transmission de données via MQTT.
Les bibliothèques utilisées incluent "Pin, SoftI2C, time, bme680, ssd1306, machine, network, umqtt.robust, sys" qui ont été utilisées pour gérer les capteurs, l'affichage, la communication réseau et la transmission de données via MQTT.
#### ESP32 en C
Sur l’ESP32 fonctionnant que nous avons configuré sur l’IDE d’Arduino, nous avons utilisé
l’écran LCD qui se branche en série. Concernant la configuration de l’IDE d’Arduino, nous
avons tout d’abord ajouté la prise en charge des cartes ESP32 sur Arduino. Pour cela, il
faut se rendre dans les préférences du logiciel (Fichiers > Préférences) et dans la partie
URL de gestionnaire des cartes supplémentaires, il faut ajouter l’URL qui correspond au
gestionnaire de carte ESP32 « https ://dl.espressif.com/dl/package_esp32_index.json ».
Sur l'ESP32 que nous avons configuré avec l'IDE Arduino, nous avons utilisé un écran LCD qui se connecte en série. Pour configurer l'IDE Arduino pour prendre en charge les cartes ESP32, voici les étapes que nous avons suivies :
1. Allez dans les préférences du logiciel (Fichiers > Préférences).
2. Dans la partie "URL de gestionnaire des cartes supplémentaires", ajoutez l'URL suivante correspondant au gestionnaire de carte ESP32 : "https://dl.espressif.com/dl/package_esp32_index.json".
<img src="./Images/arduino-ide.png" width="500" alt="Ajout de l’URL correspondant au gestionnaire de carte ESP32">
Ensuite, nous avons ajouté la libraire de l’ESP32 dans le gestionnaire de carte, pour cela
aller dans (Outils > Cartes > Gestionnaire de carte). Puis rechercher et installer le gestionnaire de carte correspondant à ESP32.
Ensuite, nous avons ajouté la bibliothèque ESP32 dans le gestionnaire de cartes :
1. Allez dans Outils > Cartes > Gestionnaire de cartes.
2. Recherchez et installez le gestionnaire de cartes correspondant à ESP32.
<img src="./Images/arduino-ide-esp32.png" width="500" alt="Ajout de l’ESP32 dans le gestionnaire de carte">
Une fois l’installation terminée, les cartes ESP32 sont disponibles dans le gestionnaire de
carte. Il reste donc à choisir la bonne carte correspondante à notre ESP32. Dans notre cas,
nous avons une WEMOS D1 MINI ESP32.
Une fois l'installation terminée, les cartes ESP32 sont disponibles dans le gestionnaire de cartes. Choisissez la carte correspondant à votre ESP32. Dans notre cas, nous avons utilisé une WEMOS D1 MINI ESP32.
L’image ci-dessous est un schéma qui montre comment l’écran LCD utilisés dans le projet
a été connecté à l’ESP32. On peut voir sur l’image comment les broches de l’ESP32 sont
connectées aux broches de l’écran pour établir une communication en série.
Le schéma ci-dessous montre comment l'écran LCD utilisé dans le projet est connecté à l'ESP32. Il montre comment les broches de l'ESP32 sont connectées aux broches de l'écran pour établir une communication série.
<img src="./Images/Esp32_2.png" width="500">
Concernant le branchage, nous avons utilisé une résistance afin de calibrer le contraste de
l’écran LCD, ce qui permet de rendre le texte s’affichant sur l’écran visible. L’affichage sur
écran LCD nécessite un voltage de 5 volts sur le PIN VDD qui est connecté au PIN VIN de
l’ESP32. Enfin, les différents PIN de l’écran LCD sont branchés à l’ESP32 selon le tableau
suivant :
Pour le câblage, nous avons utilisé une résistance pour calibrer le contraste de l'écran LCD, ce qui rend le texte affiché sur l'écran visible. L'écran LCD nécessite une tension de 5 volts sur la broche VDD, qui est connectée à la broche VIN de l'ESP32. Enfin, les différentes broches de l'écran LCD sont connectées à l'ESP32 selon le tableau suivant :
| ESP32 | Ecran LCD |
|--------------|-----------|
| GND | VSS |
| 5V(VIN) | VDD |
| 5V (VIN) | VDD |
| 4k7Ohm | V0 |
| D19 | RS |
| 4k7Ohm/GND | RW |
@ -347,12 +328,12 @@ suivant :
| 5V (VIN) | A |
| GND | K |
Le code utilisé pour programmer l'ESP32 en utilisant l'IDE d'Arduino se trouve dans le fichier : [main.ino](ESP-codes/C/main.ino)
Le code utilisé pour programmer l'ESP32 en utilisant l'IDE Arduino se trouve dans le fichier : [main.ino](ESP-codes/C/main.ino)
Pour faciliter la communication MQTT, la librairie PubSubClient a été utilisée. Elle permet à l'ESP32 d'établir une connexion avec un broker MQTT et de publier les données environnementales capturées.
Pour faciliter la communication MQTT, la bibliothèque PubSubClient a été utilisée. Elle permet à l'ESP32 d'établir une connexion avec un broker MQTT et de publier les données environnementales capturées.
De plus, la librairie LiquidCrystal a été utilisée pour faciliter l'utilisation d'un écran LCD. Cette librairie permet d'afficher les données capturées sur l'écran LCD connecté à l'ESP32, offrant ainsi une interface visuelle pour les utilisateurs.
En utilisant l'IDE d'Arduino et les librairies PubSubClient et LiquidCrystal, le code permet une configuration complète de l'ESP32 pour capturer les données environnementales, les publier via MQTT et les afficher sur un écran LCD.
De plus, la bibliothèque LiquidCrystal a été utilisée pour faciliter l'utilisation de l'écran LCD. Cette bibliothèque permet d'afficher les données capturées sur l'écran LCD connecté à l'ESP32, offrant ainsi une interface visuelle pour les utilisateurs.
En utilisant l'IDE Arduino et les bibliothèques PubSubClient et LiquidCrystal, le code permet une configuration complète de l'ESP32 pour capturer les données environnementales,
les publier via MQTT et les afficher sur un écran LCD.