I det här inlägget ska vi bygga ett automatiserat vattenbevattningssystem för liten trädgård med arduino och jordfuktighetssensor.
Introduktion
Det föreslagna systemet kan övervaka markens fuktighetsnivå och när markfuktigheten går under det förinställda värdet, kommer 12V DC-pumpen att aktiveras under en förutbestämd tidsperiod. Markfuktighetsnivån och andra funktioner i systemet kan övervakas via 16 x 2 LCD-display i realtid.
Det uppskattas att det finns 3 biljoner träd över hela världen vilket är större än antalet start i vårt hemliga Vintergatan som beräknas vara 100 miljarder. Men vi människor hugger otaliga träd för att uppfylla våra grundläggande behov till lyxbehov.
Moder Natur är utformad med ett återkopplingssystem, när en art inför enorma störningar kommer naturen att utplåna arten från existens.
Människor störde naturen omedvetet i århundraden men även efter stor utveckling inom vetenskap och teknik har störningsgraden inte minskat.
Klimatförändringar är ett exempel, när det blir tillräckligt drastiskt kommer vår art inte att hålla länge.
Detta projekt tar ett babysteg framåt för att bevara naturen, det kan bevattna din vackra lilla trädgård utan någon mänsklig interaktion. Låt oss nu gå in på projektets tekniska detaljer.
Jordfuktighetssensor:
Kärnan i projektet är markfuktighetssensor som känner av mängden fuktinnehåll i jorden. Sensorn ger ut analogt värde och en mikrokontroller tolkar dessa värden och visar fuktinnehållet.
Det finns två elektroder som kommer att införas i jorden. Elektroderna är anslutna till ett kretskort bestående av komparator IC, LED, trimmermotståndsingång och utgångsstift.
Illustration av jordfuktighetssensor:
Den har 4 + 2 stift, 2 stift för elektrodanslutning och resten av de 4 stiften är Vcc, GND, digital utgång och analog utgång. Vi ska bara använda den analoga utgångsstiftet för att känna av jordfuktighet.
Eftersom vi inte använder digital utgångsstift använder vi inte inbyggt trimmermotstånd för att kalibrera sensorn.
Nu avslutar jordfuktighetssensorn.
Schematiskt diagram:
Kretsen hålls ganska enkel och nybörjarvänlig. Schemat är uppdelat i två delar av samma projekt för att minska förvirring medan du duplicerar projektet.
Ovanstående schematiska är LCD till arduino ledningar. En 10K potentiometer finns för att justera kontrasten på LCD-skärmen.
Här är resten av schemat som består av jordfuktighetssensor, 12V DC-pump, en kalibreringsknapp och 12V (1 - 2 amp) strömförsörjning. Använd en strömförsörjning på minst 500 mA 12V DC-pumpens nuvarande betyg.
MOSFET IRF540N (eller någon motsvarande N-kanal) används istället för BJT för att förbättra systemets totala effektivitet.
Pumpen kommer att vattna din lilla trädgård, se till att du alltid har tillräcklig mängd vatten tillgängligt.
Programkod:
//-------------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
Så här kalibrerar du det här automatiska bevattningssystemet:
• Sätt i elektroden på marken med färdig hårdvara någonstans vid vattenflödets väg.
• Ändra nu de två värdena i programmet 1) Det tar tid att vattna alla växter (i minuter). 2) Tröskelnivå under vilken arduino utlöser pumpen. Du kan bara ställa in procentvärdena 80, 70, 60, 50, 40, 30, 20.
int Tid = 5 // Ställ in tid i minuter
int tröskel = 30 // endast tröskel i procent 80, 70, 60, 50, 40, 30, 20.
Ändra värdena i programmet.
• Ladda upp koden till arduino och strömförsörj kretsen. Den visar 'häll vatten och tryck på kalibrera'. Nu måste du vattna din trädgård manuellt till tillräcklig nivå.
• Efter att ha bevattnat trädgården, tryck på kalibreringsknappen. Detta kommer att bestämma ledningen av elektricitet i helt fuktig jord och snapshots referensvärdet.
• Nu är systemet redo att betjäna din lilla trädgård. Försök att lägga till en strömbackup för detta projekt. När strömmen misslyckas raderas referenskalibrerat värde ur minnet och du måste kalibrera systemet igen.
Författarens prototyp:
Angivande av markfuktighetsnivå:
När pumpen är PÅ visas den återstående tiden för att stänga av (i sekunder).
Tidigare: 3 Smarta laserlarmskyddskretsar Nästa: OCL-förstärkare förklaras
