Régulation du niveau d'eau dans une cuve (GROUPE I)

Membres du groupe : 

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

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

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

21/10/2024 : 

28/10/2024 :

04/11/2024 :

874b62df-e4fa-4996-bfc3-cf621a8294d3.jpeg                                                                                Figure 3 : Montage Tinkercad

10/11/2024 :

WhatsApp Image 2025-01-24 at 16.30.51.jpeg

Figure 4 : Montage Tinkercad final

13/11/2024  :

28/11/2024 :

05/12/2024 :

Réunion de groupe :

Branchements et essais du capteur :

Préparation du support de la cuve d'eau :

f0a2e247-4526-40b0-8a64-a386cca9cd65.jpg 2ef0c45d-44e4-4fba-a4dc-bc19910162b0.jpg

f412bbcf-68df-4526-b9a0-10b3818a0a54.jpga90a9929-39ac-42f8-997a-bf807167bc87.jpg

Figure 5 : Avancement du 05/12

11/12/2024 :

Branchements et essais de l'écran LCD :

Préparation de la cuve d'eau :

18/12/2024 :

Finalisation du code :

Réalisation des branchements :

Préparation du support :

Dysfonctionnements identifiés :

ff1eb7d0-705f-47ae-a294-bed160b121f8.jpg            Figure 6 : Réalisation des branchements

20/12/ 2024 :

Réunion de groupe en ligne :

Tests individuels des composants :

Diagnostic et solution :

d458c397-8e9e-4ff1-a81a-531d6d8a20c2.jpg

                                                                          Figure 7 : Tests individuels des composants

08/01/2025 :

527e190f-e545-4cf6-81d5-246e3cc00846.jpg   fe51fac8-457b-4574-8b4f-f75a90f98966.jpg   da00a56c-3621-4c0c-bd62-373e08110eeb.jpg

image.pngWhatsApp Image 2025-01-16 at 15.34.41.jpeg

bb097282-5791-4c6f-9cb7-523dda2a3691.jpg

                                                                                  Figure 8 : Avancement du 08/01

15/01/2024 :

1f4575c6-b092-47e0-b01a-c48b5fbef5bb.jpg                                                                 WhatsApp 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 :

WhatsApp Image 2025-01-16 at 15.28.54.jpeg   image.png

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.


Revision #33
Created 13 November 2024 14:26:49 by El Naddaf Jean
Updated 6 February 2025 20:15:59 by Sadmi Laetitia