# MU5CI803 - Optimisation et contrôle des procédés
# Régulation de température d'une cuve (Groupe B)
#### **Informations :****Noms et prénoms :**
SEJDI Linda (linda.sejdi@etu.sorbonne-universite.fr)
SOSA VARGAS Luis Angel (la.sosa.vargas@gmail.com)
THAVARAJAH Roshani (roshani.thavarajah@etu.sorbonne-universite.fr)
VASANTHAN Luxcheni (luxcheni.vasanthan@etu.sorbonne-universite.fr)
**Période :**Octobre 2024 - Janvier 2025
**Cursus :** Master 2 Chimie parcours Ingénierie Chimique
**Tuteur :******PULPYTEL Jerome (jerome.pulpytel@sorbonne-universite.fr)
#### **Contexte :**
Ce projet, réalisé dans le cadre de l'UE 803 "Optimisation et Contrôle des Procédés", porte sur la régulation et l'automatisation de la température d'une cuve contenant un liquide. Ce projet vise à développer des compétences pratiques en régulation, automatisation et intégration électronique.
#### **Objectifs :**
L'objectif de ce projet est de concevoir et de réaliser un système automatisé de régulation de température d'une cuve. Il s'appuie sur une carte Arduino, un module de Peltier, une sonde de température et un circuit électronique intégrant un écran LCD, une LED et un buzzer. Ces éléments permettent de mesurer, d'afficher en temps réel et de réguler automatiquement la température pour atteindre une consigne définie par l'utilisateur. Le système devra être capable d'assurer les fonctions suivantes :
1. **Imposer une température cible :**
La température cible est fixée dans le code Arduino au démarrage. Cette consigne initiale sert de référence pour la régulation.
2. **Afficher en temps réel :**
La température mesurée par une sonde immergée dans la cuve est affichée en temps réel sur un écran LCD. Cela permet une visualisation claire de l'évolution de la température.
3. **Réguler via le module de Peltier :**
Le module de Peltier est chargé de chauffer ou de refroidir la cuve pour maintenir la température souhaitée.
Une LED RGB indique visuellement l'état de la régulation. Suivant la couleur on a des informations sur l'état de la température.
- Rouge si la température est inférieure à la consigne
- Bleue si la température est supérieure à la consigne
- Vert si la température correspond à la consigne
4. **Ajuster dynamiquement la température cible :** Deux boutons poussoirs permettent à l'utilisateur de modifier la température cible en l'augmentant ou en la diminuant.
L'écran LCD met immédiatement à jour la nouvelle consigne et le système reprend sa régulation jusqu'à ce que la nouvelle température cible soit atteinte.
*[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2024-12/0ad13532-69cd-494e-9636-df9bc791a527.JPG)*
***Figure 1 : Montage du système de régulation thermique avec affichage LCD et le module Peltier***
#### **Matériel :**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/HwAimage.png)
#### **Connexions :****Module Peltier :**
- Pôle + : Alimentation externe
- Pôle - : Source du transistor
**Sonde DS1 :**
- VCC : Alimentation 5V
- GND : GND
- Signal : Broche D2 de l'Arduino
- Résistance de 4,7 kΩ en série avec le signal
**Transistor NMOS (IRF540N ou similaire) :**
- Source : GND
- Drain : Circuit du module Peltier
- Gate : Broche D12 de l'Arduino
- Drain relié à une borne du module Peltier, l'autre borne reliée au +12V de l'alimentation externe
- Résistance de 220 Ω entre la Gate et le sortie D12
**LED RGB :**
- Cathode : Commune à GND
- Broches rouge, verte et bleue : connectées respectivement à D10, D9 et D8 de l'Arduino, via des résistances de 220 Ω
**Ecran LCD 16x2 :**
- SCL : Broche A5 de l'Arduino
- SDA : Broche A4 de l'Arduino
- VCC : +5V de l'Arduino
- GND : GND de l'Arduino
**Buzzer :**
- Buzzer : Broche D13 de l'Arduino
- Résistance de 100Ω en série avec le buzzer
**Bouton poussoir :**
- Une broche : +5V
- Résistance de pull-down de 10 kΩ entre la broche et GND
#### **Construction :**
***Figure 2 : Schéma du système de régulation de température avec Arduino et module Peltier***
##### **Étape 1 : Conception et préparation**
La première étape consiste à bien comprendre le sujet et à établir une liste détaillée des composants nécessaires. Cette phase inclut également l'organisation des tâches au sein de l'équipe, chaque membre se voyant attribuer des responsabilités spécifiques.
##### **Étape 2 : Montage et assemblage**
La deuxième étape implique la réception du matériel et l'assemblage des composants. L'équipe installe le kit de refroidissement Peltier sur la cuve et relie tous les éléments électroniques sur une platine d'essai.
##### **Étape 3 : Programmation et test**
La troisième étape est dédiée au développement du code pour l'Arduino UNO, qui contrôle le module Peltier et régule la température de la cuve. Le programme inclut l'implémentation d'un régulateur PID pour assurer un contrôle précis de la température.
**Programme Arduino**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/capture-decran-2025-01-24-a-22-08-32.png)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/capture-decran-2025-01-24-a-22-08-47.png)
#### **Journal de bord :**
##### **07/10/2024 :**
- Attribution du projet de régulation de la température d'une cuve.
- Visite du FabLab pour découvrir les ressources disponibles.
- Réflexion sur la méthode de régulation à utiliser et prise de contact avec le groupe pour organiser la première réunion.
##### **11/10/2024 :**
- Première réunion Zoom entre les membres de l'équipe.
- Comparaison et validation de la liste finale de matériel.
##### **17/10/2024 :**
- Rendez-vous avec la tutrice pour valider officiellement la liste de matériel.
- Récupération du matériel.
- Commande du module de Peltier, dont la livraison est prévue pour mi-novembre.
- **Prochaine étape** : Simulation du système sur Tinkercad pour tester le concept avant la mise en œuvre physique.
##### **03/11/2024 :**
- Deuxième réunion Zoom entre les membres de l'équipe.
- Comparaison des simulations réalisées sur Tinkercad.
- Demande d'avis au tuteur sur le montage et le code :
Lorsque nous avons présenté notre simulation à notre tuteur, nous lui avons expliqué que nous rencontrions un problème avec les boutons poussoirs qui ne semblaient pas fonctionner. Nous lui avons demandé des remarques et suggestions pour nous aider à avancer. En réponse, il nous a précisé que les boutons fonctionnaient correctement. Lorsqu'on appuie sur le bouton, la tension passe bien de 4,17 V à 0 V. Cependant, il a souligné que le problème venait des fonctions "delay" et du temps de simulation non réel. Il est nécessaire de maintenir le bouton enfoncé pendant environ 3 à 4 secondes pour que l'incrément de température soit pris en compte.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2024-12/simulation-sur-tinkercard.png)
***Figure 3 : Simulation du système sur Tinkercad***
##### **07/11/2024 :**
- Récupération du matériel manquant que l'on avait commandé : Module Peltier, Transistor MOS, Breadboard, Pâte thermique, Ecran LCD
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2024-12/4c764efa-7fd9-4b88-8ecb-15f4ad39b417.JPG)
***Figure 4 : Matériel complet prêt pour l'assemblage du projet***
##### **21/11/2024 :**
- Première réunion au FabLab.
- Nous avons débuté l'assemblage du montage en suivant précisément la simulation réalisée sur Tinkercard.
- Problème de port identifié.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2024-12/img-4343.jpg)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2024-12/img-4347.jpg)
***Figure 5 : Assemblage et câblage des composants***
##### **12/12/2024 :**
- Deuxième réunion au Fablab.
- Plusieurs problèmes ont été rencontrés lors du montage et des tests.
**Problèmes rencontrés pendant le montage : module Peltier, sonde de température, carte Arduino et écran LCD :(**
**Problème avec le module Peltier :** Le module Peltier ne chauffait pas. Pour vérifier si le problème venait du branchement, nous avons testé avec un moteur, et celui-ci a fonctionné correctement. Nous avons conclus que le module Peltier était défectueux et l'avons remplacé par un autre.
**Problème avec la sonde de température :** L'écran LCD affichait des valeurs de température instables. Nous avons trempé la sonde dans de l'eau chaude pour tester son fonctionnement, mais sans succès. La sonde semblait donc défectueuse et un nouvel essai avec une sonde différente a été prévu.
**Problème avec la carte Arduino :** La carte Arduino initiale ne fonctionnait pas correctement. Nous avons pris la décision de la remplacer par une autre, ce qui a résolu le problème et permis de continuer les tests.
**Problème avec l'écran LCL :** Le premier écran LCD était défectueux et a également été remplacé.
- Malgré ces remplacements, les valeurs affichées par la sonde restaient instables. Nous avons consulté notre tuteur, qui nous a conseillé d'ajouter une résistance de 4,7 Ω comme montré dans la photo ci-dessous.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2024-12/img-4894.jpg)
***Figure 6 : Stabilisation des mesures de la sonde avec une résistance de 4,7 Ω***
- Même après l'ajout de la résistance, la température ne se stabilise pas.
- Nous avons envisagé deux hypothèses possibles pour expliquer ce dysfonctionnement :
1. **La sonde pourrait être défectueuse**
2. **Problème de compatibilité avec la bibliothèque Arduino utilisée** : Il se pourrait qu'elle ne soit pas entièrement adaptée, ce qui pourrait entraîner des erreurs dans la lecture des données, nécessitant un ajustement du code pour résoudre ce problème.
- Afin de valider ces hypothèses, nous avons effectué une nouvelle tentative en utilisant un capteur différent. Le problème persistait.
- **Prochaine étape** : Révision approfondie du code pour identifier et résoudre le problème.
##### **05/01/2024 :**
- La connexion du capteur de température a été vérifiée, la résistance de 4,7 Ω devait être pontée entre le câble rouge 5 V et le câble jaune analogique. Une fois cela fait, le capteur est ensuite connecté au côté connexion numérique de la carte Arduino, qui dans le code révisé 2.0 est *« ONE\_WIRE\_BUS 7 »* ou connexion numérique 7 en utilisant la bibliothèque *<OneWire.h>.*
- **Révision du code :**
Le code a été révisé et modifié pour intégrer la fonctionnalité PID permettant un contrôle total des valeurs constantes. Cela signifie qu'il peut désormais être ajusté pour obtenir la meilleure réponse en fonction de nos besoins. Dans ce cas, la constante de proportionnalité a été modifiée pour avoir une augmentation rapide de la température, ce qui entraîne inévitablement un dépassement. Donc, pour garantir une performance optimale, les constantes intégrale et différentielle doivent être modifiées en conséquence.
PID Controller V2.0 permet également l'activation ou la désactivation de la pompe de mélange tout en réduisant le décalage d'entrée entre toute pression sur un bouton et le temps de réponse de l'écran.
Enfin dans cette révision, l'instruction anti-rebond a été définie pour éviter toute pression accidentelle sur un bouton.
**Le programme a été entièrement révisé et optimisé, et fonctionne désormais parfaitement, assurant ainsi une régulation de température précise et fiable pour le système :)**
**Ainsi voici le programme qui fonctionne :**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/syjimage.png)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/nylimage.png)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/Xfcimage.png)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/Oc7image.png)
- **Optimisation des connexions et amélioration de l'ergonomie**
Dans la nouvelle révision du matériel, les connexions ont été réduites et réordonnées pour éviter les débranchements accidentels. Cette refonte simplifie également le transport du projet et améliore l'expérience de l'utilisateur en rendant le système plus accessible et facile à manipuler.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/buTimage.png)
***Figure 7 : Refonte du matériel : Simplification des connexions et amélioration de l'accessibilité***
- **Evolutions futures**
De nouvelles fonctionnalités sont en cours d'élaboration, tant sur le plan logiciel que matériel. Parmi les améliorations prévues, nous avons l'ajout de boutons de déclenchement supplémentaires permettant une éventuelle modification de la constante PID en temps réel. Une autre amélioration envisagée serait l'ajout d'un ventilateur de refroidissement pour accélérer le processus de refroidissement de l'eau chauffée en cas de besoin. Enfin, il est prévu d'utiliser le côté refroidissement du module Peltier pour refroidir un dissipateur thermique à eau connecté, afin de faciliter un refroidissement plus rapide de l'eau.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/gSoimage.png)
***Figure 8 : Nouvelle simulation du système sur Tinkercad avec les nouvelles fonctionnalités***
**Notre système de régulation fonctionne désormais de manière fluide et précise assurant un contrôle optimal de la température comme prévu :)**
Voici une vidéo illustrant les résultats obtenus après les dernières modifications. Cette démonstration met en avant l'efficacité du système mis en place.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/attachments/1222)
##### **24/01/2024 :**
**Problème rencontré pendant le test : la pompe ne fonctionne plus :(**
- Au cours de nos différents tests, la pompe a cessé de fonctionner, ce qui nous a conduits à en récupérer une nouvelle. À ce jour, le seul problème identifié reste celui de la pompe.
- Nous avons fixé un rendez-vous le lundi 27 janvier afin de présenter notre expérience.
- Par ailleurs, nous avons décidé d’intégrer un QR code à notre projet, permettant aux futurs étudiants d’accéder facilement à notre page Wiki.
##### **27/01/2024 :**
**Problème rencontré pendant la finalisation du projet : le module de Peltier ne fonctionne plus :(**
- Récupération du Module Peltier car lors de la finalisation de notre projet, nous avons rencontré un imprévu le matin même : notre module Peltier initial a cessé de fonctionner. Afin de garantir le bon déroulement de la présentation, nous avons rapidement récupéré un nouveau module de remplacement, identique au précédent, et l’avons intégré au montage final.
- Impression au laser du QR code qui sera fixé sur le support contenant les informations clés du projet : nom, prénom, titre du projet et autres détails pertinents. Cette finition apportera une touche professionnelle et facilitera l’accès rapide à des ressources complémentaires ou à la documentation du projet via le QR code.
- Montage complet des composants sur le support rigide au Fablab, permettant une fixation sécurisée et une présentation soignée. Ce support intégrera tous les éléments nécessaires, tels que la carte Arduino, le module Peltier, le capteur de température, l’écran LCD et les boutons poussoirs, organisés de manière fonctionnelle.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/image-finale.jpg)
[***Figure 9 : Montage des composants sur le support***](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/image-finale.jpg)
- Montage final de notre projet avant la présentation.
[ ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/image-finallle.jpg)
***Figure 10 : Montage final de notre projet de régulation de la température d'une cuve***
Dans cette vidéo, nous démontrons le fonctionnement du système de régulation de température à l'aide d'un module Peltier et d'une LED RGB. Nous expliquons comment la couleur de la LED change en fonction de la température mesurée par la sonde, offrant ainsi une visualisation intuitive du processus de régulation.
- **Rouge** : La LED passe au rouge lorsque la température mesurée est inférieure à la température cible. Cela indique que le système doit chauffer pour atteindre la consigne.
- **Vert** : La LED devient verte lorsque la température est stabilisée à la consigne, ce qui signifie que le système maintient la température idéale.
- **Bleu** :Si la température dépasse la consigne, la LED devient bleue, signalant que le système doit refroidir pour ajuster la température.
Cette fonctionnalité permet de suivre en temps réel l’état du système et garantit une régulation thermique précise et visuellement compréhensible. Dans la vidéo, nous mettons en évidence ces transitions de couleur en fonction des ajustements de la température cible, illustrant ainsi l’efficacité du système mis en place.
---
##### **Conclusion :**
Ce projet nous a permis d’appliquer nos connaissances théoriques en les transformant en une réalisation pratique fonctionnelle. Malgré les défis rencontrés, comme le remplacement du module Peltier en dernière minute, nous avons su faire preuve d’adaptabilité et de rigueur. Le montage final répond aux objectifs fixés, permettant un contrôle efficace de la température grâce à l’Arduino et aux différents composants intégrés. Ce projet nous a également permis de renforcer nos compétences en électronique, en programmation, et en gestion de projet. Il représente une étape importante dans notre apprentissage tout en ouvrant la voie à des améliorations futures.
**Problèmes rencontrés dans le projet : le Module Peltier :**
**Symptômes :** Le module Peltier initialement utilisé ne chauffait pas correctement, perturbant ainsi la régulation thermique et affectant le processus global de contrôle de température. Après plusieurs tests, il a été conclu que le module était défectueux.
**Solution :**Le module défectueux a été remplacé par un modèle fonctionnel. Cependant, cette défaillance en fin de projet a ajouté des contraintes de temps, nécessitant une gestion rapide et efficace des ressources pour garantir la présentation du projet.
Le plus gros problème rencontré a été le module Peltier, que nous avons dû remplacer à plusieurs reprises. Au total, nous avons utilisé au moins cinq modules Peltier pour trouver un modèle fonctionnel et garantir la réussite de notre projet.
**Améliorations possibles pour les années à suivre** :
- **Fiabilité des composants** :Amélioration : Un contrôle plus rigoureux de la qualité des composants avant leur utilisation pourrait éviter des problèmes de défaillance, comme ceux rencontrés avec le module Peltier et la carte Arduino. De plus, un stockage approprié des composants et une gestion des stocks plus efficace pourraient minimiser les risques de panne en dernière minute.
- **Stabilité des mesures de température** :Amélioration : Une investigation plus poussée sur la sonde de température et sur la bibliothèque utilisée pourrait permettre de résoudre définitivement les problèmes d’instabilité des lectures. Envisager l’utilisation de capteurs de température plus précis ou d’autres bibliothèques mieux adaptées à la régulation pourrait améliorer les performances du système.
- **Optimisation de l’interface utilisateur** :Amélioration : L’expérience utilisateur pourrait être améliorée en simplifiant l’interface. Par exemple, l’ajout d’un écran tactile pour modifier la température cible directement ou l’utilisation d’un contrôle plus intuitif avec des boutons plus réactifs permettrait de mieux répondre aux attentes d’un utilisateur.
- **Extension des fonctionnalités logicielles** :Amélioration : L’intégration de plus de fonctionnalités logicielles, comme la possibilité de visualiser l’historique des températures ou d’exporter les données de régulation sur un appareil externe (comme un smartphone ou un PC) via Bluetooth ou Wi-Fi, offrirait des capacités avancées pour les utilisateurs.
# Réalisation d'une burette automatique (Groupe A)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/Dcmimage.png)
Figure 1 : Image du montage final de la burette automatique
#### Informations
- Fatimat ABDULWAHAB, Shola ADENIYI, Aya BOUSSALEH, Hugo LUTZ et Raounaki SAID ABDALLAH
- fatimat.abdulwahab@etu.sorbonne-universite.fr; shola.adeniyi@etu.sorbonne-universite.fr; Aya.boussaleh@etu.sorbonne-universite.fr ; hugo.lutz@etu.sorbonne-universite.fr ; raounaki.said\_abdallah@etu.sorbonne-universite.fr
- Projet IC 803 - Optimisation et contrôle de procédé
- Octobre 2024 - Janvier 2025
#### ContexteDans le cadre de l'UE Optimisation et contrôle de procédés, nous devons effectuer la régulation d'un système à l'aide d'une carte Arduino. Pour ce faire, nous devons déterminer le matériel nécessaire ainsi que les branchements et le code qui permettront l'automatisation de notre procédé.
#### ObjectifsNotre sujet porte sur la réalisation d'une burette automatique. Pour effectuer la régulation, nous utiliserons un capteur de couleur pour mesurer l'intensité de la couleur dans le liquide, une électrovanne pour contrôler le débit de liquide coloré. Nous utiliserons également un capteur de distance pour mesurer la volume du liquide versé et un moteur DC pour agiter le liquide. Le but est d'atteindre une couleur définie dans le récipient rempli d'eau.
#### Matériel
- Arduino
- Breadboard
- Moteur DC
- Electrovanne
- Capteur de couleur (TCS3200)
- Capteur de distance à ultrason (Grove-Ultrasonic ranger V2.0)
- Agitateur (imprimé 3D)
- Ecran LCD (Grove - 16 x 2 LCD (White on Blue))
- Relais
- Module Mosfet
- Résistances
- Tuyaux
- Fils
- LED rouge
- Bouteille
- Photorésistance (pas utilisé)
#### Construction
##### 14/10/2024 Lors de notre rencontre, nous avons déterminé nos besoins en termes de matériel et nous avons commencé à tester les différents composants à tour de rôle en commençant par la photorésistance.
##### 21/10/2024 Nous nous sommes réunis afin de mieux définir notre projet. Voici le procédé que nous souhaitons obtenir: Dans une boîte opaque, nous aurons un récipient contenant de l’eau, la photorésistance et une lampe. La boîte opaque nous permet de contrôler la lumière qui sera détectée dans le milieu. Lorsqu'on appuie sur le bouton, un capteur à ultrason mesure le niveau du colorant/sirop à t=0, la LED rouge s’allume, l’agitateur se met en route et l’électrovanne s’ouvre. Tant que la photorésistance détecte plus de lumière qu’une valeur seuil, l'électrovanne reste ouverte donc on fait couler le sirop/colorant. Au fur et à mesure, la photorésistance détectera de moins en moins de lumière jusqu’à atteindre la couleur souhaitée. Une fois cette couleur atteinte, l’électrovanne se ferme, l’agitateur s’arrête et la LED s’éteint. On mesure le niveau du colorant à la fin afin de connaître la quantité qui a été versée pour atteindre la couleur définie; cette valeur sera ensuite affichée sur un écran LCD. Figure 2 : Schéma 3D de la burette automatique
##### 07/11/2024 Nous nous sommes retrouvés dans une salle afin d'avancer sur le projet. L’objectif est de définir ce qu’il reste à faire et de se répartir les tâches afin que nous puissions véritablement commencer les tests en utilisant directement le matériel. Nous avons réussi à faire fonctionner l’électrovanne en faisant couler de l’eau d’une bouteille à l’autre. De plus, le capteur pour la mesure de la distance est à présent fonctionnelle.[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2024-11/4cXimage.png)Figure 3 : Fonctionnement de l'électrovanne Pour l’agitateur, nous utiliserons ce modèle que nous allons imprimer en 3D: [https://www.thingiverse.com/thing:4676097/files](https://www.thingiverse.com/thing:4676097/files) . Par la suite, on utilisera de la colle pour attacher l’agitateur au moteur. Nous avons utilisé le logiciel IdeaMaker pour dimensionner l'agitateur et nous avons lancé l'impression de notre agitateur de 10 cm. [](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2024-11/CtQimage.png)Figure 4 : Agitateur imprimé en 3D
##### 25/11/2024 Nous nous sommes retrouvés au Fablab, l'objectif de la séance est de bien vérifier le fonctionnement de chaque élément séparé de notre système, notamment, le moteur utilisé pour l'agitation. Il s'avère que nous avions un moteur pas-à-pas, alors qu'il nous faudrait un moteur DC pour pouvoir agiter à de vitesses suffisantes. Nous avons donc récupéré un moteur DC et par la même occasion un capteur de couleur. Nous avons pu tester le moteur DC et l'avons attaché d'une façon un peu précaire à l'agitateur imprimé en 3D. Lors de la prochaine séance nous allons tester le capteur de couleur et trouver la manière dont nous allons fixer l'agitateur au moteur.
##### 09/12/2024 Nous nous sommes retrouvés dans une salle avec notre tuteur pour qu'il nous explique le fonctionnement de capteur de couleur ainsi que le code arduino correspondant pour la mise en marche. Ce capteur de couleur mesure l'intensité lumineuse avec différents filtres et renvoie une valeur en rouge, bleu et vert. Plus la couleur est rouge intense, plus la valeur mesurée est élevée.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/6Tpimage.png)
Figure 5 : Image du serial moniteur d'Arduino avec un seuil à "red" = 175
##### 18/12/2024 Nous nous sommes retrouvés au Fablab dans le but d'avancer dans la partie fixation de notre matériels sur le support. Le support de la bouteille a été réalisé à l'aide d'une découpeuse laser, tandis que l'électrovanne a été fixée à l'aide d'une presseuse et de vis.[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2024-12/fixation-du-support.jpeg)Figure 6 : Fixation électrovanne
##### 19/12/2024 Conception (par découpe laser) et fixation de la boite noire.[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2024-12/conception-de-la-boite-noire.jpeg)Figure 7 : Fixation de la boite noire
##### 09/01/2025Nous nous sommes réunis au Fablab pour programmer le capteur de couleur, et tester son fonctionnement. En parallèle, nous avons poursuivi l’assemblage de notre matériels sur le support.
##### 15/01/2025Nous nous sommes réunis au FabLab pour avancer sur notre projet. Nous avons recouvert l'intérieur de notre boîte noire avec du papier adhésif, puis nous avons poursuivi l'installation de notre matériel sur le support. Nous avons également connecté la LED et le moteur. Cependant, nous avons rencontré un problème avec le moteur : bien qu'il s'allume correctement lorsque la broche est réglée sur HIGH, il ne s'éteint pas avec LOW. Pour résoudre ce problème, nous avons fixé un rendez-vous avec notre tuteur le 20/01.[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/iyIimage.png)**Figure 8 : Montage Arduino avec LED et moteur sur breadboard**
##### 20/01/2025Nous avons rencontré notre tuteur pour résoudre le problème lié au moteur. Il s'est avéré que l'Arduino ne pouvait pas fournir les 5 V nécessaires à tous les composants. Pour y remédier, nous avons connecté le moteur et l'électrovanne à une alimentation indépendante de 12 V, ce qui a permis à celui-ci de fonctionner correctement. Cependant, cette tension est trop élevée donc nous utilisons un potentiomètre pour régler le la tension qui arrive au moteur et donc la vitesse du moteur. Nous avons ensuite gravé au laser un QR code menant à notre Wiki, nos noms, ainsi que l'UE encadrant notre projet, sur une planche de peuplier de 6 mm.**Figure 9 : Plaque d'identification du projet**
##### 22/01/2025Notre objectif étant de détecter un changement de couleur avec du sirop rouge, il s'avère être problématique d'avoir un agitateur rouge. De ce fait, nous avons fait une autre impression 3D d'un agitateur noir qui ne sera pas détecté par le capteur de couleur. Nous avons fait un trou au niveau de l'agitateur afin de pouvoir le fixer au moteur. Par la suite, nous avons tester notre système d'électrovanne et de capteur de distance. Les deux fonctionnent. Cependant, nous avons détecté des fuites au niveau de l'électrovanne. Néanmoins, nous avons essayé de tester l'écran LCD après un essai, ce dernier ne nous affichait plus le bon message. Par ailleurs, nous avons solidifié notre montage.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/whatsapp-image-2025-01-28-at-14-59-24.jpeg)
**Figure 10: Montage fixé avec LCD**
**Figure 11 : Nouvel agitateur noir**
##### 23/01/2025Lors de notre rencontre avec notre tuteur, il nous a aidé à régler les problèmes de fuites en nous fournissant du ruban teflon à coller sur l'électrovanne. Nous avons pu trouver la source du problème pour l'écran LCD qui ne fonctionnait pas car l'adresse utilisée n'était pas la bonne. En effet, il faut utiliser 0X3E et pas 0X27.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/whatsapp-image-2025-01-23-at-17-55-17-1.jpeg)
**Figure 12: Dos du montage avec tous les branchements**
**Figure 13 : Ecran LCD affichant le volume versé**
En modifiant le code, nous pouvons à présent afficher le volume versé dans notre gobelet. Cependant, la précision de notre capteur de distance est de 1 cm ce qui n'est pas assez précis car nous allons verser une petite quantité de sirop. Le problème qui se pose actuellement est que lorsque nous arrêtons totalement l'électrovanne l'eau continue de couler au goutte-à-goutte. De plus, le potentiomètre dégage une odeur de brûlé quand nous actionnons le moteur.
##### 27/01/2025Nous sommes allés voir notre tuteur pour des problèmes liés au moteur et à l'électrovanne. En effet, le liquide continuait de couler après avoir éteint l'électrovanne. En ce qui concerne le moteur, les potentiomètres ne nous permettaient pas de réguler la tension au borne du moteur, et donc sa vitesse de rotation. A l'issu de cette rencontre, nous avons utilisé un relais pour contrôler l'électrovanne et un module mosfet pour le moteur. Nous sommes ensuite allé au Fablab pour tester ces nouveaux composants. Le relay fonctionne, mais pas le mosfet. Nous ne pouvons toujours pas contrôler la tension au borne du moteur avec précision.
##### 28/01/2025Nous sommes allé voir notre tuteur pour résoudre nos problèmes de moteur. Finalement, nous avons remarqué que nous n'avons pas besoin de mélanger. En effet, le mélange se fait naturellement par diffusion et nous obtenons une solution bien homogène. Nous avons donc retiré le moteur et l'agitateur, qui ne sommes donc plus nécessaires.
##### Description du fonctionnement final de notre système :
Au départ, un verre d'eau est introduit dans notre boite noire, et l'agitateur est positionné dans le verre. Le système commence par faire une mesure de la distance du liquide. Ensuite le capteur de couleur mesure l'intensité du rouge dans le verre en boucle. Tant que la valeur est au dessus du seuil défini, l'électrovanne est alimentée (le liquide coloré coule) et la LED rouge est allumée. Dès que la valeur seuil est atteinte, l'électrovanne n'est plus alimenté, la LED s'éteint, et le capteur de couleur mesure une deuxième fois la distance. A l'aide de ces deux valeurs de distance, le volume de liquide ajouté est calculé et affiché sur l'écran LCD.
##### Conclusion
A l'issue de ce projet, nous avons pu atteindre notre objectif qui est de réguler la couleur finale dans un récipient d'eau. Malgré les complications avec le moteur DC, nous avons su réagir rapidement et adapter notre système avec le matériel à notre disposition. Ce projet nous a permis d'élargir nos connaissances en dehors de notre formation initiale. En effet, nous avons pu utiliser différentes machines tels que Raise3D pour l'impression 3D et la découpeuse laser pour la plaque d'identification du projet. Nous avons aussi appris à coder et à utiliser des composants électroniques divers et variés.
**Vidéo : Fonctionnement de la burette automatique**
Voici le code final utilisé pour la réalisation de notre burette automatique:
>
\#include <Wire.h> //bibliothèque pour communiquer avec I2C
\#include <Ultrasonic.h> //bibliothèque du capteur à ultrason
\#include "rgb_lcd.h" //bibliothèque de l'écran LCD
>
\#define led 2
\#define S0 3 //S0 S1 frequence
\#define S1 4
\#define S2 5 //S2 S3 filtre de couleur
\#define S3 6
\#define value 9 //valeur que renvoit le capteur de couleur
\#define valvepin 8 //Pin de contrôle pour relais de l'électrovanne
Ultrasonic ultrasonic(11); //Pin de contrôle du capteur à ultrason
>
//Création de nos différentes variables
float DistIni = 0.0;
float DistFin = 0.0;
float Volume = 0.0;
float RayonVerre = 3.4; //Valeur du rayon en cm
double rouge = 0.0;
double rougetot = 0.0;
double rougemoy = 0.0;
double rougemoy1 = 0.0;
double rougemoy2 = 0.0;
int i = 0;
int seuil = 175; //valeur de seuil
>
//Définition de l'écran LCD
rgb_lcd lcd;
const int colorR = 255;
const int colorG = 0;
const int colorB = 0;
>
void setup() {
>
//Définition du mode de nos pins
pinMode(S0, OUTPUT);
pinMode(S1, OUTPUT);
pinMode(S2, OUTPUT);
pinMode(S3, OUTPUT);
pinMode(value, INPUT);
pinMode(valvepin, OUTPUT);
pinMode(led, OUTPUT);
>
Serial.begin(9600);
>
//Choix de l'échelle de fréquence à 20%
digitalWrite(S0, HIGH);
digitalWrite(S1, LOW);
>
//Initialisation de l'écran LCD
lcd.begin(16, 2);
lcd.setRGB(colorR, colorG, colorB);
//lcd.print("Wait...");
}
>
void loop() {
>
//Mesure initiale de la distance
if (DistIni == 0) {
DistIni = ultrasonic.MeasureInCentimeters();
Serial.print("Distance initiale = ");
Serial.print(DistIni);
Serial.println(" cm");
}
>
// Mesure de l'intensité en rouge
digitalWrite(S2, LOW);
digitalWrite(S3, LOW);
>
//Nous réalisons une boucle for pour calculer une moyenne des valeur de couleur (20 valeurs sur 1 seconde)
for (int i=0; i<20; i++){
rouge = pulseIn(value, HIGH);
rougetot = rougetot + rouge;
delay(50);
}
>
rougemoy = rougetot/20;
Serial.print("red :");
Serial.println(rougemoy);
rougetot = 0.0;
>
if (rougemoy < seuil) { //Seuil de couleur rouge pas encore atteint
digitalWrite(valvepin, HIGH); //Vanne ouverte
digitalWrite(led, HIGH); //LED allumée
lcd.clear();
lcd.print(rougemoy);
}
>
// Nous gardons en mémoire les trois dernières valeurs de rouge, lorsque les trois sont supérieures au seuil, le système s'arrête.
// En effet nous avons souvent une oscillation autour du seuil qui arrête et redemarre l'électrovanne toutes les secondes.
// Attendre trois valeurs au dessus du seuil permet d'éviter ce problème
else if (rougemoy >= seuil and rougemoy1 >= seuil and rougemoy2 >= seuil) {
DistFin = ultrasonic.MeasureInCentimeters(); //Mesure de la distance finale
Volume = (DistIni - DistFin) * PI * RayonVerre * RayonVerre; //Calcul du volume
Serial.print("Distance Finale = ");
Serial.print(DistFin);
Serial.println(" cm");
lcd.clear();
lcd.print("Ready !");
lcd.setCursor(0, 1);
lcd.print("V = ");
lcd.print(Volume);
lcd.print(" mL");
digitalWrite(valvepin, LOW); //Vanne fermée
digitalWrite(led, LOW); //LED éteinte
delay(1000000);
}
>
//Nous gardons en mémoire les valeurs de rouge des deux étapes précédentes
rougemoy2 = rougemoy1;
rougemoy1 = rougemoy;
}
>
# Régulation du niveau d'eau dans une cuve (Groupe E)
#### **Informations**
**Membres du projet :**
- Jonathan LI (jonathan.li@etu.sorbonne-universite.fr)
- Léa LIN (lea.lin.1@etu.sorbonne-universite.fr)
- Bernard LUONG (bernard.luong@etu.sorbonne-universite.fr)
- Nishta RAMKHELAWON (nishta.ramkhelawon@etu.sorbonne-universite.fr)
**Formation : ** Master 2 Chimie parcours Ingénierie Chimique - MU5CI803 : Optimisation et contrôle des procédés
**Date :** 07 octobre 2024 - 29 janvier 2025
#### **Contexte**La régulation consiste à maintenir constante une grandeur physique telle que le niveau d’eau d’un réservoir percé, la température ou l’humidité d’un local. Pour cela, la régulation ajuste la "puissance" à apporter en fonction des besoins. En effet pour maintenir la consigne, il faut compenser les perturbations telles que les fuites du réservoir, les variations de la température extérieure ou de l’ensoleillement. La valeur de la grandeur que l’on cherche à maintenir constante est appelée **consigne.** Il est donc important de réguler le niveau d'eau dans un réservoir pour préserver les équilibres écologiques. De plus, dans les systèmes industriels et domestiques, un bon contrôle permet d'améliorer l'efficacité énergétique et d'éviter le gaspillage, garantissant ainsi une gestion durable des ressources en eau. Enfin, grâce à la régulation, il est possible de surveiller le fonctionnement correct de l’installation. On pourra par exemple éviter le débordement du réservoir.
#### **Objectifs**Dans le cadre du projet de l'UE 5CI803, nous allons réaliser une étude pratique portant sur la régulation du niveau d'eau dans une cuve à l'aide d'une **carte Arduino** et d'un **capteur ultrason**. Le but de ce projet est de concevoir et de mettre en œuvre un système automatisé permettant de contrôler le niveau de liquide dans un réservoir se videant dans un autre réservoir de stockage de manière continue dans un circuit fermé. Ce système repose sur l'utilisation d'un capteur ultrason pour mesurer le niveau d'eau, d'une pompe 12V pour ajuster le niveau de liquide, et d'un programme codé sur Arduino pour assurer une régulation précise et stable. Un orifice se trouve en bas du réservoir afin que le liquide se vide sous l'action de la gravité.Ce projet s'inscrit dans la première partie du cours, dédiée à la régulation et à l'automatisation, et vise à nous initier aux concepts fondamentaux de l'ingénierie chimique. Ce projet vise également à nous rencontrer avec la fabrication d'une maquette de A à Z, et la prise en main d'un microcontrôleur Arduino UNO.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/whatsapp-image-2025-01-29-a-16-13-19-2238b15c.jpg)
[***Fig. 1 Notre régulateur de niveau d'eau prise le 29/01/2025***](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/whatsapp-image-2025-01-28-a-13-11-54-8a1d40c8.jpg)
#### **Matériels**
- Support (en bois et en PMMA)
- Arduino UNO
- Écran LCD (16 x 2) I2C
- Breadboard
- Pompe 12 V (+ adaptateur 12 V)
- Capteur ultrason (HC-SR04)
- Module relais (pour contrôler la pompe en mode automatique)
- Câbles électriques x 20
- Pinces crocodiles électronique x 3
- Verre en plastique (Réservoir)
- Boîte de glace (Stockage)
- Tuyaux (1 m)
- Equerres de renfort x 2
- Collier de serrage x 3
##### **Rôles des matériels électroniques**
**Arduino UNO :** Arduino UNO est une plateforme électronique open-source comprenant une carte de circuit programmable facile à utiliser et un logiciel : Arduino IDE. La carte Arduino UNO sert à raccorder des capteurs et des actionneurs, et elle exécute un programme informatique.
**Breadboard :**
Le breadboard sert à construire les montages électroniques sans soudure.
**Capteur ultrason :**
C’est un instrument électronique qui utilise des ondes sonores ultrasonores (à travers l'air) pour mesurer la distance de l'objet cible, et le son réfléchi est converti en signal électrique. Ce capteur nous a aidé à mesurer le niveau d’eau qu’il y avait dans le réservoir. Notre capteur ultrason mesure la distance en centimètre en chiffre entier.
**L’écran LCD :**
Un I2C LCD 16x2 est un dispositif qui peut afficher du texte et des caractères sur un écran à cristaux liquides (LCD) de 16x2 (16 colonnes et 2 lignes) en utilisant le protocole I2C. On utilise un I2C LCD16x2 pour afficher des informations provenant de notre projet Arduino, telles que des relevés de capteurs. Dans notre cas, l'écran LCD affichera "Niveau d'eau %" pour nous indiquer le niveau d'eau dans le réservoir en pourcentage et "pump on" quand la pompe s'allumera.
**Pompe :**
La pompe nous aide à pomper l’eau du stockage pour remplir le réservoir. Elle va être contrôler par le module relais puisque elle aura besoin de 12 V pour fonctionner.
**Module Relais :**
Le module relais est un interrupteur commandé électriquement qui peut être activé ou désactivé pour décider de laisser passer le courant ou non. Il est conçu pour être contrôlé avec de faibles tensions, comme 5V, compatible avec votre Arduino. Notre module relais est celui qui va allumer ou éteindre la pompe quand il reçoit le signal de l’arduino. Grâce à l’alimentation de 12 V que nous avons utilisé, le relais module peut faire fonctionner la pompe puisque cette dernière a besoin de plus de 5V pour s’allumer.
#### **Machines utilisées au FabLab**
- Découpeuse laser Trotec Speedy 360
- Pistolet à colle
- Perceuse
- Multimètre
#### **Construction**Lors de notre première séance, nous avons réalisé un premier schéma du montage afin d'étudier les équipements dont nous aurions besoin pour réaliser notre projet.
[***Fig. 2 Schéma de notre montage de régulation du niveau d'eau dans une cuve***](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2024-10/5ci803.jpg)
Le schéma ci-dessous montre le fonctionnement du capteur à ultrasons que nous utilisons pour mieux le comprendre. Le capteur émet des rayons et ces derniers se transmettent lorsqu'ils arrivent au niveau d'eau et le récepteur reçoit les rayons réfléchis. Le capteur le temps mis pour que le récepteur reçoive les rayons et enregistre ensuite la distance en utilisant la vitesse du son dans l'air.
[
](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2024-11/OrCimage.png)
***Fig. 3 Fonctionnement du capteur Ultrason ( [https://www.robotique.tech/tutoriel/capteur-ultrason-arduino/](https://www.robotique.tech/tutoriel/capteur-ultrason-arduino/) )***Nous avons ensuite suivi à la lettre ces 5 étapes afin de pouvoir nous organiser au mieux dans le bon déroulement du projet :
##### Étape 1
##### La première étape consiste à rechercher sur le fonctionnement de l'Arduino UNO ainsi que le code et le montage utilisés habituellement pour l'utilisation d'un capteur à ultrasons pour la lecture du niveau d'eau. Les premiers essais sont réalisés sur Tinkercad afin de visualiser le montage dans le global.
##### Étape 2Le code d'Arduino est inspiré de ressources diverses sur Internet et sur Youtube. Une fois le Tinkercad effectué avec les différents composants électroniques, nous pouvons réaliser un montage simple pour faire fonctionner l'écran LCD avec le capteur à ultrasons. Les tests du code sont réalisés sur le logiciel Arduino IDE afin de mettre en œuvre notre montage et de modifier le code en temps réel. Nous devons notamment faire attention aux librairies utilisées dans le code car cela nous a coûté beaucoup de temps pour trouver les bonnes librairies à nos matériels électroniques.
##### Étape 3Après avoir bien vérifié que le code Arduino *(Annexe)* marche correctement avec les objectifs émis au début en testant avec deux verres d'eau et que tous les composants du montage (pompe, alimentation, carte Arduino UNO) fonctionnent comme il le faut, nous passer à l'étape de la construction du montage. En utilisant un support en bois et en PMMA, et divers outils dans le FabLab comme la découpeuse laser Trotec Speedy 360 et la perceuse, nous montons un support simple pour notre dispositif.
##### Étape 4L'avant dernière étape consiste à assembler les dispositifs électroniques et le support afin d'obtenir la maquette finale. Les tests sont réalisés pour s'assurer que l'installation fonctionne bien qu'il n'y ait pas de problèmes inattendus.
##### Étape 5La démonstration de la maquette est réalisée le 29 janvier en présence de M. Jérôme Pulpytel.
Veuillez cliquer sur le lien ci-dessous pour voir une démonstration du montage final de notre projet. Vous pourrez voir nos résultats obtenues où nous avons fixé le niveau d'eau dans le réservoir à 50%.[Vidéo de la démonstration](https://wiki.fablab.sorbonne-universite.fr/BookStack/attachments/1231)
#### **Journal de bord**
##### 07/10/2024Nous avons fait le choix de notre projet qui est la Régulation du niveau d'eau dans une cuve. Ensuite nous avons fait une schématisation du projet pour pouvoir faire une liste des matériels dont nous aurons besoin.
##### 15/10/2024Nous avons complété la liste du matériel nécessaire pour envoyer à notre tutrice.
##### 21/10/2024Récupération du matériel auprès de la tutrice et brainstorming. Essai d'un montage sur Tinkercad. Compréhension et recherches sur les différents composés utilisés (ultrasons, LCD) pour mieux comprendre leur utilité.
##### 18/11/2024Nous avons écrit dans un premier temps le code sur Tinkercad pour le capteur ultrason + l'écran LCD en utilisant la bibliothèque : Adafruit.Cela a parfaitement fonctionné sur le Tinkercad ; le capteur à ultrasons envoie un signal à l'Arduino qui signale lorsque la pompe doit fonctionner à travers un module relais.
##### ***Connexions :***
***Arduino :*** Pin 5V connecté au breadboard dans la colonne positiveGND connecté au breadboard dans la colonne négative
***Le capteur ultrason :[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/DSdscreenshot-2025-01-03-at-00-55-06.png)*** VCC : 5V de l'ArduinoGND : GND de l'ArduinoSIG : PIN 7 sur l'Arduino
***L'écran LCD :*** VCC : 5V de l'ArduinoGND : GND de l'ArduinoSCL : SCL sur l'ArduinoSDA : SDA sur l'Arduino
***Module relais :***
SIG : PIN 3 sur l'ArduinoVCC : 5V de l'ArduinoGND : GND de l'ArduinoV+ : pôle positif de la pompe V- : pôle négatif de la pompeVIN : pôle positif de l'alimentation ***Fig. 4 Schéma de notre Tinkercad***GND : pôle négatif de l'alimentation
##### 21/11/2024Nous avons fait en premier temps le branchement comme effectué sur le Tinkercad comprenant le breadboard, l'Arduino UNO, le capteur ultrason et l'écran LCD, avec le code correspondant. Sur Tinkercad, le code a bien marché mais lorsque nous avons testé sur le logiciel **Arduino IDE** , nous avons rencontré un problème de détection de port. Avec le premier ordinateur, aucun port n'est détecté. Sur le deuxième ordinateur, un port est détecté mais il ne semble pas être le bon et c'est affiché un message d'erreur sur Arduino IDE. Nous avons changé le Arduino UNO et il n'y a plus de message d'erreur. Le code fonctionne bien pour le capteur à ultrasons mais il faut le modifier encore car il ne donne pas des valeurs cohérentes. Le code n'a pas fonctionné pour l'écran LCD même si nous l'avons échangé comme vous pouvez le voir sur le schéma ci-dessous.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/ebbe7960-17f3-4e56-bd67-3374b1261b05.jpg)
***Fig. 5 Erreur affichée sur l'écran LCD***
##### 25/11/2024Nous avons recherché des nouvelles bibliographies pour faire fonctionner l'écran LCD et le capteur à ultrasons. Nous avons installé ces 2 bibliothèques suivantes sur Arduino IDE :
*1)* Grove Ultrasonic Ranger
*2)* Grove LCD RGB Backlight
##### 28/11/2024Nous avons réussi à faire fonctionner les 2 équipements : le capteur ultrason et l'écran LCD comme vous pouvez le voir sur le schéma ci-dessous. *(Voir le code en annexe)*
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/7pZ9bf7f993-92c5-443d-b6ea-e94f689e5a4a.jpg)
***Fig. 6 Affichage sur l'écran LCD ***Pour la prochaine séance, nous allons tester si la pompe fonctionne bien ou pas et si nous arrivons à réguler le niveau d'eau.
##### 29/11/2024Lors de cette séance, nous avons découvert et utilisé **Inkscape** , un logiciel de dessin vectoriel open source. Ce dernier permet de concevoir et de modifier des fichiers de format SVG, souvent utilisés par l'imprimante laser 360. Inkscape est essentiel pour créer des designs précis, définir les tracés nécessaires pour les découpes et les gravures, et convertir les fichiers dans des formats compatibles avec les machines. Grâce à ses fonctionnalités, nous avons pu préparer des motifs adaptés, ajuster leurs dimensions et optimiser la découpe ainsi que la gravure sur différents matériaux. À l'issue de cette séance, nous avons réalisé deux gravures sur deux matériaux différents, et voici les résultats obtenus :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/whatsapp-image-2025-01-28-a-13-11-54-f3c2f4ff.jpg)
***Fig. 7 Gravure sur deux plaques différentes***
##### 05/12/2024Nous avons testé la pompe avec différentes batteries de 12 V mais cela n'a pas fonctionné.
##### 12/12/2024Nous avons changé d'alimentation et la pompe fonctionne bien maintenant avec le module relais.La pompe s'arrête dès que le niveau d'eau est atteint et se rallume lorsque le niveau d'eau est inférieur au niveau souhaité. Nous avons complété la plupart des objectifs du sujet. Le montage fonctionne bien avec le code. Pour la prochaine fois, nous allons commencer à mettre en forme le montage proposé en figure 2. Il faut d'abord trouver le bon diamètre de l'orifice du bas du réservoir qui permet le débit d'eau sortant du réservoir soit inférieur au débit d'eau entrant dans le réservoir via la pompe.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2024-12/GKeimage.png)
***Fig. 8 Petite démonstration du montage***
##### 19/12/2024Nous avons réussi à trouver le bon diamètre de l'orifice du bas du réservoir et cela a permis de réguler le niveau d'eau du réservoir jusqu'à 85 %. Nous avons ensuite proposé un schéma du montage ci-dessous :
[  ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/page1-3.png)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/page2-3.png)
***Fig. 9* Schéma de (a) l'avant et (b) de l'arrière du support en bois**
##### 20/12/2024Pour le support du réservoir, nous avons décidé d'utiliser un support en PMMA où nous l'avons coupé en utilisant la découpeuse laser 360. Tout d'abord, nous avons fait des tests sur un bout de PMMA pour avoir le bon diamètre des trous correspondant aux vis que nous allons utiliser et de s'affrenchir des incertitudes de la découpeuse laser. Une fois la réalisation, nous avons trouvé le diamètre correspondant au visse que nous allons utiliser pour le support.[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/tcWimg-5793.jpg)***Fig. 10 Des tests faits par le laser pour les trous***
##### 10/01/2025Nous avons ensuite procédé à la fabrication du support pour le verre. Pour cela, nous avons découpé un grand cercle de 7,5 cm de diamètre dans une plaque de PMMA afin d'y insérer le verre en plastique servant de réservoir.[ ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/img-5792.jpg)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/img-5797.jpg)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/img-5791.jpg)***Fig. 11 Support du réservoir***Nous avons également réalisé un couvercle du réservoir pour le support du capteur à ultrasons. Le couvercle du réservoir recouvre tout le haut du réservoir, tous en laissant passer le capteur à ultrasons et le tuyau. [](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/img-5794.jpg)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/img-5796.jpg)***Fig. 12 Couvercle du réservoir***
##### 24/01/2025Réalisation des encrages sur le support en bois via des trous.À l'arrière de ce support, nous avons percé quatre petits trous de la taille des vis, positionnés de manière à permettre une fixation régulière en fonction de l'équerre, afin de l'accrocher solidement au support en bois. Ces trous ont été réalisés avec une perceuse à des emplacements stratégiques pour allier praticité et esthétisme. Nous avons également ajouté de petits trous pour fixer la pompe, l'écran LCD et connecter les équipements à l'Arduino à l'arrière du support en bois. L'ancrage de la pompe et de l'écran LCD sera assuré à l'aide de colliers de serrage.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/HhHimage.png)
***Fig. 13 Collier de serrage***
##### 27/01/2025Réalisation du montage final.Nous avons rassemblé toutes les pièces de puzzle de notre projet : le support pour notre réservoir, l'encrage de la pompe en haut à droite, le LCD en haut à gauche. Le stockage d'eau sera placé en dessous du réservoir relié par un tuyau et une pompe.Nous avons rencontré un petit problème avec la pompe car nous l'avons placée en haut et donc elle ne pouvait pas bien pomper l'eau dans le réservoir. Quand nous avons placé la pompe beaucoup trop haute, la pression était trop élevée et donc elle ne pouvait pas transporter l'eau dans le tuyau. Pour résoudre ce problème, nous avons décidé de remplir le tuyau avec l'eau manuellement avant de démarrer la pompe. Une autre solution était de placer la pompe au bas près du stockage.
[ ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/img-5869.jpg)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/whatsapp-image-2025-01-28-a-13-11-54-7c594163.jpg)
***Fig. 14 Montage (presque) final***
##### 29/01/2025Pour notre dernière session, nous avons utilisé la découpeuse laser 360 pour faire la gravure du QR code qui mêne à la page de notre wiki sur une plaque de bois Peltier de épaisseur 6 mm.[ ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/img-5890.jpg) [](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/img-5904.jpg)
***Fig. 15 Gravure du QR code***
Présentation du montage final.Lors de notre dernière séance, nous avons souhaité peaufiner les derniers détails afin de rendre notre projet aussi abouti que possible. Cela inclut notamment l'ajout d'étiquettes pour une meilleure compréhension de notre travail, ainsi que l'organisation optimisée des câbles à l'arrière du support. Ces ajustements nous ont finalement permis d'obtenir le résultat suivant :
[ ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/img-5891.jpg)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/img-5905.jpg)[ ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/img-5891.jpg)
***Fig. 16 Montage final (devant et l'arrière du support)***
#### **Conclusion**En conclusion, ce projet nous a permis de mettre en application les concepts de régulation et d'automatisation en concevant un système de contrôle du niveau d'eau dans une cuve à l'aide d'un capteur à ultrasons et d'une carte Arduino . Grâce à une approche progressive et méthodique, nous avons pu surmonter les différentes difficultés techniques rencontrées, notamment le choix des bibliothèques logicielles, les problèmes de connexion des composants et l'optimisation du débit de l'eau dans le circuit.L'intégration de la pompe et du module relais a permis d'assurer une régulation efficace du niveau d'eau, validant ainsi les principes de contrôle mis en œuvre. De plus, l'utilisation du FabLab et des outils de fabrication numérique nous a offert une expérience concrète de prototypage, nous initiant aux techniques de découpe laser et de modélisation.Au-delà de l'aspect technique, ce projet nous a permis de développer des compétences essentielles en gestion de projet, en travail d'équipe et en résolution de problèmes. La démonstration finale a confirmé le bon fonctionnement de notre système, illustrant la pertinence des choix techniques réalisés.
#### **Annexe**
Voici le code utilisé :
```
#include "Ultrasonic.h"
#include
#include "rgb_lcd.h"
rgb_lcd lcd; // setting up LCD screen
const int colorR = 255;
const int colorG = 0;
const int colorB = 0;
const float water_height_needed_percentage = 80; // en %, choissisez le niveau d'eau souhaité
const float max_height = 14; // en cm, mesurez le profondeur du réservoir
float water_height; // mesure le niveau d'eau dans le réservoir
float water_height_percentage; //calcule le % d'eau dans le réservoir
float distance; // distance entre la surface d'eau et l'ultrason
bool pump;
const int relay_pin = 3; // PIN 3 sur l'Arduino
Ultrasonic ultrasonic(7); // PIN 7 sur l'Arduino
void setup()
{
pinMode(relay_pin, OUTPUT);
digitalWrite(relay_pin, LOW);
lcd.begin(16, 2); // set up the LCD's number of columns and rows
lcd.setRGB(colorR, colorG, colorB);
// Pour afficher sur l'écran LCD
lcd.print("Niveau d'eau % :");
delay(100);
Serial.begin(9600);
}
void loop()
{
distance = ultrasonic.MeasureInCentimeters(); // mesure la distance entre la surface d'eau et l'ultrason par le capteur ultrason
Serial.print(distance); //0~14cm
Serial.println(" cm");
water_height = max_height - distance;
water_height_percentage = (water_height/max_height) * 100.0;
if (water_height_percentage >= water_height_needed_percentage) {
digitalWrite(relay_pin, LOW); // Eteint la pompe si le niveau d'eau est atteint
pump = false;
}
else
{
digitalWrite(relay_pin, HIGH); // Allume la pompe si le niveau d'eau est inférieur à celui souhaité
pump = true;
Serial.print("PUMP ON\n");
}
// Afficher les détails sur l'écran LCD
lcd.setCursor(0, 1);
lcd.print(water_height_percentage);
if (pump)
{
lcd.print(" pump on");
}
else
{
lcd.print(" "); // pour effacer le "pump on" sur l'écran
}
delay(250);
}
```
Pour mieux comprendre le code, voici un schéma pour expliquer les variables détaillées dans le code.
#### **Remerciements**Nous tenons à remercier chaleureusement M. Pulpytel et Mme Akrour pour leur encadrement tout au long du projet 5CI803. Nous avons énormément apprécié travailler sur ce projet, qui nous a permis d'acquérir de nouvelles compétences et d'approfondir nos connaissances. Votre accompagnement et vos conseils nous ont été très précieux. Merci encore pour votre soutien et votre disponibilité !De la part de toute l'équipe E !
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/whatsapp-image-2025-01-29-a-18-00-43-bbd7b89b.jpg)
(Une pensée également pour Jonathan LI)
# Régulation de température par mélangeage de liquide chaud froid. (Groupe C)
#### **Informations**
- Melissa IMATOUKEN (Melissa.Imatouken@etu.sorbonne-universite.fr)
- Sonia KHALDI (sonia.khaldi@etu.sorbonne-universite.fr)
- Djamila REZIG (djamila.rezig@etu.sorbonne-universite.fr)
- Farah SAAD (farah.saad@etu.sorbonne-universite.fr)
- Yasmine BOUGUERBA ( Yasmine.bouguerba@etu.sorbonne-universite.fr)
Cursus : Master 2 de Chimie- Parcours Ingénierie Chimique
**Date : 14 octobre 2024 - 27 Janvier 2025**
#### **Contexte**
Dans les procédés industriels, le contrôle de la température est essentiel pour assurer la qualité, l’efficacité et la sécurité des opérations. La régulation de température par mélange de fluides à différentes températures est une méthode couramment utilisée, particulièrement dans les applications où une température de sortie précise est requise pour des étapes en aval. Dans ce contexte, le projet s’intéresse à la conception et la mise en œuvre d’un système permettant de contrôler et de réguler la température par le mélange de deux flux de liquides, l’un chaud et l’autre froid, en utilisant des pompes et un capteur de température. Cette régulation se fait en ajustant le débit des deux fluides afin d’atteindre une température cible définie par l’utilisateur.
#### **Objectifs**
L’objectif principal de ce travail est de concevoir un système permettant de contrôler et de réguler la température d’un flux résultant du mélange de deux liquides, l’un à température ambiante et l’autre préchauffé à environ 50 °C. Cette étude sera réaliser en utilisant un programme Arduino. Les objectifs spécifiques de cette étude sont donc :
1. Définition et Contrôle de la Température : Permettre à l’utilisateur de définir une température cible pour le mélange final. Le système devra alors ajuster les débits des deux fluides pour atteindre cette température de manière fiable et stable.
2. Contrôle des Débits : Les deux liquides seront pompés séparément et mélangés en fonction des besoins de température. L’une des pompes opérera à débit constant pour l’eau à température ambiante, tandis que l’autre fournira un débit variable pour l’eau chaude. Cela permet de moduler la température finale du mélange.
3. Mesure de Température : Une sonde de température étanche sera installée pour mesurer en temps réel la température du mélange et permettre les ajustements nécessaires des débits.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/whatsapp-image-2025-01-27-a-17-34-26-5732e446.jpg)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/whatsapp-image-2025-01-27-a-17-34-26-8a5ab7bc.jpg)
#### **Matériel**
Le matériel dont nous avons eu besoin pour notre projet sont les suivant :
- Aluminium pour perte thermique
- 2 réservoirs (bouteille en plastique)
- Une cuve
- Des tuyaux plastiques
- 2 pompes (le type de pompe reste à déterminer)
- 2 transistors
- Arduino
- Câblages électroniques
- Resistance de 4,7 KOhm
- Agitateur
- Alimentation
- Capteur étanche
- 3 Leds (rouge vert bleu) + resistance adapter
#### **Machines utilisées**
- Perceuse
- Découpeuse laser
#### **Construction**
#### **Étape 1 : Préparation**
- Création des schémas fonctionnels (pompes, LED, sonde de température).
- Rassemblement et test des composants (Arduino, capteurs, pompes, etc.).
- Installation d’Arduino IDE et simulation sur TinkerCAD.
- Photos des composants et captures des schémas.
#### **Étape 2 : Assemblage**
- Découpage et perçage des plaques (bois, plexiglas ou MDF).
- Fixation des pompes, cuves et autres composants.
- Photos des étapes d’assemblage et des fichiers d’usinage.
#### **Étape 3 : Connexion et test**
- Branchement des composants à l’Arduino.
- Chargement du code et tests de fonctionnement (pompes, LED, sonde).
- Photos du montage final et captures du code utilisé.
#### **Étape 4 : Boucle de régulation**
- Implémentation du code de régulation basé sur les lectures du capteur de température.
- Utilisation de la fonction `analogWrite` pour contrôler les pompes en fonction de la température cible.
- Test de la boucle pour s'assurer que :
- Les pompes fonctionnent simultanément ou indépendamment selon les besoins.
- Les LEDs s’allument correctement en fonction de l’état des pompes et de la sonde.
- Photos et vidéos du système en fonctionnement.
#### **Journal de bord**
##### **Lundi 07 octobre 2024**Attribution des sujets de projets.**Intitulé** : Régulation de température par mélangeage de liquide chaud froid.
**Objectifs fixés pour la séance prochaine:**
- [x] Recherche individuelle sur le sujet.
- [x] Chaque membre doit établir une liste des composants nécessaires.
- [x] Schématiser la régulation (croquis).
- [x] Prise de contact avec le tuteur pour fixer un rendez-vous.
##### **Lundi 14 octobre 2024**Réunion de groupe pour discuter de nos idées et nous mettre d’accord sur un plan faisable à présenter au tuteur.Points aborder lors de la réunion :
- Liste des composants à soumettre au tuteur.
- Les différents schémas de régulation potentiels.
Les réservoirs ne sont pas nécessaires et les vannes ne créeront que des pertes de charges supplémentaires.
Mieux vaut avoir un T pour mélanger les deux flux avant d’arriver dans la cuve pour réduire le temps d’homogénéisation de la température dans la cuve (+un meilleur aspect esthétique)
Ce schéma est le plus cohérant avec les composants disponible et le but de notre régulation.Bilan du rendez-vous avec le tuteur :
- Réponses à nos questions et conseils pratiques.
- Schéma 3 validé.
- Liste des composants validée.
- Récupération de certains composants (Arduino, Platine, résistance, câblages, deux transistors et le capteur de température étanche).
Liste des composants supposés:
- 2 réservoirs (dont un est isotherme)
- Une cuve
- Des tuyaux plastiques
- 3 rodages/joints
- 2 pompes (le type de pompe reste à déterminer)
- 2 transistors
- Arduino
- Câblages électroniques
- Platine
- Resistance de 4,7 KOhm
- Agitateur (à voir)
- Alimentation (doit être adapter aux pompes)
- Capteur étanche
- Leds
- Robinet pour vider la cuve de mélange (facultatif)
**Objectifs fixés pour la séance prochaine:**
- [x] Simuler le projet sur TinkerCAD grâce au schéma et liste des composants.
- [x] Installer Arduino IDE.
- [x] Prochaine réunion le 21/10.
##### **Lundi 21 octobre 2024**
Réunion du groupe au FabLab pour valider la simulation du système de régulation faite sur TinkerCad, en s'assurant qu'il fonctionne correctement avec les composants disponibles.
Les différents circuits proposés par les membres :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2024-10/bP9image.png)
Le circuit proposé au tuteur :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2024-10/dvdimage.png)
Commentaires du tuteur sur le montage :****
Le montage semble correct, tous les composants nécessaires sont bien connectés pour faire fonctionner la simulation.Code appliqué :
void setup() {
Serial.begin(9600);
pinMode(9, OUTPUT); pinMode(8, OUTPUT); pinMode(7, OUTPUT); pinMode(6, OUTPUT);
}
void loop() {
int reading = analogRead(A0);
float voltage = reading \* (5000 / 1024.0);
float temperature = (voltage - 500) / 10;
Serial.println(temperature);
delay(100);
if (temperature > 30) {
digitalWrite(9, HIGH);
digitalWrite(8, LOW);
}
if (temperature < 30) {
digitalWrite(9, LOW);
digitalWrite(8, HIGH);
}
if (temperature == 30) {
digitalWrite(9, LOW);
digitalWrite(8, LOW);
}
if (temperature > 30) {
digitalWrite(7, HIGH);
} else {
digitalWrite(7, LOW);
}
if (temperature < 30)
{
digitalWrite(6, HIGH);
} else {
digitalWrite(6, LOW);
}
}
Commentaires du tuteur sur le code :
Bien que le code fonctionne correctement, il ne répond pas exactement aux exigences de la régulation attendue. En effet, initialement, nous avions configuré les deux pompes pour fonctionner en mode tout ou rien (TOR) :
- La pompe d'eau chaude s'allumait lorsque la température était inférieure à 30°C.
- La pompe d'eau froide s'allumait uniquement lorsque la température dépassait 30°C.
Cependant, le tuteur a proposé d'ajuster ce fonctionnement pour obtenir une régulation plus précise. Désormais, le débit de la pompe d'eau froide doit rester constant, tandis que le débit de la pompe d'eau chaude doit varier en fonction des besoins pour maintenir la température cible.
le tuteur demande l'implémentation de la fonction analoguewrite au lieu de digitalwrite pour nos deux moteurs.
**Objectifs fixés pour la séance prochaine :**
- [x] Amélioration du Code Arduino.
- [x] Prise en main du capteur étanche DS18B20.
- [x] prendre rdv avec tuteur pour récupérés les composants manquants.
##### **Mercredi 13 novembre 2024**
Récupérations du matériels manquants
##### **Lundi 18 novembre 2024**
Nous nous sommes réunies au Fablab pour une session de brainstorming sur la réalisation de notre projet. Lors de cette rencontre, nous avons passé en revue la liste des composants nécessaires et constaté qu'il manquait certains éléments. Nous avons également identifié que certains contenants, tels que ceux pour l’eau chaude, l’eau à température ambiante et le mélange, devront être conçus par nos soins. Cela inclut la réflexion sur le choix des matériaux, le dimensionnement et les caractéristiques techniques. Étant donné qu’une bouteille isotherme n’est pas disponible, nous avons décidé de la concevoir nous-mêmes en utilisant de la laine de verre et du ruban aluminium (scotch métallisé) pour garantir une bonne isolation thermique.
Les équipements manquant :
- - Silicone
- Boutons poussoir on off
- 4 plaques plexiglas
- Scotch métallisé
- Les vises
- Les équerres (5)
- Thermos
- Serre Câbles
- Laine de verre
- Joint en T
Prise en main du capteur de température (DS18B20) :
Pour découvrir et utiliser le capteur de température DS18B20, nous avons suivi un tutoriel en ligne intitulé **\[GUIDE\] Arduino : capteur de température DS18B20 – câblage et code**. Ce tutoriel nous a permis de comprendre le branchement correct du capteur, ainsi que de mettre en œuvre le code nécessaire pour son utilisation avec Arduino.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2024-11/whatsapp-image-2024-11-18-a-17-10-25-61625bfb.jpg)
Branchement effectué par nous :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2024-11/b4himage.png)
Nous rencontrons un problème de lecture sur l'ordinateur.
**Objectifs fixés pour la séance prochaine:**
- [x] Envoyer un e-mail au professeur pour signaler le matériel manquant
- [x] Installer Arduino IDE
- [x] Installer Python 3.11
- [ ] Réaliser un branchement fonctionnel
##### **Mercredi 14 décembre 2024:**
Réunion du groupe au FabLab pour avancer sur les tâches fixées lors de la séance précédente. Rendez-vous avec M. Pulpytel afin d'obtenir des conseils pour progresser correctement dans notre projet.
Nous avons réussi à installer Arduino IDE et à utiliser Python 3.11. Nous avons pu utiliser Arduino, mais nous n'avons pas réussi à faire fonctionner la sonde de température et les pompes.
##### **Mercredi 18 décembre 2024 :**
Nous avons réussi à brancher correctement la sonde de température et à trouver un code fonctionnel, ce qui nous a permis de vérifier que la sonde fonctionne correctement.
[Video fonctionnement du capteur étanche DS18B20.](https://wiki.fablab.sorbonne-universite.fr/BookStack/attachments/1206)
**Code :**
\#include <OneWire.h>
\#include <DallasTemperature.h>
\#define ONE\_WIRE\_BUS A1 // Broche de la sonde
OneWire oneWire(ONE\_WIRE\_BUS);
DallasTemperature sensors(&oneWire);
void setup() {
Serial.begin(9600);
sensors.begin();
}
void loop() {
sensors.requestTemperatures();
float temperature = sensors.getTempCByIndex(0);
if (temperature == DEVICE\_DISCONNECTED\_C) {
Serial.println("Erreur : Sonde non détectée !");
} else {
Serial.print("Température : ");
Serial.print(temperature);
Serial.println(" °C");
}
delay(1000);
}
##### **Jeudi 23 décembre 2024 :**
Nous avons voulu tester les pompes pour vérifier leur fonctionnement. Pour cela, nous avons essayé différents montages électriques et expérimenté avec plusieurs codes adaptés à notre projet. Malgré nos efforts pour ajuster les branchements et modifier le code en fonction des spécifications techniques des pompes, aucun des tests n'a permis de les faire fonctionner correctement. Cette situation nous pousse à envisager des vérifications supplémentaires sur le matériel utilisé, comme la compatibilité des pompes avec notre alimentation ou le bon fonctionnement des composants électroniques. Il est également possible que des erreurs dans le code ou dans le montage soient à l'origine du problème, ce qui nécessite une analyse approfondie
##### **Jeudi 16/01/2025 :**
Nous nous sommes réunis au Fablab afin d'entamer le montage
1. **Perçage de la plaque en bois** : Réalisation des trous nécessaires pour insérer les vis, le support, les pompes et les récipients.
2. **Assemblage des cuves** : Fixation des cuves sur le support, ainsi que l'installation de l'agitateur[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/whatsapp-image-2025-01-16-a-16-22-15-15ffe0af.jpg)
3. **Découpage laser de la plaque en MDF 3mm** : Gravure de nos noms et du nom du projet sur une plaque MDF
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/whatsapp-image-2025-01-16-a-16-26-18-e900702b.jpg)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/whatsapp-image-2025-01-16-a-17-26-53-b916b9ab.jpg)
- **Nous avons également réussi à tester les pompes. Il s'est avéré qu'une seule pompe fonctionne. Voici notre circuit de montage ainsi que le code.**
**Vidéo de la pompe fonctionne :**
**Montage :**
[Video fonctionnement de la pompe](https://wiki.fablab.sorbonne-universite.fr/BookStack/attachments/1208)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/whatsapp-image-2025-01-16-a-23-12-41-52ce2de8.jpg)
**Code :**
// Déclaration des broches
const int pump\_pin = 9; // Broche connectée à la base du transistor pour la pompe
const int LED\_pin = 10; // Broche connectée à la cathode de la LED
void setup() {
// Configurer les broches en sortie
pinMode(pump\_pin, OUTPUT); // Contrôle de la pompe
pinMode(LED\_pin, OUTPUT); // Contrôle de la LED
Serial.begin(9600); // Initialisation du Moniteur Série pour le débogage
Serial.println("Configuration terminée. Prêt à démarrer.");
}
void loop() {
// Activer la pompe pour aspirer l'eau
analogWrite(pump\_pin, 220); // Ajustez la valeur (200 sur 255) selon la puissance souhaitée
digitalWrite(LED\_pin, LOW); // Allumer la LED pour indiquer l'activation
Serial.println("Pompe activée pour aspiration.");
// La pompe reste allumée sans interruption. Pas de désactivation ici.
// Aucune pause ou arrêt de la pompe dans la boucle.
}
Fonctionnement des deux pompes en alternance : notre objectif est de nous assurer que les deux pompes peuvent également fonctionner simultanément.
**Code:**
void setup() {
pinMode(8, OUTPUT); // Pompe chaude
pinMode(9, OUTPUT); // Pompe froide
}
void loop() {
analogWrite(8, 255); // Allumer pompe chaude à pleine puissance
delay(5000); // Attendre 5 secondes
analogWrite(8, 0); // Éteindre pompe chaude
analogWrite(9, 255); // Allumer pompe froide à pleine puissance
delay(5000); // Attendre 5 secondes
analogWrite(9, 0); // Éteindre pompe froide
}
##### **Lundi 20/01/2025 :**
Nous avons réussi à réaliser le montage complet de tous les composants, c'est-à-dire les deux pompes accompagnées de leurs LEDs respectives, ainsi que la sonde de température avec sa LED.
Voici le montage
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/whatsapp-image-2025-01-20-a-13-20-45-ba135dd0.jpg)
**le code :**
\#include "OneWire.h"
\#include "DallasTemperature.h"
// Définition des broches
const int pump1\_pin = 9; // Broche connectée à la pompe 1
const int pump2\_pin = 8; // Broche connectée à la pompe 2
const int LED\_pump1 = 10; // LED associée à la pompe 1
const int LED\_pump2 = 12; // LED associée à la pompe 2
const int LED\_temp = 11; // LED associée à la sonde de température
\#define ONE\_WIRE\_BUS A1 // Broche où la sonde DS18B20 est connectée
OneWire oneWire(ONE\_WIRE\_BUS); // Initialisation du bus OneWire
DallasTemperature sensors(&oneWire); // Création de l'objet DallasTemperature
void setup() {
// Configuration des broches en sortie
pinMode(pump1\_pin, OUTPUT); // Contrôle de la pompe 1
pinMode(pump2\_pin, OUTPUT); // Contrôle de la pompe 2
pinMode(LED\_pump1, OUTPUT); // Contrôle de la LED associée à la pompe 1
pinMode(LED\_pump2, OUTPUT); // Contrôle de la LED associée à la pompe 2
pinMode(LED\_temp, OUTPUT); // Contrôle de la LED associée à la sonde
// Initialisation du Moniteur Série
Serial.begin(9600);
sensors.begin(); // Activation de la sonde DS18B20
Serial.println("Configuration terminée. Prêt à démarrer.");
}
void loop() {
// Activation des pompes
analogWrite(pump1\_pin, 220); // Active la pompe 1 (PWM 220)
analogWrite(pump2\_pin, 220); // Active la pompe 2 (PWM 220)
// Allumer les LEDs associées aux pompes
digitalWrite(LED\_pump1, HIGH); // LED associée à la pompe 1 ON
digitalWrite(LED\_pump2, HIGH); // LED associée à la pompe 2 ON
Serial.println("Pompes activées, LEDs des pompes allumées.");
// Lecture de la température
sensors.requestTemperatures();
float tempC = sensors.getTempCByIndex(0); // Lire la température en degrés Celsius
// Afficher la température dans le Moniteur Série
Serial.print("Température : ");
Serial.print(tempC);
Serial.println(" °C");
// Vérification de la température pour la LED de la sonde
if (tempC > 15.0) {
digitalWrite(LED\_temp, HIGH); // Allumer la LED associée à la sonde
Serial.println("Température > 15°C : LED associée à la sonde allumée.");
} else {
digitalWrite(LED\_temp, LOW); // Éteindre la LED associée à la sonde
Serial.println("Température <= 15°C : LED associée à la sonde éteinte.");
}
delay(1000); // Attendre 1 seconde avant de répéter la boucle
}
##### **Jeudi 24/01/2025 :**
Nous nous sommes réunis au Fablab et avons finalisé notre montage comme suit :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/whatsapp-image-2025-01-27-a-17-34-26-8ffb5ba1.jpg)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/whatsapp-image-2025-01-27-a-17-34-26-a2bfdb1d.jpg)
Cependant, nous avons rencontré plusieurs problèmes :
1. 1. Les pompes nécessitaient une alimentation comprise entre 9 et 12 V. Pour remédier à ce problème, nous avons utilisé une alimentation équipée d'un connecteur de tension adapté.
2. Certaines broches d'alimentation de la breadboard ne fonctionnaient pas. Pour résoudre ce problème, nous avons utilisé un multimètre afin d'identifier les broches fonctionnelles.
3. Nous avons dû changer l'Arduino, car sa mémoire ne recevait plus de signal.
##### **LUNDI 27/01/2025:**
Le jour de la soutenance et remise du projet à M.Pulpytel,
Nous avons mis en place le code de régulation proportionnelle nécessaire pour faire fonctionner notre montage de régulation. Cependant, nous rencontrons un problème de conflit entre le code d'actionnement et le code de mesure de la température : les deux fonctionnent indépendamment, mais pas simultanément.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/whatsapp-image-2025-01-27-a-17-53-33-99f9dcdf.jpg)
En effet, soit la sonde capte correctement la température et envoie la commande à la pompe pour atteindre la consigne, mais cette dernière ne répond pas (elle ne se déclenche pas), soit les deux pompes réagissent aux variations de température, mais la sonde reste bloquée à -127°C.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/fYHimage.png)
**code de régulation : **
\#include <OneWire.h>
\#include <DallasTemperature.h>
// Pin assignments
\#define ONE\_WIRE\_BUS A1 // Broche pour la sonde DS18B20
const int pumpHotPin = 8; // Pompe d'eau chaude (PWM)
const int pumpColdPin = 9; // Pompe d'eau froide (PWM)
const int ledHotPin = 12; // LED associée à la pompe d'eau chaude
const int ledColdPin = 10; // LED associée à la pompe d'eau froide
const int ledTempPin = 11; // LED associée à la consigne atteinte
// OneWire and DallasTemperature objects
OneWire oneWire(ONE\_WIRE\_BUS);
DallasTemperature sensors(ONE\_WIRE\_BUS);
// Proportional control parameters
double Setpoint, Input, Output;
double Kp = 2.0; // Gain proportionnel
// Variables
int targetTemperature = 30; // Température cible en °C
const double marginOfError = 1.0; // Marge d'erreur de 1 °C
void setup() {
Serial.begin(9600);
// Initialize pins
pinMode(pumpHotPin, OUTPUT);
pinMode(pumpColdPin, OUTPUT);
pinMode(ledHotPin, OUTPUT);
pinMode(ledColdPin, OUTPUT);
pinMode(ledTempPin, OUTPUT);
// Initialize DS18B20 sensor
sensors.begin();
}
void loop() {
// Read temperature from DS18B20
sensors.requestTemperatures(); // Demander une lecture
Input = sensors.getTempCByIndex(0); // Récupérer la température en °C
// Calculate proportional output
Output = Kp \* (Setpoint - Input); // Calcul proportionnel
// Control pumps
analogWrite(pumpHotPin, max(0, Output)); // Contrôle de la pompe d'eau chaude
analogWrite(pumpColdPin, max(0, -Output)); // Contrôle de la pompe d'eau froide
// Control LEDs (ON/OFF behavior)
digitalWrite(ledHotPin, Output > 0 ? HIGH : LOW); // LED d'eau chaude ON/OFF
digitalWrite(ledColdPin, Output < 0 ? HIGH : LOW); // LED d'eau froide ON/OFF
digitalWrite(ledTempPin, abs(Input - Setpoint) <= marginOfError ? HIGH : LOW); // LED consigne ON/OFF
// Print data to monitor
Serial.print("Temperature: ");
Serial.print(Input);
Serial.print(" °C, Target: ");
Serial.println(Setpoint);
// Display pump activity
if (Output > 0) {
Serial.println("Pompe chaude active");
} else if (Output < 0) {
Serial.println("Pompe froide active");
} else {
Serial.println("Pompes inactives");
}
delay(2000); // Stabilisation
}
### **CONCLUSION :**En conclusion, ce projet de régulation de température nous a permis d’allier théorie et pratique en explorant les aspects essentiels de la conception, de l’assemblage et de la programmation d’un système intégré. Bien que notre projet n’ait pas totalement abouti en raison de certains problèmes techniques, dont certains ont été résolus et d'autres non, cette expérience a été extrêmement enrichissante. Nous avons beaucoup appris, tant sur le plan technique que méthodologique, en développant notre capacité à collaborer, à résoudre des problèmes et à comprendre les systèmes de régulation appliqués aux procédés industriels.
# Réalisation d'une burette automatique (Groupe D)
## Réalisation d'une burette automatique par mesure de niveau de solution
**Projet MUCI803 : Optimisation et contrôle des procédés (groupe D)**
**Membres du groupe : **
Anis BEKHOUKHE (Anis\_Rabah.Bekhoukhe@etu.sorbonne-universite.fr)Selin CENGIZ (selin.cengiz@etu.sorbonne-universite.fr)Thomas SU (Thomas.Su@etu.sorbonne-universite.fr)Steeve VONGSOUPHY (steeve.vongsouphy@etu.sorbonne-universite.fr)
**Formation :** M2 Chimie, parcours ingénierie chimique
**Date :** 21/10/2024 à Janvier 2025
#### Contexte
Dans le cadre de ce projet, nous avons conçu une burette automatique équipée d’un capteur de niveau afin de remplir un récipient jusqu’à un volume précis. L’objectif de ce projet est de réaliser un système capable de délivrer automatiquement un liquide, en ajustant le débit en fonction du niveau de remplissage mesuré. Pour ce faire, nous avons utilisé une carte Arduino et un breadboard pour assembler les composants nécessaires, tels qu’un capteur de niveau et un système de commande du débit. Ce projet répond à un besoin fréquent dans les laboratoires de chimie, où la précision du dosage et la répétabilité des mesures sont primordiales. En réalisant ce dispositif, nous avons pu mettre en pratique mes connaissances en électronique, programmation et instrumentation, tout en prenant en compte les impératifs de sécurité et de fiabilité.
#### Matériel utilisé
- Burette de 30 mL
- Servomoteur
- Capteur de distance (radar)
- Carte Arduino
- Breadboard
- Fils de connexion
- Module MOS
- Fond de bouteille en plastique coupé
#### Appareils utilisés
- Imprimante 3D Prusa MK4S
- Imprimante 3D Raise 3DPro2
- Découpeuse laser Trotec Speedy 100
- Perceuse
- Scie
- Pistolet à colle
#### Présentation de la burette automatique
Nous allons réaliser la burette automatique dans le cas d'une dilution automatisée, elle sera équipée d'un modèle 3D (à imprimer) à fixer au robinet : elle jouera le rôle de la main et sera connectée à un servomoteur.
Ce servomoteur sera relié à un système de régulation (comportant une carte Arduino, le module MOS) qui sera relié au capteur de niveau. La burette sera remplie d'une solution et le récipient se trouvant en dessous de la burette sera remplie de la même solution au fur et à mesure que le robinet de la burette sera automatiquement ouverte.
Lorsque le niveau de solution désiré sera détecté : le servomoteur sera activé et fermera donc la burette.
#### Journal de bord21/10/24 : Nous avons tout d'abord commencé par récupérer le matériel qui nous sera utile lors de ce projet. Ensuite, nous nous sommes installés au FabLab afin de réfléchir au contexte, au but ainsi qu'à l'utilité de la burette automatique. Ensemble, nous avons imaginé quelles fonctions doit remplir la burette automatique, ce qui nous a permis de faire une liste des étapes que doit suivre notre dispositif. Nous avons également commencé à faire les branchements électroniques ainsi qu'à réfléchir aux codes à pour notre Arduino. Nous avons fait une liste du matériel qui nous manquait et transmis à notre tuteur.25/11/24 :Nous avons reçu le matériel que nous avions demandé, donc nous avons retrouvé notre tuteur pour le récupérer. Nous avons ensuite débuté les bons branchements électroniques au FabLab avec le bon matériel. Nous avons également modélisé une pièce mélangeur pour notre solution sur un logiciel 3D et avons réussi à l'imprimer. Nous avons aussi commencé la modélisation du dispositif qui permet la connexion entre le robinet de la burette et le servomoteur. Le code Arduino a également été entamé. 20/12/24Nous avons poursuivi nos travaux de câblage, nous avons collé l'hélice fabriquée sur le DC moteur, et nous avons aussi poursuivi la modélisation du dispositif permettant de manipuler la burette.08/01/25La modélisation du modèle permettant la connexion entre le servomoteur et le robinet de la burette a été réalisée. Cette pièce a été réalisée grâce au logiciel de Blender. Nous l'avons imprimé avec l'imprimante Raise3DPro, cependant les fentes sur la pièce 3d sont trop petites.15/01/25La modélisation de l'actionneur a été ajustée et la pièce a été réimprimée. Nous avons réussi à placer la nouvelle pièce sur la burette et le servomoteur. Nous avons commencé la conception de notre palette (placement des différentes pièces, plaquette comportant nos noms, QR code...), ainsi que la calibration du capteur de lumière. Nous avons décidé de changer de mode de fonctionnement de la burette en raisonnant sur l'intensité de la couleur rouge : la consigne sera une intensité, et la burette fermera lorsque cette intensité sera atteinte. 24/01/25Lorsque nous essayons de calibrer le capteur de lumière, Arduino IDE nous donne des valeurs aberrantes : La valeur que donne le capteur pour une certaine couleur (ici le rouge) normalement diminue en fonction de l'intensité de celle-ci, mais ceci est avéré sur une surface solide, en effet lorsque nous l'essayons dans de l'eau colorée en rouge, les valeurs ne donnent pas les valeurs espérées, nous avons donc conclu qu'il n'est pas fait pour des liquides transparents. Nous avons en parallèle poursuivi les branchements et la conception de la palette.27/01/25Pour régler ce problème de transparence, M. Lanis (notre tuteur) nous a conseillé d'opacifier le milieu avec du lait, cependant cela ne marche pas non plus, nous avons donc conclu que le capteur marche uniquement avec des surfaces solides. Nous avons ensuite essayé la burette avec le pH-mètre en utilisant du vinaigre, et fermer la burette dès qu'on a le pH voulu. La valeur du pH est censé diminuer avec l'ajout de vinaigre sauf que la valeur ne cesse d'osciller au lieu de diminuer linéairement. En voyant que le pH-mètre était défectueux nous avons décidé de faire une burette volumétrique : imposer un volume désiré et faire arrêter le burette dès que ce volume est atteint. En parallèle, nous avons commencé les premières installations sur la maquette.29/01/25
Nous avons fait la découpe du support qui a permis de fixer la burette ainsi que le capteur de niveau et le servomoteur. En parallèle, tous les composants ont été rassemblés et tous les branchements ont été faits afin de tester le fonctionnement du code ainsi que du système. Tout fonctionnait bien, ce qui nous a poussé à garder la burette volumétrique.
30/01/25
Nous avons modélisé la plaquette contenant le nom du projet, nos noms ainsi qu'un QR code redirigeant les utilisateurs sur cette page. Ensuite, la découpeuse laser a été utilisée faire la gravure sur une chute de bois du type MDF 6mm. La maquette a été rassemblée entièrement et les essais du système ont été conduits. Nous avons détecté une erreur dans le code que nous avons vite réussi à corriger.
31/01/25
Nous avons fait quelques derniers ajustements sur la maquette et sur le code. Nous avons relu et mis à jour notre page wiki, avant d'accueillir notre professeur pour lui présenter notre projet.
#### Code Arduino
```
#include
int ult_pin=3;
const int stepsPerRevolution = 2038;
Stepper myStepper = Stepper(stepsPerRevolution, 8, 10, 9, 11);
int consigne = 4;
int KP = 1000;
int distance =0;
void setup() {
// put your setup code here, to run once:
Serial.begin(9600);
myStepper.setSpeed(10);
delay(2000);
}
void loop() {
// put your main code here, to run repeatedly:
pinMode(ult_pin, OUTPUT);
digitalWrite(ult_pin, LOW);
delayMicroseconds(2);
digitalWrite(ult_pin, HIGH);
delayMicroseconds(5);
digitalWrite(ult_pin,LOW);
pinMode(ult_pin,INPUT);
long duration;
duration = pulseIn(ult_pin,HIGH);
long centimetre;
centimetre = duration/34/2;
distance = centimetre +1;
//Serial.println(distance);
int error = distance - consigne;
Serial.println(error);
delay(1000);
if (error >0) {
int output = KP*error;
myStepper.step(-stepsPerRevolution/4);
delay(output);
myStepper.step(stepsPerRevolution/4);
delay(1000);
}
}
```
#### Schéma des branchements[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/schema-electronique.PNG)
#### Photos de la maquette[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/whatsapp-image-2025-01-31-at-14-59-32.jpeg)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/whatsapp-image-2025-01-31-at-14-59-32-1.jpeg)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/whatsapp-image-2025-01-31-at-14-59-33.jpeg)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/whatsapp-image-2025-01-31-at-14-59-33-1.jpeg)
#### Vidéo de fonctionnement de notre dispositif
Allez sur le lien suivant afin de visualiser le fonctionnement de la burette automatique :
https://youtube.com/shorts/vhanZpFX8P4
#### Difficultés rencontrées
Plusieurs difficultés ont été rencontrées durant la réalisation de ce projet. On peut notamment parler des difficultés liées au matériel. Tout d'abord, nous avons dû faire face à des fils électriques défectueux. Après avoir contacté notre tuteur, ce dernier nous a fourni de nouveaux fils. Le module ne fonctionnait pas non plus, et pareil qu'avec les fils électriques, on nous en a fourni un autre.
Nous avons ensuite réalisé que notre capteur de couleur ne marchait pas sur des solutions. En effet, il ne détecte la couleur des surfaces solides uniquement. Ce problème nous a poussé à nous orienter vers le pH-mètre (qu'on avait déjà en notre possession), et de construire un montage de mesure de pH. Malheureusement, après de gros efforts d'écriture de code et de branchements, nous avons réalisé que le pH-mètre qui nous a été fourni ne fonctionnait pas non plus... Nous avons ainsi choisi de nous orienter sur le capteur de distance afin de travailler selon le niveau de solution présent dans un récipient.
Une autre difficulté liée à ce projet à été l'étape d'impression 3D. Pour pouvoir imprimer précisément les pièces qui nous étaient utiles, nous avons lu beaucoup de ressources sur internet et regardé beaucoup de vidéos afin d'apprendre à utiliser le logiciel de modélisation 3D Blender et pouvoir modéliser par nous même les pièces qu'on voulait. Nous avons ainsi réussi à imprimer une hélice (qui ne nous a pas servi au final, étant donné que le capteur de couleur et le pH-mètre étaient défectueux) ainsi qu'une clef de robinet faisant le lien entre le servomoteur et le robinet de la burette (pièce noire visible sur les photos de la maquette).
# Régulation de température d'une cuve (Groupe G)
#### **Informations**
**Membres du groupe :**
- Nassim TIZI OUKDAL (*nassim.tizi\_oukdal@etu.sorbonne-universite.fr*) ;
- Maria BELHADEF (*maria.belhadef@etu.sorbonne-universite.fr*) ;
- Rayane OUBAZIZ (*rayane.oubaziz@etu.sorbonne-universite.fr*) ;
- Yanis Zakaria LAKEHAL (*yanis.zakaria.lakehal@etu.sorbonne-universite.fr*).
**Cursus :** **Master 2 Chimie - Parcours : Ingénierie Chimique**
**Tuteur :** PULPYTEL Jerome (*jerome.pulpytel@sorbonne-universite.fr*)
**Période :** Octobre 2024 - Janvier 2025
#### **Contexte**
Le présent projet s'inscrit dans le cadre de l'UE803 Optimisation et Contrôle des Procédés, il consiste à la régulation et l'automatisation d'un système de contrôle de la température d'une cuve de liquide en utilisant une carte Arduino avec le matériel et le code nécessaire au fonctionnement du système.
#### **Mode opératoire**
Le projet consiste à contrôler la température d'une cuve de liquide.
- L'utilisateur défini une température à atteindre dans la cuve.
- Le module Peltier va chauffer l'eau contenue dans la cuve à une température souhaitée.
- Une sonde de température étanche mesurera la température dans la cuve.
- Récupérer l'eau chaude en utilisant une pompe et on le renverser dans la cuve afin d'uniformiser la température de l'eau.
- On arrêt l'opération lors qu'on atteindre la température désirée (consigne définie par un utilisateur).
#### **Matériels utilisés**
La liste des composants essentiels pour notre configuration comprend les éléments suivants :
Structure de support
1
Bécher
1
Petits réservoirs
2
Tuyaux de raccordement
2
Pompes
1
Sonde de température étanche
1
Élément Peltier
1
Carte Arduino UNO
1
Breadboard
1
Transistor TIP 122
1
Résistances
1
Câble USB
1
Module d’affichage LED
1
Fils de connexion
~ 20
Câbles d'alimentation externe de 12V
1
#### **Étapes de conception**
- ##### **Étape 01 : Conception et préparation**
La première étape consiste à bien cerner le sujet et à établir une liste complète des composants indispensables. Elle inclut aussi l'organisation des tâches au sein de l'équipe, en assignant à chaque membre des responsabilités définies.
- ##### **Étape 02 : Modélisation sous Tinkercard**
Dans l'étape de modélisation sous Tinkercad, l'objectif est de concevoir une représentation du système et d'anticiper d’éventuels problèmes et d’optimiser la conception avant de passer à l’assemblage physique.
Cette étape permet de réaliser les principales actions suivantes :
***1. Création des composants***
- - *Modéliser les éléments clés du système.*
- *Importer des modèles existants si disponibles.*
***2. Assemblage virtuel***
- - *Positionner les composants pour simuler leur disposition réelle.*
- *Vérifier l'agencement des composants.*
***3. Simulation des connexions électroniques***
- - *Concevoir le schéma des connexions entre capteurs, régulateurs, microcontrôleur, etc.*
- *Tester le fonctionnement théorique des circuits avant l'assemblage réel.*
***4. Optimisation et validation***
- - *Ajuster les dimensions et la disposition des composants pour éviter les erreurs de fabrication.*
- *Vérifier que tous les éléments s’emboîtent correctement.*
- ##### **Étape 03 : Montage et assemblage**
La troisième étape comprend la réception du matériel et l’assemblage des composants selon le prototype établi durant l'étape 3.
- ##### **Étape 04 : Programmation, test et validation**
La dernière étape concerne le développement du code pour l’Arduino UNO, qui gère le module Peltier et assure la régulation thermique de la cuve et de faire des tests afin d'assurer le bon fonctionnement du système.
*Les deux étapes 03 et 04 sont réalisées en parallèle.*
#### **Journal du bord**
- ---
**Date 14/10/2024**
- - Choix du projet.
- Création de la page Wiki FablabSU du projet.
- Réflexion sur le schéma de principe de fonctionnement de système à réaliser.
- Préparation de la liste de matériel préliminaire et l'envoyée à notre tutrice.
- ---
**Date 04/11/2024**
Récupération d'une première partie du matériel.
Début de la simulation du système partie par partie sur Tinkercard pour tester le concept avant la mise en œuvre physique.
- ---
**Date 20/12/2024**
Nous avons pris l'initiative d'utiliser la machine de découpe laser pour réaliser certaines pièces nécessaires à notre projet. Notamment, la découpe de quelques planches en bois et de gravé sur l'une d'eux.
Récupération du matériel manquant notamment l'élément pelteir, un module d'affichage LED et une Breadboard plus grande ainsi que des LED de plusieurs couleurs.
Compléter la simulation du système sur Tinkercard sans inclure l'élément peltier et inclure dans sa place un moteur électrique.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-02/simulation-tinkercard.png)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-02/cartes-de-circuits.png)
- ---
**Date 16/01/2025**
Nous avons récupéré le matériel manquant, notamment le support, afin de poursuivre l'assemblage et d'assurer le bon fonctionnement du système.
- ---
**Date 17/01/2025**
Lors de cette séance, nous avons testé le fonctionnement de l'élément Peltier, en nous concentrant sur le contrôle de la température en fonction de la consigne donnée.
- ---
**Date 24/01/2025**
Lors de cette séance, nous avons testé le fonctionnement des électrovannes ainsi que de l'agitateur, en mettant l'accent sur le contrôle de la température en fonction de la consigne définie.
Nous avons identifié certains problèmes liés au branchement des électrovannes avec les relais.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/20250124-182806.jpg)
Demande d'avis et de l'aide au tuteur sur ce montage et le code.
En suivant les recommandations de notre tuteur, nous avons décidé de remplacer les électrovannes et l'agitateur par une pompe, afin d'assurer une meilleure homogénéisation de la température de l'eau.
Plusieurs problèmes ont été rencontrés lors de cette séance lors du montage :
- - Le module peltier ne fonctionne plus. Pour vérifier si le problème venait du branchement, nous avons testé d'abord avec le voltage aux bornes d'alimentation 12V à l'aide d'un multimètre, et celui-ci a indiqué correctement le voltage. Nous avons tasté par la suite le branchement avec un autre module peltier et celui-là a fonctionné correctement. Nous avons conclus que le module peltier était défectueux. nous avons acheté un autre.
- Le transistor ne fonctionne plus, nous l'avons donc remplacé par un autre.
- ---
**Date 27 et 30 /01/2025**
Au cours de ces deux séances, nous avons finalisé la conception et le montage du matériel en intégrant les modifications apportées à notre conception initiale.
Nous avons aussi réalisé plusieurs tests pour vérifier que le système fonctionne comme prévu.
##### ***Le code final est donc le suivant :***
```c++
#include // Pour la communication avec le capteur DS18B20
#include // Pour lire la température du capteur DS18B20
#include
#include
#define ONE_WIRE_BUS A0 // Broche pour le capteur DS18B20
#define MOTOR_PIN 13 // Broche pour contrôler le module Peltier
#define PUMP_PIN 10 // Broche pour contrôler la pompe
LiquidCrystal_I2C lcd(0x3e, 16, 2);
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);
int targetTemp = 24; // Température cible initiale
float currentTemp;
void setup() {
lcd.init(); // Initialize the LCD
lcd.backlight();
sensors.begin();
Serial.begin(9600); // Initialisation de la communication série
sensors.begin(); // Initialisation du capteur DS18B20
pinMode(MOTOR_PIN, OUTPUT); // Définir la broche du module Peltier comme sortie
pinMode(PUMP_PIN, OUTPUT); // Définir la broche de la pompe comme sortie
digitalWrite(MOTOR_PIN, LOW); // Désactiver le module Peltier au démarrage
digitalWrite(PUMP_PIN, LOW); // Désactiver la pompe au démarrage
}
void loop() {
sensors.requestTemperatures(); // Demande de mise à jour de la température
currentTemp = sensors.getTempCByIndex(0); // Obtenir la température en Celsius
Serial.print("currentTemp: "); // Afficher la température actuelle
Serial.println(currentTemp); // Afficher la température
lcd.setCursor(0, 0);
lcd.print("La temperature est : ");
lcd.print("currentTemp");
lcd.setCursor(0, 1);
// Contrôler le module Peltier
if (currentTemp < 24) {
digitalWrite(MOTOR_PIN, HIGH); // Active le module Peltier
Serial.println("Module Peltier activé.");
} else {
digitalWrite(MOTOR_PIN, LOW); // Désactive le module Peltier
Serial.println("Module Peltier désactivé.");
}
// Contrôler la pompe
if (currentTemp < 24) {
digitalWrite(PUMP_PIN, HIGH); // Active la pompe
Serial.println("Pompe activée.");
} else {
digitalWrite(PUMP_PIN, LOW); // Désactive la pompe
Serial.println("Pompe désactivée.");
}
delay(1000); // Attendre 1 seconde avant de refaire la lecture
}
```
#### **Conclusion**
Ce projet nous a permis de concrétiser nos connaissances théoriques en les transformant en une application pratique fonctionnelle. Malgré les défis rencontrés, tels que le remplacement imprévu du module Peltier et des électrovannes par une pompe, nous avons su faire preuve de flexibilité et de rigueur pour surmonter les obstacles.
Le système final répond aux objectifs définis, assurant un contrôle optimal de la température grâce à l'Arduino et aux composants associés. Ce projet a renforcé nos compétences en électronique, programmation et gestion de projet, constituant ainsi une étape clé de notre apprentissage et ouvrant la voie à de futures améliorations.
# Régulation de la Température d'une Cuve (Groupe F)
**Régulation de la Température d'une Cuve dans FABLAB **Dans le cadre de notre formation en**Ingénierie Chimique** à **l'Université Sorbonne** pour l'année universitaire **2024-2025**, nous avons été amenés à réaliser un projet académique dans le cadre de l’unité d’enseignement **803, intitulée 'Optimisation des Procédés Industriels'**. Ce projet est mené sous la supervision du **professeur Jérôme Pulpytel** et porte sur la '**Régulation de la température d'une cuve à l’aide d’un module Peltier**'.L'objectif principal de cette étude est de concevoir et d’optimiser un système permettant de contrôler avec précision la température au sein d’une cuve, en exploitant les propriétés thermoélectriques du module Peltier.**Objectifs**L'objectif de ce projet réalisé au FABLAB est de construire un montage permettant de mesurer la température au sein d'une cuve, laquelle varie en fonction du module Peltier, qu'il refroidisse ou chauffe. **Réalisateurs**Notre Groupe est composé de 4 personnes : **AISSANI Nourhane ; Nourhane.Aissani@etu.sorbonne-universite.fr****BOURDANE Chayma ; Chayma.Bourdane@etu.sorbonne-universite.fr****CHAIBI Kenza ; Kenza.Chaibi@etu.sorbonne-universite.fr****DOUALI Lynda ; Lynda.Douali@etu.sorbonne-universite.fr**Ensemble, nous combinons nos connaissances et nos savoir-faire pour mener à bien notre projet et atteindre nos objectifs avec efficacité et rigueur.**Durée du projet**La durée du projet : de **06-11-2024** à **31-01-2025****Schéma du projet**Nous avons tout d'abord essayé de réaliser un petit schéma dessiné en collaboration avec les membres de l'équipe. Cela nous a permis de visualiser le montage et de mieux comprendre les étapes à suivre ainsi que les équipements nécessaires. Cette démarche préliminaire nous a aidés à clarifier notre idée et à planifier efficacement notre projet. Grâce à ce schéma, nous avons pu identifier les défis potentiels et anticiper les solutions, ce qui a grandement facilité la mise en œuvre du montage final.
***Figure : Schéma dessiné du montage***
##### **Contexte du Projet**Le projet vise à contrôler la température d'un liquide contenu dans une cuve à l'aide d'un système combinant un module Peltier et une sonde de température étanche. L'utilisateur peut définir une température cible, et le système ajustera automatiquement la température du liquide pour l'atteindre, en chauffant ou refroidissant selon les besoins.
##### **Matériels**
- **Module Peltier :** TEC1-12706, Cet élément thermoélectrique peut chauffer ou refroidir selon le sens du courant
- **Alimentation 12V : **pour fournir de l'énergie au module du Peltier : batterie 12V
- **Sonde de température étanche PT100 : **Pour mesurer précisément la température du liquide dans la cuve.
- **Microcontrôleur Arduino UNO R3 : **Pour gérer les lectures de température et contrôler le module Peltier.
- **Module MOS : **Pour permettre au microcontrôleur de contrôler la puissance délivrée au module Peltier.
- **Dissipateur thermique : **en aluminium avec ventilateur intégré ou bien + système de ventilation (éviter surchauffage max transfert thermique) A fixer sur le coté chaud du module Peltier pour dissiper la chaleur (ou le froid) produit par le module.
- **Cuve : **Pour contenir l’eau à chauffer/refroidir. (0,5 à 1litre)
- **Pompes/ agitateur à Hélices : **Pour homogénéiser la température dans la cuve.
- **Supports et fixations : **Pour maintenir le module Peltier, le dissipateur, et la sonde de température en place.
- **Pâte thermique à base de silicone ou d'argent de jaute conductivité thermique (>1.5 W/mK) : **pour +++ conductivité thermique entre Peltier et Dissipateur
- **Câblage, Fils de connexion (jumper wires), connecteurs à souder adaptés aux tensions et courants utilisés, tuyaux d'eau.**
- **Resistance**
- **Lampes**
##### **Journal du bord - Régulation de la Température d'une cuve avec module Peltier**
##### ***Séance \[06-11-2024\]***Lors de cette première séance, nous avons récupéré le matériel nécessaire et commencé à comprendre le rôle ainsi que le fonctionnement de chaque composant utilisé dans notre projet. Ensuite nous avons rassemblé notre support sur lequel nous avons fixer le montage de notre projet.
[  ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/L55image.png)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/C8Dimage.png)
***Figure : Support + Matériels du projet*****Objectifs fixés pour la prochaine séance programmée le 15-11-2024** : chercher et proposer pour chaque membre du groupe un montage sur **Tinkercad.**
##### ***Séance \[15-11-2024\]***Après que chacun de nous a effectué des recherches pour proposer un montage sur **Tinkercad**, nous avons programmé cette séance pour discuter d'avantage des montages proposés.***Tinkercad**** :*******Joue un rôle crucial dans votre projet de régulation de la température d'une cuve. Cette plateforme en ligne permet de concevoir et de simuler des circuits électroniques de manière intuitive et interactive. En utilisant Tinkercad, chaque membre du groupe peut créer et tester des montages électroniques spécifiques à la régulation de la température. Cela facilite la visualisation et la compréhension des différentes configurations possibles avant de les implémenter physiquement. Ainsi, Tinkercad aide à optimiser le processus de conception et à garantir que les solutions proposées sont viables et efficaces pour maintenir la température de la cuve à un niveau optimal.Les montages proposés pour l'équipe sont les suivants :
[  ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/STpimage.png)[ ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/pBgimage.png) [ ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/pBgimage.png)
***Figure : Montage proposée par recherche dans la littérature***Après avoir discuté en profondeur pour bien comprendre les objectifs et les exigences du projet, nous avons comparé les différents montages proposés par chaque membre de l'équipe. Cette comparaison nous a permis d'évaluer les avantages et les inconvénients de chaque montage en termes de faisabilité, d'efficacité et de compatibilité avec notre matériel disponible, tel que l'écran **LCD**, carte **Arduino,** **module Peltier (présenté par LED)**, **breadboard et sonde de température noir TMP**. Finalement, nous avons choisi le montage qui nous semblait le plus adapté pour réaliser le montage réel, en tenant compte de tous ces critères. Cette approche nous a permis de nous rapprocher de notre objectif final et de garantir que le montage choisi répondra aux besoins spécifiques de notre projet de régulation de la température d'une cuve.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/tinkercad.png)
***Figure : Montage proposée sur Tinkcard***Avec le code Arduino suivant :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/jXrimage.png)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/rFIimage.png)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/t6Oimage.png)
***Figure : Code Arduino sur Tinkcard*****Objectifs fixés pour la prochaine séance programmée le 29-11-2024** : faire le montage, une première essai à tester.
##### ***Séance \[29-11-2024\]***Lors de cette séance, nous avons commencé à réaliser le prototype de notre projet. Après la fixation du support dans la première séance, nous avons procédé aux connexions entre les différents composants du projet, notamment **l'Arduino, la breadboard, le MOSFET, les indicateurs LED et les résistances.**
**Voici les Connexions principales du projet :**
**MOSFET**
**Module Peltier**
- Gate (G) : Connectée à la broche D6 (sortie PWM) de l’Arduino.
- Drain (D) : Connecté à la borne négative du module Peltier.
- Source (S) : Connectée à la rangée GND de la breadboard (reliée au GND de l’Arduino et de l’alimentation externe).
- Borne positive (+) : Connectée au +12V de l’alimentation externe.
- Borne négative (-) : Connectée au Drain (D) du MOSFET.
**LED**
**Arduino**
- Anode (longue) : Connectée à la broche D3 de l’Arduino via une résistance de 220 Ω.
- Cathode (courte) : Connectée à la rangée GND de la breadboard.
- GND : Connecté à la rangée GND de la breadboard.
- D6 : Connectée à la Gate du MOSFET.
- D3 : Connectée à l’Anode de la LED via une résistance.
**Alimentation externe (pour le module Peltier)**
- +12V : Connecté à la borne positive du module Peltier.
- GND : Connecté à la rangée GND de la breadboard (partagée avec l’Arduino et le MOSFET).
Les résultats de notre montage obtenus au Fablab sont illustrés dans la figure suivante :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2024-11/GRgwhatsapp-image-2024-11-22-at-16-40-15.jpeg)
***Figure : Première essai du montage*****Objectifs fixés pour la prochaine séance programmée le 06-12-2024** : tester le fonctionnement de Arduino, en utilisant le code.
##### ***Séance \[06-12-2024\]***Lors de cette séance, nous avons procédé à tester le code Arduino suivant sur le montage.
Mais nous n'avons constaté aucun réponse de la part du montage.
L'écran LCD ne répond pas non plus, ce qui nous a permis d'identifier un problème. Donc nous avons décider de chercher et déterminer si le problème provient du montage, du code ou d'un élément manquant dans les deux. Nous avons donc décidé d'arrêter ici pour cette séance, car nous n'avons pas pu détecter l'origine du problème. et de aller faire des recherches dans la littérature.
##### ***Séance \[11-12-2024\]***Aujourd'hui, nous avons procédé à la construction de notre plaque du projet, qui comprend :
- **Nom du module MU5CI803 : OPTIMISATION ET CONTROLE DES PROCEDES,**
- **Nom du Projet, **
- **Nom du Groupe F,**
- **Code QR pour le Wiki FABLAB,**
- **Noms des réalisateurs du projet,**
- **Logo de Sorbonne Université.**
Pour construire cette plaque, nous avons utilisé le logiciel**Inkscape**et **la machine de découpe au laser** : ***Inkscape*** est un éditeur de graphiques vectoriels open-source, similaire à Adobe Illustrator. Il utilise le format de fichier SVG (Scalable Vector Graphics) et permet de créer et manipuler des illustrations techniques et artistiques, telles que des logos, des diagrammes et des typographies
***Figure : Logiciel Inkscape******La machine de découpe au laser***est un appareil qui utilise un faisceau laser à haute densité pour découper des matériaux. Ce procédé de fabrication permet une découpe précise et rapide de divers matériaux en concentrant une grande quantité d'énergie sur une petite surface
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/1738312577353.jpg)
***Figure : Machine de coupe par Laser*** La plaque obtenus pour notre projet est la suivante :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/Y6Limage.png)
***Figure : Plaque de notre Projet***
##### ***Séance \[15-01-2025******\]***Lors de cette séance, notre objectif était de débuter la construction de notre montage sur le support déjà fixé. Pour ce faire, nous avons commencé par **percer des trous dans la plaque** afin d'insérer les différents équipements nécessaires à la fixation du montage. Cette étape initiale est cruciale pour assurer la stabilité et la fonctionnalité de l'ensemble. [](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/JcXimg-20250124-182417.jpg)***Figure : Perçage des trous sur la plaque***Nous avons pris soin de mesurer et de marquer les emplacements des trous avec précision pour éviter toute erreur. Une fois les trous percés, nous avons procédé à l'installation des composants, en veillant à ce qu'ils soient solidement fixés et correctement alignés. Cette préparation minutieuse nous permettra de poursuivre le projet dans de bonnes conditions et d'assurer le bon fonctionnement du montage final
##### ***Séance \[17-01-2025******\]***Afin d'assurer une répartition homogène de la température dans l'ensemble du mélange réactionnel au sein de la cuve, nous avons initialement opté pour l'installation d'un petit agitateur. Cependant après avoir constaté que nous disposions d'une pompe, nous avons envisagé de l'utiliser comme alternative plus efficace.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/whatsapp-image-2025-01-31-at-15-44-01.jpeg)
***Figure : Agitateur***Cette **pompe** à pour rôle d'aspirer l'eau à partir d'un réservoir externe et de la refouler à l'intérieur de la cuve. Ce système permettrait d'améliorer la circulation de l'eau et d'assurer une meilleure régulation thermique, en évitant ainsi toute variation de température susceptible d'affecter le processus de réaction.
##### ***Séance \[22-01-2025\]***Lors de la dernière séance du **15-01-2025**, nous avons presque terminé de préparer tous les équipements et le matériel nécessaires pour assembler et fixer le montage final. Nous avons soigneusement vérifié chaque composant pour nous assurer qu'il est prêt à être utilisé. Ensuite, nous avons procédé à l'assemblage en suivant les étapes prévues, en veillant à ce que chaque élément soit correctement positionné et solidement fixé. Cette préparation minutieuse est essentielle pour garantir la stabilité et le bon fonctionnement de notre montage. Les résultats finaux de notre projet sont illustrés dans la figure suivante :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/whatsapp-image-2025-01-31-at-15-43-18.jpeg)
***Figure : Montage du projet***
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/jX0img-20250129-wa0003.jpg)
***Figure : Equipements du projet***Les figures montre clairement les différentes équipement de l'assemblage. Nous sommes satisfaits des progrès réalisés jusqu'à présent et nous continuerons à travailler avec diligence pour atteindre nos objectifs.Voici le résultats obtenus pour le produit fini :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/img-20250129-wa0002.jpg)
***Figure : Montage du projet finale***
##### ***Séance \[27-01-2025\]***Après avoir réalisé le montage, cette séance avait pour objectif de tester un code Arduino sur le montage réalisé. Nous avons soigneusement préparé le montage en vérifiant chaque composant et en nous assurant que tout était correctement assemblé. Ensuite, nous avons chargé le code Arduino suivant pour voir comment le montage réagirait.Le code Arduino, est le suivant :
**// PID COntroller V2.0**
**// Program has PID functionality, Pump on/off**
****
**\#include <DallasTemperature.h>**
**\#include <OneWire.h>**
**\#include <Wire.h>**
**\#include <rgb\_lcd.h>**
**\#include <PID\_v1\_bc.h>**
****
**// Pin Definitions**
**\#define ONE\_WIRE\_BUS 7 // Pin for temperature sensor**
**\#define BTN\_UP\_PIN 2 // Button to increase target temperature**
**\#define BTN\_DOWN\_PIN 4 // Button to decrease target temperature**
**\#define LED\_R\_PIN 10 // Pin for red LED**
**\#define LED\_G\_PIN 9 // Pin for green LED**
**\#define LED\_B\_PIN 8 // Pin for blue LED**
**\#define MOTOR\_PIN 12 // Pin to control the motor**
**\#define PUMP\_PIN 11 // Pin to control the pump**
****
**OneWire oneWire(ONE\_WIRE\_BUS);**
**DallasTemperature sensors(&oneWire);**
****
**rgb\_lcd lcd;**
****
**// PID Variables**
**double currentTemp = 0.0; // Current temperature reading**
** } else if (currentTemp > targetTemp + hysteresis) {**
** digitalWrite(LED\_R\_PIN, LOW);**
** digitalWrite(LED\_G\_PIN, LOW);**
** digitalWrite(LED\_B\_PIN, HIGH); // Blue: Too hot**
** } else {**
** digitalWrite(LED\_R\_PIN, LOW);**
** digitalWrite(LED\_G\_PIN, HIGH); // Green: Target temperature reached**
** digitalWrite(LED\_B\_PIN, LOW);**
** }**
****
** delay(25); // Stabilization delay**
**}**
Avec ce code Arduino, nous avons rien observé dans le montage, ce qui signifie qu'il ne fonctionne pas. Nous n'avons pas encore identifié la source du dysfonctionnement. Nous allons continuer à examiner le montage et le code pour trouver la cause du problème et y remédier.
##### ***Séance \[28-01-2025\]***Lors de cette séance, nous avons tenté de tester un code Arduino sur le montage réalisé. Voici le code que nous avons essayé :
**// C++ code**
**//**
**\#include <LiquidCrystal.h>**
**//#include <LiquidCrystal\_I2C.h>**
**// Définition des broches**
**const int tempSensorPin = A0; // Broche du capteur de température**
**float targetTemp = 10.0; // Température de consigne en °C**
** // Affichage de la température sur l'écran LCD**
** lcd.setCursor(0, 1); // Place le curseur à la 2ème ligne**
** lcd.print(temperature); // Affiche la température lue**
****
** // Affichage de la température cible**
** lcd.setCursor(0, 0); // Place le curseur en haut à gauche**
** lcd.print("Temp: "); **
** lcd.print(targetTemp); // Affiche la température actuelle**
****
** //LCD **
** // lcd.setCursor(0, 0);**
**// lcd.print("Temp: ");**
**// lcd.print(currentTemp, 1); // Display with 1 decimal place**
**// lcd.print(" C "); // Clear extra characters**
** // Display target temperature on LCD**
**// lcd.setCursor(0, 1);**
** //lcd.print("Set: ");**
**// lcd.print(targetTemp, 1); // Display with 1 decimal place**
**// lcd.print(" C ");**
****
** delay(500); // Pause de 500 ms avant la prochaine lecture**
**}**
**const int capteurTempPin = A0; // Pin pour la sonde TMP36**
**const int chauffagePin = 9; // LED rouge pour chauffer**
**const int refroidissementPin = 10; // LED bleue pour refroidir**
**float temperature = 0.0;**
**const float tempCible = 50.0; // Température cible (en °C)**
Avec ce code Arduino, nous avons constaté que la lampe répondait en s'allumant en vert
Les résultats obtenus sont illustrés dans la vidéo suivante.
***Figure : Vidéo de montage avec code de essai 1***
Cependant, nous avons également observé que l'écran LCD **ne détectait toujours pas la température**, bien qu'il soit** allumé**. Face à cette situation, nous avons procédé à une vérification minutieuse de plusieurs aspects du montage et du code afin d'identifier les éventuelles erreurs. Malgré nos efforts, il semble qu'il reste encore des ajustements à faire pour que tout fonctionne correctement. Nous continuerons à travailler sur ce projet avec détermination, dans le but de trouver une solution et de faire en sorte que le montage fonctionne comme prévu. Nous sommes convaincus qu'avec persévérance et rigueur, nous parviendrons à surmonter ces obstacles et à atteindre nos objectifs.
##### ***Séance \[29-01-2025\]***Lors de cette séance, nous avons tenté de corriger le code afin que notre montage fonctionne correctement.
**Code Arduino du projet finale :**
**\#include <OneWire.h>**
**\#include <DallasTemperature.h>**
**\#include <Wire.h>**
**\#include "rgb\_lcd.h"**
**// Data wire is connected to pin 2**
**\#define ONE\_WIRE\_BUS 2**
**OneWire oneWire(ONE\_WIRE\_BUS);**
**DallasTemperature sensors(&oneWire);**
**rgb\_lcd lcd;**
**void setup() {**
** pinMode(3,1);pinMode(9,1); pinMode(10,1);**
**lcd.begin(16,2); // Initialize the LCD**
** lcd.setRGB(255,255,0);**
** sensors.begin();**
**}**
**void loop() {**
** sensors.requestTemperatures(); // Send the command to get temperature readings**
** float tempC = sensors.getTempCByIndex(0); // Read temperature in Celsius**
**lcd.setCursor(0, 0);**
** lcd.print("La temperature est : "); **
** lcd.setCursor(0, 1);**
** lcd.print(tempC);**
** if(tempC<35) digitalWrite(3,1);**
** else digitalWrite(3,0);**
** if(tempC>=35)digitalWrite(9,1);**
** delay(200);**
** digitalWrite(9,0);**
** if(tempC<35)digitalWrite(10,1);**
** delay(200);**
** digitalWrite(10,0);**
**}**
Ce code Arduino nous a permis d'obtenir les résultats suivants :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/whatsapp-image-2025-01-31-at-16-08-59-2.jpeg)
***Figure : Montage final***
Après avoir constaté un problème dans notre approche initiale, nous avons identifié et corrigé l'erreur. Une fois ce changement effectué, les lampes ont fonctionné correctement et ont répondu au code Arduino. Les résultats obtenus sont illustrés dans la figure suivante.
***Figure : Montage final***
Nous avons constaté et conclu qu'il n'est pas possible d'alimenter simultanément la pompe et l'Arduino. En effet, lorsque le module Peltier commence à chauffer, la pompe s'arrête. Nous avons donc déterminé qu'il est nécessaire de fournir une alimentation séparée pour chaque composant.
##### ***Séance \[31-01-2025\]***Soutenance du Projet finale illustré dans la figure :
##### ***Conclusion***Le projet de régulation de la température d'une cuve à l'aide d'un module Peltier a été une expérience enrichissante et formatrice. Nous avons réussi à concevoir et à assembler un système capable de contrôler la température d'un liquide contenu dans une cuve, en utilisant les propriétés thermoélectriques du module Peltier. Le montage final inclut divers composants tels que le microcontrôleur Arduino UNO R3, une sonde de température étanche PT100 et module MOSFET.
##### ***Problèmes rencontrés***Nous avons rencontré au début des problèmes dans le code Arduino, notamment avec l'écran LCD qui ne détectait pas la température, bien qu'il soit allumé Nous avons procédé à une vérification minutieuse de plusieurs aspects du montage et du code pour identifier les éventuelles erreurs, mais on 'a juste modifié un branchement de câble et on 'a réussi à avoir un fonctionne correctement de l'écran
##### ***Perspectives***Pour améliorer ce projet, plusieurs perspectives peuvent être envisagées :
1. **Optimisation du Code :** Continuer à affiner le code Arduino pour résoudre les problèmes de détection de température et améliorer la précision du contrôle de la température.
2. **Amélioration du Montage :** Revoir le montage pour s'assurer que tous les composants sont correctement connectés et fonctionnent de manière optimale.
3. **Ajout de Fonctionnalités :** Intégrer des fonctionnalités supplémentaires telles que des alertes en cas de dépassement de la température cible, ou la possibilité de contrôler le système à distance via une application mobile.
4. **Tests et Validation :** Effectuer des tests supplémentaires pour valider le fonctionnement du système dans différentes conditions et s'assurer de sa fiabilité à long terme.Nous sommes convaincus qu'avec persévérance et rigueur, nous parviendrons à surmonter ces obstacles et à atteindre nos objectifs. Ce projet nous a permis de développer nos compétences en ingénierie et en travail d'équipe, et nous sommes impatients de continuer à travailler sur ces améliorations pour aboutir à un système pleinement opérationnel.
##### ***Remerciement***Nous tenons à exprimer notre profonde gratitude à notre professeur, **Jérôme Pulpytel**, pour cette opportunité enrichissante au FABLAB. Ce projet nous a permis d'appliquer concrètement les concepts étudiés en cours et de développer nos compétences pratiques. Grâce à son encadrement et à ses précieux conseils, nous avons pu mener à bien notre projet et acquérir une expérience précieuse qui nous sera bénéfique dans notre parcours académique et professionnel. Merci infiniment pour votre soutien et votre dévouement.
---
# Régulation du niveau d'eau dans une cuve (GROUPE I)
**Membres du groupe :**
- Jean EL NADDAF
- Amina ROUABHIA
- Laetitia SADMI
- Mohamed-Ali HAMZA
- Redha MELHEB
- Silya BAZIZI
**Cursus : Master 2 Chimie - Parcours ingénierie chimique**
**Date : 15/10/2024**
**Contexte :**
La gestion des ressources en eau est un défi majeur dans les domaines industriel, agricole et domestique. Le contrôle du niveau d'eau dans des réservoirs ou des cuves est une problématique essentielle pour garantir une utilisation optimale et éviter des problèmes tels que le débordement, la pénurie ou les dysfonctionnements des équipements associés. Dans l'industrie, des systèmes similaires sont utilisés pour gérer les fluides dans des procédés critiques, tandis qu'en agriculture, ils permettent une gestion efficace de l'irrigation. Dans les contextes domestiques, ces systèmes servent à automatiser des tâches comme le remplissage des réservoirs d'eau de pluie ou des piscines.
Avec l'évolution des technologies de mesure et de contrôle, des solutions innovantes comme les capteurs ultrasoniques et les microcontrôleurs (par exemple, Arduino) offrent des alternatives fiables, abordables et programmables pour résoudre ces problèmes. Ces dispositifs permettent une automatisation accrue tout en réduisant les coûts énergétiques et les besoins en maintenance.
**Objectif :**
Ce projet vise à concevoir et développer un système automatisé de régulation du niveau d’eau dans une cuve. L’objectif principal est de maintenir un niveau d’eau optimal en utilisant un capteur ultrason pour mesurer en temps réel la hauteur du liquide, une pompe pour ajuster le niveau, et une carte Arduino pour gérer les données et commander les équipements.
Les objectifs spécifiques sont les suivants :
1. Mesurer le niveau de liquide dans la cuve à l’aide d’un capteur ultrasonique.
2. Réguler le niveau d’eau en activant ou désactivant une pompe pour atteindre et maintenir un niveau défini.
3. Permettre à l’utilisateur de définir un niveau cible pour le liquide dans la cuve.
4. Implémenter un circuit de recirculation d’eau pour simuler un système fonctionnel.
5. Ajouter une LED d’alerte qui s’allume lorsque le niveau d’eau approche un seuil très haut, agissant comme une première alerte contre les débordements.
6. Afficher des messages d’état sur un écran LCD pour informer en temps réel de la situation, comme "Niveau haut" ou "Niveau bas".
7. Utiliser un orifice placé au bas de la cuve pour permettre une vidange par gravité, avec un débit proportionnel à la hauteur du liquide.
**Matériel utilisé :**
- Arduino UNO (+ adaptateur 12 V)
- Breadboard
- Tuyaux x2
- Câbles électriques (f-f, m-m, f-m) x45
- Fer à souder
- Pompe 12V
- Batterie 9V
- Module relais ( on/off)
- Écran LCD 16x2 I2C
- Diode électroluminescente (LED)
- Résistance 10 kΩ
- Capteur ultrason (HC-SR04)
- Condensateur
- Support (en bois et en PMMA)
- Cuves en plastiques (réservoirs et stockage) x2
- Pistolet à colle
- Perceuse
- Soudeuse
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/photo-2024-11-10-20-15-36.jpg)
**Figure 1 :** Ensemble du matériel utilisé
**Machines utilisées :**
\- Découpeuse Laser Trotec Speedy 360
\- Découpeuse Laser Trotec Speedy 100
\- Plieuse CRClarke
**Construction**
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/l6Aimage.png)
**Figure 2** : Schéma structuré de départ
Dans le cadre de ce projet, plusieurs étapes sont fondamentales pour parvenir à la réalisation finale. Voici les différentes phases du processus :
**Phase 1 :** Mise en place du montage électronique en utilisant une carte Arduino.
**Phase 2 :** Recherche, adaptation et simulation d’un code Arduino sur la plateforme Tinkercad pour valider le fonctionnement.
**Phase 3 :** Assemblage d’un système destiné à réguler le niveau d’eau dans une cuve.
**Phase 4 :** Mise en œuvre finale : remplissage des réservoirs avec de l’eau dans un circuit fermé, suivi de tests approfondis pour valider le système.
**Phase 5 :** Démonstration finale du projet.
**Journal de bord :**
**07/10/2024 : Attribution des projets**
**Intitulé du projet : Régulation du niveau d'eau dans une cuve**
**15/10/2024 :**
- Réunion de groupe : discussion et échange d’idées
- Prise de contact avec la tutrice.
- Etablissement d’un plan de travail et répartition des tâches
- Listing du matériel nécessaire
**21/10/2024 :**
- Finalisation de la liste du matériel nécessaire
- Transmission de la liste à la tutrice
**28/10/2024 :**
- Récupération du matériel
**04/11/2024 :**
- Brainstorming et essai de la simulation sur Tinkercad
[ ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/874b62df-e4fa-4996-bfc3-cf621a8294d3.jpeg)[ **Figure 3** : Montage Tinkercad](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/874b62df-e4fa-4996-bfc3-cf621a8294d3.jpeg)
**10/11/2024 :**
- Organisation d'une réunion en visioconférence : discussion sur l'avancement du projet, prospection du matériel nécessaire et élaboration d'un plan de travail pour les prochaines étapes.
- Finalisation de la simulation sur Tinkercad : programmation et validation des branchements.
- Ajout d'une photo ou capture d'écran de la simulation réalisée sur Tinkercad.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/0r1whatsapp-image-2025-01-24-at-16-30-51.jpeg)
**Figure 4 :** Montage Tinkercad final
**13/11/2024 :**
- Réunion de groupe
- Préparation de schéma pour le montage
- Ajustement support
- Etablissement d’une liste supplémentaire de matériel
- Transmission de la seconde liste à la tutrice
**28/11/2024 :**
- Récupération du matériel manquant
**05/12/2024 :**
**Réunion de groupe :**
- Organisation d'une réunion pour coordonner les tâches et discuter de l'avancement du projet.
**Branchements et essais du capteur :**
- Réalisation des connexions nécessaires pour tester le capteur.
- Modification du code : bien que le code fonctionnait correctement dans Tinkercad, il s'est avéré incompatible avec le capteur physique à notre disposition, nécessitant des ajustements.
**Préparation du support de la cuve d'eau :**
- - Découpage du support destiné à accueillir la cuve d'eau.
[ ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/f0a2e247-4526-40b0-8a64-a386cca9cd65.jpg)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/2ef0c45d-44e4-4fba-a4dc-bc19910162b0.jpg)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/f412bbcf-68df-4526-b9a0-10b3818a0a54.jpg)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/ww2a90a9929-39ac-42f8-997a-bf807167bc87.jpg)
**Figure 5** : Avancement du 05/12
**11/12/2024 :**
**Branchements et essais de l'écran LCD :**
- Réalisation des connexions nécessaires pour tester l'écran LCD.
- Téléchargement et installation de la bibliothèque appropriée pour le Grove - LCD RGB Backlight.
- Tests concluants de l'écran LCD en combinaison avec le capteur à ultrasons.
**Préparation de la cuve d'eau :**
- Fixation du support de la cuve d'eau.
- Installation du tuyau d'eau sur la cuve.
**18/12/2024 :**
**Finalisation du code :**
- Programmation des fonctionnalités liées à la pompe et à la LED.
**Réalisation des branchements :**
- Connexion de tous les équipements (LED, capteur ultrason, écran LCD, pompe).
- Observation d'une absence de réponse de la pompe malgré les branchements effectués.
**Préparation du support :**
- Prise des dimensions et préparation du support pour le montage final.
**Dysfonctionnements identifiés :**
- - Détection d'un problème causé par un code défectueux lié au capteur, impactant le fonctionnement global
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/ff1eb7d0-705f-47ae-a294-bed160b121f8.jpg)[ ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/ff1eb7d0-705f-47ae-a294-bed160b121f8.jpg)[ **Figure 6** : Réalisation des branchements](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/ff1eb7d0-705f-47ae-a294-bed160b121f8.jpg)
**20/12/ 2024 :**
**Réunion de groupe en ligne :**
- Organisation d'une réunion virtuelle pour coordonner les tâches et échanger sur l'avancement du projet.
**Tests individuels des composants :**
- Réalisation d'essais pour chaque composant en utilisant le code spécifique correspondant.
**Diagnostic et solution :**
- - Identification d'un dysfonctionnement sur un côté de la breadboard.
- Adaptation en utilisant la partie fonctionnelle de la breadboard pour poursuivre les connexions et les tests.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/d458c397-8e9e-4ff1-a81a-531d6d8a20c2.jpg)
**Figure 7** : Tests individuels des composants
**08/01/2025 :**
- **Réalisation du support de capteur :**
- Découpe du support du capteur à l'aide de la machine TROTEC.
- Pliage du support à l'aide de la machine CRClarke.
**Début du montage :**
- Fixation des cuves d'eau sur le support principal.
- Perçage du support principal pour permettre le passage des câbles électriques nécessaires aux raccordements des différents équipements (pompe et afficheur) ainsi que des tuyaux.
- Installation de l'afficheur LCD et de la LED.
[ ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/527e190f-e545-4cf6-81d5-246e3cc00846.jpg)[ ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/fe51fac8-457b-4574-8b4f-f75a90f98966.jpg)[ ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/YUzda00a56c-3621-4c0c-bd62-373e08110eeb.jpg)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/hyQimage.png)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/VFlwhatsapp-image-2025-01-16-at-15-34-41.jpeg)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/bb097282-5791-4c6f-9cb7-523dda2a3691.jpg)
**Figure 8** : Avancement du 08/01
**15/01/2024 :**
- Soudage des câbles électriques à la LED à l'aide d'un fer à souder.
- Poursuite du montage :
- Fixation du support de l'Arduino, du module relais, et de la breadboard à l'arrière du support initial.
- Gravure des noms et du thème du projet sur une planche en bois pour une finition esthétique.
- Test du code sur le montage et validation du bon fonctionnement.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/1f4575c6-b092-47e0-b01a-c48b5fbef5bb.jpg) **[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/ET5whatsapp-image-2025-01-16-at-16-22-53.jpeg)**
**Figure 9** : Avancement du 15/01
**16/01/2024 :**
**Finalisation, résolution de problèmes et apport de touche finale au montage :**
- Réalisation de gravures sur deux planches distinctes pour inscrire les noms et le thème, afin d'améliorer l'esthétique globale du montage.
- Identification et résolution de problèmes de code rencontrés lors de la mise en œuvre ; cependant, certains problèmes subsistent et nécessitent une analyse approfondie.
- Exploration d'une méthode de moyenne glissante à intégrer dans le code pour améliorer les performances et la précision.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/whatsapp-image-2025-01-16-at-15-28-54.jpeg)[ ](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/Ww1image.png)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/whatsapp-image-2025-01-16-at-17-41-10.jpeg)
**Figure 10** : Avancement du 16/01
**17/01/2024 :**
**Tentatives de résolution des problèmes de code identifiés lors de la séance précédente en appliquant la méthode de la moyenne glissante.**
La régulation est désormais pleinement fonctionnelle.
**Nouvelle problématique rencontrée :**
Un dysfonctionnement de l'affichage sur l'écran LCD a été identifié, causé par l'utilisation d'une bibliothèque incompatible.
**Rôle de la moyenne glissante dans notre projet :**
Dans notre projet, les mesures du capteur à ultrasons étaient fortement perturbées par les vibrations et les interférences générées par la pompe à eau, ce qui rendait les données imprécises et instables.
Dans un premier temps, nous avons opté pour une moyenne classique, consistant à calculer la moyenne arithmétique d'un ensemble de valeurs captées sur une période donnée. Bien que cette méthode ait permis de réduire partiellement les fluctuations, elle ne s'adaptait pas suffisamment à notre système de régulation.
Pour améliorer la précision, nous avons ensuite implémenté une moyenne glissante. Celle-ci calcule en temps réel la moyenne des n dernières valeurs mesurées, en actualisant constamment les données au fur et à mesure des nouvelles lectures. Cette méthode s’est avérée plus efficace, car elle permet de lisser les variations tout en suivant les évolutions rapides des mesures.
En comparant les deux approches, nous avons constaté que la moyenne glissante offrait des données plus précises et stables, tout en réduisant significativement l'impact des perturbations de la pompe à eau sur les relevés du capteur.
**Code final :**
\#include <Wire.h>
\#include "rgb\_lcd.h"
// Initialisation de l'écran LCD
rgb\_lcd lcd;
// Définition des couleurs RGB
const int colorR = 255; // Rouge
const int colorG = 0; // Vert
const int colorB = 255; // Bleu
\#define SIG\_PIN 8 // SIG pin connected to the sensor
\#define LED\_PIN 9 // Pin 9 connecté à la LED
\#define PUMP\_PIN 7 // Pin 7 connecté à la pompe
\#define WINDOW\_SIZE 10 // Taille de la fenêtre pour la moyenne glissante
float measurements\[WINDOW\_SIZE\]; // Tableau pour stocker les mesures
int index = 0; // Index actuel dans le tableau
int count = 0; // Nombre de mesures ajoutées (jusqu'à WINDOW\_SIZE)
float sum = 0; // Somme des valeurs dans le tableau
void setup() {
Serial.begin(9600);
// Initialisation de l'écran avec 16 colonnes et 2 lignes
lcd.begin(16, 2);
// Configuration de la couleur du rétroéclairage
lcd.setRGB(colorR, colorG, colorB);
pinMode(LED\_PIN, OUTPUT); // Initialise la broche 9 comme sortie
pinMode(PUMP\_PIN, OUTPUT); // Initialise la broche 7 comme sortie
}
void loop() {
lcd.clear();
float duration, distance;
float movingAverage;
lcd.clear();
// Envoi de l'impulsion de trigger à l'ultrason
pinMode(SIG\_PIN, OUTPUT);
digitalWrite(SIG\_PIN, LOW);
delayMicroseconds(2);
digitalWrite(SIG\_PIN, HIGH);
delayMicroseconds(10);
digitalWrite(SIG\_PIN, LOW);
pinMode(SIG\_PIN, INPUT);
duration = pulseIn(SIG\_PIN, HIGH);
// Conversion de la durée en distance (cm)
distance = duration \* 0.034 / 2.0;
// Mise à jour du tableau circulaire pour la moyenne glissante
sum -= measurements\[index\]; // Retirer la valeur actuelle du tableau de la somme
measurements\[index\] = distance; // Ajouter la nouvelle mesure au tableau
sum += distance; // Ajouter la nouvelle mesure à la somme
index = (index + 1) % WINDOW\_SIZE; // Passer à l'index suivant (circulaire)
if (count < WINDOW\_SIZE) {
count++; // Incrémenter le nombre de mesures jusqu'à atteindre WINDOW\_SIZE
}
// Calcul de la moyenne glissante
movingAverage = sum / count;
Serial.print(movingAverage);
Serial.println(" cm");
if (movingAverage >= 4) {
digitalWrite(LED\_PIN, HIGH); // Allumer la LED
digitalWrite(PUMP\_PIN, HIGH); // Allumer la pompe
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("Pump On");
}
else if (movingAverage <= 2 && movingAverage > 0.7) {
digitalWrite(LED\_PIN, LOW); // Éteindre la LED
digitalWrite(PUMP\_PIN, LOW); // Éteindre la pompe
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("Pump Off");
}
else if (movingAverage <= 0.7 && movingAverage >= 0) {
lcd.clear();
delay(50);
}
else if (movingAverage <= 4 && movingAverage > 2) {
lcd.clear();
}
delay(750);
}
**Lien drive vers une vidéo démonstrative :** **https://drive.google.com/drive/folders/1Vl2MxxTgznQfRN5DDF0JkZ3zPN5uSHpV?usp=sharing**
**24/01/2024** : Date prévue pour la présentation du montage et du code finalisés.
**Conclusion**
Au fil des semaines, ce projet nous a confrontés à divers défis, notamment des incompatibilités entre les simulations sur Tinkercad et le matériel physique, des erreurs dans le code nécessitant des ajustements, ainsi que des difficultés liées à l’assemblage et au fonctionnement des composants. Ces obstacles, bien que parfois complexes et exigeants, ont représenté une occasion précieuse de développer nos compétences en résolution de problèmes et d’affiner notre approche méthodique face aux imprévus.
Travailler en équipe sur ce projet nous a également permis d’améliorer notre coordination et de mieux répartir les responsabilités, tout en apprenant à collaborer de manière efficace et structurée. Chaque étape, de la conception initiale à la démonstration finale, a contribué à enrichir notre compréhension des systèmes automatisés et des outils technologiques accessibles, tels que les microcontrôleurs et les capteurs.
Bien qu’il s’agisse d’une maquette simplifiée dans un cadre pédagogique, ce projet nous a offert un aperçu réaliste des défis que l’on peut rencontrer dans des projets industriels réels. Il a également illustré l’importance de la rigueur, de l’adaptabilité et de la créativité dans la mise en œuvre de solutions techniques.
# Réalisation d'une burette automatique (Groupe H)
##### **Réalisation d'une burette automatique par mesure d'intensité optique :**Dans le cadre du module *"Optimisation et contrôle des procédés"* , notre projet, intitulé *"Réalisation d'une burette automatique"* , vise à concevoir un dispositif innovant pour automatiser les opérations de titrage en laboratoire. Ce projet s'inscrit dans une démarche visant à optimiser la précision, l'efficacité et la reproductibilité des expériences chimiques.
##### ***Membres du projet ***
- AIT MBAREK Amani, TOUNSI Imene, CECCAROSSI Giuliano, ENNAZI Fadwa, GHERROUZ Mohamed Amine
- ; amani.ait\_mbarek@etu.sorbonne-universite.fr ; Imene.Tounsi@etu.sorbonne-universite.fr ; Giuliano\_Rey.Ceccarossi@etu.sorbonne-universite.fr ; Mohamed\_amine.GHERROUZ@etu.sorbonne-universite.fr
- Projet MU5CI803 : Optimisation et contrôle des procédés (groupe H)
- Période du réalisation du projet : Octobre 2024 - Janvier 2025
##### ***Contexte***
Dans le cadre de l'UE "Optimisation et contrôle des processus", nous avons pour objectif de réguler un système en utilisant une carte Arduino. Pour atteindre cet objectif, il est essentiel de déterminer le matériel requis, de concevoir et assembler correctement la structure, ainsi que de réaliser les branchements nécessaires. En outre, nous devons développer les différents codes permettant l’automatisation du procédé.
L’objectif principal sera d’appliquer nos connaissances en programmation (notamment avec l’environnement Arduino) tout en utilisant les équipements du fablab pour réaliser une manipulation manuelle des machines. Cela nous permettra de créer un système automatisé et optimisé, consistant en une burette capable de verser une quantité précise de liquide coloré dans un récipient, afin d’obtenir un changement de couleur conforme à la valeur souhaitée.
##### ***Objectifs***Notre sujet porte sur la réalisation d'une burette automatique. Pour effectuer la régulation, nous utiliserons un capteur de mesure d'intensité optique et notre actionnement sera un servomoteur; Le but est d'atteindre une couleur définie dans le récipient rempli d'eau.
##### ***Matériels nécessaires :***
- *Carte Arduino*
- *Photorésistance*
- *Servomoteur*
- *Planche à pain*
- *Résistances*
- *Transistor*
- *LED verte et rouge*
- *Tuyaux*
- *Fils*
- *Destinataires : verres*
- *Robinet*
- *Électrovanne *
- *Agitateur (impression 3D)*
- *Plaque peuplier 6mm*
#### **Mise en situation **Le titrage est une technique utilisée en laboratoire pour déterminer la concentration d'une solution chimique. Toutefois, les manuels de titrages présentent des limites en termes de précision et de reproductibilité, en raison des erreurs humaines et des variations dans la manipulation. C'est dans ce contexte que s'inscrit notre projet visant à concevoir une burette automatique capable de réguler avec précision l'ajout d'un réactif, jusqu'à l'obtention d'une couleur cible dans le récipient de titrage. Pour assurer ceci, nous avons choisi de baser notre système sur une approche innovante utilisant une carte Arduino comme unité de contrôle et d'intégrer un capteur d'intensité optique qui permet de détecter précisément le changement de couleur, tandis qu'un servomoteur qui agit en tant qu'actionnement pour ouvrir et fermer une électrovanne, régulant ainsi l'écoulement du réactif. Ensuite le dispositif sera complété par un ensemble d'éléments mécaniques et électroniques à savoir : une breadboard pour les connexions, des tuyaux pour le transfert des liquides, et un agitateur imprimé en 3D pour homogénéiser la solution. Ce système vise à offrir une solution automatisée, économique et efficace, adaptée aux besoins des laboratoires pédagogiques ou de recherche.
##### **Journal de bord**
##### **Lundi 14/10/2024 : **Suite à notre première réunion, nous avons examiné deux approches distinctes. La première consiste à détecter le point d'équivalence par un changement de couleur chimique, en utilisant un dosage colorimétrique (oxydoréduction ou acide-base). L'avantage principal de cette méthode réside dans sa simplicité et sa rapidité d'exécution. La seconde approche, quant à elle, repose sur une détection physique de la couleur. Elle implique l'ajout progressif d'une solution colorée dans un récipient initialement rempli d'eau pure. L'ajout se poursuit jusqu'à l'obtention de la concentration finale souhaitée, ce qui se traduit par une variation de l'intensité lumineuse. Ce paramètre sera mesuré avec précision à l’aide d’un capteur spécifique. Après une discussion approfondie et une analyse comparative des deux méthodes, nous avons décidé d'opter pour la seconde approche qui est plus conforme aux instructions imposées dans le sujet. L'image suivante montre le schéma de discussion et brainstorming :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2024-11/EgUimage.png)
Ensuite nous avons fait un schéma qui résume l'idée que nous avons choisie :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2024-11/b8simage.png)
##### **Lundi 04/11/2024 :**Aujourd'hui, nous avons discuté des approches pratiques pour la réalisation du projet en examinant les matériels disponibles et nécessaires. Nous avons également pris en compte les dimensions spécifiques de chaque élément, comme le volume du récipient destiné au mélange ou le débit du système de pompage à intégrer.Par ailleurs, nous avons abordé les expériences de dilution à réaliser afin de déterminer des valeurs fixes (consignes), notamment le volume de solution colorée à ajouter, ainsi que les concentrations initiale (C₀) et finale (Cf).
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2024-11/aWpimage.png)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/l33image.png)
##### **Lundi 18/11/2024 : *****1) Conception expérimentale pour trouver la concentration de la solution colorée : Cm ***Pour cela, nous aurons besoin d'une balance analytique et de plusieurs récipients. L'objectif est de déterminer une concentration optimale de colorant qui permette d'obtenir une solution colorée, ni trop foncée ni trop claire. Nous réalisons plusieurs dilutions en maintenant un volume fixe d'eau, en variante uniquement la masse de colorant ajouté. La balance analytique sera utilisée pour mesurer avec précision les masses d'eau et de colorant.En connaissant la masse d'eau et de colorant ajouté, nous pourrons calculer la concentration de chaque dilution préparée, exprimée en pourcentage massique (%wt). Ensuite, à l'œil nu, nous déterminerons quelle dilution sera la plus adaptée pour notre travail.Le plan expérimental sera montré à suite : ***2) Conception expérimentale pour trouver le volume de solution colorée à ajouter (V)***Pour ce faire, il sera nécessaire de définir au préalable la concentration finale souhaitée. Ensuite, en connaissant la concentration de la solution colorée initiale, nous pourrons calculer le volume à ajouter pour atteindre la concentration finale visée à l'aide de la règle de dilution :
**Vsc\*Csc = Veau \* Cf**
**Vsc = Veau\*Cf / Vsc**
avec :
- Vsc = volume solution colorée à ajouter
- Csc = cconcentration solution colorée à ajouter (calculée précedemment)
- Veau = volume d'eau initial dans le récipient
- Cf = concentration finale souhaitée dans le récipient ***3) Conception expérimentale pour l'étalonnage de la pompe : ***
**Lundi 18/11/2024 :**
**Conception expérimentale pour déterminer la concentration de la solution colorée (Cm)**
Nous avons utilisé une balance analytique et plusieurs récipients pour préparer différentes dilutions de colorant dans un volume fixe d'eau. En ajustant les masses de colorant, nous avons calculé les concentrations (% massique) pour chaque dilution. Ensuite, à l'œil nu, nous avons sélectionné la dilution offrant une teinte optimale.
**Conception expérimentale pour déterminer le volume de solution colorée à ajouter (V)**
En connaissant la concentration initiale de la solution colorée (Csc) et le volume d'eau dans le récipient (Veau), nous avons calculé le volume de solution colorée à ajouter pour obtenir la concentration finale souhaitée (Cf) à l'aide de la formule :
**Vsc\*Csc = Veau \* Cf**
**Vsc = Veau\*Cf / Vsc**
avec :
- Vsc = volume solution colorée à ajouter
- Csc = cconcentration solution colorée à ajouter (calculée précedemment)
- Veau = volume d'eau initial dans le récipient
- Cf = concentration finale souhaitée dans le récipient
**Conception expérimentale pour l'étalonnage de la pompe**
L'étalonnage visait à mesurer et ajuster les performances de la pompe pour garantir son bon fonctionnement dans le système.
##### **Mercredi 04/12/2024 :**Dans le cadre de notre projet, nous avons réalisé plusieurs manipulations afin de déterminer la concentration optimale à utiliser par la suite. Voici les étapes suivies :**Préparation des solutions de colorant**Nous avons préparé deux solutions :
- - La première en dissolvant **10 gouttes de colorant** dans **100 ml d'eau** .
- La deuxième en dissolvant **18 gouttes de colorant** dans **100 ml d'eau** .**Mesures et tests de coloration**Pour chacune des solutions préparées, nous avons procédé de la manière suivante :À l'aide d'une burette graduée, nous avons versé la solution goutte à goutte dans un bécher contenant **100 ml d'eau** .Nous avons surveillé la coloration obtenue jusqu'à atteindre la teinte désirée.Nous avons noté le volume de solution versé pour chaque essai.**Choix de la solution optimale**Après avoir comparé les résultats pour les deux solutions, nous avons décidé d'utiliser la **première solution (10 gouttes dans 100 ml d'eau)** . Cette option permet d'atteindre la coloration souhaitée avec un volume de solution plus important, offrant ainsi une meilleure précision et une marge de manœuvre dans les ajustements.**Préparation de la solution diluée**À partir de la **solution mère** (10 gouttes dans 100 ml d'eau), nous avons prélevé **20 ml** que nous avons ajoutés à **100 ml d'eau** pour préparer une **solution fille** diluée.**Mesure de l'intensité lumineuse**Nous avons ensuite inséré un code dans le logiciel Arduino pour mesurer la valeur de l'intensité lumineuse de la couleur rouge dans chacune des solutions. Ces mesures permettent d'affiner notre choix et d'intégrer ces paramètres dans notre système automatisé.Ci-dessous le code utilisé : // Définition des broches du capteur TCS3200 const int S0 = 2; const entier S1 = 3 ; const entier S2 = 4 ; const entier S3 = 5 ; const int capteurOut = 6 ; void setup() { // Configurer les broches de sortie pinMode(S0, OUTPUT); pinMode (S1, SORTIE); pinMode (S2, SORTIE); pinMode (S3, SORTIE); pinMode(sensorOut, INPUT); // Régler la mise à l'échelle à 20% (S0 HIGH, S1 LOW) digitalWrite(S0, HIGH); écriture numérique (S1, FAIBLE); Série.begin(9600); } void loop() { int redFrequency, greenFrequency, blueFrequency; // Lecture de la composante Rouge digitalWrite(S2, LOW); écriture numérique (S3, FAIBLE); redFrequency = pulseIn(sensorOut, LOW); // Lecture de la composante Verte digitalWrite(S2, HIGH); écriture numérique (S3, ÉLEVÉ); greenFrequency = pulseIn (sensorOut, LOW); // Lecture de la composante Bleue digitalWrite(S2, LOW); écriture numérique (S3, ÉLEVÉ); blueFrequency = pulseIn(sensorOut, LOW); // Affichage des valeurs dans le moniteur série Serial.print("Rouge: "); Serial.print (rougeFréquence); Serial.print("Vert:"); Serial.print (fréquence verte); Serial.print("Bleu: "); Serial.println(blueFrequency); retard (500); // Attente avant la prochaine conférence }
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2024-12/ccyimage.png)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2024-12/MZVimage.png)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2024-12/agpimage.png)
##### **Mercredi 18/12/2024 :**Nous avons préparé le support destiné à la présentation de notre projet en plusieurs étapes suivantes. Tout d'abord, nous avons démonté l'ancien support en dévissant ses différentes parties afin de récupérer les plaques et les éléments réutilisables. Ensuite, nous avons pris avec précision les dimensions des anciennes plaques pour nous assurer que les nouvelles soient parfaitement adaptées aux besoins du projet. Une fois ces mesures relevées, nous avons découpé les nouvelles plaques à l'aide d'une scie, en veillant à obtenir des découpes nettes et précises. Enfin, nous avons assemblé le nouveau support en fixant solidement les plaques découpées, tout en vérifiant la stabilité et la solidité de l'ensemble. Ce support est maintenant prêt à accueillir notre projet pour une présentation optimale.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2024-12/y6k8dbiy.png)
##### **Lundi 30/12/2024**Nous avons effectué les différents branchements entre la carte Arduino, la breadboard, la pompe et le capteur de couleur. Cela nous a permis de préparer l'intégration de ces composants pour les prochaines étapes de notre projet.
##### **Mercredi 15/01/2025**Nous avons lu le manuel d'utilisation de la découpeuse laser sur le Wiki du Fablab pour bien comprendre son fonctionnement et ses consignes de sécurité.Ensuite, nous avons utilisé la découpeuse laser pour fabriquer un support destiné à couvrir le verre. Ce support comprend des trous conçus spécifiquement pour permettre le passage des tuyaux, du capteur de couleur et de l'agitateur.En parallèle, nous avons travaillé sur le code en intégrant la partie nécessaire au bon fonctionnement du capteur de couleur. Cela inclut l'interfaçage avec la carte Arduino et les tests initiaux pour valider les valeurs captées.
##### **Jeudi 16/01/2025**Nous avons découpé différents socles qui serviront de supports pour les récipients. Ces supports ont été ajustés pour assurer la stabilité et l'ergonomie de l'ensemble du dispositif.Nous avons également consulté le manuel d'utilisation de l'imprimante 3D Raise3D afin de l'utiliser pour imprimer notre agitateur. Après avoir exporté le modèle de l'agitateur depuis notre logiciel de conception, nous l'avons redimensionné selon les besoins du projet. Finalement, nous avons imprimé l'agitateur avec les dimensions adéquates. Celui-ci sera fixé au moteur pour assurer un bon mélange.
##### **Vendredi 17/01/2025**
Nous avons effectué plusieurs découpages supplémentaires sur la plaque principale et commencé à fixer les socles des différents composants à l'aide de vis, afin d'assurer une fixation solide. Avant cela, nous avons réalisé un dimensionnement préliminaire sur un brouillon, permettant de déterminer les positions les plus optimales des composants sur la plaque en bois. Cette approche visait à garantir que le positionnement spatial de chaque élément ne nuise pas au bon fonctionnement des autres. Vous trouverez ci-joint la feuille de brouillon utilisée pour le montage structurel.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/whatsapp-image-2025-01-31-at-14-56-56.jpeg)
De manière similaire, nous avons procédé pour les composants électroniques situés à l’arrière de la plaque de bois. Pour leur fixation, nous avons choisi des vis de taille appropriée et utilisé une perceuse, disponible dans l'atelier de menuiserie, afin de réaliser les perforations aux emplacements préalablement sélectionnés.[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/whatsapp-image-2025-01-31-at-15-14-21.jpeg)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-01/whatsapp-image-2025-01-31-at-15-14-22.jpeg)Ensuite, nous avons testé individuellement chaque appareil (pompe, capteur de couleur, agitateur, etc.) pour nous assurer de leur bon fonctionnement. Pendant ces tests, nous avons constaté que la résistance utilisée n'était pas adaptée, ce qui a nécessité de la remplacer par une autre correspondante aux spécifications requises.Par ailleurs, nous avons également dû changer le transistor, car nous avions initialement sélectionné une référence incorrecte. Après avoir installé le bon transistor, les tests ont été repris avec succès.
##### **Lundi 20/01/2025 :**Nous avons finalisé les derniers éléments du montage et avancé sur le branchement des différents composants entre eux. Cette étape nous a permis de tester l'intégration complète du système et de nous assurer que le code fonctionne correctement en interaction avec les composants.Voici le code après les ajustements réalisés :\#include <Wire.h> #include <LiquidCrystal\_I2C.h> # définir 5 #définir S2 4 #définir S3 3 int R,V,B; temps longs non signés ; int pompe = 8 ; int agitateur = 6 ; LiquidCrystal\_I2C écran LCD ( 0x 27 , 16 , 2 ) ; configuration vide() { pinMode ( sortie, ENTRÉE ) ; pinMode ( S2, SORTIE ) ; pinMode ( S3, SORTIE ) ; pinMode ( pompe,SORTIE ) ; pinMode ( agitateur,OUTPUT ) ; écran LCD. initialiser () ; // Initialiser l'écran LCD LCD . rétroéclairage () ; écran LCD.setCursor ( 0 , 0 ) ; écran LCD. print ( "Ca,commence !" ) ; retard (2000); digitalWrite ( agitateur, 1 ) ; digitalWrite ( pompe, 1 ) ; } boucle vide() { écriture numérique ( S2, 0 ) ; écriture numérique ( S3, 0 ) ; R = pulseIn ( sortie, 0 ) ; retarder ( 10 ) ; int temps = millis () ; si ( R< 220 ) { digitalWrite ( pompe, 0 ) ; débit flottant = ( 27,77 \*temps ) / 1000 ; lcd .clear () ; // Efface l'affichage de l'écran LCD.setCursor ( 0 , 0 ) ; écran LCD . print (" Le débit est : " ) ; écran LCD.setCursor ( 0 , 1 ) ; écran LCD . imprimer ( flux ) ; écran LCD.imprimer ( "ml" ) ; } }
##### **Mercredi 22/01/2025 :**En testant le bon fonctionnement de l'ensemble du montage, nous avons constaté que l'afficheur LCD n'affiche pas les résultats comme prévu. Pour identifier la cause du problème, nous avons décidé d'effectuer un test isolé. Nous avons utilisé un code simple pour afficher un message basique sur le LCD sans qu'il soit lié au reste du montage. Cette méthode nous permet de vérifier si le problème provient du module LCD lui-même ou d'une autre partie du système.
##### **Lundi 27/01/2025 :**
Nous avons réalisé des essais sur la solution en utilisant notre capteur afin de vérifier son bon fonctionnement. Parallèlement, nous avons préparé les éléments décoratifs de notre montage à l’aide de la découpeuse laser, ce qui a permis d’améliorer l’esthétique de notre dispositif.
##### **Jeudi 30/01/2025 :**
Nous avons apporté quelques modifications au code afin d’optimiser ses performances et d’assurer son bon fonctionnement. Voici la version finale du code :
\#include <Wire.h>
\#include "rgb\_lcd.h"
\#define out 5
\#define S2 4
\#define S3 3
int R,G,B;unsigned long temps;int pomp = 8;
int agitateur = 6;
rgb\_lcd lcd;
void setup() {
pinMode(out,INPUT);
pinMode(S2,OUTPUT);
pinMode(S3,OUTPUT);
pinMode(pomp,OUTPUT);
pinMode(agitateur,OUTPUT);
lcd.begin(16,2); // Initialize the LCD
lcd.setRGB(255,255,0);
lcd.setCursor(0, 0);
lcd.print("Ca,commance !");
delay(2000);
digitalWrite(agitateur,1);
digitalWrite(pomp,1);
}
void loop() {
digitalWrite(S2,0);
digitalWrite(S3,0);
R = pulseIn(out,0);
delay(10);
int temps = millis();
if(R<220) {
digitalWrite(pomp,0);
float flow = (27.77\*temps)/1000;
lcd.clear(); // Clear the display
lcd.setCursor(0, 0);
lcd.print("Le Volume est : ");
lcd.setCursor(0, 1);
lcd.print(flow);
lcd.print("ml");
}
}
Nous avons ensuite effectué un test du montage complet, qui s’est révélé concluant.
##### **Vendredi 31/01/2025 :**
Nous avons réalisé les dernières retouches, notamment en fixant les pièces finales pour finaliser l’assemblage. Nous avons également préparé notre solution et effectué plusieurs essais pour nous assurer de la fiabilité de l’ensemble avant la présentation finale de notre projet.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-02/whatsapp-image-2025-02-03-at-15-36-06.jpeg)