Skip to main content

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. La figure montre les résultats obtenus à la fin avec les membres de l'équipe.IMG-20250131-WA0020.jpg

Figure : Projet final et les membres de l'équipe

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.image.png

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.

image.png

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.

                                                              image.png        image.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 :

                                 image.png     image.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.

tinkercad.png

Figure : Montage proposée sur Tinkcard

Avec le code Arduino suivant :

image.png

image.png

image.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 :

WhatsApp 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 typographies1738312577300.jpg

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

1738312577353.jpg

Figure : Machine de coupe par Laser

 La plaque obtenus pour notre projet est la suivante : 

image.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. 

IMG_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. 

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 : 

WhatsApp Image 2025-01-31 at 15.43.18.jpeg

 Figure : Montage du projet

IMG-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 : 

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
double targetTemp = 30.0;      // Initial target temperature
double motorOutput = 0.0;      // PID output to control the motor
double Kp = 2.0, Ki = 0.5, Kd = 1.0; // PID constants
 
PID pidController(&currentTemp, &motorOutput, &targetTemp, Kp, Ki, Kd, DIRECT);
 
// Button Timing Variables
unsigned long lastButtonUpTime = 0;
unsigned long lastButtonDownTime = 0;
const unsigned long buttonPressInterval = 25; // Faster response time for buttons
 
// Pump Control Variables
bool pumpState = false;        // Tracks if the pump is ON or OFF
bool simultaneousPressDetected = false; // Tracks simultaneous press detection
 
void setup() {
 // Initialize LCD
 lcd.begin(16, 2);
 lcd.setRGB(255, 255, 255); // White backlight
 
 // Welcome message
 lcd.setCursor(0, 0);
 lcd.print("Regulation Temp");
 delay(2000);
 lcd.clear();
 
 // Pin configuration
 pinMode(BTN_UP_PIN, INPUT_PULLUP);
 pinMode(BTN_DOWN_PIN, INPUT_PULLUP);
 pinMode(LED_R_PIN, OUTPUT);
 pinMode(LED_G_PIN, OUTPUT);
 pinMode(LED_B_PIN, OUTPUT);
 pinMode(MOTOR_PIN, OUTPUT);
 pinMode(PUMP_PIN, OUTPUT);
 
 // Initialize LEDs and Pump
 digitalWrite(LED_R_PIN, LOW);
 digitalWrite(LED_G_PIN, LOW);
 digitalWrite(LED_B_PIN, LOW);
 digitalWrite(PUMP_PIN, LOW);
 
 // Start temperature sensor
 sensors.begin();
 Serial.begin(9600);
 
 // Initialize PID controller
 pidController.SetMode(AUTOMATIC);   // Set PID mode to automatic
 pidController.SetOutputLimits(0, 255); // Set motor output range
}
 
void loop() {
 // Request temperature from sensor
 sensors.requestTemperatures();
 currentTemp = sensors.getTempCByIndex(0);
 
 // Display current temperature on LCD
 lcd.setCursor(0, 0);
 lcd.print("Temp: ");
 lcd.print(currentTemp, 1); // Display with 1 decimal place
 lcd.print(" C    ");      // Clear extra characters
 
 // Adjust target temperature with independent debounce logic
 if (digitalRead(BTN_UP_PIN) == LOW && millis() - lastButtonUpTime > buttonPressInterval) {
   targetTemp += 0.5;       // Increase target temperature
   lastButtonUpTime = millis();
 }
 if (digitalRead(BTN_DOWN_PIN) == LOW && millis() - lastButtonDownTime > buttonPressInterval) {
   targetTemp -= 0.5;       // Decrease target temperature
   lastButtonDownTime = millis();
 }
 
 // Display target temperature on LCD
 lcd.setCursor(0, 1);
 lcd.print("Set: ");
 lcd.print(targetTemp, 1); // Display with 1 decimal place
 lcd.print(" C    ");
 
 // Pump control: Detect simultaneous press of BTN_UP_PIN and BTN_DOWN_PIN
 if (digitalRead(BTN_UP_PIN) == LOW && digitalRead(BTN_DOWN_PIN) == LOW) {
   simultaneousPressDetected = true; // Simultaneous press detected
 }
 
 if (digitalRead(BTN_UP_PIN) == HIGH && digitalRead(BTN_DOWN_PIN) == HIGH && simultaneousPressDetected) {
   pumpState = !pumpState; // Toggle pump state
   digitalWrite(PUMP_PIN, pumpState ? HIGH : LOW); // Turn pump ON/OFF
   simultaneousPressDetected = false; // Reset detection flag
   delay(200); // Debounce delay for pump toggle
 }
 
 // Run PID computation
 pidController.Compute();
 
 // Control motor output based on PID output
 analogWrite(MOTOR_PIN, motorOutput);
 
 // Control LEDs based on temperature state
 const float hysteresis = 1.0; // Temperature tolerance range
 if (currentTemp < targetTemp - hysteresis) {
   digitalWrite(LED_R_PIN, HIGH); // Red: Heating needed
   digitalWrite(LED_G_PIN, LOW);
   digitalWrite(LED_B_PIN, LOW);
 } 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
float currentTemp = 0.0;       // Température actuelle


// Initialisation de l'écran LCD
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
//LiquidCrystal_I2C lcd(0x3E, 16, 2);
//LiquidCrystal_I2C lcd(0x27, 20, 4);
//rgb_lcd lcd;

void setup()
{
 
  Serial.begin(9600);
  pinMode(9, OUTPUT);
  pinMode(10, OUTPUT);
  // Initialisation de l'écran LCD
lcd.begin(16, 2); // Initialisation du LCD 16x2
  lcd.print("Température: "); // Affiche "Température" sur la première ligne
// Initialize LCD
  
  //lcd.init();        // Initialize the LCD
//  lcd.backlight();
 //lcd.begin(16, 2);
 //lcd.setRGB(255, 255, 255); // White backlight
 
 // Welcome message
 lcd.setCursor(0, 0);
 lcd.print("Regulation Temp");
 delay(2000);
 lcd.clear();
}

void loop()
{
  
  // Get a reading from the temperature sensor:
  int reading = analogRead(A0);
  // Convert the reading into voltage:
  float voltage = reading * (5000 / 1024.0);
  // Convert the voltage into the temperature in Celsius:
  float temperature = (voltage - 500) / 10;
  // Print the temperature in the Serial Monitor:
  Serial.println(temperature);
  delay(1000); // wait a second between readings
  
  if(temperature >=50) digitalWrite(9, HIGH) ;
  else  digitalWrite(9, LOW);  

  if(temperature <=50) digitalWrite(10, HIGH) ;
  else  digitalWrite(10, LOW); 
    
  // 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 : 

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.