Circuito de irrigação automática usando Arduino

Neste post, vamos construir um sistema de irrigação de água automatizado para pequenos jardins usando arduino e sensor de umidade do solo.

Introdução

O sistema proposto pode monitorar o nível de umidade do solo e quando a umidade do solo ficar abaixo do valor predefinido, a bomba de 12 V DC será acionada por um período de tempo predeterminado. O status do nível de umidade do solo e outras funções do sistema podem ser monitorados via display LCD 16 x 2 em tempo real.

Estima-se que existam 3 trilhões de árvores em todo o globo, o que é maior do que o número de árvores nascidas em nossa galáxia, a Via Láctea, que é estimada em 100 bilhões. Mas, nós, humanos, cortamos um número incontável de árvores para atender às nossas necessidades básicas de luxo.

A Mãe Natureza é projetada com um sistema de feedback, quando uma espécie apresenta grandes perturbações, a natureza vai exterminar a espécie.

Os seres humanos estavam perturbando a natureza sem saber por séculos, mas, mesmo após um grande desenvolvimento na ciência e tecnologia, a taxa de perturbação não diminuiu.

A mudança climática é um dos exemplos, quando se torna drástica o suficiente, nossa espécie não vai durar muito.
Este projeto dá um passo de bebê para preservar a natureza, ele pode irrigar seu lindo pequeno jardim sem qualquer interação humana. Agora vamos entrar nos detalhes técnicos do projeto.

Sensor de umidade do solo:

O coração do projeto é sensor de umidade do solo que pode detectar a quantidade de conteúdo de umidade no solo. O sensor fornece um valor analógico e um microcontrolador interpretará esses valores e exibirá o teor de umidade.

São dois eletrodos, que serão inseridos no solo. Os eletrodos são conectados a uma placa de circuito que consiste em IC comparador, LED, resistor trimmer de entrada e pinos de saída.

Ilustração do sensor de umidade do solo:

Possui 4 + 2 pinos, 2 pinos para conexão do eletrodo e o restante dos 4 pinos são Vcc, GND, saída digital e saída analógica. Vamos usar apenas o pino de saída analógica para detectar a umidade do solo.
Como não estamos usando o pino de saída digital, não usaremos o resistor trimmer integrado para calibrar o sensor.

Agora, isso conclui o sensor de umidade do solo.

Diagrama esquemático:

O circuito é bastante simples e amigável para iniciantes. O esquema é dividido em duas partes do mesmo projeto para reduzir a confusão ao duplicar o projeto.

O esquema acima é o LCD para arduino fiação. Um potenciômetro de 10K é fornecido para ajustar o contraste do display LCD.

Aqui está o resto do esquema consistindo de sensor de umidade do solo, bomba de 12 V DC, um botão de calibração e fonte de alimentação de 12 V (1 - 2 A). Use uma fonte de alimentação pelo menos superior a 500mA da classificação de corrente da bomba de 12 Vcc.

O MOSFET IRF540N (ou qualquer canal N equivalente) é usado em vez de BJTs para melhorar a eficiência geral de energia do sistema.

A bomba irá regar seu pequeno jardim, certifique-se de que você sempre tenha a quantidade adequada de água disponível.

Código do 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-------------//

Como calibrar este sistema de irrigação automática:

• Com o hardware concluído, insira o eletrodo no solo, em algum lugar no caminho do fluxo de água.
• Agora altere os dois valores no programa 1) O tempo que levará para regar todas as plantas (em minutos). 2) Nível limite abaixo do qual o Arduino aciona a bomba. Você pode definir os valores de porcentagem 80, 70, 60, 50, 40, 30, 20 somente.

int Time = 5 // Definir o tempo em minutos
limite interno = 30 // definir limite em porcentagem 80, 70, 60, 50, 40, 30, 20 apenas.

Altere os valores no programa.

• Carregue o código para o Arduino e ligue o circuito. Ele exibirá “despeje água e pressione calibrar”. Agora você tem que regar manualmente o seu jardim até um nível suficiente.
• Depois de regar o jardim, pressione o botão de calibração. Isso determinará a condução de eletricidade em solo totalmente úmido e disparará o valor de referência.
• Agora o sistema está pronto para servir ao seu pequeno jardim. Por favor, tente adicionar um backup de energia para este projeto. Quando a energia falhar, o valor calibrado de referência será apagado da memória e você terá que calibrar o sistema novamente.

Protótipo do autor:

Indicação do nível de umidade do solo:

Assim que a bomba for ligada, ela exibirá o tempo restante para desligar (em segundos).