Chapitre 2 :

Conception de Matériaux et Composants pour

l'Automatisation et la Sécurité.
 I. Introduction
Le choix des matériaux est une tâche fondamentale et très complexe, et pour cela nous
avons parlé dans ce chapitre à propos des matériaux utilisés dans la voiture électrique,

1- Architecture matérielle
I. Vue global:

J’avais un robot électrique, semblable à une voiture, qui est capable de se rendre
dans un parking intelligent. Chacun de ces éléments est équipé de composants de
fabrication spécifiques
II.Matériaux et composants de robot : 1-

Les Moteur :

On alimente quatre moteurs le chasés

Figure 1: les moteurs.

Un moteur 4.5V est un type de moteur électrique qui fonctionne avec une tension nominale
de 4,5volts, Le chiffre 200 rpm indique la vitesse de rotation du moteur, mesurée en tours par
minute. Dans ce cas, le moteur tourne à 200 tours par minute, ce qui peut être ajusté en fonction
des besoins spécifiques de l’application.
 Figure 2: Moteur DC

2-Capteurs ultra-son :

Le capteur ultrason est un composant essentiel utilisé dans de nombreux projets de robotique pour la
détection d'obstacles et la mesure de distances. Il utilise des ondes sonores à haute fréquence pour détermi-
ner la distance entre lui-même et un objet en mesurant le temps qu'il faut aux ondes sonores pour être
réfléchies et revenir au capteur. Ce capteur est largement utilisé pour la navigation autonome des robots, la
création de systèmes d'évitement d'obstacles, et bien d'autres applications nécessitant une mesure précise
de la distance. Son utilisation est répandue en raison de sa fiabilité, de sa facilité d'utilisation et de son faible
coût

Figure 3: Capteurs ultra-son.

Dans notre projet, nous avons utilisé le capteur ultrason pour permettre à notre robot de détecter les obs-
tacles environnants et d'ajuster son mouvement en conséquence. Le capteur ultrason émet des ondes sonores
à haute fréquence et mesure le temps nécessaire à leur retour après avoir été réfléchies par un objet. Cette
information nous permet de calculer la distance entre le 40 robot et l'obstacle le plus proche. En intégrant
cette fonctionnalité, notre robot . Bien sûr, voici une version plus détaillée :
Grâce à ses capteurs sophistiqués, le système est capable de détecter les barrières présentes dans le parking.
Cette fonctionnalité permet au robot de réagir de manière autonome et sécurisée en s'arrêtant automatique-
ment dès qu'il détecte la présence d'une barrière, contribuant ainsi à prévenir les collisions et assurant un
fonctionnement efficace et sécurisé dans l'environnement du parking.
 Figure 4: fonction de capteur ultra-son.

Carte de puissance l298n :

La carte de puissance L298N est un module électronique utilisé pour contrôler les moteurs à
courant continu dans divers appareils, tels que les robots, les voitures télécommandées et les
imprimantes 3D. Il dispose de deux ponts-H intégrés, ce qui permet de contrôler 4 moteurs
indépendamment. La vitesse des moteurs peut être ajustée grâce à des signaux de commande
PWM. La carte offre également une protection contre la surchauffe et les surintensités pour éviter
les dommages. Elle est compatible avec une gamme de tensions d'alimentation et peut être utilisée
avec des circuits logiques TTL et CMOS. En bref, la carte de puissance L298N est un composant
polyvalent pour le contrôle précis des moteurs à courant continu.

Figure 5: Carte de puissance l298n.

La carte ESP 32 :

La carte ESP32 est conçue pour offrir une plateforme de développement complète et conviviale
pour une variété d'applications, allant des projets amateurs aux produits commerciaux. Voici
quelques points clés à prendre en compte lors de l'introduction à cette carte :
 Microcontrôleur ESP32 : Au cœur de la carte ESP32 se trouve le microcontrôleur ESP32,
un puissant système sur puce (SoC) développé par Expressif System. Ce microcontrôleur
intègre un double cœur processeur Xtensa 32 bits, une connectivité Wi-Fi et Bluetooth,
ainsi que de nombreuses interfaces pour connecter une gamme de périphériques.
  Connectivité sans fil : La carte ESP32 intègre la connectivité sans fil Wi-Fi et Bluetooth,
ce qui permet aux développeurs de créer des dispositifs IoT et des applications qui
peuvent se connecter à des réseaux locaux ou à des appareils mobiles.
 Facilité de programmation : La carte ESP32 peut être programmée à l'aide de plusieurs
environnements de développement, y compris l'IDE Arduino, ESP-IDF (Expressif IoT
Développement Framework) et d'autres outils de développement tiers. Cela permet aux
développeurs de choisir l'environnement qui convient le mieux à leurs besoins et à leur
niveau de compétence.

Figure 6 : Fonctionne de la carte Esp 32

La batterie 18650 :

Les batteries rechargeables 3,7V offrent une capacité énergétique de 18650 mWh, ce qui les rend
idéales pour alimenter une variété d'appareils électroniques. Avec leur tension 37 nominale de 3,7 volts,
ces batteries fournissent une puissance stable et fiable pour une utilisation prolongée. Grâce à leur
conception rechargeable, elles peuvent être rechargées et réutilisées à plusieurs reprises, ce qui les rend
économiques et écologiques. Leur capacité élevée de 18650 mWh leur permet de maintenir une autonomie
prolongée, ce qui en fait un choix idéal pour notre véhicule.
 Figure 7: La batterie.

Dans le contexte de notre robot, les batteries rechargeables 3,7V sont comme source d'alimentation
principale. Leur tension nominale de 3,7 volts les rend compatibles avec nos composants, y compris la carte
ESP32 et les capteurs utilisés dans ce robot. Avec leur capacité élevée de 18650 mWh, ces batteries offrent
une autonomie prolongée, ce qui est crucial pour assurer le fonctionnement continu du robot

III. Les composants de parking:

IV. Le cadre de parking :

Figure 8: le cadre de parking.

Dans cette partie , nous allons détailler le cadre physique de ce parking, qui est essentiel pour comprendre
son fonctionnement.
Le parking autonome est divisé en trois sections égales, chaque section ayant une largeur de 30 cm. La
largeur totale du parking est de 1,60 mètres (160 cm)ainsi que sa longueur est de 1,70 mètres. Cette division
en trois parties permet une optimisation de l'espace et facilite la gestion du flux de véhicules.
La première entrée du parking a une largeur de 30 cm, ce qui est suffisant pour permettre à un véhicule de
taille standard de s'engager en toute sécurité dans le parking. Cette entrée est conçue pour faciliter l'accès
des véhicules au système autonome de stationnement.
En résumé, le cadre de ce parking autonome robotisé est caractérisé par sa division en trois parties égales,
chaque partie ayant une largeur de 30 cm, et par une entrée initiale de 30 cm de large.
Ce parking est aussi entouré par un entourage jaune qui mesure 7cm de sa largeur .
Ces dimensions ont été soigneusement conçues pour assurer un fonctionnement efficace et sécurisé du
système de stationnement autonome.

Capteur Infrarouge :

Le capteur d’évitement d’obstacles à capteur infrarouge IR est une solution peu coûteuse pour la
détection d’évitement pour la robotique, la voiture intelligente et d’autres utilisations
électroniques. Dans certains cas, ce capteur est utilisé en paire, avec un capteur placé avant et un
autre placé après une barrière ou un obstacle. Lorsque le robot ou la voiture approche de la barrière,
le premier capteur détecte sa présence et déclenche l'ouverture de la barrière. Une fois que le
véhicule a franchi la barrière, le second capteur détecte sa présence et déclenche l'arrêt du véhicule,
assurant ainsi un contrôle précis du mouvement et de la sécurité dans les applications de
stationnement ou de déplacement automatisé.

Figure 9: Capteur Infrarouge

A. Principe de fonctionnement:
L'émetteur infrarouge envoie un signal infrarouge qui, en cas de surface réfléchissante
(par exemple de couleur blanche), rebondit dans certaines directions, y compris celle du
récepteur infrarouge qui capte le signal détectant l'objet.

Figure 10: Fonctionnement du Capteur Infrarouge

Lorsque la surface est absorbante (par exemple de couleur noire), le signal IR n'est pas
réfléchi et l'objet ne peut pas être détecté par le capteur. Ce résultat se produirait mêmesi
l'objet est absent.

B. Caractéristiques Techniques:

 Voltage de fonctionnement : DC 3,3 V-5 V

 Intensité du courant >= 20 mA
 Température de fonctionnement : -10 °C à + 50 °C
 Plage de distance: 2-40 cm
 Interface IO : interface 3 fils (GND / Vcc / OUT)
 Signal de sortie: tension TTL.
 Mode d’hébergement : régulation de résistance multi-cercle
 Angle effectif: 35 °
 Taille: 41,7 * 16,7 mm
 Poids: 5g
V. Capteur HW-511 :
Le capteur HW-511 est spécifiquement conçu pour diverses applications, en particulier dans les
domaines de la surveillance et de l'automatisation. Il appartient à la catégorie des capteurs de
proximité ou de distance et est principalement utilisé pour détecter la présence ou l'absence d'objets
à des distances courtes.
Fonctionnant généralement grâce à la technologie infrarouge, ce capteur émet un faisceau
infrarouge et mesure le temps nécessaire pour que ce faisceau revienne après avoir été réfléchi par
un objet. Cette mesure permet ensuite de calculer la distance entre le capteur et l'objet cible.
Outre sa capacité à mesurer la distance, le capteur HW-511 est également utilisé pour détecter la
disponibilité des places de stationnement dans les parkings. En analysant les zones où le faisceau
infrarouge est intercepté, il peut déterminer si une place est occupée ou libre, facilitant ainsi la
gestion du stationnement et l'orientation des conducteurs vers les places disponibles.

Figure 11: Capteur HW-511

Chapitre 3 :

Réalisation
Introduction :

Dans le cadre de notre projet, le programme Arduino IDE a joué un rôle central. Cet outil de
développement intégré a été essentiel pour établir une connexion vitale entre la carte ESP32 du
robot et celle du parking. Grâce à la flexibilité et à la puissance de l'Arduino IDE, nous avons pu
concevoir et mettre en œuvre des programmes sur mesure, parfaitement adaptés aux exigences
spécifiques de notre projet.

Ce chapitre offre une plongée en profondeur dans les multiples programmes que nous avons
développés et déployés pour atteindre nos objectifs. Chaque aspect de ces programmes sera
minutieusement examiné, avec des explications détaillées sur leur fonctionnement et leur
contribution à la réalisation globale du projet. En mettant en évidence les choix de conception et
les défis rencontrés, nous fournirons une vue d'ensemble complète du processus de développement
logiciel qui a guidé notre démarche. Ensuite, nous procéderons à une analyse des enseignements
tirés de cette expérience, tout en envisageant les perspectives d'amélioration et les pistes
d'exploration futures.

Définition du programme Arduino IDE :

L'Arduino IDE (Integrated Development Environment) est un logiciel essentiel pour de nombreux
projets de fin d'études (PFE) dans le domaine de l'ingénierie électronique et de l'informatique
embarquée. Il fournit une plateforme de développement conviviale pour écrire, téléverser et tester
le code destiné aux microcontrôleurs Arduino et à d'autres cartes compatibles. Cette introduction
met en évidence l'importance de l'IDE Arduino pour les projets de fin d'études.

Importance de l'Arduino IDE pour les PFE :

 Facilité d'utilisation : L'IDE Arduino offre une interface utilisateur intuitive, adaptée aux
débutants comme aux utilisateurs expérimentés. Cela facilite la prise en main et
l'apprentissage pour les étudiants qui travaillent sur leur projet de fin d'études.

 Large compatibilité matérielle : Avec la prise en charge de nombreuses cartes Arduino et

microcontrôleurs compatibles, l'IDE Arduino offre aux étudiants une flexibilité pour
choisir le matériel le mieux adapté à leurs besoins de projet.

 Bibliothèques et exemples intégrés : Parmi ces bibliothèques , on trouve : <esp_now.h>

<Wifi. H> <ESP32Servo.h>
 L'IDE Arduino est livrée avec une collection de bibliothèques et d'exemples prédéfinis qui
couvrent un large éventail de fonctionnalités. Cela permet aux étudiants de gagner du temps
en utilisant des codes préexistants et en les adaptant à leurs besoins spécifiques. Débogage
simplifié : L'IDE Arduino offre des outils de débogage intégrés, tels que la console série,
qui permettent aux étudiants de surveiller les données en temps réel et de diagnostiquer les
problèmes éventuels dans leur code.
 Flexibilité de programmation : Les étudiants peuvent utiliser différents langages de
programmation pris en charge par l'IDE Arduino, notamment C/C++ et des variantes telles
que Wiring et Processing. Cela leur permet d'adapter leur approche de programmation en
fonction de leurs compétences et de leurs besoins spécifiques.

 Prototypage rapide : Grâce à sa simplicité d'utilisation et à sa rapidité de mise en œuvre,

l'IDE Arduino permet aux étudiants de réaliser rapidement des prototypes fonctionnels
pour leurs projets de fin d'études, ce qui facilite l'itération et l'amélioration du concept. 

D2FINITION DU ESP NOW :

ESP32 NOW est un protocole de communication sans fil propriétaire développé par Espressif
Systems, conçu spécifiquement pour les microcontrôleurs de la famille ESP32. Il permet la
communication directe entre les modules ESP32 sans passer par un routeur WiFi ou une
connexion Bluetooth.

Contrairement au WiFi classique, ESP32 NOW fonctionne en utilisant une topologie de réseau
en étoile simple, où un nœud maître communique avec plusieurs nœuds esclaves. Cela le rend
particulièrement adapté aux applications où plusieurs dispositifs ESP32 doivent échanger des
données de manière simple et efficace, comme dans les systèmes domotiques , les capteur
distribués ou les réseaux de capteurs IoT.

Les avantages clés d'ESP32 NOW incluent une latence réduite, une consommation d'énergie plus
faible par rapport aux connexions WiFi traditionnelles et une configuration simplifiée.
Cependant, comme il s'agit d'un protocole propriétaire, son utilisation limite l'interopérabilité
avec d'autres dispositifs et technologies de communication.
 Le code ESP32 utilisé:
Nous avons utilisé ce code ESP32Now pour établir une connexion entre les deux cartes ESP32.
Plus précisément, la carte ESP32 du robot a été configurée en tant que “Slave”, tandis que celle
du parking a été désignée comme “Master” Ce choix de configuration a permis une
communication efficace et bidirectionnelle entre les deux dispositifs.

Nous allons diviser le code en deux parties distinctes : l'une dédiée à la carte ESP32 maître, que
nous nommerons ESP code Master, et l'autre dédiée à la carte ESP32 Slave. Cette segmentation
nous permettra de mieux organiser notre développement et de nous concentrer sur les
fonctionnalités spécifiques de chaque carte.

Figure 12: ESP32 NOW

 a. ESP32 Master :
b. Organigramme du nœud maitre (Parking) :

Debut
Inclure bibliothèques :
esp_now.h - WiFi.h - ESP32Servo.h

Initialisation :
Broches Capteurs et servomoteur

Mode Wifi STA

Initialisation ESPNow


Enregistrement de la fonction pour obtenir l’état

des pacques transmis du maitre vers esclave :
OnDataSent(macadresse, status)

Lire l’état des capteurs du parking

ScanForSlave()

SlaveCnt > 0 & P_Entree

Oui

Parking plein ?
SlaveCnt > 0 & P_Presence Non
manageSlave()
Oui
Fermer Barrière sendData()

Ouvrir Barrière

1) CODE ESP32 master :

Le code ESP32 Master assume la responsabilité de coordonner les opérations de la barrière de

stationnement. Il intègre un capteur infrarouge qui scrute l'environnement pour détecter l'approche
du robot. Une fois ce dernier détecté, la barrière se déclenche automatiquement, s'ouvrant
gracieusement pour permettre au robot d'entrer dans l'enceinte de stationnement.

Lorsque le robot a pénétré dans la zone de stationnement, un autre capteur infrarouge, positionné
stratégiquement, repère sa présence et signale à la carte ESP32 Master de refermer la barrière,
assurant ainsi la sécurité et la confidentialité de la zone.
Mais le rôle de la carte ESP32 Master ne s'arrête pas là. Elle établit également une connexion avec
la carte ESP32 esclave pour échanger des informations cruciales sur la disponibilité des
 emplacements de stationnement. Cette connexion permet de déterminer précisément quelles places
sont libres parmi les trois capteurs de stationnement.
En cas de saturation, où les trois positions sont occupées, la barrière reste fermée, empêchant tout
autre véhicule d'entrer. Cette stratégie garantit un contrôle efficace de l'accès au stationnement,
optimisant ainsi son utilisation et minimisant les risques de congestion.

/**
ESPNOW - Basic communication - Master
Date: 26th September 2017
Author: Arvind Ravulavaru <https://github.com/arvindr21>
Purpose: ESPNow Communication between a Master ESP32 and multiple ESP32 Slaves
Description: This sketch consists of the code for the Master module.
Resources: (A bit outdated)
a. https://espressif.com/sites/default/files/documentation/esp-
now_user_guide_en.pdf
b. http://www.esploradores.com/practica-6-conexion-esp-now/

<< This Device Master >>

Flow: Master
Step 1 : ESPNow Init on Master and set it in STA mode
Step 2 : Start scanning for Slave ESP32 (we have added a prefix of `slave` to
the SSID of slave for an easy setup)
Step 3 : Once found, add Slave as peer
Step 4 : Register for send callback
Step 5 : Start Transmitting data from Master to Slave(s)

Flow: Slave
Step 1 : ESPNow Init on Slave
Step 2 : Update the SSID of Slave with a prefix of `slave`
Step 3 : Set Slave in AP mode
Step 4 : Register for receive callback and wait for data
Step 5 : Once data arrives, print it in the serial monitor

Note: Master and Slave have been defined to easily understand the setup.
Based on the ESPNOW API, there is no concept of Master and Slave.
Any devices can act as master or salve.

// Sample Serial log with 1 master & 2 slaves

Found 12 devices
1: Slave:24:0A:C4:81:CF:A4 [24:0A:C4:81:CF:A5] (-44)
3: Slave:30:AE:A4:02:6D:CC [30:AE:A4:02:6D:CD] (-55)
2 Slave(s) found, processing..
Processing: 24:A:C4:81:CF:A5 Status: Already Paired
Processing: 30:AE:A4:2:6D:CD Status: Already Paired
Sending: 9
 Send Status: Success
Last Packet Sent to: 24:0a:c4:81:cf:a5
Last Packet Send Status: Delivery Success
Send Status: Success
Last Packet Sent to: 30:ae:a4:02:6d:cd
Last Packet Send Status: Delivery Success

*/

#include <esp_now.h>
#include <WiFi.h>
#include <ESP32Servo.h>

Servo myservo; // create servo object to control a servo

const int Presence_P = 2; // Broche pour le capteur 1
const int Entree_P = 4; // Broche pour le capteur 2
int pos = 0; // variable to store the servo position
int servoPin = 18;
// Global copy of slave
#define NUMSLAVES 20
esp_now_peer_info_t slaves[NUMSLAVES] = {};
int SlaveCnt = 0;

#define CHANNEL 1
#define PRINTSCANRESULTS 0
const int P1 = 5; // Broche pour le capteur 1
const int P2 = 16; // Broche pour le capteur 2
const int P3 = 17; // Broche pour le capteur 1
const int P4 = 13; // Broche pour le capteur 2

typedef struct struct_message {

int a[3];
int Etat;
} struct_message;

// Create a structured object

struct_message myData;

// Init ESP Now with fallback

void InitESPNow() {
WiFi.disconnect();
if (esp_now_init() == ESP_OK) {
Serial.println("ESPNow Init Success");
}
else {
Serial.println("ESPNow Init Failed");
// Retry InitESPNow, add a counte and then restart?
// InitESPNow();
// or Simply Restart
 ESP.restart();
}
}

// Scan for slaves in AP mode

void ScanForSlave() {
int8_t scanResults = WiFi.scanNetworks();
//reset slaves
memset(slaves, 0, sizeof(slaves));
SlaveCnt = 0;
Serial.println("");
if (scanResults == 0) {
Serial.println("No WiFi devices in AP Mode found");
} else {
Serial.print("Found "); Serial.print(scanResults); Serial.println(" devices ");
for (int i = 0; i < scanResults; ++i) {
// Print SSID and RSSI for each device found
String SSID = WiFi.SSID(i);
int32_t RSSI = WiFi.RSSI(i);
String BSSIDstr = WiFi.BSSIDstr(i);

if (PRINTSCANRESULTS) {
Serial.print(i + 1); Serial.print(": "); Serial.print(SSID); Serial.print("
["); Serial.print(BSSIDstr); Serial.print("]");
Serial.print(" ("); Serial.print(RSSI); Serial.print(")");
Serial.println("");
}
delay(10);
// Check if the current device starts with `Slave`
if (SSID.indexOf("Slave") == 0) {
// SSID of interest
Serial.print(i + 1); Serial.print(": "); Serial.print(SSID); Serial.print("
["); Serial.print(BSSIDstr);
Serial.print("]"); Serial.print(" ("); Serial.print(RSSI);
Serial.print(")"); Serial.println("");
// Get BSSID => Mac Address of the Slave
int mac[6];

if ( 6 == sscanf(BSSIDstr.c_str(), "%x:%x:%x:%x:%x:%x", &mac[0], &mac[1],

&mac[2], &mac[3], &mac[4], &mac[5] ) ) {
for (int ii = 0; ii < 6; ++ii ) {
slaves[SlaveCnt].peer_addr[ii] = (uint8_t) mac[ii];
}
}
slaves[SlaveCnt].channel = CHANNEL; // pick a channel
slaves[SlaveCnt].encrypt = 0; // no encryption
SlaveCnt++;
}
}
 }

if (SlaveCnt > 0) {
Serial.print(SlaveCnt); Serial.println(" Slave(s) found, processing..");
} else {
Serial.println("No Slave Found, trying again.");
}

// clean up ram
WiFi.scanDelete();
}

// Check if the slave is already paired with the master.

// If not, pair the slave with master
void manageSlave() {
if (SlaveCnt > 0) {
for (int i = 0; i < SlaveCnt; i++) {
Serial.print("Processing: ");
for (int ii = 0; ii < 6; ++ii ) {
Serial.print((uint8_t) slaves[i].peer_addr[ii], HEX);
if (ii != 5) Serial.print(":");
}
Serial.print(" Status: ");
// check if the peer exists
bool exists = esp_now_is_peer_exist(slaves[i].peer_addr);
if (exists) {
// Slave already paired.
Serial.println("Already Paired");
} else {
// Slave not paired, attempt pair
esp_err_t addStatus = esp_now_add_peer(&slaves[i]);
if (addStatus == ESP_OK) {
// Pair success
Serial.println("Pair success");
} else if (addStatus == ESP_ERR_ESPNOW_NOT_INIT) {
// How did we get so far!!
Serial.println("ESPNOW Not Init");
} else if (addStatus == ESP_ERR_ESPNOW_ARG) {
Serial.println("Add Peer - Invalid Argument");
} else if (addStatus == ESP_ERR_ESPNOW_FULL) {
Serial.println("Peer list full");
} else if (addStatus == ESP_ERR_ESPNOW_NO_MEM) {
Serial.println("Out of memory");
} else if (addStatus == ESP_ERR_ESPNOW_EXIST) {
Serial.println("Peer Exists");
} else {
Serial.println("Not sure what happened");
}
delay(100);
 }
}
} else {
// No slave found to process
Serial.println("No Slave found to process");
}
}

// Define a data structure

//uint8_t data = 0;
// send data
void sendData() {
//data++;

for (int i = 0; i < SlaveCnt; i++) {

const uint8_t *peer_addr = slaves[i].peer_addr;
if (i == 0) { // print only for first slave
Serial.print("Sending: ");
Serial.println(myData.Etat);
}
esp_err_t result = esp_now_send(peer_addr,(uint8_t *) &myData, sizeof(myData));
Serial.print("Send Status: ");
if (result == ESP_OK) {
Serial.println("Success");
} else if (result == ESP_ERR_ESPNOW_NOT_INIT) {
// How did we get so far!!
Serial.println("ESPNOW not Init.");
} else if (result == ESP_ERR_ESPNOW_ARG) {
Serial.println("Invalid Argument");
} else if (result == ESP_ERR_ESPNOW_INTERNAL) {
Serial.println("Internal Error");
} else if (result == ESP_ERR_ESPNOW_NO_MEM) {
Serial.println("ESP_ERR_ESPNOW_NO_MEM");
} else if (result == ESP_ERR_ESPNOW_NOT_FOUND) {
Serial.println("Peer not found.");
} else {
Serial.println("Not sure what happened");
}
delay(100);
}
}

// callback when data is sent from Master to Slave

void OnDataSent(const uint8_t *mac_addr, esp_now_send_status_t status) {
char macStr[18];
snprintf(macStr, sizeof(macStr), "%02x:%02x:%02x:%02x:%02x:%02x",
 mac_addr[0], mac_addr[1], mac_addr[2], mac_addr[3], mac_addr[4],
mac_addr[5]);
Serial.print("Last Packet Sent to: "); Serial.println(macStr);
Serial.print("Last Packet Send Status: "); Serial.println(status ==
ESP_NOW_SEND_SUCCESS ? "Delivery Success" : "Delivery Fail");
}

void setup() {
Serial.begin(115200);
pinMode(Presence_P, INPUT);
pinMode(Entree_P, INPUT);
pinMode(P1, INPUT);
pinMode(P2, INPUT);
pinMode(P3, INPUT);
//pinMode(P4, INPUT);
//Set device in STA mode to begin with
WiFi.mode(WIFI_STA);
Serial.println("ESPNow/Multi-Slave/Master Example");
// This is the mac address of the Master in Station Mode
Serial.print("STA MAC: "); Serial.println(WiFi.macAddress());
// Init ESPNow with a fallback logic
InitESPNow();
// Once ESPNow is successfully Init, we will register for Send CB to
// get the status of Trasnmitted packet
esp_now_register_send_cb(OnDataSent);

myservo.attach(servoPin); // attaches the servo on pin 18 to the servo object

delay(100); // waits 15ms for the servo to reach the position
myservo.write(0); // tell servo to go to position in variable 'pos'
delay(100); // waits 15ms for the servo to reach the position
}

void loop() {
// In the loop we scan for slave
myData.a[0] = digitalRead(P1);
myData.a[1] = digitalRead(P2);
myData.a[2] = digitalRead(P3);

if ((myData.a[0]== 0) && (myData.a[1]==0) && (myData.a[2]==0))

{
myData.Etat = 1;
}
else
{
myData.Etat = 0;
}
 ScanForSlave();
// If Slave is found, it would be populate in `slave` variable
// We will check if `slave` is defined and then we proceed further
if (SlaveCnt > 0) { // check if slave channel is defined
// `slave` is defined
// Add slave as peer if it has not been added already
manageSlave();
// pair success or already paired
// Send data to device

sendData();
} else {
// No slave found to process
}
int P_Presence = digitalRead(Presence_P);
int P_Entree = digitalRead(Entree_P);

if ((P_Entree == 0) && (P_Presence == 1) && (myData.Etat==0) )

{
myservo.write(90); // tell servo to go to position in variable 'pos'
delay(15); // waits 15ms for the servo to reach the position
}
else if (P_Presence == 0)
{
myservo.write(0); // tell servo to go to position in variable 'pos'
delay(15); // waits 15ms for the servo to reach the position
}

// wait for 3seconds to run the logic again

//delay(500);
}
 c. ESP32 Slave :
d. Organigramme du nœud esclave (Voiture) :

Debut
Inclure bibliothèques :
esp_now.h - WiFi.h

Initialisation :
Broches Capteur ultrason et moteurs

Mode Wifi AP

Initialisation ESPNow


Lire la distance libre devant voiture

Ultrasonic_Ranging()

Non
Distance < 28

Avance Voiture Arrêt Voiture

delay(200)
Non
Connexion avec parking ?

OnDataRecv()

Parking plein ?
Non

P1 vide
Oui
P2 vide
MoveP1()
Oui
MoveP3() MoveP2()

2) CODE ESP SLAVE :

Dans le code ESP32 SLAVE, nous avons intégré un programme dédié au contrôle des
mouvements des roues du robot. À l'intérieur de l'unité robotique, un capteur à ultrasons est
déployé pour détecter les obstacles, notamment la barrière. Dès qu'un obstacle est détecté, le
robot interrompt ses déplacements de manière automatique.
Une fois que la barrière est opérationnelle et ouverte, le robot reprend son avancée pour atteindre
la zone de stationnement. Lorsqu'il se trouve à proximité de la barrière ouverte, le robot initie une
connexion avec les cartes esclaves et la carte ESP32 Master.
 La carte maître informe ensuite le robot de l'emplacement disponible où il peut se stationner. Cette
interaction permet une gestion efficace de l'espace de stationnement en guidant le robot vers une
place libre, tout en réduisant les risques de congestion et en optimisant l'utilisation des
emplacements disponibles.

#include <esp_now.h>
#include <WiFi.h>

#define CHANNEL 1
// Define a data structure
typedef struct struct_message {
int a[4];
int Etat;
int Com;
} struct_message;

// Create a structured object

struct_message myData;

// Motor A
int motor1Pin1 = 13; // 8
int motor1Pin2 = 27; // 6
int enable1Pin = 17;
// Motor A
int motor2Pin1 = 18; // 13
int motor2Pin2 = 2;
//int enable2Pin = 16;

int echoPin = 16; // ultrasonic module ECHO to D13

int trigPin = 4; // ultrasonic module TRIG to D12

int Park = 0;
int m = 0;
// Setting PWM properties
const int freq = 30000;
const int pwmChannel1 = 0;
//const int pwmChannel2 = 1;
const int resolution = 8;
int dutyCycle;

int Ultrasonic_Ranging() {
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
int distance = pulseIn(echoPin, HIGH); // reading the duration of high level
 distance = distance / 58; // Transform pulse time to distance
delay(50);
return distance;
}

// Init ESP Now with fallback

void InitESPNow() {
WiFi.disconnect();
if (esp_now_init() == ESP_OK) {
Serial.println("ESPNow Init Success");
}
else {
Serial.println("ESPNow Init Failed");
// Retry InitESPNow, add a counte and then restart?
// InitESPNow();
// or Simply Restart
ESP.restart();
}
}

// config AP SSID
void configDeviceAP() {
String Prefix = "Slave:";
String Mac = WiFi.macAddress();
String SSID = Prefix + Mac;
String Password = "123456789";
bool result = WiFi.softAP(SSID.c_str(), Password.c_str(), CHANNEL, 0);
if (!result) {
Serial.println("AP Config failed.");
} else {
Serial.println("AP Config Success. Broadcasting with AP: " + String(SSID));
}
}

// callback when data is recv from Master

void OnDataRecv(const uint8_t *mac_addr, const uint8_t *incomingData, int data_len)
{
char macStr[18];
memcpy(&myData, incomingData, sizeof(myData));
snprintf(macStr, sizeof(macStr), "%02x:%02x:%02x:%02x:%02x:%02x",
mac_addr[0], mac_addr[1], mac_addr[2], mac_addr[3], mac_addr[4],
mac_addr[5]);
Serial.print("Last Packet Recv from: "); Serial.println(macStr);
Serial.print("Last Packet Recv Data: ");
Serial.println(data_len);
Serial.print("Etat Position : ");
Serial.println(myData.a[0]);
Serial.println(myData.a[1]);
Serial.println(myData.a[2]);
 Serial.println(myData.a[3]);
Serial.print("Etat_Parking: ");
Serial.println(myData.Etat);
Serial.println();
Serial.println("");
}

void setup() {
// sets the pins as outputs:
pinMode(motor1Pin1, OUTPUT);
pinMode(motor1Pin2, OUTPUT);
pinMode(enable1Pin, OUTPUT);

pinMode(motor2Pin1, OUTPUT);
pinMode(motor2Pin2, OUTPUT);
//pinMode(enable2Pin, OUTPUT);

pinMode(trigPin, OUTPUT); // Sets the trigPin as an Output

pinMode(echoPin, INPUT); // Sets the echoPin as an Input
// configure LED PWM functionalitites
ledcSetup(pwmChannel1, freq, resolution);
//ledcSetup(pwmChannel2, freq, resolution);

// attach the channel to the GPIO to be controlled

ledcAttachPin(enable1Pin, pwmChannel1);
//ledcAttachPin(enable2Pin, pwmChannel2);

myData.Com = 0;
Serial.begin(115200);

// testing
Serial.print("Testing DC Motor...");
WiFi.mode(WIFI_AP);
// configure device AP mode
configDeviceAP();
// This is the mac address of the Slave in AP Mode
Serial.print("AP MAC: "); Serial.println(WiFi.softAPmacAddress());
// Init ESPNow with a fallback logic
InitESPNow();

Stop();
dutyCycle = 210;
ledcWrite(pwmChannel1, dutyCycle);
}

void loop()
{

int distance = Ultrasonic_Ranging();

delay(300);
Serial.print("distance=");
Serial.println(distance);

//dutyCycle = 150;
//ledcWrite(pwmChannel1, dutyCycle);
//ledcWrite(pwmChannel2, dutyCycle);
// Move the DC motor forward at maximum speed

if (distance < 28)

{ //assuming the front distance less than 30cm
Stop();
m = 1;
while((myData.Com == 0) && (m == 1))
{
esp_now_register_recv_cb(OnDataRecv);
}
Serial.print("myData.Com ="); Serial.print(myData.Com);
delay(1000);
if ((myData.a[0] == 1) && (myData.Com == 1))
{
moveP1();
m == 0;
myData.Com = 0;
Serial.println("Position 1");
}
else if ((myData.a[1] == 1) && (myData.Com == 1))
{
moveP2();
m == 0;
myData.Com = 0;
Serial.println("Position 2");
}
else if ((myData.a[3] == 1) && (myData.Com == 1))
{
moveP3();
m == 0;
myData.Com = 0;
Serial.println("Position 3");
}

}
else if (m==0)
{
Avant_N();
delay(100);
}
}

void move(int motor1State, int motor2State, int duration)

{
digitalWrite(motor1Pin1, motor1State);
digitalWrite(motor1Pin2, !motor1State);
digitalWrite(motor2Pin1, motor1State);
digitalWrite(motor2Pin2, !motor1State);
delay(duration);
Stop();
}

void Avant(int duration) {

move(HIGH, HIGH, duration);
}

void Arriere(int duration) {

move(LOW, LOW, duration);
}

void Right(int duration) {

move(LOW, HIGH, duration);
}

void Left(int duration) {

move(HIGH, LOW, duration);
}

void Stop()
{
digitalWrite(motor1Pin1, LOW);
digitalWrite(motor1Pin2, LOW);
digitalWrite(motor2Pin1, LOW);
digitalWrite(motor2Pin2, LOW);
}

void Avant_N()
{
digitalWrite(motor1Pin1, HIGH);
digitalWrite(motor1Pin2, LOW);
digitalWrite(motor2Pin1, HIGH);
digitalWrite(motor2Pin2, LOW);
}

void moveP1()
{
Avant(1500);
delay(12000);
 Avant(2400);
}

void moveP2()
{
Avant(1300);
delay(9000);
Right(1700);
delay(300);
Avant(1000);
delay(300);
Left(1400);
delay(300);
Avant(2100);
}

void moveP3()
{
Avant(1300);
delay(9000);
Right(1700);
delay(300);
Avant(1800);
delay(300);
Left(1400);
delay(300);
Avant(2100);
}

En conclusion, ce chapitre a présenté la mise en œuvre réussie de notre projet grâce à

l'utilisation des cartes ESP32 Master et esclave, ainsi que du protocole ESP-NOW. Nous avons
démontré comment ces composants ont permis une coordination efficace de l'ouverture de la
barrière en fonction de la détection du robot et de la disponibilité des places de stationnement.
Cette approche a abouti à la création d'un système de stationnement intelligent et automatisé,
améliorant l'efficacité et la sécurité de l'accès au stationnement. En envisageant des pistes
d'amélioration futures, nous sommes prêts à poursuivre le développement de notre solution pour
répondre aux besoins évolutifs de notre projet.