In questo post costruiremo un sistema automatizzato di irrigazione dell'acqua per piccoli giardini utilizzando arduino e sensore di umidità del suolo.
introduzione
Il sistema proposto può monitorare il livello di umidità del suolo e quando l'umidità del suolo scende al di sotto del valore preimpostato, la pompa 12V CC verrà attivata per un periodo di tempo predeterminato. Lo stato del livello di umidità del suolo e altre funzioni del sistema possono essere monitorati tramite display LCD 16 x 2 in tempo reale.
Si stima che ci siano 3 trilioni di alberi in tutto il mondo, un numero maggiore del numero di partenze nella nostra galassia della Via Lattea che si stima sia di 100 miliardi. Ma noi umani tagliamo innumerevoli alberi per soddisfare i nostri bisogni di base per soddisfare le esigenze di lusso.
Madre Natura è progettata con un sistema di feedback, quando una specie introduce enormi disturbi, la natura cancellerà la specie dall'esistenza.
Gli esseri umani hanno disturbato la natura inconsapevolmente per secoli ma, anche dopo un grande sviluppo della scienza e della tecnologia, il tasso di disturbo non è diminuito.
Il cambiamento climatico è uno degli esempi, quando diventa abbastanza drastico la nostra specie non durerà a lungo.
Questo progetto fa un piccolo passo avanti per preservare la natura, può irrigare il tuo delizioso piccolo giardino senza alcuna interazione umana. Ora passiamo ai dettagli tecnici del progetto.
Sensore di umidità del suolo:
Il cuore del progetto è sensore di umidità del suolo che può rilevare la quantità di contenuto di umidità nel suolo. Il sensore emette un valore analogico e un microcontrollore interpreterà quei valori e visualizzerà il contenuto di umidità.
Sono presenti due elettrodi, che verranno inseriti nel terreno. Gli elettrodi sono collegati a un circuito stampato composto da IC comparatore, LED, ingresso resistore trimmer e pin di uscita.
Illustrazione del sensore di umidità del suolo:
Ha 4 + 2 pin, 2 pin per il collegamento degli elettrodi e il resto dei 4 pin sono Vcc, GND, uscita digitale e uscita analogica. Utilizzeremo solo il pin di uscita analogico per rilevare l'umidità del suolo.
Dal momento che non stiamo utilizzando il pin di uscita digitale, non utilizzeremo la resistenza trimmer integrata per calibrare il sensore.
Ora, questo conclude il sensore di umidità del suolo.
Diagramma schematico:
Il circuito è abbastanza semplice e adatto ai principianti. Lo schema è diviso in due parti dello stesso progetto per ridurre la confusione durante la duplicazione del progetto.
Lo schema sopra è il LCD per arduino cablaggio. Viene fornito un potenziometro da 10K per regolare il contrasto del display LCD.
Ecco il resto dello schema composto da sensore di umidità del suolo, pompa 12V DC, un pulsante di calibrazione e alimentazione 12V (1 - 2 amp). Utilizzare un alimentatore almeno superiore a 500 mA della corrente nominale della pompa a 12 V CC.
Il MOSFET IRF540N (o qualsiasi canale N equivalente) viene utilizzato al posto dei BJT per migliorare l'efficienza energetica complessiva del sistema.
La pompa innaffierà il tuo piccolo giardino, assicurati di avere sempre a disposizione una quantità adeguata di acqua.
Codice del programma:
//-------------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
Come calibrare questo sistema di irrigazione automatico:
• Con l'hardware completo, inserire l'elettrodo sul terreno, da qualche parte sul percorso del flusso d'acqua.
• Modificare ora i due valori nel programma 1) Il tempo necessario per irrigare tutte le piante (in minuti). 2) Livello di soglia al di sotto del quale l'arduino fa scattare la pompa. È possibile impostare solo i valori percentuali 80, 70, 60, 50, 40, 30, 20.
int Time = 5 // Imposta il tempo in minuti
int threshold = 30 // imposta la soglia solo in percentuale 80, 70, 60, 50, 40, 30, 20.
Modificare i valori nel programma.
• Carica il codice su arduino e alimenta il circuito. Verrà visualizzato 'versare acqua e premere calibrare'. Ora devi irrigare manualmente il tuo giardino a un livello sufficiente.
• Dopo aver irrigato il giardino, premere il pulsante di calibrazione. Questo determinerà la conduzione dell'elettricità in un terreno completamente umido e istantaneamente il valore di riferimento.
• Ora il sistema è pronto per servire il tuo piccolo orto. Prova ad aggiungere un backup di alimentazione per questo progetto. In caso di interruzione dell'alimentazione, il valore di riferimento calibrato verrà cancellato dalla memoria e sarà necessario calibrare nuovamente il sistema.
Prototipo dell'autore:
Indicazione del livello di umidità del suolo:
Una volta che la pompa è accesa, verrà visualizzato il tempo rimanente per lo spegnimento (in secondi).
Precedente: 3 circuiti di protezione allarme laser intelligente Avanti: Spiegazione dell'amplificatore OCL
