Automatyczny obwód nawadniający wykorzystujący Arduino

Automatyczny obwód nawadniający wykorzystujący Arduino

W tym poście zamierzamy zbudować zautomatyzowany system nawadniania małego ogrodu z wykorzystaniem arduino i czujnika wilgotności gleby.



Wprowadzenie

Proponowany system może monitorować poziom wilgotności gleby a gdy wilgotność gleby spadnie poniżej zadanej wartości, pompa 12 V DC zostanie uruchomiona na określony czas. Stan wilgotności gleby i inne funkcje systemu można monitorować za pomocą wyświetlacza LCD 16 x 2 w czasie rzeczywistym.

Szacuje się, że na całym świecie są 3 biliony drzew, czyli więcej niż liczba startów w naszej rodzimej galaktyce Drogi Mlecznej, szacowanej na 100 miliardów. Ale my, ludzie, wycinamy niezliczoną liczbę drzew, aby zaspokoić nasze podstawowe potrzeby związane z luksusem.





Matka Natura została zaprojektowana z systemem sprzężenia zwrotnego, kiedy gatunek wprowadza ogromne zakłócenia, natura wymaże go z istnienia.

Istoty ludzkie przez wieki nieświadomie zakłócały naturę, ale nawet po wielkim rozwoju nauki i technologii tempo tych zaburzeń nie zmniejszyło się.



Zmiana klimatu jest jednym z przykładów, kiedy stanie się wystarczająco drastyczna, nasz gatunek nie przetrwa długo.
Ten projekt to krok dziecka do ochrony przyrody, może nawadniać Twój piękny mały ogród bez interakcji z człowiekiem. Przejdźmy teraz do szczegółów technicznych projektu.

Czujnik wilgotności gleby:

Sercem projektu jest czujnik wilgotności gleby który może wyczuć ilość wilgoci w glebie. Czujnik podaje wartość analogową, a mikrokontroler zinterpretuje te wartości i wyświetli zawartość wilgoci.

Istnieją dwie elektrody, które zostaną wprowadzone do gleby. Elektrody są podłączone do płytki drukowanej składającej się z układu scalonego komparatora, diody LED, styków wejściowych i wyjściowych rezystora trymera.

Ilustracja czujnika wilgotności gleby:

moduł czujnika wilgotności gleby

Posiada 4 + 2 piny, 2 piny do podłączenia elektrody, a pozostałe 4 piny to Vcc, GND, wyjście cyfrowe i wyjście analogowe. Zamierzamy używać tylko analogowego pinu wyjściowego do wykrywania wilgotności gleby.
Ponieważ nie używamy cyfrowego pinu wyjściowego, nie będziemy używać wbudowanego rezystora trymera do kalibracji czujnika.

Na tym kończy się czujnik wilgotności gleby.

Schemat:

Tor jest dość prosty i przyjazny dla początkujących. Schemat jest podzielony na dwie części tego samego projektu, aby uniknąć nieporozumień podczas powielania projektu.

Schemat okablowania LCD dla automatycznego systemu nawadniania

Powyższy schemat to LCD do arduino okablowanie. Potencjometr 10K służy do regulacji kontrastu wyświetlacza LCD.

Automatyczny system nawadniania oparty na mikrokontrolerze

Oto reszta schematu składająca się z czujnika wilgotności gleby, pompy 12V DC, przycisku kalibracji oraz zasilacza 12V (1 - 2A). Należy używać źródła zasilania co najmniej większego niż 500 mA prądu znamionowego pompy 12 V DC.

MOSFET IRF540N (lub dowolny równoważny kanał N) jest używany zamiast BJT, aby poprawić ogólną wydajność energetyczną systemu.

Pompa podleje Ci mały ogródek, upewnij się, że zawsze masz odpowiednią ilość wody.

Kod programu:

//-------------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

Jak skalibrować ten automatyczny system nawadniania:

• Z gotowym sprzętem umieść elektrodę na ziemi, gdzieś na drodze przepływu wody.
• Teraz zmień dwie wartości w programie 1) Ilość czasu potrzebna na podlewanie wszystkich roślin (w minutach). 2) Poziom progowy, poniżej którego arduino uruchamia pompę. Możesz ustawić tylko wartości procentowe 80, 70, 60, 50, 40, 30, 20.

int Time = 5 // Ustaw czas w minutach
intreshold = 30 // ustaw próg tylko w procentach 80, 70, 60, 50, 40, 30, 20.

Zmień wartości w programie.

• Prześlij kod do arduino i zasil obwód. Wyświetli się „wlej wodę i naciśnij kalibrację”. Teraz musisz ręcznie podlać ogród do odpowiedniego poziomu.
• Po podlaniu ogrodu naciśnij przycisk kalibracji. Pozwoli to określić przewodnictwo elektryczne w całkowicie wilgotnej glebie i zginie wartość odniesienia.
• Teraz system jest gotowy do obsługi Twojego małego ogrodu. Spróbuj dodać rezerwę zasilania dla tego projektu. W przypadku awarii zasilania skalibrowana wartość odniesienia zostanie usunięta z pamięci i konieczne będzie ponowne skalibrowanie systemu.

Prototyp autora:

Obraz prototypu automatycznego nawadniania opartego na Arduino

Wskazanie poziomu wilgotności gleby:

Po włączeniu pompa wyświetli pozostały czas do wyłączenia (w sekundach).




Poprzedni: 3 inteligentne obwody zabezpieczające alarm laserowy Dalej: Objaśnienie wzmacniacza OCL