Realizar uma automação com arduino é algo prático, barato e acima de tudo divertido, nesse post vamos ver como preparar seu projeto de automação de irrigação para ser implementado em outros locais.
O projeto que será apresentado conta com uma boa quantidade de sensores e uma lógica de fácil interpretação, ele foi implementado na escola onde estudei, o IFPI Campus Floriano e foi feito para funcionar por longos períodos de tempo e com pouca manutenção.
Vamos inicialmente visualizar o ambiente onde o projeto deve ser implementado e ver quais pontos precisam de atenção. A água que deve ser usada para irrigar o jardim vem de um reservatório que pode ou não estar com água, então vamos precisar de um sensor para saber isso.
Para levar a água até as plantas vamos usar uma bomba que funciona com energia solar, nesse ponto temos outras duas variáveis que vão precisar de sensores também, saber se a bomba precisa ser ligada ou não, e se temos energia para ligá-la, já que pode ou não haver sol para gerar energia.
Materiais necessários para o projeto Irrigação Autônoma com Arduino
Agora vamos entender a utilidade de cada sensor.
Para que o arduino saiba que horas deve irrigar o jardim, precisamos dar um relógio para ele, e essa é a função do RTC.
A signa RTC significa Real Time Clock, em português Relógio de Tempo Real, ele consegue informar que horas são para o arduino a qualquer momento, além disso pode informar o dia, mês, ano e possui uma bateria própria, então mesmo que você desligue o arduino e ligue ele dias depois o RTC ainda vai informar as horas com precisão.
Esse sensor é tão útil que nesse momento você está usando um, seja no seu computador ou no seu celular, esse sensor é responsável por informar as horas para o seu aparelho.
Módulo RTC DS1307
Como foi dito antes, a bomba que vai levar a água até as plantas funciona com energia solar, mas e se não houver sol? Seja por causa de chuva ou por nuvens, nosso sistema de irrigação precisa estar preparado para isso, então precisamos de um sensor para informar isso ao arduino.
Você pode pensar “Mas se a variável é a luz do sol, porque não usar um sensor de luz solar?” Se essa pergunta passou pela sua cabeça, parabéns, você tem uma mente crítica, entretanto um sensor de luminosidade não acabaria com nossos problemas.
Imagine uma chuva com sol, coisa que acontece bastante nesse país tropical, o sensor de luminosidade não conseguiria identificar que está chovendo, e não daria uma leitura totalmente precisa.
Agora imagine outra situação, temos o sensor de luz e um sensor de chuva para resolver o primeiro problema, se uma nuvem fizer sombra apenas na placa solar e não no sensor de luz? Temos aqui outra situação problemática, seria maravilhoso ter apenas um único sensor fosse capaz de ter as informações necessárias sem esses problemas, e temos, um sensor de corrente elétrica é capaz disso.
Sensor de corrente elétrica ACS712
Medindo a corrente de saída da placa fotovoltaica podemos saber se temos a quantidade de luz necessária para ligar a bomba d’água, no caso de uma chuva fraca, onde a luz não diminui, o jardim ainda não teria água o suficiente com a chuva, e a irrigação seria necessária.
No caso de uma sombra sobre a placa solar, com a corrente de saída da placa saberíamos se a sombra é passageira ou não, e poderíamos novamente ligar a bomba se tivermos energia o suficiente. Automação é sinônimo de simplicidade, sempre busque ser simples e objetivo para escolher o que usar e como fazer, o simples quase nunca falha.
Voltando à primeira variável que citei nesse post, a água vem de um reservatório que pode ou não estar com água, podemos usar um sensor que indique constantemente o nível da água, mas isso é realmente necessário? Não, apenas saber se temos ou não água no reservatório já é o bastante, e para isso vamos usar um sensor de nível tipo bóia, visto na imagem abaixo.
Sensor de Nível da água 90º
Ele pode nos dar a informação necessária e também é simples de usar e instalar, como disse antes, o simples quase nunca falha.
Com todos esses sensores já podemos desenvolver o sistema e fazê-lo funcionar, temos os sensores necessários para conseguir os dados necessários, mas qual seria o diferencial desse projeto para outros semelhantes a ele? Possuir um diferencial, algo que destaca você é algo importante em qualquer momento da vida, e porque fazer diferente nos projetos que desenvolvemos? Vamos adicionar outros equipamentos que são nosso diferencial;
Agora vamos entender a função de cada um deles.
Com esse sensor podemos ter os dados da água que vai até o reservatório, no contexto que o projeto está, isso é incrível. Teríamos uma base de dados e depois de certo tempo saberíamos a quantidade de água que é utilizada, o momento em que o reservatório recebe mais água entre outras coisas, e depois poderíamos desenvolver uma maneira de tornar a irrigação ainda mais eficiente.
Sensor de fluxo e vazão de água
Armazenar todos os dados do projeto em um local seguro, onde seja possível ter acesso fácil a eles também seria um diferencial positivo no projeto, e para isso utilizaremos um módulo que permite escrever informações em um micro cartão de memória, é possível escrever os dados no formato bloco de notas (.txt) ou diretamente no formato excel (.xls), o que facilita muito a análise dos dados.
Módulo Micro SD card
Agora vamos pensar em como alimentar todos esses componentes, de onde podemos pegar a eletricidade necessária para a placa e os sensores? Esse projeto possui uma placa solar que alimenta a bomba d’água, podemos usar essa placa solar para alimentar também o arduino e tornar todo o projeto 100% ecológico, já que utilizaremos apenas fontes de energia renovável.
Entretanto para isso é necessário um regulador de tensão robusto o bastante para suportar toda a potência da nossa placa fotovoltaica, sendo assim o regulador de tensão step down atende às nossas necessidades.
Regulador de Tensão LM2596
Vamos lembrar que esse projeto deve funcionar sozinho praticamente todo o tempo, então pensar em proteção contra o clima é de vital importância, foram feitas caixas especialmente para a proteger a bomba d’água e o circuito eletrônico do sol, chuva e humidade, é possível ver as caixas de proteção nas imagens abaixo.
Sistema de irrigação instalado.
Depois de todo esse trabalho escrever a programação não parece tão difícil não é? Abaixo segue o código cuja lógica foi modelada para essa aplicação em específico. Caso queira utilizá-la em seu projeto, lembre-se de adaptá-la para seus componentes e sua aplicação final.
#include <DS1307.h> //biblioteca RTC
#include <Wire.h> //biblioteca RTC
#include <SD.h> //bilbioteca SD card
#include <SPI.h> //bilbioteca SD card
#include <LiquidCrystal.h>
const int rs = 3, en = 4, d4 = 5, d5 = 6, d6 = 7, d7 = 8;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
File myFile;
int pinoSS = 53; // Pin 53 para Mega / Pin 10 para UNO
int rtc[7];
const int sensorCorrente = A0;
float sensorValue = 0;
float currentValue = 0;
float voltsporUnidade = 0.0048875855327468;
float ruido =0.00;
int boia = 22;
int rele = 24;
int ledred = 26;
int ledgreen = 28;
int botton = 30;
byte sensorInterrupt = 0; // 0 = digital pin 2
byte sensorPin = 2; // 2,3,18,19,20,21
float calibrationFactor = 4.5;
volatile byte pulseCount;
float flowRate;
unsigned int flowMilliLitres;
unsigned long totalMilliLitres;
unsigned long oldTime;
void setup()
{
Serial.begin(9600);
lcd.begin(16,2);
//RTC.stop();
//RTC.set(DS1307_SEC,00); //define o segundo
//RTC.set(DS1307_MIN,8); //define o minuto
//RTC.set(DS1307_HR,21); //define a hora
//RTC.set(DS1307_DOW,2); //define o dia da semana
//RTC.set(DS1307_DATE,10); //define o dia
//RTC.set(DS1307_MTH,2); //define o mes
//RTC.set(DS1307_YR,20); //define o ano
//RTC.start();
pinMode(sensorPin, INPUT);
pinMode(rele, OUTPUT);
pinMode(ledred, OUTPUT);
pinMode(ledgreen, OUTPUT);
pinMode(pinoSS, OUTPUT);
pinMode(botton, INPUT);
digitalWrite(sensorPin, HIGH);
digitalWrite(ledgreen, LOW);
digitalWrite(ledred, LOW);
digitalWrite(rele, HIGH);
pulseCount = 0;
flowRate = 0.0;
flowMilliLitres = 0;
totalMilliLitres = 0;
oldTime = 0;
attachInterrupt(sensorInterrupt, pulseCounter, FALLING);
if (SD.begin()) { // Inicializa o SD Card
Serial.println("SD Card pronto para uso."); // Imprime na tela
digitalWrite(ledgreen, HIGH);
delay(3000);
digitalWrite(ledgreen, LOW);
}
else {
Serial.println("Falha na inicialização do SD Card.");
digitalWrite(ledred, HIGH);
delay(3000);
digitalWrite(ledred, LOW);
return;
}
// Serial.print(rtc[7]);
}
void loop()
{
RTC.get(rtc,true);
for(int i=0; i<7; i++)
{
Serial.print(rtc[4]); //dia
Serial.print(" ");
Serial.print(rtc[5]); //mes
Serial.print(" ");
Serial.print(rtc[6]); //ano
Serial.print(" ");
Serial.print(rtc[3]); //dia da semana
Serial.print(" ");
Serial.print(rtc[2]); //hora
Serial.print(" ");
Serial.print(rtc[1]); //minuto
Serial.print(" ");
Serial.print(rtc[0]); //segundo
Serial.println(" ");
}
if ((millis() - oldTime) > 1000) // Only process counters once per second
{
detachInterrupt(sensorInterrupt);
flowRate = ((1000.0 / (millis() - oldTime)) * pulseCount) / calibrationFactor;
oldTime = millis();
flowMilliLitres = (flowRate / 60) * 1000;
totalMilliLitres += flowMilliLitres;
unsigned int frac;
Serial.print("Flow rate: ");
Serial.print(int(flowRate)); // Print the integer part of the variable
Serial.print("."); // Print the decimal point
frac = (flowRate - int(flowRate)) * 10;
Serial.print(frac, DEC) ; // Print the fractional part of the variable
Serial.print("L/min");
Serial.print(" Output Liquid Quantity: "); // Output separator
Serial.print(totalMilliLitres);
Serial.println("mL");
// Reset the pulse counter so we can start incrementing again
pulseCount = 0;
// Enable the interrupt again now that we've finished sending output
attachInterrupt(sensorInterrupt, pulseCounter, FALLING);
if(frac, DEC > 0){
horaAtual();
myFile = SD.open("Dados.txt", FILE_WRITE);
myFile.print("Flow rate: ");
myFile.print(int(flowRate));
myFile.print(".");
myFile.print(frac, DEC);
myFile.println("L/min");
myFile.close();
}
}
// /*
//Função liga bomba
if(rtc[2] == 13 && rtc[1] >= 30){ //horario para ligar
horaAtual();
Nivel();
if(digitalRead(boia) == 1){
lcd.clear();
lcd.write("Bomba ativada");
Serial.print("Bomba ativada");
digitalWrite(rele, LOW);
digitalWrite(ledgreen, HIGH);
digitalWrite(ledred, LOW);
delay(3000);
acs712();
if(currentValue <=3){
lcd.clear();
lcd.write("Corrente insuficiente");
Serial.print("Corrente insuficiente");
delay(1000);
for (int i = 0; i < 12; i++) { //Rolando o display para a esquerda 12 vezes
lcd.scrollDisplayLeft();
}
digitalWrite(rele, HIGH);
digitalWrite(ledgreen, LOW);
digitalWrite(ledred, HIGH);
}
}
}
if(rtc[2] >= 14 /*&& rtc[1] >= 03*/){
Serial.println("Bomba desativada");
digitalWrite(rele, HIGH);
digitalWrite(ledgreen, LOW);
digitalWrite(ledred, HIGH);
}
// Função morte instantânea **Cuidado**
if(digitalRead(botton) == HIGH){
lcd.print("SD successfully saved");
Serial.print("SD successfully saved");
delay(1000);
for (int i = 0; i < 12; i++) { //Rolando o display para a esquerda 12 vezes
lcd.scrollDisplayLeft();
}
digitalWrite(ledgreen, HIGH);
digitalWrite(ledred, HIGH);
while (1) {}
}
// */
}
void acs712()
{
currentValue =0;
for(int index =0; index<5000; index++){
sensorValue = analogRead(sensorCorrente); // le o sensor na pino analogico A0
sensorValue = (sensorValue -510)* voltsporUnidade; // ajusta o valor lido para volts começando da metada ja que a saída do sensor é vcc/2 para corrente =0
currentValue = currentValue +(sensorValue/66)*1000; // a saída do sensor 66 mV por amper
}
myFile = SD.open("Dados.txt", FILE_WRITE);
myFile.print("Corrente = ");
myFile.println(currentValue);
myFile.close();
}
void Nivel()
{
int estado = digitalRead(boia);
Serial.print("Leitura do sensor : ");
Serial.println(estado);
switch(estado)
{
// ambos os casos não serão usados para automação bomba, necessario apenas variavel digitalRead
case 0:
Serial.println("Caixa abaixo do nivel minino");
break;
case 1:
Serial.println("Caixa acima do nivel minino");
break;
}
myFile = SD.open("Dados.txt", FILE_WRITE);
if(estado == 1){
myFile.println("Caixa acima do nivel minino");
}
else{
myFile.println("Caixa abaixo do nivel minino");
}
myFile.close();
}
void horaAtual()
{
myFile = SD.open("Dados.txt", FILE_WRITE);
myFile.print("Date: ");
myFile.print(rtc[4]);
myFile.print("/");
myFile.print(rtc[5]);
myFile.print("/");
myFile.print(rtc[6]);
myFile.print(" Hour ");
myFile.print(rtc[2]);
myFile.print(":");
myFile.println(rtc[1]);
myFile.print(":");
myFile.println(rtc[0]);
myFile.close();
}
void pulseCounter()
{
pulseCount++;
}
Você também pode conferir o código completo e atualizado visitando o repositório desse post no GitHub da Eletrogate.
Lembrem-se que o foco desse post não é reproduzir esse projeto ao pé da letra, mas sim entender como montá-lo e adaptá-lo para as suas necessidades. Visualizando também o diagrama de como é a ligação dos principais componentes podemos compreender ainda mais a lógica da programação.
Diagrama, ligação dos principais sensores
Primeiramente, obrigado por ler esse post até o final, meu objetivo é mostrar como desenvolver seu projeto, seja ele qual for, como escolher os materiais e como saber se esse ou aquele sensor vai ser realmente útil. Ficou com alguma dúvida ou quer acrescentar algo? Comente! ficarei feliz em respondê-lo assim que possível.
Conheça a Metodologia Eletrogate e ofereça aulas de robótica em sua escola!
|
A Eletrogate é uma loja virtual de componentes eletrônicos do Brasil e possui diversos produtos relacionados à Arduino, Automação, Robótica e Eletrônica em geral.
Tenha a Metodologia Eletrogate dentro da sua Escola! Conheça nosso Programa de Robótica nas Escolas!
Rua Rio de Janeiro, 441 - Sala 1301
Centro - Belo Horizonte/MG
CEP 30160-041
*Não temos atendimento físico
Eletrogate Componentes Eletrônicos
CNPJ: 18.917.521/0001-73
