Automatisk vandingskredsløb ved hjælp af Arduino

Automatisk vandingskredsløb ved hjælp af Arduino

I dette indlæg skal vi konstruere et automatiseret vandvandingssystem til lille have ved hjælp af arduino og jordfugtighedsføler.



Introduktion

Det foreslåede system kan overvåg jordens fugtighedsniveau og når jordfugtighed går under den forudindstillede værdi, udløses 12V jævnstrømspumpen i en forudbestemt periode. Status for jordfugtighedsniveau og andre funktioner i systemet kan overvåges via 16 x 2 LCD-display i realtid.

Det anslås, at der er 3 billioner træer over hele kloden, hvilket er større end antallet af start i vores hjemlige Mælkevejs galakse, som anslås til at være 100 milliarder. Men vi mennesker klipper utallige antal træer for at opfylde vores grundlæggende behov til luksusbehov.





Moder Natur er designet med et feedback-system, når en art introducerer enorme forstyrrelser, vil naturen udslette arten fra eksistensen.

Mennesker forstyrrede naturen ubevidst i århundreder, men selv efter stor udvikling inden for videnskab og teknologi er forstyrrelseshastigheden ikke reduceret.



Klimaændringer er et af eksemplerne, når vores art ikke bliver drastisk nok, holder den ikke længe.
Dette projekt tager et baby skridt fremad for at bevare naturen, det kan overrisle din dejlige lille have uden menneskelig interaktion. Lad os nu komme ind på tekniske detaljer om projektet.

Jordfugtighedssensor:

Hjertet i projektet er jordfugtighedsføler som kan registrere mængden af ​​fugtindhold i jorden. Sensoren afgiver analog værdi, og en mikrocontroller fortolker disse værdier og viser fugtindholdet.

Der er to elektroder, som indsættes i jorden. Elektroderne er forbundet til et kredsløbskort bestående af komparator IC, LED, trimmermodstandsindgang og udgangsstifter.

Illustration af jordfugtighedssensor:

jordfugtighedsmodul

Den har 4 + 2 ben, 2 ben til elektrodeforbindelse, og resten af ​​de 4 ben er Vcc, GND, digital udgang og analog udgang. Vi skal kun bruge den analoge udgangsstift til at føle jordfugtighed.
Da vi ikke bruger digital udgangsstift, bruger vi ikke indbygget trimmermodstand til at kalibrere sensoren.

Nu afsluttes jordfugtighedssensoren.

Skematisk diagram:

Kredsløbet holdes ret simpelt og begyndervenligt. Skematisk er opdelt i to dele af det samme projekt for at reducere forvirring, mens du duplikerer projektet.

LCD-ledningsdiagram til automatisk vandingssystem

Ovenstående skematisk er LCD til arduino ledningsføring. Der findes et 10K potentiometer til at justere LCD-displayets kontrast.

Microcontroller-baseret automatisk vandingssystem

Her er resten af ​​skemaet, der består af jordfugtighedssensor, 12V jævnstrømspumpe, en kalibreringsknap og 12V (1 - 2 amp) strømforsyning. Brug en strømforsyning, der mindst er 500 mA 12V DC pumpens aktuelle værdi.

MOSFET IRF540N (eller en hvilken som helst tilsvarende N-kanal) bruges i stedet for BJT'er til at forbedre systemets samlede effektivitet.

Pumpen vander din lille have, og sørg for, at du altid har tilstrækkelig mængde vand til rådighed.

Programkode:

//-------------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ådan kalibreres dette automatiske vandingssystem:

• Indsæt elektroden på jorden med færdig hardware, et eller andet sted ved vandstrømmens sti.
• Skift nu de to værdier i programmet 1) Det tager tid at vandre alle planterne (i minutter). 2) Tærskelniveau, under hvilket arduino udløser pumpen. Du kan kun indstille procentværdierne 80, 70, 60, 50, 40, 30, 20.

int Tid = 5 // Indstil tid i minutter
int-tærskel = 30 // kun indstillet tærskel i procent 80, 70, 60, 50, 40, 30, 20.

Skift værdierne i programmet.

• Upload koden til arduino og tænd for kredsløbet. Det viser 'hæld vand og tryk på kalibrer'. Nu skal du manuelt vande din have til tilstrækkeligt niveau.
• Efter vanding i haven skal du trykke på kalibreringsknappen. Dette vil bestemme ledningen af ​​elektricitet i fuld fugtig jord og snap-shot referenceværdien.
• Nu er systemet klar til at betjene din lille have. Prøv at tilføje en sikkerhedskopi til dette projekt. Når strømmen svigter, slettes den referencekalibrerede værdi af hukommelsen, og du bliver nødt til at kalibrere systemet igen.

Forfatterens prototype:

Arduino-baseret automatisk kunstvandingsprototype-billede

Angivelse af jordfugtighedsniveau:

Når pumpen er tændt, viser den resterende tid til at slukke (i sekunder).




Forrige: 3 Smart Laser Alarm Protection Circuits Næste: OCL-forstærker forklaret