Introduction Générale

Contexte général

Ce projet a été développé au sein de l’Orange Digital Center Maroc, un espace dédié à l’innovation, à la créativité et au prototypage rapide. Au FabLab, les individus et les équipes ont accès à des outils de pointe, notamment des imprimantes 3D, des découpeuses laser ainsi qu’à diverses ressources électroniques et mécaniques. Le centre offre un environnement collaboratif permettant aux innovateurs, entrepreneurs et étudiants de transformer leurs idées en produits concrets. En mettant l’accent sur des solutions durables et à fort impact, l’Orange Digital Center favorise le développement de projets innovants répondant aux besoins de la société et du marché.

Avec l’essor de l’industrie 4.0, l’intégration des technologies intelligentes dans les systèmes industriels est devenue une nécessité pour améliorer la productivité, la fiabilité et la durabilité des équipements. Parmi ces technologies, l’Internet des objets (IoT), les systèmes embarqués et l’intelligence artificielle jouent un rôle central en permettant la collecte, le traitement et l’analyse des données en temps réel.

Dans ce contexte, les imprimantes 3D occupent une place de plus en plus importante dans les domaines de la fabrication, du prototypage rapide et de l’innovation technologique. Toutefois, leur fonctionnement continu et leurs contraintes les rendent sensibles à l’usure et aux défaillances. Il devient donc essentiel de mettre en place des solutions intelligentes capables de surveiller leur état et d’anticiper les pannes.

Constat et problématique

Le constat principal est que la maintenance des imprimantes 3D est généralement réalisée de manière corrective ou préventive classique, ce qui peut entraîner des arrêts imprévus, une perte de temps et des coûts supplémentaires. De plus, l’absence de systèmes intelligents de surveillance en temps réel limite la capacité à détecter les anomalies avant qu’elles ne provoquent des défaillances critiques.

Ainsi, la problématique de ce projet peut être formulée comme suit : Comment concevoir un système embarqué intelligent capable de surveiller, analyser et prédire les pannes d’une imprimante 3D en temps réel ?

Objectifs du travail

Ce projet vise à répondre à cette problématique à travers les objectifs suivants :

1. Objectif 1 : Développer un système d’acquisition de données basé sur une carte ESP32 et des capteurs afin de mesurer les paramètres critiques de l’imprimante 3D.
2. Objectif 2 : Mettre en place une architecture IoT permettant la transmission, le stockage et la gestion des données via MQTT, Node.js, MongoDB et Firebase.
3. Objectif 3 : Concevoir une interface web interactive pour la visualisation des données en temps réel et le suivi de l’état de la machine.
4. Objectif 4 : Intégrer des techniques d’intelligence artificielle pour analyser les données et mettre en œuvre une stratégie de maintenance prédictive.

Organisation du rapport

Ce rapport est structuré en quatre chapitres :

1. Présentation de l’organisme d’accueil et du cadre du projet, décrivant l’environnement de travail ainsi que le contexte dans lequel le projet a été réalisé.
2. Étude théorique et technologique, présentant les notions liées aux systèmes embarqués, à l’IoT, aux protocoles de communication et à la maintenance prédictive.
3. Conception et architecture du système, détaillant les choix techniques, le matériel utilisé et l’architecture logicielle mise en place.
4. Réalisation, tests et validation, décrivant l’implémentation pratique du système, les résultats obtenus et leur analyse critique.

Conception et réalisation d’un système embarqué intelligent de maintenance prédictive pour imprimante 3D basé sur ESP32 et intelligence artificielle

Inventaire des matériels

Carte microcontrôleur principale :

1. ESP32 DevKit V1 – Module Wi-Fi & Bluetooth Dual-Core
2. Breadboard 800 pts
3. Câble USB-A

Capteurs et actionneurs :

1. Module ADS1115 (convertisseur ADC 16 bits)
2. Capteur de courant ACS712 (30A)
3. Capteur de tension B25 (0-25V)
4. Capteur de gaz MQ-2
5. Capteur de vibration piézoélectrique
6. Module MPU6050 (accéléromètre + gyroscope)
7. Deux capteurs de température KY-028 (NTC)

Matériel de test

1. Imprimante 3D Creality CR10MAX
2. Ordinateur sous Windows/Linux

Logiciels utilisés

1. Arduino IDE
2. Visual Studio Code
3. Node.js
4. MQTT Explorer
5. Python 3
6. Firebase
7. MongoDB

Électronique passive et connectique

1. Résistance 100kΩ
2. Résistance 10kΩ
3. Résistance 1kΩ
4. Câbles Dupont
5. Barrette de pins
6. Condensateur 100µF
7. Condensateur 0.1µF

Alimentation

1. Connecteur DC jack
2. Adaptateur secteur 5V / 3A

Outillage et consommables

1. Fer à souder
2. Fil d'étain
3. Multimètre
4. Pince coupante
5. Pince à dénuder
6. Vis
7. Colliers de serrage
8. Ruban adhésif double-face
9. Boîtier de protection (optionnel)
10. Entretoises (optionnel)

Étude et Analyse des Besoins

Avant toute réalisation, il est nécessaire d'identifier les paramètres critiques de l'imprimante 3D :

1. Température des composants
2. Vibrations mécaniques
3. Consommation électrique
4. Tension d'alimentation
5. Émissions de fumée ou de gaz
6. Informations provenant de la carte mère via UART

Cette analyse permet de déterminer les capteurs à utiliser et les données à surveiller.

Le système est organisé selon l'architecture suivante :

Capteurs → ESP32 → MQTT → Serveur Node.js → Base de données → Intelligence Artificielle → Dashboard

Le rôle de chaque bloc est :

1. Les capteurs collectent les données.
2. L'ESP32 effectue l'acquisition et la transmission.
3. MQTT transporte les données en temps réel.
4. Node.js reçoit et traite les informations.
5. MongoDB et Firebase stockent les données.
6. Random Forest analyse les données.
7. L'interface web affiche les résultats.

Installer les différents capteurs sur l'imprimante :

Surveillance électrique

1. ACS712 pour mesurer le courant.
2. B25 pour mesurer la tension.

Surveillance thermique

1. Deux capteurs KY-028 placés à proximité des éléments chauffants.

Surveillance mécanique

1. MPU6050 pour mesurer les vibrations et mouvements.
2. Capteur piézoélectrique pour détecter les chocs et vibrations anormales.

Surveillance environnementale

1. MQ-2 pour détecter fumées et gaz.

Les capteurs analogiques sont connectés au module ADS1115 afin d'améliorer la précision des mesures.

Le programme ESP32 réalise :

1. Lecture des capteurs.
2. Conversion des données.
3. Création des messages JSON.
4. Connexion Wi-Fi.
5. Publication des données MQTT.
6. Communication UART avec la carte mère de l'imprimante.

Chaque mesure est envoyée périodiquement vers le serveur de supervision.

Code carte ESP32 :

Le serveur Node.js permet :

1. La réception des messages MQTT.
2. Le traitement des données.
3. La sauvegarde dans MongoDB.
4. La synchronisation avec Firebase.
5. La création automatique du dataset CSV utilisé pour l'entraînement de l'IA.

Pour entraîner l'algorithme de Machine Learning :

1. Faire fonctionner l'imprimante normalement.
2. Enregistrer les données des capteurs.
3. Simuler plusieurs anomalies :
4. Surchauffe
5. Vibrations excessives
6. Anomalies électriques
7. Défauts d'impression
8. Étiqueter les données collectées.

Le résultat est un fichier CSV contenant les données normales et anormales.

Code collector pour la collecte des données et la création de csv pour l’entrainement de l’algorithme :

1. Chargement des données

Le programme commence par charger un fichier CSV contenant les données historiques :

Chaque ligne représente un instant de fonctionnement du système, avec des mesures issues de différents capteurs (température, vibrations, courant, tension, gaz, etc.).

Les valeurs manquantes sont ensuite supprimées :

Cela garantit que le modèle ne soit pas perturbé par des données incomplètes.

2. Sélection des variables (features)

Le modèle utilise un ensemble de variables appelées features. Elles représentent l’état physique et électronique du système :

1. Variables électriques : voltage, current
2. Température moteur : temp_motor_bottom, temp_motor_top
3. Gaz : gas
4. Vibrations : vibration_left, vibration_right
5. Mouvement (IMU) : accX, accY, accZ, gyroX, gyroY, gyroZ
6. État système : wifi_rssi, heap
7. Paramètres imprimante / machine : nozzle_temp, bed_temp, positions posX, posY, posZ, posE

La variable à prédire est :

Elle représente l’état du système (normal, anomalie, panne).

3. Vérification des données

Avant l’entraînement, le code vérifie que toutes les colonnes nécessaires sont présentes dans le dataset. Si une colonne manque, le programme s’arrête pour éviter une erreur.

4. Préparation des données

a. Séparation X / y

1. X contient les mesures des capteurs
2. y contient le label (état du système)

b. Encodage des labels

Les classes textuelles (ex: "normal", "fault") sont transformées en valeurs numériques :

Cela permet au modèle de les traiter mathématiquement.

c. Normalisation

Les données des capteurs sont mises à la même échelle :

Cette étape améliore la stabilité et la performance du modèle.

5. Division entraînement / test

Le dataset est divisé en deux parties :

1. 80 % pour l’entraînement
2. 20 % pour les tests

La stratification garantit que chaque classe est bien représentée dans les deux ensembles.

6. Modèle Random Forest

Le modèle utilisé est un Random Forest Classifier, qui est un ensemble de plusieurs arbres de décision.

Explication des paramètres principaux :

1. 300 arbres (n_estimators) pour améliorer la robustesse
2. profondeur maximale de 20 pour éviter le surapprentissage
3. class_weight="balanced" pour gérer les classes déséquilibrées
4. n_jobs=-1 pour utiliser tous les cœurs du processeur

7. Entraînement du modèle

Le modèle apprend à partir des données d’entraînement :

Il construit progressivement des arbres de décision capables de reconnaître les différents états du système.

8. Évaluation

Après l’entraînement, le modèle est testé sur des données inconnues :

Plusieurs métriques sont calculées :

1. Accuracy : taux global de bonnes prédictions
2. Classification report : précision, rappel et F1-score pour chaque classe
3. Matrice de confusion : erreurs de classification

9. Importance des variables

Le modèle calcule également quelles variables influencent le plus la décision :

Cela permet d’identifier les capteurs les plus critiques dans la détection des pannes (par exemple vibrations ou température moteur).

10. Sauvegarde du modèle

Enfin, trois fichiers sont sauvegardés pour une utilisation future :

1. random_forest_model.pkl : le modèle entraîné
2. scaler.pkl : le normaliseur des données
3. label_encoder.pkl : l’encodage des classes

1. Ces fichiers permettent de réutiliser le modèle sans réentraînement.

1. Objectif du code

Ce programme a pour rôle de :

1. Recevoir des données de capteurs en temps réel via MQTT
2. Transformer ces données au bon format
3. Appliquer le modèle Random Forest déjà entraîné
4. Prédire l’état de la machine (normal, anomalie, panne)
5. Envoyer le résultat vers un autre topic MQTT

2. Chargement du modèle IA

Au démarrage, le système charge les fichiers sauvegardés lors de l’entraînement :

Ces éléments sont essentiels :

1. model : le Random Forest entraîné
2. scaler : normalisation des données (même transformation que l’entraînement)
3. encoder : conversion des labels numériques en texte

3. Communication MQTT

Le système utilise MQTT pour recevoir et envoyer les données :

1. Topic d’entrée :

1. Topic de sortie :

Le broker utilisé est public :

Cela permet de recevoir des données IoT en temps réel depuis une machine ou un microcontrôleur.

4. Extraction des features

La fonction principale extract_features() transforme le JSON reçu en un vecteur de données exploitable par le modèle.

Les données sont organisées par catégories :

a. Données électriques

1. voltage
2. current

b. Température

1. motor_bottom
2. motor_top

c. Gaz

1. mq2

d. Vibrations

1. left_rms
2. right_rms

e. Mouvement (IMU)

1. accélération (x, y, z)
2. gyroscope (x, y, z)

f. Système

1. wifi_rssi
2. heap mémoire

g. Paramètres machine (Marlin)

1. température buse et plateau
2. positions X, Y, Z, E

Si une donnée est manquante, une valeur par défaut (0) est utilisée pour éviter les erreurs.

5. Réception des messages MQTT

Chaque fois qu’un message arrive sur le topic, la fonction suivante est déclenchée :

Elle réalise plusieurs étapes.

6. Conversion des données

Le message MQTT est converti depuis JSON :

Puis transformé en vecteur numérique :

Ensuite, les données sont normalisées avec le même scaler que l’entraînement :

7. Prédiction du modèle

Le modèle Random Forest analyse les données et prédit la classe :

Puis la classe numérique est reconvertie en texte :

8. Calcul de la confiance

Le système calcule également un score de confiance :

Cela représente la probabilité de la prédiction la plus probable.

9. Résultat final

Le résultat envoyé contient :

Exemple :

Ce résultat est affiché dans la console.

10. Envoi vers MQTT

Le résultat est ensuite publié sur un autre topic :

Cela permet à d’autres systèmes (dashboard, application mobile, serveur) de recevoir la prédiction en temps réel.

11. Boucle en temps réel

Le client MQTT reste actif en permanence :

Le système fonctionne donc comme un service d’IA temps réel embarqué, capable de surveiller une machine en continu.

L'interface web permet :

1. L'affichage des données en temps réel.
2. La visualisation des graphiques.
3. La consultation de l'historique.
4. L'affichage des alertes.
5. Le suivi de l'état global de l'imprimante.

vous pouvez trouvez le code source de l'interface web dans ce lien drive :

https://drive.google.com/drive/folders/1jQ3DTrtk6CK6nidwNPCCq0TNQANUIbw8?usp=sharing

Le hosting avec Vercel est une solution de déploiement cloud moderne qui permet de publier rapidement des applications web et des APIs sans gérer d’infrastructure serveur. Vercel automatise entièrement le processus de build, de déploiement et de mise à l’échelle : à chaque modification du code, une nouvelle version est générée et déployée en quelques secondes. La plateforme est particulièrement adaptée aux projets front-end (React, Next.js, etc.), mais peut aussi exposer des fonctions backend sous forme de serverless functions. Grâce à son CDN intégré, les contenus sont distribués globalement pour garantir des temps de réponse rapides. Vercel simplifie ainsi le passage du développement à la production en offrant une solution stable, scalable et facile à intégrer avec des projets modernes.

Code serveur local pour l’interface :

1. Objectif global du système

Ce programme sert à :

1. Recevoir des données de capteurs via MQTT
2. Traiter et structurer ces données
3. Détecter des anomalies / pannes
4. Stocker les données (CSV, MongoDB, Firebase)
5. Envoyer les données en temps réel au dashboard (WebSocket)

2. Technologies utilisées

Le backend combine plusieurs technologies :

1. MQTT : communication IoT en temps réel
2. MongoDB : base de données NoSQL
3. Firebase Realtime Database : synchronisation cloud
4. Express.js : API web
5. Socket.io : temps réel vers interface web
6. Filesystem (CSV) : stockage local des datasets
7. Node.js : runtime principal

3. Architecture des données

Deux flux principaux existent :

a. Capteurs

Topic MQTT :

→ données JSON des capteurs (température, vibration, courant…)

b. Marlin (machine state / logs firmware)

Topic MQTT :

→ logs bruts de la machine (firmware type Marlin)

4. Initialisation du serveur

Le serveur Express est lancé sur un port défini :

Il sert :

1. un dashboard web (public/)
2. des APIs d’export CSV
3. une route de santé /health

5. Gestion des fichiers CSV

Le code crée automatiquement deux fichiers :

1. dataset_labeled.csv → dataset IA
2. marlin_logs.csv → logs machine

Chaque nouvelle donnée est ajoutée ligne par ligne pour constituer un dataset d’entraînement.

6. Connexions aux bases de données

a. MongoDB

Si une URI est fournie :

Les données capteurs sont stockées dans la collection capteurs.

b. Firebase Realtime Database

Si une clé service est disponible :

Les données sont envoyées en temps réel vers Firebase.

7. WebSocket (temps réel dashboard)

Socket.io permet de pousser les données instantanément vers l’interface web :

1. io.emit("data", data) → capteurs
2. io.emit("marlin", marlinEntry) → logs machine

Cela permet un dashboard live sans refresh.

8. Réception MQTT

Le cœur du système est ici :

Chaque message reçu est traité selon son type.

9. Traitement des données Marlin

Si le message vient du topic Marlin :

1. Il est sauvegardé dans un fichier CSV
2. Il est parsé (parseMarlinLine)
3. Il est envoyé à Firebase
4. Il est envoyé au dashboard en temps réel

👉 Cela permet de suivre l’état bas niveau de la machine.

10. Traitement des capteurs

Si le message vient des capteurs :

Étapes :

a. Parsing JSON

b. Flatten des données

👉 transforme JSON complexe en structure simple

c. Détection d’anomalies

👉 applique une logique ou un modèle pour détecter :

1. normal
2. anomalie
3. panne

d. Fusion des données

11. Stockage des données

Chaque donnée est envoyée vers plusieurs systèmes :

a. CSV local (dataset IA)

👉 sert à entraîner le modèle ML

b. Firebase (temps réel cloud)

c. MongoDB (base historique)

12. Dashboard en temps réel

👉 met à jour instantanément l’interface web avec les nouvelles données capteurs

13. API REST

a. Health check

Retourne l’état du système :

1. MongoDB connecté ou non
2. Firebase actif ou non
3. MQTT connecté ou non

b. Export dataset IA

Télécharge le fichier CSV utilisé pour entraîner le modèle.

c. Export logs Marlin

Télécharge les logs bruts de la machine.

14. Gestion des connexions MQTT

Le code gère aussi :

1. connexion
2. erreurs
3. reconnexion
4. souscription aux topics

15. Résumé global

Ce backend agit comme un système IoT industriel complet :

1. Capteurs envoient des données via MQTT
2. Le backend reçoit et traite les données
3. Il détecte les anomalies
4. Il stocke les données dans :
5. CSV (IA training)
6. MongoDB (historique)
7. Firebase (cloud temps réel)
8. Il envoie les données au dashboard via WebSocket

Effectuer plusieurs scénarios de test :

Test thermique

Augmenter artificiellement la température afin de vérifier la détection.

Test vibratoire

Créer des vibrations anormales.

Test électrique

Faire varier la tension ou le courant.

Test IA

Vérifier que le modèle classe correctement les états de fonctionnement.

Le système développé permet :

1. Une surveillance continue de l'imprimante 3D.
2. La détection précoce des anomalies.
3. La génération d'alertes automatiques.
4. La création d'un historique complet des données.
5. La prédiction des pannes grâce à l'intelligence artificielle.

Cette solution améliore considérablement la fiabilité de l'imprimante et réduit les arrêts imprévus.

Ce projet démontre qu'il est possible de réaliser un système complet de maintenance prédictive à faible coût en combinant l'ESP32, les technologies IoT et l'intelligence artificielle.

Grâce à l'acquisition de données en temps réel, à l'utilisation du protocole MQTT et à l'algorithme Random Forest, le système est capable d'anticiper certaines défaillances avant qu'elles n'affectent le fonctionnement de l'imprimante 3D.

Cette architecture peut être facilement adaptée à d'autres machines industrielles telles que les moteurs électriques, les pompes, les compresseurs ou les lignes de production, ouvrant ainsi la voie à des applications industrielles plus avancées dans le domaine de la maintenance intelligente.