In diesem Beitrag werden wir ein automatisiertes Wasserbewässerungssystem für kleine Gärten mit Arduino und Bodenfeuchtesensor bauen.
Einführung
Das vorgeschlagene System kann Überwachen Sie den Bodenfeuchtigkeitsgehalt und wenn die Bodenfeuchtigkeit unter den voreingestellten Wert fällt, wird die 12-V-Gleichstrompumpe für einen vorbestimmten Zeitraum ausgelöst. Der Status des Bodenfeuchtigkeitsniveaus und andere Funktionen des Systems können über ein 16 x 2 LCD-Display in Echtzeit überwacht werden.
Es wird geschätzt, dass es weltweit 3 Billionen Bäume gibt, was mehr ist als die Anzahl der Starts in unserer Heimatmilchstraßengalaxie, die auf 100 Milliarden geschätzt wird. Aber wir Menschen fällen unzählige Bäume, um unsere Grundbedürfnisse nach Luxusbedürfnissen zu erfüllen.
Mutter Natur ist mit einem Rückkopplungssystem ausgestattet. Wenn eine Art große Störungen verursacht, löscht die Natur die Art aus der Existenz.
Der Mensch störte die Natur jahrhundertelang unwissentlich, aber selbst nach einer großen Entwicklung in Wissenschaft und Technologie hat sich die Störungsrate nicht verringert.
Der Klimawandel ist eines der Beispiele, wenn er drastisch genug wird, hält unsere Art nicht lange an.
Dieses Projekt macht einen kleinen Schritt nach vorne, um die Natur zu bewahren. Es kann Ihren schönen kleinen Garten ohne menschliche Interaktion bewässern. Kommen wir nun zu den technischen Details des Projekts.
Bodenfeuchtesensor:
Das Herzstück des Projekts ist Bodenfeuchtesensor die den Feuchtigkeitsgehalt im Boden erfassen kann. Der Sensor gibt einen Analogwert aus und ein Mikrocontroller interpretiert diese Werte und zeigt den Feuchtigkeitsgehalt an.
Es gibt zwei Elektroden, die in den Boden eingeführt werden. Die Elektroden sind mit einer Leiterplatte verbunden, die aus Komparator-IC, LED, Eingangs- und Ausgangspins des Trimmerwiderstands besteht.
Abbildung des Bodenfeuchtesensors:
Es hat 4 + 2 Pins, 2 Pins für den Elektrodenanschluss und die restlichen 4 Pins sind Vcc, GND, digitaler Ausgang und analoger Ausgang. Wir werden nur den analogen Ausgangsstift zum Erfassen der Bodenfeuchtigkeit verwenden.
Da wir keinen digitalen Ausgangspin verwenden, verwenden wir keinen integrierten Trimmerwiderstand, um den Sensor zu kalibrieren.
Damit ist der Bodenfeuchtesensor abgeschlossen.
Schematische Darstellung:
Die Strecke ist recht einfach und anfängerfreundlich gehalten. Der Schaltplan ist in zwei Teile desselben Projekts unterteilt, um Verwirrung beim Duplizieren des Projekts zu vermeiden.
Das obige Schema ist das LCD zu Arduino Verdrahtung. Ein 10K-Potentiometer dient zum Einstellen des Kontrasts des LCD-Displays.
Der Rest des Schaltplans besteht aus einem Bodenfeuchtesensor, einer 12-V-Gleichstrompumpe, einem Kalibriertaster und einer 12-V-Stromversorgung (1 bis 2 Ampere). Bitte verwenden Sie ein Netzteil mit mindestens 12 mA Gleichstrom der 12-V-Gleichstrompumpe.
Der MOSFET IRF540N (oder ein äquivalenter N-Kanal) wird anstelle von BJTs verwendet, um die Gesamtleistungseffizienz des Systems zu verbessern.
Die Pumpe bewässert Ihren kleinen Garten. Stellen Sie sicher, dass immer genügend Wasser zur Verfügung steht.
Programmcode:
//-------------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
So kalibrieren Sie dieses automatische Bewässerungssystem:
• Führen Sie die Elektrode mit fertiger Hardware irgendwo am Weg des Wasserflusses in den Boden ein.
• Ändern Sie nun die beiden Werte im Programm. 1) Die Zeit, die benötigt wird, um alle Pflanzen zu gießen (in Minuten). 2) Schwellenwert, unterhalb dessen das Arduino die Pumpe auslöst. Sie können nur die Prozentwerte 80, 70, 60, 50, 40, 30, 20 einstellen.
int Time = 5 // Zeit in Minuten einstellen
int Schwelle = 30 // Schwelle nur in Prozent 80, 70, 60, 50, 40, 30, 20 einstellen.
Ändern Sie die Werte im Programm.
• Laden Sie den Code auf Arduino hoch und versorgen Sie die Schaltung mit Strom. Es wird 'Wasser gießen und Kalibrieren drücken' angezeigt. Jetzt müssen Sie Ihren Garten manuell auf ein ausreichendes Niveau gießen.
• Drücken Sie nach dem Gießen des Gartens die Kalibriertaste. Dadurch wird die Stromleitung in vollständig feuchtem Boden bestimmt und der Referenzwert im Schnappschuss aufgenommen.
• Jetzt ist das System bereit, Ihren kleinen Garten zu bedienen. Bitte versuchen Sie, ein Backup für dieses Projekt hinzuzufügen. Wenn die Stromversorgung ausfällt, wird der kalibrierte Referenzwert aus dem Speicher gelöscht und Sie müssen das System erneut kalibrieren.
Prototyp des Autors:
Angabe des Bodenfeuchtigkeitsniveaus:
Sobald die Pumpe eingeschaltet ist, wird die verbleibende Zeit zum Ausschalten angezeigt (in Sekunden).
Zurück: 3 intelligente Laseralarmschutzschaltungen Weiter: OCL-Verstärker erklärt
