Réalisation du Système Embarqué

. Outils de Travaille
Pour développer le système embarqué de ce projet, nous avons utilisé comme outils matériels
un ordinateur portable, une voiture électrique et une voiture de test qui possèdent les
caractéristiques suivantes :

Marque OMEN
Processeur Intel Core I7 10th 2.6GHz
Mémoire 16GO
Disque Dur 512GO SSD
Système d’exploitation Windows 11 Professionnel
Tableau 1 Environnement matériel ordinateur

Marque RENOLT ZOE

Puissance 135CH
Carburant Électrique
Modèle R110
Charge utile 425
Tableau 2 Environnement matériel Voiture électrique

Marque DACIA
Puissance 110CH
Carburant Diesel
Modèle Sandero Stepway
Tableau 3 Environnement matériels Voiture de test

Le développement des systèmes embarqués a toujours besoin d’une programmation logiciel.

Alors on a utilisé les technologies décrites ci-dessous pour programmer et élaborer le système.

L’IDE de l’Arduino :

L'IDE Arduino est un logiciel open-source et gratuit qui agit comme un environnement de
développement intégré (EDI) pour programmer les cartes Arduino et compatibles. Il simplifie
la création de programmes en offrant un éditeur de texte, un compilateur, un chargeur de
programme et des bibliothèques intégrées, le tout dans une interface conviviale. Conçu pour
être facile à utiliser, il est idéal pour les débutants en programmation et en électronique.
Langage C++ :

C++ est un langage informatique orienté objet, il a été développé comme une amélioration
multiplateforme de C - comme l’IDE Arduino - pour fournir aux développeurs un degré plus
élevé de contrôle sur la mémoire et les ressources système

Bibliothèque ESP32 :

L'ESP32 est un microcontrôleur puissant et polyvalent qui offre de nombreuses

fonctionnalités pour le développement de projets électroniques. L'IDE Arduino prend en
charge l'ESP32 et offre une large gamme de bibliothèques pour simplifier le développement
de projets avec ce microcontrôleur.

Bibliothèque virtuabotixRTC :

La bibliothèque VirtuabotixRTC est une bibliothèque open-source pour l'IDE Arduino qui
permet d'utiliser un module d'horloge temps réel (RTC) DS1302 avec les cartes Arduino.
Cette bibliothèque facilite l'utilisation du module RTC et offre un certain nombre de
fonctionnalités pour simplifier le développement de projets qui nécessitent une horloge
précise.

Développement :
Dans cette partie nous allons expliquer le programme qui gouverne le système. Comment il
est illustré dans le code ci-dessous le programme commence par la déclaration des
bibliothèques et les variables utilisées dans le programme ainsi que la création des objets liés
au class des bibliothèques déclarées.

#include "BluetoothSerial.h"
#include "virtuabotixRTC.h"
#include "SPI.h"

#include "SD.h"

String PIDs[4] = {"010C", "010D", "0105", "0110"};

String PIDs_labels[4] = {"RPM Moteur", "Vitess Voiture", "Temperature", "Debit Air"};

float PIDs_scale[4] = {0.25, 1, 1, 0.01};

float PIDs_offset[4] = {0, 0, -40, 0};

float PIDs_length[4] = {4, 2, 2, 4};

uint8_t ServerMAC[6] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xBA};

 Figure Programme. Initial

rôle des variables :

 PIDs : Un tableau qui contient les PID qui vont être envoyés sous forme de requête

au ELM327.

 PIDs_labels : Un tableau qui contient les libelles des PIDS

 PIDs_scale : Un tableau qui contient les l’échèle qui doit être multiplier par la valeur
reçue
 PIDs_scale : Un tableau qui contient les valeurs de décalage qui doit être ajouté sur
la valeur reçue
 PID_length : Un tableau qui contient les nombres des Octets des données de chaque
PID
 ServerMAC : Un tableau qui contient les Octets de l’adresse MAC de l’ELM327
 Pin : Le code pin utilisé pour connecter au ELM327
 isSppOpened : Il représente l’etat de la canal SPP du Bluetooth
 request : Il représente la valeur du PID envoyé au ELM327 dans chaque itération
 resp : Il représente la valeur de la réponse reçue pas l’ESP32

Avant de parler sur le programme principal, on doit télécharger le petit programme ci-dessous
pour régler le temps dans la RTC
#include "virtuabotixRTC.h"
virtuabotixRTC RTC(5, 4,
2); void setup(){

RTC.setDS1302Time(15, 22, 21, 1, 11, 12, 2022);

SD.begin(16)

File logFile = SD.open("log.txt", FILE_WRITE);

Figure fonction setup()

void btCallback(esp_spp_cb_event_t event, esp_spp_cb_param_t *param){

switch (event){

case ESP_SPP_CLOSE_EVT:
isSppOpened = false;
break;

case ESP_SPP_OPEN_EVT:
isSppOpened =
true; break;
 Figure fonction callback du Bluetooth

void btConnect(){

connected = SerialBT.connect(ServerMAC); while(!

connected) {

connected = SerialBT.connect(ServerMAC);

Figure fonction de connexion du Bluetooth

void setup()

SerialBT.begin("ESP32_Client", true);
SerialBT.register_callback(btCallback);
btConnect();

Figure fonction set up de programme

Dans le code de la fonction ‘loop()’ premièrement le programme vérifie la connexion avec

l’ELM327 dans chaque itération. Ensuite il va itérer avec une boucle for sur les PIDs stockés
dans le tableau PIDs [4] et il va convertir la structure de chaque PID de ‘String’ à des Octets
‘uint8_t’ et après il va l’envoyer via Bluetooth sériel à travers la fonction ‘SerialBT.write()’.
Après il va attendre jusqu’à le buffer de réception série est plain avec la réponse et il va
récupérer chaque Octet dans le buffer et le poser dans la variable ‘resp’ jusqu’à ce qu’il arrive
à ‘\n’, ‘\r’, ‘>’ ou ‘^’ et il sort de la boucle ‘while’.

Deuxièmement le programme prend la valeur souhaitée en HEX de la trame et il enlève les

espaces dans le string et finalement il va la stocker dans une variable nommée ‘clean_resp’.

Dans chaque itération de la boucle for il va tester si la valeur récupérée est convenable. Ce
test est appliqué en trois étapes :

Il teste si la Tame récupérée commence par le nombre ‘41’ qui signifie que c’est une réponse
d’un PID de service 1

Il teste la réponse est du PID demandée.

Il teste si le nombre des Octets récupéré est égal au nombre des Octets demandé
void loop(){

if(!
isSppOpened)
{ btConnect
();

for (int i=0; i<sizeof(PIDs)/sizeof(PIDs[0]); i++){

request = PIDs[i] + "\r\n"

char buf[request length()];

memcpy(buf, request.c_str(), request.length());

SerialBT.write((uint8_t *)buf, request.length());
while (!SerialBT.available());

while
(SerialBT.available()) {
char c =
SerialBT.read();

if (c != '\n' && c!= '>' && c!= '\r' && c!= '^')
{ resp = resp + c;

else{

break;

String clean_resp =
resp.substring(6);
clean_resp.replace(" ", "");
RTC.updateTime();

if (resp.startsWith("41") &&

Figure fonction loop()