Circuit de reg automàtic mitjançant Arduino

En aquesta publicació construirem un sistema de reg automàtic d’aigua per a jardins petits amb arduino i sensor d’humitat del sòl.

Introducció

El sistema proposat pot controlar el nivell d’humitat del sòl i quan la humitat del sòl sigui inferior al valor preestablert, la bomba de 12V CC s'activarà durant un període de temps predeterminat. L'estat del nivell d'humitat del sòl i altres funcions del sistema es poden controlar mitjançant pantalla LCD de 16 x 2 en temps real.

S'estima que hi ha 3 bilions d'arbres a tot el món, que és superior al nombre d'inici a la nostra galàxia de la Via Làctia, que s'estima que és de 100.000 milions. Però, els humans tallem un nombre incomptable d’arbres per satisfer les nostres necessitats bàsiques a les de luxe.

La Mare Natura està dissenyada amb un sistema de retroalimentació, quan una espècie introdueix enormes pertorbacions, la natura eliminarà l’espècie de l’existència.

Els éssers humans van estar inquietant la natura sense saber-ho durant segles, però, fins i tot després d’un gran desenvolupament en ciència i tecnologia, la taxa de pertorbació no s’ha reduït.

El canvi climàtic és un dels exemples, quan es fa prou dràstic, la nostra espècie durarà poc.
Aquest projecte fa un pas endavant per preservar la natura, pot regar el vostre encantador jardí sense cap interacció humana. Ara anem a conèixer els detalls tècnics del projecte.

Sensor d'humitat del sòl:

El centre del projecte és sensor d'humitat del sòl que pot detectar la quantitat d'humitat del sòl. El sensor proporciona un valor analògic i un microcontrolador interpretarà aquests valors i mostrarà el contingut d'humitat.

Hi ha dos elèctrodes que s’introduiran al sòl. Els elèctrodes estan connectats a una placa de circuit composta per circuits comparatius IC, LED, pinça d'entrada i sortida de resistència de tall.

Il·lustració del sensor d'humitat del sòl:

Té 4 + 2 pins, 2 pins per a la connexió d’elèctrodes i la resta dels 4 pins són Vcc, GND, sortida digital i sortida analògica. Utilitzarem només el pin de sortida analògic per detectar la humitat del sòl.
Com que no fem servir pin de sortida digital, no farem servir resistència de retallador integrada per calibrar el sensor.

Ara, això conclou el sensor d’humitat del sòl.

Diagrama esquemàtic:

El circuit es manté força senzill i amable per a principiants. L'esquema es divideix en dues parts del mateix projecte per reduir la confusió mentre es duplica el projecte.

L'esquema anterior és el LCD a arduino cablejat. Es proporciona un potenciòmetre de 10K per ajustar el contrast de la pantalla LCD.

Aquí teniu la resta de l’esquema que consisteix en un sensor d’humitat del sòl, una bomba de 12 V CC, un polsador de calibració i una font d’alimentació de 12 V (1 - 2 amp). Utilitzeu una font d'alimentació com a mínim superior a 500 mA de la potència actual de la bomba de 12 V CC.

El MOSFET IRF540N (o qualsevol canal N equivalent) s’utilitza en lloc dels BJT per millorar l’eficiència energètica general del sistema.

La bomba us regarà un petit jardí, assegureu-vos que sempre disposeu d’una quantitat adequada d’aigua.

Codi del programa:

//-------------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 {
z = z - 1
delay(1000)
lcd.clear()
lcd.setCursor(0,0)
lcd.print('PUMP IS ON, WILL')
lcd.setCursor(0,1)
lcd.print('TURN OFF IN:')
lcd.print(z)
}
Time = y
rescue = false
digitalWrite(motor, LOW)
}
delay(1000)
}
//-------------Program Developed By R.Girish-------------//

Com calibrar aquest sistema de reg automàtic:

• Amb el maquinari complet, introduïu l'elèctrode a terra, en algun lloc del camí del flux d'aigua.
• Ara canvieu els dos valors del programa 1) El temps que trigareu a regar totes les plantes (en minuts). 2) Nivell llindar per sota del qual l’arduino activa la bomba. Podeu establir només els valors percentuals 80, 70, 60, 50, 40, 30, 20.

int Temps = 5 // Estableix el temps en minuts
llindar int = 30 // defineix el llindar només en percentatges 80, 70, 60, 50, 40, 30, 20.

Canvieu els valors del programa.

• Pengeu el codi a arduino i alimenteu el circuit. Es mostrarà 'abocar aigua i premeu calibrar'. Ara heu de regar manualment el vostre jardí a un nivell suficient.
• Després de regar el jardí, premeu el botó de calibració. Això determinarà la conducció d’electricitat en sòls totalment humits i obtindrà el valor de referència.
• Ara el sistema està preparat per servir el vostre petit jardí. Intenteu afegir una còpia de seguretat d'alimentació per a aquest projecte. Quan l'alimentació falla, el valor calibrat de referència s'esborrarà de la memòria i haureu de calibrar el sistema de nou.

Prototip de l'autor:

Indicació del nivell d'humitat del sòl:

Un cop la bomba estigui engegada, mostrarà el temps restant per apagar-la (en segons).