Circuit d'irrigation automatique utilisant Arduino

Essayez Notre Instrument Pour Éliminer Les Problèmes





Dans cet article, nous allons construire un système d'irrigation d'eau automatisé pour petit jardin à l'aide d'arduino et d'un capteur d'humidité du sol.

introduction

Le système proposé peut surveiller le niveau d'humidité du sol et lorsque l'humidité du sol descend en dessous de la valeur prédéfinie, la pompe 12 V CC se déclenchera pendant une période de temps prédéterminée. L'état du niveau d'humidité du sol et d'autres fonctions du système peuvent être surveillés via un écran LCD 16 x 2 en temps réel.



On estime qu'il y a 3 billions d'arbres à travers le monde, ce qui est plus grand que le nombre de départs dans notre galaxie de la Voie lactée d'origine, qui est estimé à 100 milliards. Mais, nous, les humains, avons coupé un nombre incalculable d'arbres pour répondre à nos besoins de base en matière de luxe.

Mère Nature est conçue avec un système de rétroaction, lorsqu'une espèce introduit d'énormes perturbations, la nature effacera l'espèce de son existence.



Les êtres humains ont dérangé la nature sans le savoir pendant des siècles, mais, même après de grands progrès scientifiques et technologiques, le taux de perturbation n’a pas diminué.

Le changement climatique en est un exemple, quand il devient suffisamment radical, notre espèce ne durera pas longtemps.
Ce projet fait un petit pas en avant pour préserver la nature, il peut irriguer votre joli petit jardin sans aucune interaction humaine. Passons maintenant aux détails techniques du projet.

Capteur d'humidité du sol:

Le cœur du projet est capteur d'humidité du sol qui peut détecter la quantité d'humidité dans le sol. Le capteur émet une valeur analogique et un microcontrôleur interprète ces valeurs et affiche la teneur en humidité.

Il y a deux électrodes, qui seront insérées dans le sol. Les électrodes sont connectées à une carte de circuit imprimé composée de comparateurs IC, LED, broches d'entrée et de sortie de la résistance de réglage.

Illustration du capteur d'humidité du sol:

module de capteur d

Il a 4 + 2 broches, 2 broches pour la connexion de l'électrode et le reste des 4 broches sont Vcc, GND, sortie numérique et sortie analogique. Nous allons utiliser uniquement la broche de sortie analogique pour détecter l'humidité du sol.
Puisque nous n'utilisons pas de broche de sortie numérique, nous n'utiliserons pas de résistance de réglage intégrée pour calibrer le capteur.

Maintenant, cela conclut le capteur d'humidité du sol.

Diagramme schématique:

Le circuit est assez simple et convivial pour les débutants. Le schéma est divisé en deux parties du même projet pour réduire la confusion lors de la duplication du projet.

Schéma de câblage LCD pour système d

Le schéma ci-dessus est le LCD vers arduino câblage. Un potentiomètre 10K est fourni pour régler le contraste de l'écran LCD.

Système d

Voici le reste du schéma composé d'un capteur d'humidité du sol, d'une pompe 12 V CC, d'un bouton poussoir de calibrage et d'une alimentation 12 V (1 - 2 ampères). Veuillez utiliser une alimentation électrique d'au moins plus de 500 mA du courant nominal de la pompe 12 V CC.

Le MOSFET IRF540N (ou tout autre canal N équivalent) est utilisé à la place des BJT pour améliorer l'efficacité énergétique globale du système.

La pompe arrosera votre petit jardin, assurez-vous que vous disposez toujours d'une quantité d'eau suffisante.

Code de programme:

//-------------Program Developed By R.Girish-------------//
#include
LiquidCrystal lcd(12, 11, 5, 4, 3, 2)
int Time = 5 // Set time in minutes
int threshold = 30 // set threshold in percentage 80, 70, 60, 50, 40, 30, 20 only.
int i
int x
int y
int z
int start
int calibrateValue
const int calibrateBTN = A1
const int input = A0
const int motor = 7
boolean calibration = false
boolean rescue = false
void setup()
{
Serial.begin(9600)
pinMode(input, INPUT)
pinMode(calibrateBTN, INPUT)
pinMode(motor, OUTPUT)
digitalWrite(calibrateBTN, HIGH)
lcd.begin(16,2)
lcd.setCursor(0,0)
lcd.print('Pour water and')
lcd.setCursor(0,1)
lcd.print('press calibrate')
while(!calibration)
{
if(digitalRead(calibrateBTN)==LOW)
{
calibrateValue = analogRead(input)
x = 1023 - calibrateValue
x = x/10
Serial.print('Difference = ')
Serial.println(x)
Serial.print('Calibration Value = ')
Serial.println(calibrateValue)
delay(500)
lcd.clear()
lcd.setCursor(0,0)
lcd.print('Calibration done')
lcd.setCursor(0,1)
lcd.print('successfully !!!')
calibration = true
delay(2000)
}
}
}
void loop()
{
if(analogRead(input)<= calibrateValue)
{
delay(500)
lcd.clear()
lcd.setCursor(0,0)
lcd.print('Soil Moisture')
lcd.setCursor(0,1)
lcd.print('Level: 100%')
}
if(analogRead(input) > calibrateValue && analogRead(input) <= calibrateValue+x)
{
lcd.clear()
lcd.setCursor(0,0)
lcd.print('Soil Moisture')
lcd.setCursor(0,1)
lcd.print('Level: 90 to 99%')
}
if(analogRead(input) > calibrateValue+x && analogRead(input) <= calibrateValue+2*x )
{
lcd.clear()
lcd.setCursor(0,0)
lcd.print('Soil Moisture')
lcd.setCursor(0,1)
lcd.print('Level: 80 to 90%')
start = 80
}
if(analogRead(input) > calibrateValue+2*x && analogRead(input) <= calibrateValue+3*x)
{
lcd.clear()
lcd.setCursor(0,0)
lcd.print('Soil Moisture')
lcd.setCursor(0,1)
lcd.print('Level: 70 to 80%')
start = 70
}
if(analogRead(input) > calibrateValue+3*x && analogRead(input) <= calibrateValue+4*x)
{
lcd.clear()
lcd.setCursor(0,0)
lcd.print('Soil Moisture')
lcd.setCursor(0,1)
lcd.print('Level: 60 to 70%')
start = 60
}
if(analogRead(input) > calibrateValue+4*x && analogRead(input) <= calibrateValue+5*x)
{
lcd.clear()
lcd.setCursor(0,0)
lcd.print('Soil Moisture')
lcd.setCursor(0,1)
lcd.print('Level: 50 to 60%')
start = 50
}
if(analogRead(input) > calibrateValue+5*x && analogRead(input) <= calibrateValue+6*x)
{
lcd.clear()
lcd.setCursor(0,0)
lcd.print('Soil Moisture')
lcd.setCursor(0,1)
lcd.print('Level: 40 to 50%')
start = 40
}
if(analogRead(input) > calibrateValue+6*x && analogRead(input) <= calibrateValue+7*x)
{
lcd.clear()
lcd.setCursor(0,0)
lcd.print('Soil Moisture')
lcd.setCursor(0,1)
lcd.print('Level: 30 to 40%')
start = 30
}
if(analogRead(input) > calibrateValue+7*x && analogRead(input) <= calibrateValue+8*x)
{
lcd.clear()
lcd.setCursor(0,0)
lcd.print('Soil Moisture')
lcd.setCursor(0,1)
lcd.print('Level: 20 to 30%')
start = 20
}
if(analogRead(input) > calibrateValue+8*x && analogRead(input) <= calibrateValue+9*x)
{
lcd.clear()
lcd.setCursor(0,0)
lcd.print('Soil Moisture')
lcd.setCursor(0,1)
lcd.print('Level: 10 to 20%')
start = 10
}
if(analogRead(input) > calibrateValue+9*x && analogRead(input) <= calibrateValue+10*x)
{
lcd.clear()
lcd.setCursor(0,0)
lcd.print('Soil Moisture')
lcd.setCursor(0,1)
lcd.print('Level: <10%')
rescue = true
}
if(start == threshold || rescue)
{
y = Time
digitalWrite(motor, HIGH)
Time = Time*60
z = Time
for(i=0 i

Comment calibrer ce système d'irrigation automatique:

• Une fois la quincaillerie terminée, insérez l'électrode sur le sol, quelque part sur le trajet de l'écoulement de l'eau.
• Modifiez maintenant les deux valeurs dans le programme 1) Le temps nécessaire pour arroser toutes les plantes (en minutes). 2) Niveau de seuil en dessous duquel l'arduino déclenche la pompe. Vous pouvez définir les valeurs de pourcentage 80, 70, 60, 50, 40, 30, 20 uniquement.

int Time = 5 // Régler l'heure en minutes
seuil int = 30 // définir le seuil en pourcentage 80, 70, 60, 50, 40, 30, 20 uniquement.

Modifiez les valeurs dans le programme.

• Téléchargez le code sur arduino et alimentez le circuit. Il affichera «verser de l'eau et appuyer sur calibrer». Vous devez maintenant arroser manuellement votre jardin à un niveau suffisant.
• Après avoir arrosé le jardin, appuyez sur le bouton de calibrage. Cela déterminera la conduction de l'électricité dans un sol entièrement humide et capturera la valeur de référence.
• Le système est maintenant prêt à servir votre petit jardin. Veuillez essayer d'ajouter une alimentation de secours pour ce projet. En cas de panne de courant, la valeur étalonnée de référence sera effacée de la mémoire et vous devrez à nouveau étalonner le système.

Prototype de l'auteur:

Image de prototype d

Indication du niveau d'humidité du sol:

Une fois la pompe allumée, elle affichera le temps restant pour s'éteindre (en secondes).




Une paire de: 3 circuits de protection d'alarme laser intelligents Suivant: Amplificateur OCL expliqué