În acest post vom construi un sistem automat de irigare a apei pentru o grădină mică folosind arduino și senzor de umiditate a solului.
Introducere
Sistemul propus poate monitorizați nivelul de umiditate al solului iar atunci când umiditatea solului scade sub valoarea prestabilită, pompa de 12V DC va fi declanșată pentru o perioadă de timp prestabilită. Starea nivelului de umiditate a solului și alte funcții ale sistemului pot fi monitorizate prin afișaj LCD de 16 x 2 în timp real.
Se estimează că există 3 trilioane de copaci pe tot globul, ceea ce este mai mare decât numărul de porniri din galaxia noastră Calea Lactee, care este estimată la 100 de miliarde. Dar noi, oamenii, tăiem un număr nenumărat de copaci pentru a ne îndeplini nevoile de bază pentru nevoile de lux.
Mama Natură este proiectată cu un sistem de feedback, atunci când o specie introduce tulburări uriașe, natura va șterge specia din existență.
Ființele umane au tulburat natura, fără să știe, de secole, dar, chiar și după o mare dezvoltare în știință și tehnologie, rata perturbării nu s-a redus.
Schimbările climatice sunt unul dintre exemple, când devine suficient de drastică, specia noastră nu va dura mult.
Acest proiect face un pas înainte pentru a păstra natura, poate iriga grădina ta minunată, fără interacțiuni umane. Acum, să trecem la detaliile tehnice ale proiectului.
Senzor de umiditate a solului:
Inima proiectului este senzor de umiditate a solului care poate simți cantitatea de umiditate din sol. Senzorul dă valoare analogică și un microcontroler va interpreta aceste valori și va afișa conținutul de umiditate.
Există doi electrozi, care vor fi introduși în sol. Electrozii sunt conectați la o placă de circuite formată din IC de comparare, LED, intrare rezistor trimmer și pin de ieșire.
Ilustrarea senzorului de umiditate a solului:
Are 4 + 2 pini, 2 pini pentru conectarea electrodului iar restul celor 4 pini sunt Vcc, GND, ieșire digitală și ieșire analogică. Vom folosi doar pinul de ieșire analogic pentru a detecta umiditatea solului.
Întrucât nu folosim pinul de ieșire digital, nu vom folosi rezistența de tundere integrată pentru a calibra senzorul.
Acum, asta încheie senzorul de umiditate al solului.
Diagramă schematică:
Circuitul este păstrat destul de simplu și prietenos pentru începători. Schema este împărțită în două părți ale aceluiași proiect pentru a reduce confuzia în timp ce se duplică proiectul.
Schema de mai sus este LCD la arduino cablare. Un potențiometru de 10K este prevăzut pentru a regla contrastul afișajului LCD.
Iată restul schemei constând din senzor de umiditate a solului, pompă de 12V DC, buton de calibrare și sursă de alimentare de 12V (1 - 2 amp). Vă rugăm să utilizați o sursă de alimentare de cel puțin mai mare de 500mA din curentul nominal al pompei 12V DC.
MOSFET IRF540N (sau orice canal N echivalent) este utilizat în locul BJT-urilor pentru a îmbunătăți eficiența energetică generală a sistemului.
Pompa vă va uda grădina mică, asigurați-vă că aveți întotdeauna o cantitate adecvată de apă disponibilă.
Codul programului:
//-------------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
Cum se calibrează acest sistem automat de irigare:
• Cu echipamentul completat, introduceți electrodul pe sol, undeva pe calea fluxului de apă.
• Acum modificați cele două valori din program 1) Cantitatea de timp care va dura până la udarea tuturor plantelor (în minute). 2) Nivelul pragului sub care arduino declanșează pompa. Puteți seta doar valorile procentuale 80, 70, 60, 50, 40, 30, 20.
int Time = 5 // Setați timpul în minute
prag int = 30 // setați pragul doar în procente 80, 70, 60, 50, 40, 30, 20.
Schimbați valorile din program.
• Încărcați codul pe arduino și alimentați circuitul. Se va afișa „se toarnă apă și se apasă calibrare”. Acum trebuie să vă udați manual grădina la un nivel suficient.
• După udarea grădinii, apăsați butonul de calibrare. Acest lucru va determina conducerea electricității în sol complet umezit și va realiza instantaneu valoarea de referință.
• Acum sistemul este gata să vă servească mica grădină. Vă rugăm să încercați să adăugați o copie de rezervă pentru acest proiect. Când alimentarea cade, valoarea calibrată de referință va fi ștearsă din memorie și va trebui să calibrați sistemul din nou.
Prototipul autorului:
Indicarea nivelului de umiditate al solului:
Odată ce pompa este pornită, va afișa timpul rămas pentru oprire (în secunde).
Precedent: 3 circuite inteligente de protecție a alarmelor laser Următorul: Amplificatorul OCL a fost explicat
