Système de remplissage d’eau piloté par Arduino

Arduino UNO 15-11-24

60 0

Plan de tutoriel

1- Présentation du système de remplissage d’eau

2- Comment la carte Arduino commande le système de remplissage d'eau ?

3- Matériel nécessaire

4- Montage du système

5- Programmation de la carte Arduino

Présentation du système de remplissage d’eau

Un système de remplissage d’eau est un dispositif automatisé utilisé pour gérer le remplissage de réservoirs, cuves, ou autres contenants avec de l’eau, en contrôlant le niveau et en prévenant les débordements.

Principe de Fonctionnement

Étape 1 : Détection du niveau bas

Si le niveau d’eau est détecté comme bas par le capteur, le contrôleur électronique active la pompe ou ouvre la vanne.

Étape 2 : Remplissage

L’eau est pompée ou acheminée vers le réservoir.

Étape 3 : Détection du niveau haut

Lorsque le capteur de niveau haut détecte que le réservoir est plein, le contrôleur arrête la pompe ou ferme la vanne.

Cycle continu :

Ce processus se répète automatiquement à chaque baisse du niveau d'eau.

Applications

Usage domestique : Remplissage automatique de réservoirs d’eau pour la maison.

Agriculture : Irrigation automatisée en fonction des besoins.

Industriel : Systèmes de refroidissement ou stockage d'eau.

Stations de lavage : Contrôle des niveaux d'eau dans des bassins.

Avantages

Économie d'eau : Pas de débordement.

Pratique : Fonctionnement automatique sans intervention humaine.

Personnalisable : Peut être adapté pour diverses applications.

Comment la carte Arduino commande le système de remplissage d'eau ?

Le commandement de la carte Arduino dans un système de remplissage d'eau utilisant un clavier 4x4, un afficheur LCD I2C 16x2, un capteur de débit YF-S401 et une pompe à eau 12V est un système interactif et automatisé permettant un contrôle précis du remplissage d’eau. Voici une description détaillée du fonctionnement de ce système :

1- Principe Général

La carte Arduino joue le rôle de contrôleur central en intégrant les éléments suivants :

Saisie des paramètres utilisateur via le clavier 4x4 (comme la quantité d'eau à remplir).

Affichage en temps réel des informations sur le remplissage grâce à l'écran LCD I2C.

Mesure précise du débit d'eau grâce au capteur de débit YF-S401.

Commande de la pompe pour réguler l'écoulement d'eau en fonction des paramètres définis par l'utilisateur.

Fonctionnement du Système

Étape 1 : Entrée des Paramètres

1- L'utilisateur entre la quantité d'eau souhaitée (en litres ou millilitres) via le clavier 4x4.

2- L’Arduino enregistre cette valeur et l'affiche sur l’écran LCD.

Étape 2 : Activation de la Pompe

1- Une fois la quantité saisie, l'utilisateur appuie sur une touche pour démarrer le processus.

2- L'Arduino active le relais pour démarrer la pompe 12V.

Étape 3 : Mesure et Contrôle

1- Le capteur YF-S401 mesure le débit en temps réel et transmet les impulsions à l'Arduino.

2- L'Arduino calcule la quantité totale d’eau écoulée en fonction des impulsions : Volume d’eau = (Nombre d’impulsions) × (Facteur de conversion du capteur).

3- L’écran LCD affiche la quantité d’eau restante à remplir.

Étape 4 : Arrêt Automatique

1- Lorsque la quantité définie est atteinte, l’Arduino désactive le relais pour arrêter la pompe.

2- L’écran LCD affiche un message indiquant que le remplissage est terminé.

Étape 5 : Réinitialisation

L'utilisateur peut réinitialiser le système pour une nouvelle opération via le clavier.

Matériel nécessaire

Carte Arduino UNO

Arduino Uno

La carte Arduino est le microcontrôleur qui gère l'ensemble du système.

Clavier 4x4

Utilisé pour entrer des paramètres tels que la quantité d’eau à remplir (en litres ou en millilitres).

Chaque touche correspond à un chiffre ou une commande spécifique (par exemple, démarrer, arrêter, effacer).

Afficheur LCD I2C 16x2

Pinouts of 1602 LCD display with I2C

Affiche les informations essentielles : la quantité d'eau restante à remplir et le débit d’eau en temps réel.

Capteur de débit YF-S401

Mesure le débit d'eau (litres par minute) en comptant les impulsions générées par l'eau passant dans le capteur.

Chaque impulsion correspond à un volume d'eau précis (selon les spécifications du capteur).

Permet à l'Arduino de calculer la quantité d'eau délivrée et de comparer avec la valeur cible.

Pompe à eau 12V

Commandée via un relais.

Active ou désactive l’écoulement de l’eau selon les données du capteur et les paramètres définis.

Module relais

Permet de commuter la pompe en toute sécurité (gérer les tensions et courants plus élevés).

Fils de connexion :

Fils de connexion

Pour relier les différents composants du système.

Plaque d'essai (Breadboard) :

plaque d'essai

On utilise la plaque d'essai pour faciliter le câblage des différents composants.

Batterie 9V:

Elle est une source d’alimentation pour le système.

Montage du système

1- Schéma de câblage de la carte Arduino avec la pompe à eau et du capteur de débit d’eau:

Capteur de débit YF-S401

Le capteur comporte trois fils :

Rouge (VCC) : Connecté au 5V de l'Arduino.

Noir (GND) : Connecté au GND de l'Arduino.

Jaune (Signal) : Connecté à une broche numérique (par ex., D2).

d. Module Relais

Le relais contrôle la pompe. Il a plusieurs bornes :

Signal (IN) : Connecté à une broche numérique (par ex., D3) de l'Arduino.

VCC : Connecté au 5V de l'Arduino.

GND : Connecté au GND de l'Arduino.

La partie puissance du relais est connectée à la pompe :

NO (Normally Open) : Connecté à la borne positive de la pompe.

NO(Common) : Connecté à la borne positive de l'alimentation 9V.

GND de la pompe : Directement relié à la borne négative de l'alimentation 9V.

e. Pompe à eau 12V

+ : Connecté au COM du relais.

- : Connecté au GND de l'alimentation 9V.

2- Schéma de câblage de la carte Arduino avec le clavier matriciel 4x4:

Le clavier est connecté à l'Arduino via 8 broches numériques :

Colonnes (4) : Connectées à 4 broches numériques (par ex., D4 à D7).

Lignes (4) : Connectées à 4 autres broches numériques (par ex., D8 à D11).

3- Schéma de câblage de la carte Arduino avec l'afficheur LCD I2C 16x2

Afficheur LCD I2C 16x2

L'adaptateur I2C réduit les connexions nécessaires au LCD. Seules 4 broches sont utilisées :

SDA : Connecté à A4 (ou SDA selon votre Arduino).

SCL : Connecté à A5 (ou SCL selon votre Arduino).

VCC : Connecté au 5V de l'Arduino.

GND : Connecté au GND de l'Arduino.

Programmation de la carte Arduino

Voici le programme qui permet de commander le remplissage de la bouteille par la carte Arduino et le clavier matriciel 4x4.

Il faut télécharger ces deux bibliothèques : LiquidCrystal_I2C et keypad

#include <Keypad.h>
#include <LiquidCrystal_I2C.h> 
const int ROW_NUM = 4; //four rows
const int COLUMN_NUM = 4; //four columns

char keys[ROW_NUM][COLUMN_NUM] = {
{'1','2','3', 'A'},
{'4','5','6', 'B'},
{'7','8','9', 'C'},
{'*','0','#', 'D'}
};
LiquidCrystal_I2C lcd(0x27, 20, 4); // ligne 8 
byte pin_rows[ROW_NUM] = {11, 10, 9, 8}; //connect to the row pinouts of the keypad
byte pin_column[COLUMN_NUM] = {7, 6, 5, 4}; //connect to the column pinouts of the keypad
Keypad keypad = Keypad( makeKeymap(keys), pin_rows, pin_column, ROW_NUM, COLUMN_NUM );

int sensorInterrupt = 0;  // interrupt 0
int sensorPin       = 2; //Digital Pin 2
int solenoidValve = 5; // Digital pin 5
unsigned int SetPoint = 400; //400 milileter
String code="";
/*The hall-effect flow sensor outputs pulses per second per litre/minute of flow.*/
float calibrationFactor = 90; //You can change according to your datasheet

volatile byte pulseCount =0;  

float flowRate = 0.0;
unsigned int flowMilliLitres =0;
unsigned long totalMilliLitres = 0,volume=0;

unsigned long oldTime ;
const int relais_moteur = 3; // // le relais est connecté à la broche 1 de la carte Adruino

void setup()
{ totalMilliLitres = 0;
  pinMode(relais_moteur, OUTPUT);
  lcd.init(); // initialisation de l’afficheur
  lcd.clear();
  lcd.backlight(); // active le rétro-éclairage
  lcd.setCursor(0, 0); // se positionner à la première ligne
  lcd.print("donner volume:");  // Afficher le mot ‘carte’

  // Initialize a serial connection for reporting values to the host
  Serial.begin(9600);
  pinMode(solenoidValve , OUTPUT);
  digitalWrite(solenoidValve, HIGH);
  pinMode(sensorPin, INPUT);
  digitalWrite(sensorPin, HIGH);
  /*The Hall-effect sensor is connected to pin 2 which uses interrupt 0. Configured to trigger on a FALLING state change (transition from HIGH
  (state to LOW state)*/
  attachInterrupt(sensorInterrupt, pulseCounter, FALLING); //you can use Rising or Falling
}

void loop()
{
  char key = keypad.getKey(); 
    //lcd.clear();

  if(key) // On appuie sur une touche du clavier
    { 
  code+=key;
  lcd.setCursor(0, 1); // se positionner à la première ligne
  lcd.print(code);  // Afficher le mot ‘carte’
  delay(100);
    }

    if (key=='D') { // si on appuie sur la touche 'D' 
     if(code.toInt()<=1500){
        volume=code.toInt();
     }
     else{
        lcd.clear();
        lcd.backlight(); // active le rétro-éclairage
        lcd.setCursor(0, 0); // se positionner à la première ligne
        lcd.print("donner volume:");  // Afficher le mot ‘carte’
     }
    code="";
    }

if (totalMilliLitres<volume) {
    digitalWrite(relais_moteur, HIGH); // On demarre la pompe à eau

   if((millis() - oldTime) > 1000)    // Only process counters once per second
  { 
    // Disable the interrupt while calculating flow rate and sending the value to the host
    detachInterrupt(sensorInterrupt);

    // Because this loop may not complete in exactly 1 second intervals we calculate the number of milliseconds that have passed since the last execution and use that to scale the output. We also apply the calibrationFactor to scale the output based on the number of pulses per second per units of measure (litres/minute in this case) coming from the sensor.
    flowRate = ((1000.0 / (millis() - oldTime)) * pulseCount) / calibrationFactor;

    // Note the time this processing pass was executed. Note that because we've
    // disabled interrupts the millis() function won't actually be incrementing right
    // at this point, but it will still return the value it was set to just before
    // interrupts went away.
    oldTime = millis();

    // Divide the flow rate in litres/minute by 60 to determine how many litres have
    // passed through the sensor in this 1 second interval, then multiply by 1000 to
    // convert to millilitres.
    flowMilliLitres = (flowRate / 60) * 1000;

    // Add the millilitres passed in this second to the cumulative total
    totalMilliLitres += flowMilliLitres;

    unsigned int frac;

    // Print the flow rate for this second in litres / minute
    Serial.print("Flow rate: ");
    Serial.print(flowMilliLitres, DEC);  // Print the integer part of the variable
    Serial.print("mL/Second");
    Serial.print("\t");           
    lcd.clear();
    lcd.backlight(); // active le rétro-éclairage
    lcd.setCursor(0, 0); // se positionner à la première ligne
    lcd.print("debit:");
    lcd.print(flowMilliLitres);  // Afficher le debit sur l'afficheur lcd    
        lcd.print(" ml/s");    
    // Print the cumulative total of litres flowed since starting
    Serial.print("Output Liquid Quantity: ");        
    Serial.print(totalMilliLitres,DEC);

    Serial.println("mL"); 
    Serial.print("\t");     
        lcd.setCursor(0, 1); // se positionner à la première ligne
        lcd.print("volume:");  // Afficher le mot ‘carte’          
        lcd.print(totalMilliLitres);  // Afficher la quantite remplie    
        lcd.print(" ml"); 
    if (totalMilliLitres > 40)
    {
      SetSolinoidValve();
    }

// Reset the pulse counter so we can start incrementing again
    pulseCount = 0;

    // Enable the interrupt again now that we've finished sending output
    attachInterrupt(sensorInterrupt, pulseCounter, FALLING);
  }
}else  {
  digitalWrite(relais_moteur, LOW); // On arrete la pompe a eau
  volume=0;
}

}

//Insterrupt Service Routine

void pulseCounter()
{
  // Increment the pulse counter
  pulseCount++;
}

void SetSolinoidValve()
{
  digitalWrite(solenoidValve, LOW);
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

#include <Keypad.h>

#include <LiquidCrystal_I2C.h>

const int ROW_NUM = 4; //four rows

const int COLUMN_NUM = 4; //four columns

char keys[ROW_NUM][COLUMN_NUM] = {

{'1','2','3', 'A'},

{'4','5','6', 'B'},

{'7','8','9', 'C'},

{'*','0','#', 'D'}

};

LiquidCrystal_I2C lcd(0x27, 20, 4); // ligne 8

byte pin_rows[ROW_NUM] = {11, 10, 9, 8}; //connect to the row pinouts of the keypad

byte pin_column[COLUMN_NUM] = {7, 6, 5, 4}; //connect to the column pinouts of the keypad

Keypad keypad = Keypad( makeKeymap(keys), pin_rows, pin_column, ROW_NUM, COLUMN_NUM );

int sensorInterrupt = 0; // interrupt 0

int sensorPin = 2; //Digital Pin 2

int solenoidValve = 5; // Digital pin 5

unsigned int SetPoint = 400; //400 milileter

String code="";

/*The hall-effect flow sensor outputs pulses per second per litre/minute of flow.*/

float calibrationFactor = 90; //You can change according to your datasheet

volatile byte pulseCount =0;

float flowRate = 0.0;

unsigned int flowMilliLitres =0;

unsigned long totalMilliLitres = 0,volume=0;

unsigned long oldTime ;

const int relais_moteur = 3; // // le relais est connecté à la broche 1 de la carte Adruino

void setup()

{ totalMilliLitres = 0;

pinMode(relais_moteur, OUTPUT);

lcd.init(); // initialisation de l’afficheur

lcd.clear();

lcd.backlight(); // active le rétro-éclairage

lcd.setCursor(0, 0); // se positionner à la première ligne

lcd.print("donner volume:"); // Afficher le mot ‘carte’

// Initialize a serial connection for reporting values to the host

Serial.begin(9600);

pinMode(solenoidValve , OUTPUT);

digitalWrite(solenoidValve, HIGH);

pinMode(sensorPin, INPUT);

digitalWrite(sensorPin, HIGH);

/*The Hall-effect sensor is connected to pin 2 which uses interrupt 0. Configured to trigger on a FALLING state change (transition from HIGH

(state to LOW state)*/

attachInterrupt(sensorInterrupt, pulseCounter, FALLING); //you can use Rising or Falling

}

void loop()

{

char key = keypad.getKey();

//lcd.clear();

if(key) // On appuie sur une touche du clavier

{

code+=key;

lcd.setCursor(0, 1); // se positionner à la première ligne

lcd.print(code); // Afficher le mot ‘carte’

delay(100);

}

if (key=='D') { // si on appuie sur la touche 'D'

if(code.toInt()<=1500){

volume=code.toInt();

}

else{

lcd.clear();

lcd.backlight(); // active le rétro-éclairage

lcd.setCursor(0, 0); // se positionner à la première ligne

lcd.print("donner volume:"); // Afficher le mot ‘carte’

}

code="";

}

if (totalMilliLitres<volume) {

digitalWrite(relais_moteur, HIGH); // On demarre la pompe à eau

if((millis() - oldTime) > 1000) // Only process counters once per second

{

// Disable the interrupt while calculating flow rate and sending the value to the host

detachInterrupt(sensorInterrupt);

// Because this loop may not complete in exactly 1 second intervals we calculate the number of milliseconds that have passed since the last execution and use that to scale the output. We also apply the calibrationFactor to scale the output based on the number of pulses per second per units of measure (litres/minute in this case) coming from the sensor.

flowRate = ((1000.0 / (millis() - oldTime)) * pulseCount) / calibrationFactor;

// Note the time this processing pass was executed. Note that because we've

// disabled interrupts the millis() function won't actually be incrementing right

// at this point, but it will still return the value it was set to just before

// interrupts went away.

oldTime = millis();

// Divide the flow rate in litres/minute by 60 to determine how many litres have

// passed through the sensor in this 1 second interval, then multiply by 1000 to

// convert to millilitres.

flowMilliLitres = (flowRate / 60) * 1000;

// Add the millilitres passed in this second to the cumulative total

totalMilliLitres += flowMilliLitres;

unsigned int frac;

// Print the flow rate for this second in litres / minute

Serial.print("Flow rate: ");

Serial.print(flowMilliLitres, DEC); // Print the integer part of the variable

Serial.print("mL/Second");

Serial.print("\t");

lcd.clear();

lcd.backlight(); // active le rétro-éclairage

lcd.setCursor(0, 0); // se positionner à la première ligne

lcd.print("debit:");

lcd.print(flowMilliLitres); // Afficher le debit sur l'afficheur lcd

lcd.print(" ml/s");

// Print the cumulative total of litres flowed since starting

Serial.print("Output Liquid Quantity: ");

Serial.print(totalMilliLitres,DEC);

Serial.println("mL");

Serial.print("\t");

lcd.setCursor(0, 1); // se positionner à la première ligne

lcd.print("volume:"); // Afficher le mot ‘carte’

lcd.print(totalMilliLitres); // Afficher la quantite remplie

lcd.print(" ml");

if (totalMilliLitres > 40)

{

SetSolinoidValve();

}

// Reset the pulse counter so we can start incrementing again

pulseCount = 0;

// Enable the interrupt again now that we've finished sending output

attachInterrupt(sensorInterrupt, pulseCounter, FALLING);

}

}else {

digitalWrite(relais_moteur, LOW); // On arrete la pompe a eau

volume=0;

}

//Insterrupt Service Routine

void pulseCounter()

{

// Increment the pulse counter

pulseCount++;

}

void SetSolinoidValve()

{

digitalWrite(solenoidValve, LOW);

}

0 commentaire

laisser un commentaire

Annuler la réponse

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Nom *

Email *

Message *

Passion de robotique

Tutoriels récents

Bras robotique pour Arduino

Arduino UNO 21-11-24

Remplissage automatique des bouteilles en utilisant Arduino et KY-032

Arduino UNO 21-11-24

Robot voiture contrôlé par Micro:bit et télécommande

Micro:bit 20-11-24

Fonctionner un moteur à courant continu de 5V avec Micro:bit

Micro:bit 20-11-24

Construire un GPS commandé par Arduino

Arduino UNO 20-11-24

Atelier robotique

Tutoriels populaires

Allumer une LED connectée à la carte ESP32 via WIFI

ESP32 Wifi 2797vues

Afficher la température et l’humidité mesurées par le capteur DHT11 connecté à Arduino sur l’afficheur LCD I2C

Arduino UNO 2716vues

Allumer une LED par la carte ESP32

ESP32 2553vues

Présentation de la carte ESP32

ESP32 2399vues

La carte ESP32 et l’afficheur LCD I2C 1602

ESP32 2320vues

Construction des robots

Tutoriels plus commentés

Commander trois LEDs par la télécommande en utilisant le capteur KY-032 et la carte Micro:bit

Micro:bit 3 commentaires

Allumer une LED connectée à l’Arduino UNO via WIFI

Arduino UNO Wifi 3 commentaires

Création des jeux avec Micro:bit et MakeCode

Micro:bit 2 commentaires

Afficher la température et l’humidité mesurées par le capteur DHT11 connecté à Arduino sur l’afficheur SSD1306

Arduino UNO 2 commentaires

Système de détection d’obstacles basé sur HC-SR04, afficheur SSD1306 et Arduino UNO

Arduino UNO 2 commentaires

Système de remplissage d’eau piloté par Arduino

Plan de tutoriel

1- Présentation du système de remplissage d’eau

2- Comment la carte Arduino commande le système de remplissage d'eau ?

3- Matériel nécessaire

4- Montage du système

5- Programmation de la carte Arduino

Présentation du système de remplissage d’eau

Principe de Fonctionnement

Applications

Avantages

Comment la carte Arduino commande le système de remplissage d'eau ?

Fonctionnement du Système

Étape 1 : Entrée des Paramètres

Étape 2 : Activation de la Pompe

Étape 3 : Mesure et Contrôle

Étape 4 : Arrêt Automatique

Étape 5 : Réinitialisation

Matériel nécessaire

Clavier 4x4

Afficheur LCD I2C 16x2

Capteur de débit YF-S401

Pompe à eau 12V

Module relais

Montage du système

1- Schéma de câblage de la carte Arduino avec la pompe à eau et du capteur de débit d’eau:

Capteur de débit YF-S401

d. Module Relais

e. Pompe à eau 12V

2- Schéma de câblage de la carte Arduino avec le clavier matriciel 4x4:

3- Schéma de câblage de la carte Arduino avec l'afficheur LCD I2C 16x2

Afficheur LCD I2C 16x2

Programmation de la carte Arduino

0 commentaire

laisser un commentaire

Annuler la réponse

Passion de robotique

Tutoriels récents

Atelier robotique

Tutoriels populaires

Construction des robots

Tutoriels plus commentés

Bras robotique

Categories

Maison intelligente

But de ce site web

Coordonnées

Articles populaires

Photos des articles