Arduino Industrie Projet

Système intelligent de remplissage d’eau contrôlé par Arduino

02-04-22 4607

Un système intelligent de remplissage de liquides est un dispositif automatisé qui utilise des capteurs, des algorithmes de contrôle et des moteurs pour remplir de manière précise et répétable des récipients avec des liquides. Il peut être utilisé dans de nombreuses applications, telles que la production de boissons, la fabrication de produits chimiques et la gestion de l’irrigation.

Voici comment fonctionne généralement un système intelligent de remplissage de liquides :

Le système est configuré en fonction des paramètres de remplissage souhaités, tels que le volume de liquide à remplir, la vitesse de remplissage et la précision du remplissage.
Le système utilise des capteurs pour mesurer le niveau de liquide dans le récipient et détecter les obstacles éventuels.
Le système utilise des algorithmes de contrôle pour déterminer la quantité de liquide à remplir et le débit de remplissage nécessaire pour atteindre les paramètres de remplissage souhaités.
Le système utilise des moteurs pour actionner les robinets de remplissage et les valves de contrôle de débit de manière à remplir le récipient de manière précise et répétable.

Un système intelligent de remplissage de liquides peut être conçu de manière à s’adapter à de nombreux types de liquides et de récipients et à être facilement

Objectif du projet:

Dans ce projet, nous allons concevoir et construire un prototype de machine de remplissage automatique de bouteilles à l’aide de la carte Arduino:

La carte Arduino assure toutes les fonctions de contrôle.

La quantité souhaitée de liquide à remplir est d’abord donnée par l’utilisateur via le clavier matriciel 4 × 4 et la valeur d’entrée est affichée sur l’écran LCD 16 × 2. La quantité de liquide saisie doit être comprise entre (0 et 1500 ml).

L’eau est extraite du réservoir par la pompe à eau et passe à travers le capteur de débit de liquide qui permet d’envoyer la valeur du débit d’eau à la carte Arduino.

Enfin, le relais coupe la connexion de la pompe à eau lorsque le liquide qui a traversé le capteur est presque égal à la quantité donnée par l’utilisateur.

Fonctionnement du système de remplissage:

Composants nécessaires

carte Arduino

Une carte Arduino est une carte de développement électronique basée sur un microcontrôleur. Elle est conçue pour être facilement utilisable par les développeurs et les hobbyistes pour créer des projets électroniques.

Les cartes Arduino sont principalement utilisées pour contrôler des appareils électroniques en utilisant du code informatique, mais elles peuvent également être utilisées pour traiter et afficher des données. Elles sont souvent utilisées dans des projets de robotique, de domotique, de domaine de l’Internet des objets (IoT) et dans de nombreux autres domaines de l’électronique de loisir et professionnelle.

capteur de débit yf-s401

Le capteur de débit YF-S401 est un capteur de débit d’eau qui mesure la quantité de liquide qui passe à travers un tuyau en utilisant un rotor à aubes. Il est souvent utilisé dans les applications de contrôle de débit, de mesure de consommation d’eau et de détection de fuites.

Le capteur de débit YF-S401 est généralement connecté à un microcontrôleur ou à un ordinateur via un bus de données, comme le bus I2C ou le bus SPI (Serial Peripheral Interface). Le microcontrôleur ou l’ordinateur envoie des commandes au capteur pour démarrer la mesure de débit et recevoir les données de débit en retour.

pompe à eau de 12V

Une pompe à eau de 12 V est une pompe électrique qui utilise un moteur électrique alimenté par une tension de 12 V pour pomper des liquides à travers un tuyau. Elle est souvent utilisée dans les applications de refroidissement, de transfert de liquides et de systèmes de distribution d’eau.

relais

Un relais est un interrupteur électrique qui est utilisé pour mettre un circuit sous ou hors tension. Il est souvent utilisé pour contrôler un circuit à haute puissance avec un signal à faible puissance, comme un interrupteur ou un signal de commande informatique. Les relais sont utilisés dans une grande variété d’applications, notamment les systèmes de commande industrielle. Ils peuvent être utilisés pour contrôler des moteurs, des lumières et d’autres charges électriques. Certains relais sont conçus pour commuter rapidement un circuit sous et hors tension, tandis que d’autres sont conçus pour un contrôle plus précis et peuvent être utilisés pour moduler le courant qui traverse un circuit.

clavier matriciel 4×4

Un clavier matriciel 4×4 est un type de clavier qui utilise une grille de 4 colonnes et 4 lignes de touches pour entrer des données. Chaque touche est associée à une combinaison unique de lignes et de colonnes, ce qui permet de détecter la touche appuyée en mesurant la résistance entre les lignes et les colonnes.

Les claviers matriciels 4×4 sont couramment utilisés dans les applications où il est nécessaire de conserver de l’espace, comme les télécommandes, les appareils électroniques portables et les dispositifs de contrôle industriels. Ils sont également souvent utilisés dans les projets de loisir et de bricolage, comme les projets de robotique et de domotique.

afficheur I2C LCD

Un afficheur I2C LCD est un type d’afficheur à cristaux liquides (LCD) qui utilise le protocole de communication en série I2C (Inter-Integrated Circuit) pour se connecter à un microcontrôleur ou à un autre dispositif de traitement de données.

Les afficheurs I2C LCD sont couramment utilisés dans les projets électroniques pour afficher des données et des informations, comme des messages, des valeurs de capteurs et d’autres données. Ils sont souvent utilisés dans les projets de robotique et de domotique, ainsi que dans les appareils électroniques portables et les dispositifs de contrôle industriels.

Pour utiliser un afficheur I2C LCD, il est nécessaire de le connecter à un microcontrôleur ou à un autre dispositif de traitement de données en utilisant les broches de communication SDA (données) et SCL (horloge). En utilisant des bibliothèques de logiciels ou des instructions de programmation spécifiques, il est possible d’envoyer des données à l’afficheur et de les afficher sur l’écran. Les afficheurs I2C LCD sont connus pour leur faible consommation d’énergie et leur simplicité de configuration et d’utilisation.

batterie de 9V

Une batterie de 9 volts est une pile qui fournit une tension de sortie de 9 volts. Elles sont souvent utilisées dans les appareils électroniques portables tels que les radiodiffuseurs, les jouets et les outils électroniques. Elles sont également couramment utilisées dans les applications de bricolage et de loisir, telles que les circuits électroniques et les projets de robotique.

des fils de connexion

Les fils de connexion sont des fils électriques utilisés pour connecter des composants électroniques à une carte de développement ESP32. Ils sont généralement utilisés pour connecter des capteurs, des actionneurs, des afficheurs et d’autres composants à la carte ESP32 afin de créer des circuits électroniques.

Il existe deux types de fils de connexion: les fils de connexion mâle-mâle et les fils de connexion mâle-femelle. Les fils de connexion mâle-mâle sont utilisés pour connecter des composants qui ont tous deux des broches mâles, tandis que les fils de connexion mâle-femelle sont utilisés pour connecter des composants avec une broche mâle et une broche femelle.

Les fils de connexion sont généralement fabriqués en cuivre ou en alliage de cuivre et sont revêtus d’un isolant en plastique pour protéger les fils électriques et empêcher les courts-circuits. Ils sont disponibles dans une variété de couleurs pour aider à identifier et organiser les différents fils dans un circuit.

Plaque d’essai

Une plaque d’essai est un type de carte de développement électronique qui permet aux développeurs de tester et de prototyper facilement des circuits électroniques. Elles sont souvent utilisées par les développeurs pour tester rapidement des idées et des conceptions avant de les intégrer à un projet plus important ou de les intégrer dans une carte de développement plus permanente.

Les plaques d’essai sont généralement basées sur un microcontrôleur, qui est un processeur facile à utiliser et à programmer qui peut être utilisé pour contrôler une variété de circuits électroniques. Les plaques d’essai incluent généralement des broches d’extension qui permettent de connecter facilement des composants électroniques tels que des capteurs, des afficheurs, des moteurs et d’autres composants.

Montage de la carte Arduino avec la pompe à eau et du capteur de débit d’eau:

Le relais est le composant intermédiaire entre la carte Arduino et la pompe à eau. Elle permet à la carte Arduino de commander la pompe à eau.

Le rôle du relais est de faire démarrer ou arrêter la pompe responsable du remplissage des bouteilles.

On connecte:

la borne (-) du relais à la broche GND de l’Arduino
la borne (+) du relais à la broche 3.3V de l’Arduino
la borne (S) du relais à la broche N°3 de l’Arduino

le rôle du capteur yf-s401 est la mesure de débit de l’eau au cours de remplissage.

On connecte :

Le fil rouge à la broche 5V de l’Arduino
le fil marron à la broche GND de l’Arduino
le fil jaune à la broche N°2 de l’Arduino

Montage de la carte Arduino avec le clavier matriciel:

Le clavier matriciel est le composant intermédiaire entre la carte Arduino et l’utilisateur. Elle permet de saisir la valeur du volume d’eau à remplir dans la bouteille.

Montage de la carte Arduino avec l’afficheur I2C LCD 1602A:

On utilise l’afficheur I2C LCD 1602A pour afficher: la valeur du volume saisie par l’utilsateur, le débit d’eau et la quantité d’eau remplie dans la bouteille.

On connecte:

la broche SDA de l’afficheur LCD au PIN 4 de l’Arduino
la broche SCL de l’afficheur LCD au PIN 5 de l’Arduino
la broche GND de l’afficheur LCD à la broche GND de l’Arduino
la broche VCC de l’afficheur LCD à la borne (+) d’une batterie de 9V

Programme Arduino

Voici le programme qui permet de commander le remplissage de la bouteille par la carte Arduino.

#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);

}

Vous pouvez voir aussi

Capteur ultrason Arduino

21-05-24

Utilisation de la caméra OV7670 avec la carte Arduino UNO

12-03-23

2 commentaires

Eulah 18-10-2222

Oh mmy goodness! Incrediblpe aarticle dude! Thanks, However I aam experiencing problems wit ypur RSS. I don't undersstand whyy I cannot subscribe to it. Is there anyone else getting the samme RSS issues? Anyone who knoows thee answer will you kindly respond? Thanx!!

Christel 17-10-2222

This iis a reallly god tipp especioally too thoxe frersh to tthe blogosphere. Sort buut veryy precise information… Appreciate your sharng this one. A mut reqd post!