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
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:
- Recherche individuelle sur le sujet.
- Chaque membre doit établir une liste des composants nécessaires.
- Schématiser la régulation (croquis).
- 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:
- Simuler le projet sur TinkerCAD grâce au schéma et liste des composants.
- Installer Arduino IDE.
- 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 :
Le circuit proposé au tuteur :
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 :
- Amélioration du Code Arduino.
- Prise en main du capteur étanche DS18B20.
- 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.
Branchement effectué par nous :
Nous rencontrons un problème de lecture sur l'ordinateur.
Objectifs fixés pour la séance prochaine:
- Envoyer un e-mail au professeur pour signaler le matériel manquant
- Installer Arduino IDE
- 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.
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
-
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.
- Assemblage des cuves : Fixation des cuves sur le support, ainsi que l'installation de l'agitateur
- Découpage laser de la plaque en MDF 3mm : Gravure de nos noms et du nom du projet sur une plaque MDF
- 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
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
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 :
Cependant, nous avons rencontré plusieurs problèmes :
-
- 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é.
- 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.
- 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.
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.
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.
No Comments