Projet : Nettoyage en place automatisé
Projet : Nettoyage en place automatisé
Projet : Nettoyage en place automatisé ( https://drive.google.com/file/d/1FS5lEPSNvT7yhqJQlm9i7CSsU28oJ8LH/view?usp=sharing )
GROUPE 7
Membres du projet : Inès Dridi, Abdelkerim Hissein, Riad Aberkane, Yousra Lasmi
Promotion : 2025-2026 M2 Chimie parcours Ingénierie Chimique
Date de début du projet : 14 octobre 2025
Date de fin estimée du projet : janvier 2026
1. INTRODUCTION :
Le projet « NEP automatisé » consiste à concevoir un prototype de système de nettoyage en place à échelle réduite, piloté par une carte Arduino Uno. L’objectif est de reproduire, de manière pédagogique, automatisée et sécurisée, un procédé industriel de nettoyage des équipements de procédé (cuves, tuyauteries) en utilisant uniquement des produits non dangereux et alimentaires (eau, vinaigre blanc et liquide vaisselle). Dans un contexte industriel, la maîtrise des opérations de nettoyage est essentielle pour garantir la qualité des productions, limiter les contaminations croisées en réduisant les interventions manuelles et optimiser la consommation d’eau.
Pour des raisons de temps et de difficulté, nous avons simplifié le sujet avec Monsieur Pulpytel : Le projet consiste maintenant à concevoir et automatiser un procédé expérimental ayant pour objectif d’étudier l’efficacité de cycles successifs de lavage à l’eau d’une cuve contenant initialement du chlorure de sodium (NaCl). L’enjeu principal est de déterminer, de manière automatique, après combien de cycles de nettoyage la cuve peut être considérée comme propre, c’est-à-dire lorsque la conductivité de l'eau de nettoyage devient inférieure à un seuil défini.
2. MATÉRIEL UTILISÉ :
2.1 Réactifs
Les réactifs de ce procédé sont le chlorure de sodium NaCl et l’eau :
- NaCL est introduit manuellement dans la cuve au début du procédé et se dissout dans l’eau lors des cycles de remplissage grâce à l'agitation. Son élimination est suivie par la mesure de la conductivité de la solution de nettoyage, proportionnelle à la concentration ionique.
- l'eau est l’unique agent de lavage stocké dans un bac et envoyé par une pompe dans la cuve contenant NaCl.
2.2 Composants du procédé
- Cuve représentant un réacteur : petit récipient(un verre) où l’on introduit le NaCl. La cuve est équipée d’un détecteur de niveau bas (LSL) et d’un détecteur de niveau haut (LSH).
- Bac d’alimentation en eau : Alimenté manuellement, il contient l’eau destinée au remplissage de la cuve.
- Bac de récupération : Récupère les eaux de nettoyage issues de la vidange.
- Pompes de 12V :
- P1 : Pompe de remplissage permettant de transférer l’eau propre du bac d’alimentation vers la cuve.
- P2 : Pompe de vidange permettant de vidanger la cuve vers le bac de récupération et entraîne l’effluent vers le conductimètre.
- Capteurs de niveau :
- LSH : Level Switch High qui détecte le niveau haut dans la cuve → arrêt du remplissage.
- LSL : Level Switch Low qui détecte le niveau bas → arrêt de la vidange et déclenchement de la mesure de conductivité.
- Conductimètre : le conductimètre est placé dans le réacteur, il mesure la conductivité de la solution, indicateur direct de la concentration en NaCl. Il sert ainsi de critère final d’arrêt du procédé lorsque la valeur mesurée devient inférieure ou égale au seuil de propreté.
- Un Arduino Uno, un module relais et un écran LCD pour le contrôle et le suivi.
3. AVANCEMENT DU PROJET
- 14 octobre 2025 – Choix du sujet
L’équipe a sélectionné le thème du projet, portant sur la conception et l’automatisation d’un système de rinçage à l’eau et de nettoyage au liquide vaisselle et au vinaigre banc.
- 17 octobre 2025 – Envoi du sujet retenu
Le choix final du sujet a été transmis à l’enseignant pour validation.
- 24 octobre 2025 – Sélection des composants
Remise du document recensant l’ensemble des composants nécessaires, accompagnés de leurs spécifications techniques détaillées ainsi que des fournisseurs référencés.
- 27 au 31 octobre 2025 – Élaboration du P&ID et du GRAFCET
Production des premières versions du schéma d’instrumentation (P&ID) et du GRAFCET définissant le cycle automatisé.
- 7 novembre 2025 – Organisation du travail au FabLab
Répartition de l’équipe en binômes afin d’optimiser la présence lors des créneaux disponibles au FabLab :
• un groupe assigné au mardi après-midi,
• un second groupe assigné au jeudi après-midi.
- 17 novembre 2025 – Récupération du matériel et échanges techniques
Collecte des différents éléments matériels, inscription au FabLab et ajustements du procédé suite aux remarques et recommandations de Monsieur Pulpytel.
- 22 novembre 2025 – Finalisation des documents techniques
Établissement des versions finales du P&ID et du GRAFCET, intégrant toutes les modifications demandées :
Explication du Fonctionnement du système : lien entre GRAFCET et P&ID
-
-
Vérification de l’alimentation en eau
S’assurer que la cuve d’alimentation est correctement remplie avec de l’eau propre destinée au cycle de nettoyage. -
Sécurisation de l’installation
Confirmer que l’ensemble des pompes est à l’arrêt avant le lancement de la procédure. -
Contrôle de l’état du réacteur
Vérifier que le réacteur est entièrement vide. Le niveau bas (LSL) doit indiquer 0, signifiant l’absence d’eau résiduelle. -
Lancement du cycle de nettoyage
-
Mettre en marche la pompe d’alimentation (Pompe 1).
-
Maintenir la pompe d’évacuation (Pompe 2) fermée.
Le réacteur se remplit jusqu’à atteindre le niveau haut (LSH).
À ce seuil, arrêter la Pompe 1.
-
-
Phase d’agitation
Activer le système d’agitation afin d’assurer une solubilisation des dépôts de sel.
L’agitation est maintenue pendant une durée définie. -
Arrêt de l’agitation
Une fois le temps de brassage écoulé, arrêter le dispositif d’agitation. -
Mesure de la conductivité in situ
Effectuer une mesure de conductivité directement dans le réacteur afin d’évaluer la concentration résiduelle en sel dissous. -
Vidange du réacteur
-
Ouvrir la Pompe 2 pour procéder à la vidange complète.
-
Arrêter la vidange lorsque le niveau bas (LSL = 0) est détecté.
-
-
Évaluation de la qualité du nettoyage
Comparer la conductivité mesurée avec la valeur de référence.-
Si la conductivité est supérieure au seuil dé
fini,fini, un nouveau cycle de nettoyage est automatiquement déclenché. -
Si la conductivité est inférieure ou égale au
seuil,seuil, le système s’arrête : le nettoyage est considéré comme conforme.
-
-
- 27 novembre 2025:
Impression 3D de l'agitateur au Fablab
- 27 novembre 2025 - Tentatives et ajustements de l’impression 3D de l’agitateur Au cours de cette séance au FabLab, nous avons procédé à l’impression 3D de l’agitateur destiné à être fixé sur l’axe du moteur. Une première impression a été lancée sur l’imprimante Prusa MK4S, mais celle-ci n’a pas abouti : le filament ne s’est pas correctement déposé, entraînant une pièce instable, partiellement fondue et déformée, comme en témoignent les résidus visibles sur la plaque d’impression.
Après analyse, nous avons conclu que le défaut provenait de paramètres inadaptés, notamment une rigidité trop faible et l’absence de supports pour maintenir la géométrie de la pièce.
À la suite de cet essai infructueux, nous avons décidé d’ajuster les paramètres pour la seconde impression :
- augmenter la rigidité du modèle à 20 %,
- ajouter des supports d’impression,
- vérifier l’adhérence du plateau et la température du filament.
3 décembre 2025 - Réalisation du montage mécanique et premières étapes d’assemblage
Lors de cette séance, nous avons commencé la construction physique du dispositif. Nous avons découpé les différentes plaques de support, percé les ouvertures nécessaires à l’installation du moteur et de la cuve, puis assemblé les éléments sur la structure en aluminium.
Le moteur a été fixé sur une platine supérieure, tandis que la cuve a été positionnée sur un support intermédiaire afin de reproduire l’architecture prévue dans le P&ID. Cette séance a permis de vérifier l’alignement entre le moteur, l’axe et la cuve et de confirmer la faisabilité du système avant l’intégration des capteurs et de l’automatisation.
- 05 décembre 2025
Lors de l’utilisation de l'écran LCD I2C (Grove LCD RGB Backlight V4.0) avec une carte Arduino, l’écran s’allumait mais n’affichait aucun texte.
Les tests avec un scanner I2C n’ont détecté aucune adresse, malgré un câblage correct et un programme fonctionnel.
Cela indique un problème matériel de communication I2C (module LCD ou carte Arduino défectueux).
- 8 décembre 2025 - Intégration d’une première pompe et préparation du bac d’alimentation Lors de cette séance, nous nous sommes concentrés sur l’intégration de la première pompe et sur l’emplacement optimal du bac d’alimentation en eau et de la pompe. Il faut s’assurer un transfert fluide entre le bac d’alimentation et la cuve, tout en tenant compte des contraintes d’encombrement et de passage des tuyaux. Après repérage, nous avons percé les ouvertures nécessaires pour le passage des câbles et des conduites.
Nous avons également choisi de fixer la pompe à l’aide de rizlans, laissants la possibilité d’ajuster la position de la pompe ultérieurement sans percer de nouvelles pièces ni risquer d’endommager l’ensemble. Pour fixer le bac d’alimentation, nous avons découpé un support muni d’un trou circulaire de 68 mm de diamètre. Ce trou, calibré au laser, permet d’insérer et maintenir une bouteille en position verticale, tout en garantissant sa stabilité durant les opérations de remplissage.
- 11 décembre 2025 - Remplacement de l'écran LCD et montage du dispositif (suite)
Après le problème rencontré avec l'écran LCD, Il a été finalement décidé de le remplacer LCD ainsi que l'Arduino.
Durant cette séance, nous avons également poursuivi notre travail sur le montage du dispositif expérimental.
- 18 Décembre 2025 : Montage du dispositif (suite)
Pour la phase suivante, nous avons décidé de comprendre et de réaliser le branchement des différents composants. Dans un premier temps, l’objectif principal était de les faire fonctionner séparément à l’aide de programmes exécutés sur l’IDE Arduino, afin de valider individuellement leur alimentation et leur activation. Une fois ces tests unitaires réalisés, nous passerons à la mise en marche de l’ensemble du système, en activant tous les composants simultanément dans le circuit. C’est ce qui sera développé et expliqué dans la suite.
- 22/12/2025 :
Adaptation au matériel électronique utilisé et test du matériel à l’aide de codes sur l’IDE Arduino. Nous avons également étudié et réalisé le câblage des différents composants (pompe, relais, carte Arduino, batterie), en suivant les schémas de connexion adaptés. Le branchement des composants est détaillé dans l’ Annexe 1.
- 23/12/2025: Tests et branchements des composants (Suite) :
Nous avons vérifié le bon fonctionnement de la pompe à l’aide d’un programme exécuté depuis l’IDE Arduino, afin de nous assurer de son bon fonctionnement après son branchement. Nous avons également étudié le principe de fonctionnement du capteur de niveau d’eau pour comprendre son mode de détection et son comportement dans le circuit. Enfin, nous avons testé le conductimètre également à travers un programme exécuté depuis l'IDE Arduino et en utilisant les solutions étalons mises à disposition, dans le but de confirmer son bon fonctionnement et la cohérence des mesures obtenues.
- 24/12/2025 : Visio sur Google meet - discussion et élaboration de la version finale du GRAFCET du système.
- 1-01-2026 Description du branchement électronique du système
1. Écran LCD
L’écran LCD sert à afficher les informations importantes du système (état du nettoyage, niveau, messages, etc.).
- La borne GND de l’écran est reliée au GND de l’Arduino : cela permet d’avoir une référence électrique commune.
- La borne VCC est reliée au 5V de l’Arduino : elle alimente l’écran.
- Les bornes SDA et SCL permettent la communication entre l’écran et l’Arduino :
- SDA (A4) transmet les données,
- SCL (A5) synchronise la communication.
Grâce à cette connexion, l’Arduino peut envoyer du texte à afficher sur l’écran avec seulement deux fils de communication.
2. Capteur de niveau
Le capteur de niveau permet de mesurer la hauteur du liquide dans la cuve, sans contact direct avec le liquide.
- GND est relié au GND de l’Arduino.
- VCC est relié au 5V de l’Arduino pour alimenter le capteur.
- La broche Trig (pin 9) envoie une impulsion ultrason.
- La broche Echo (pin 8) reçoit le signal réfléchi.
L’Arduino mesure le temps entre l’envoi et la réception du signal pour calculer le niveau du liquide.
3. Pompe, relais, batterie et Arduino
La pompe fonctionne avec une batterie externe, car elle consomme plus de puissance que ce que l’Arduino peut fournir.
Le relais joue le rôle d’un interrupteur électrique commandé par l’Arduino.
La Pompe:
- La borne Pompe + est reliée au contact NO (Normally Open) du relais.
- La borne Pompe − est reliée au − de la batterie.
Quand le relais est activé, le courant passe et la pompe démarre.
Batterie
- La borne Batterie + est reliée au contact NC du relais.
- La borne Batterie − est reliée directement à la pompe −.
La batterie fournit l’énergie nécessaire au fonctionnement de la pompe.
Relais
- Relais + est relié au 5V de l’Arduino pour alimenter le module relais.
- Relais − est relié au GND de l’Arduino.
- Relais S est relié à la broche 3(pin) de l’Arduino.
Lorsque l’Arduino envoie un signal sur la broche 3, le relais s’active et autorise la mise en marche de la pompe.
4. Conductimètre
Le conductimètre est prévu pour mesurer la conductivité du liquide lors des phases de nettoyage et de rinçage.
1-01-2026 modification ancien grafcet jugé non conforme aux exigences attendus
Schéma grafcet et Principe de fonctionnement du CIP
Principe de fonctionnement du CIP automatisé
Le fonctionnement du système de nettoyage en place (CIP) est basé sur le GRAFCET présenté ci-dessus.dessus. Celui-ci permet de décrire de manière séquentielle et logique les différentes étapes du procédé de nettoyage mis en œuvre sur un système CIP à échelle réduite,duite, depuis l’état d’attente jusqu’à la fin du cycle de nettoyage.
Description des différentes étapes du cycle
Étape 0 : Attente
Le système est à l’état initial. L’ensemble des actionneurs (pompes et agitateur) est à l’arrêt. Le cycle de nettoyage débute après l’activation du bouton de démarrage.
Étape 1 : Détection du niveau
Le capteur de niveau du réacteur est interrogé afin de déterminer si le volume de liquide de nettoyage présent dans le réacteur est suffisant.
Étape 2 : Remplissage du réacteur
Si un niveau bas est détecté, la pompe 1 est enclenchée afin d’alimenter le réacteur en solution de nettoyage (eau). Le système retourne ensuite à l’étape de détection du niveau.
Étape 3 : Niveau haut atteint
Lorsque le niveau haut est détecté, la pompe 1 est arrêtée,e, garantissant un volume constant de solution de nettoyage dans le réacteur.
Étape 4 : Agitation
L’agitateur est mis en fonctionnement afin d’assurer une meilleure dissolution du sel dans l’eau et d’améliorer l’efficacité du nettoyage. L’agitation est maintenue pendant 30 secondes,secondes, puis arrêtée.
Étape 5 : Mesure de la conductivité
Après l’agitation, la conductivité du liquide présent dans le réacteur est mesurée à l’aide d’un capteur de conductivité. Cette mesure permet d’évaluer le degré de propreté du système.
Étape 6 : Vidange du réacteur
La pompe 2 est activée afin d’assurer la vidange du réacteur. La valeur de conductivité mesurée est comparée à une valeur seuil prédéfinie, correspondant à une conductivité proche de celle de l’eau claire.
Étape 7 : Fin du cycle
Si la conductivité est inférieure à la valeur seuil, le cycle de nettoyage est considéré comme terminé. Dans le cas contraire, un nouveau cycle de nettoyage est relancé automatiquement.
- 26/01/2026 -
finalisationFinalisation du montage dudispositif.dispositif .
- 28-29/01/2026 - Connexions des composants
Durant ces séances, nous avons travaillé sur:
- la connexion de tous les éléments afin de les faire fonctionner ensemble dans le circuit.
- La fixation des composants électroniques
Annexe30/01/20262::
Finalisation du projet et présentation
Aujourd’hui, nous avons finalisé le programme général en fusionnant l’ensemble des programmes développés pour chaque élément. Un dysfonctionnement de la pompe a été constaté, dû à un problème d’alimentation ; la batterie devait donc être remplacée.
Le conductimètre a également été intégré au programme. Cependant, les valeurs mesurées se sont révélées aberrantes (par exemple, une conductivité de 4000 us/cm mesurée dans l’air), alors que l’appareil avait été préalablement calibré. Nous supposons que ces anomalies proviennent de manipulations antérieures, notamment lors du prêt du conductimètre à un autre groupe.
Programme C++ pour la mise en marche du dispositif (version finale):
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
// ---------- PINS ----------
const int trigPin = 9;
const int echoPin = 8;
const int relaisRemplissage = 3;
const int relaisVidange = 5;
const int motorPin = 11;
const int boutonStop = 2;
const int capteurEC = A0;
// ---------- SEUILS ----------
const float SEUIL_BAS = 20.0;
const float SEUIL_HAUT = 5.0;
const float EC_SEUIL = 800.0; // 1000 µS/cm
// ---------- CALIBRATION EC ----------
const float FACTEUR_CALIB = 32.86;
// ---------- PARAMÈTRES ----------
const int VITESSE_AGITATION = 71;
const unsigned long DUREE_AGITATION = 20000; // 20 sec
const unsigned long DUREE_VIDANGE = 26000; // 26 sec
const int MAX_CYCLES = 3; // Maximum 3 cycles
// ---------- MACHINE D'ÉTATS ----------
enum Etat { ATTENTE, REMPLISSAGE, AGITATION, MESURE_EC, VIDANGE, FIN, URGENCE };
Etat etat = ATTENTE;
// ---------- VARIABLES GLOBALES ----------
int nombreCycles = 0;
float dernierEC = 0;
bool nettoyageValide = false;
// ---------- LCD I2C ----------
LiquidCrystal_I2C lcd(0x27, 16, 2);
// ---------- SETUP ----------
void setup() {
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);
pinMode(relaisRemplissage, OUTPUT);
pinMode(relaisVidange, OUTPUT);
pinMode(motorPin, OUTPUT);
pinMode(boutonStop, INPUT_PULLUP);
digitalWrite(relaisRemplissage, LOW);
digitalWrite(relaisVidange, LOW);
analogWrite(motorPin, 0);
Serial.begin(9600);
lcd.init();
lcd.backlight();
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Systeme demarre");
delay(2000);
}
// ---------- LOOP ----------
void loop() {
// Vérification arrêt d'urgence
if (digitalRead(boutonStop) == LOW) {
etat = URGENCE;
}
switch (etat) {
case ATTENTE:
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Etat : ATTENTE");
lcd.setCursor(0,1);
lcd.print("Cycle ");
lcd.print(nombreCycles + 1);
lcd.print("/");
lcd.print(MAX_CYCLES);
Serial.print("Etat : ATTENTE - Cycle ");
Serial.print(nombreCycles + 1);
Serial.print("/");
Serial.println(MAX_CYCLES);
etat = REMPLISSAGE;
delay(1000);
break;
case REMPLISSAGE: {
float distance = mesureDistance();
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Remplissage");
lcd.setCursor(0,1);
lcd.print("Dist: ");
lcd.print(distance);
Serial.print("Remplissage - Distance = ");
Serial.println(distance);
if (distance <= SEUIL_HAUT) {
digitalWrite(relaisRemplissage, LOW);
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Niveau HAUT");
lcd.setCursor(0,1);
lcd.print("Pompe OFF");
Serial.println("Niveau haut atteint - Passage agitation");
etat = AGITATION;
delay(2000);
} else if (distance > SEUIL_HAUT && distance <= SEUIL_BAS) {
digitalWrite(relaisRemplissage, HIGH);
} else {
digitalWrite(relaisRemplissage, LOW);
}
delay(500);
break;
}
case AGITATION:
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Agitation...");
lcd.setCursor(0,1);
lcd.print("Cycle ");
lcd.print(nombreCycles + 1);
lcd.print("/");
lcd.print(MAX_CYCLES);
Serial.print("Debut agitation - Cycle ");
Serial.print(nombreCycles + 1);
Serial.print("/");
Serial.println(MAX_CYCLES);
digitalWrite(relaisRemplissage, LOW);
analogWrite(motorPin, VITESSE_AGITATION);
delay(DUREE_AGITATION);
analogWrite(motorPin, 0);
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Agitation OK");
Serial.println("Agitation terminee - Passage mesure EC");
etat = MESURE_EC;
delay(2000);
break;
case MESURE_EC: {
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Mesure EC...");
Serial.println("=== Debut mesure EC ===");
const int nbMesures = 10;
float sommeEC = 0;
for(int i=0; i<nbMesures; i++){
int brute = analogRead(capteurEC);
float ec = brute * FACTEUR_CALIB;
sommeEC += ec;
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Mesure ");
lcd.print(i+1);
lcd.print("/");
lcd.print(nbMesures);
lcd.setCursor(0,1);
lcd.print("EC:");
lcd.print(ec, 0);
lcd.print(" uS/cm");
Serial.print("Mesure ");
Serial.print(i+1);
Serial.print(" - Brute=");
Serial.print(brute);
Serial.print(" | EC=");
Serial.print(ec, 0);
Serial.println(" µS/cm");
delay(1000);
}
float ecMoyenne = sommeEC / nbMesures;
dernierEC = ecMoyenne;
lcd.clear();
lcd.setCursor(0,0);
lcd.print("EC Moyenne:");
lcd.setCursor(0,1);
lcd.print(ecMoyenne, 0);
lcd.print(" uS/cm");
Serial.println("========================");
Serial.print("EC MOYENNE = ");
Serial.print(ecMoyenne, 0);
Serial.println(" µS/cm");
delay(3000);
// Incrémenter le compteur de cycles
nombreCycles++;
// LOGIQUE DE DÉCISION
lcd.clear();
lcd.setCursor(0,0);
if (ecMoyenne <= EC_SEUIL) {
// EC <= 1000 → EAU PROPRE → NETTOYAGE VALIDE
lcd.print("EC <= ");
lcd.print(EC_SEUIL, 0);
lcd.setCursor(0,1);
lcd.print("VALIDE!");
Serial.print("EC <= ");
Serial.print(EC_SEUIL, 0);
Serial.println(" µS/cm - Nettoyage VALIDE");
nettoyageValide = true;
} else if (nombreCycles >= MAX_CYCLES) {
// EC > 1000 mais on a atteint le max de cycles → ARRÊT
lcd.print("EC > ");
lcd.print(EC_SEUIL, 0);
lcd.setCursor(0,1);
lcd.print("MAX CYCLES!");
Serial.print("EC > ");
Serial.print(EC_SEUIL, 0);
Serial.println(" µS/cm - Nettoyage NON VALIDE");
Serial.println("!!! MAX CYCLES ATTEINT (3/3) !!!");
Serial.println("→ ARRET DU SYSTEME");
nettoyageValide = false;
} else {
// EC > 1000 et on n'a pas atteint le max → RECOMMENCER
lcd.print("EC > ");
lcd.print(EC_SEUIL, 0);
lcd.setCursor(0,1);
lcd.print("Cycle ");
lcd.print(nombreCycles);
lcd.print("/");
lcd.print(MAX_CYCLES);
Serial.print("EC > ");
Serial.print(EC_SEUIL, 0);
Serial.println(" µS/cm - Nettoyage NON VALIDE");
Serial.print("Cycle ");
Serial.print(nombreCycles);
Serial.print("/");
Serial.print(MAX_CYCLES);
Serial.println(" → Recommencer");
nettoyageValide = false;
}
Serial.print("Nombre de cycles effectues : ");
Serial.println(nombreCycles);
Serial.println("========================");
delay(3000);
etat = VIDANGE;
break;
}
case VIDANGE:
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Vidange...");
Serial.println("Debut vidange");
digitalWrite(relaisVidange, HIGH);
delay(DUREE_VIDANGE);
digitalWrite(relaisVidange, LOW);
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Vidange OK");
Serial.println("Vidange terminee");
delay(2000);
// Décision : FIN ou recommencer ?
if (nettoyageValide || nombreCycles >= MAX_CYCLES) {
// Si valide OU si max cycles atteint → FIN
etat = FIN;
} else {
// Sinon recommencer
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Recommencer");
lcd.setCursor(0,1);
lcd.print("cycle ");
lcd.print(nombreCycles + 1);
lcd.print("/");
lcd.print(MAX_CYCLES);
Serial.println("→ Recommencer le cycle de nettoyage");
delay(2000);
etat = ATTENTE;
}
break;
case FIN:
lcd.clear();
lcd.setCursor(0,0);
if (nettoyageValide) {
lcd.print("Nettoyage");
lcd.setCursor(0,1);
lcd.print("VALIDE!");
Serial.println("=========================");
Serial.println("=== NETTOYAGE VALIDE ===");
} else {
lcd.print("MAX CYCLES");
lcd.setCursor(0,1);
lcd.print("NON VALIDE");
Serial.println("=========================");
Serial.println("=== MAX CYCLES ATTEINT ===");
Serial.println("=== NETTOYAGE NON VALIDE ===");
}
Serial.print("EC finale : ");
Serial.print(dernierEC, 0);
Serial.println(" µS/cm");
Serial.print("Nombre total de cycles : ");
Serial.println(nombreCycles);
Serial.println("=========================");
delay(10000);
break;
case URGENCE:
digitalWrite(relaisRemplissage, LOW);
digitalWrite(relaisVidange, LOW);
analogWrite(motorPin, 0);
lcd.clear();
lcd.setCursor(0,0);
lcd.print("!!! URGENCE !!!");
lcd.setCursor(0,1);
lcd.print("Systeme STOP");
Serial.println("ARRET D'URGENCE ACTIVE");
while(digitalRead(boutonStop) == LOW) delay(100);
etat = ATTENTE;
nombreCycles = 0;
nettoyageValide = false;
break;
}
}
// ---------- MESURE ULTRASON ----------
float mesureDistance() {
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
long duree = pulseIn(echoPin, HIGH, 30000);
if (duree == 0) return 999;
return duree * 0.034 / 2;
}
Explication du programme:
Ce programme Arduino sert à faire fonctionner automatiquement un système de nettoyage par cycles, de manière simple et organisée. Au démarrage, le programme initialise toutes les broches, éteint les pompes et le moteur pour être en sécurité, démarre la communication série et allume l’écran LCD pour afficher l’état du système. Ensuite, le programme fonctionne comme une suite d’étapes bien définies : il commence par mesurer le niveau d’eau avec un capteur ultrason, et selon la distance mesurée, il allume ou éteint la pompe de remplissage pour atteindre le bon niveau sans déborder. Une fois le niveau correct atteint, la pompe s’arrête et le système lance une phase d’agitation : un moteur tourne pendant un temps donné pour bien mélanger l’eau. Après l’agitation, le programme mesure la conductivité de l’eau (EC) plusieurs fois, calcule une moyenne pour avoir une valeur plus fiable, puis compare cette valeur à un seuil afin de savoir si l’eau est assez propre. Si l’eau est propre, le nettoyage est considéré comme réussi ; sinon, le système peut recommencer un nouveau cycle, dans la limite de trois cycles maximum. Après chaque cycle, l’eau est vidangée grâce à une pompe dédiée. Tout au long du fonctionnement, l’écran LCD affiche l’état actuel (remplissage, agitation, mesure, vidange, fin) et un bouton permet d’arrêter immédiatement le système en cas d’urgence, ce qui coupe toutes les sorties.
CONCLUSION
Le projet « CIP automatisé » a permis de concevoir et de réaliser un prototype fonctionnel capable de simuler un cycle de nettoyage industriel par circulation (Clean-In-Place) à échelle réduite. À travers une approche expérimentale axée sur l’élimination du chlorure de sodium, nous avons réussi à traduire un processus physique complexe en une suite d'opérations automatisées pilotées par une carte Arduino Uno. Cette réalisation a couvert l'intégralité de la chaîne de conception, depuis l’élaboration des schémas techniques comme le P&ID et le GRAFCET, jusqu’à l’intégration physique des composants et le développement du programme informatique final.
Le déroulement du projet a toutefois été marqué par plusieurs défis techniques qui ont nécessité une grande capacité d'adaptation de la part de l'équipe. Nous avons dû faire face à des échecs d'impression 3D pour l'agitateur, résolus par un ajustement des paramètres de rigidité, ainsi qu'à des défaillances de composants électroniques, notamment au niveau de la communication I2C de l'écran LCD. Ces obstacles, bien que contraignants, ont été formateurs en nous forçant à mettre en place des tests unitaires rigoureux pour isoler les pannes et valider chaque étape du montage avant l'assemblage final.
Malgré les anomalies de mesures constatées sur le conductimètre lors de la phase finale; probablement dues à une usure du capteur ou à des manipulations externes ,le système a démontré sa capacité à enchaîner les cycles de remplissage, d'agitation et de vidange de manière autonome. Ce prototype remplit ainsi ses objectifs pédagogiques en illustrant parfaitement les enjeux de l'automatisme industriel ;la maîtrise de la consommation de ressources, la sécurité des installations et la garantie d'une propreté mesurable et répétable. Pour l'avenir, une fiabilisation des capteurs et une meilleure gestion de la puissance permettraient de transformer ce prototype en un outil de test encore plus précis.
Annexe 1:
| Composant | Borne / broche | connecté à | ||
| Ecran LCD | GND | Arduino (GND) | ||
| VCC | Arduino (5V) | |||
| SDA | Arduino (SDA ou A4) | |||
| SDL | Arduino (SDL ou A5) | |||
| Capteur de niveau | GND | Arduino (GND) | ||
| Echo | Arduino (~8) | |||
| Trig | Arduino (~ 9) | |||
| Vcc | Arduino (5 V) | |||
| Pompe-relais-batterie-Arduino: | ||||
| Pompe | Pompe + | Relais NO | ||
| Pompe - | Batterie - | |||
| Batterie | Batterie + | Relais CENTRE | ||
| Relais | Relais + | Arduino 5V | ||
| Relais - | Arduino GND | |||
| Relais S | Arduino Pin 3 | |||
| MOSFET-moteur-Arduino | SIG | Pin 11 | ||
| GND | GND Arduino | |||
| V+ | + moteur | |||
|
V- |
- moteur | |||
| GND | GND betterie | |||
| VIN | 9V batterie | |||
| Conductimètre | ||||
| VCC | Arduino (5V) | |||
GND |
GND Arduino | |||
| A0 Arduino | ||||