Leitura da Umidade do Solo

Introdução

Ter plantas em casa sempre nos traz uma sensação de estar próximo da natureza, mas hoje em dia acaba se tornando algo difícil devido à rotina diária de trabalho e estudo, fazendo com que muitas vezes nos esqueçamos de regar as plantas de casa, e muitas vezes deixando o seu solo secar. Portanto seria muito bom se tivéssemos algum método de visualizar se o solo de nossas plantas está precisando ser irrigado ou não.

Neste tutorial aprenderemos como utilizar o sensor de solo capacitivo para realizar a leitura da umidade do solo das plantas, e como aproveitar essa informação para nos informar se devemos regar ou não a planta.

Lista de Materiais

Lista completa de produtos

comprar

BlackBoard UNO R3

R$ 94,90 no PIX

Sensor de Umidade de Solo Capacitivo

R$ 6,45 no PIX

LCD 16x2 Com Interface I2C

R$ 22,70 no PIX

Sensor Capacitivo Vs. Resistivo

Existem basicamente dois modelos de sensores de solo: os resistivos e os capacitivos. Os sensores de solo resistivos identificam a mudança de resistência elétrica no solo: quanto maior a concentração de água, maior será sua condutividade, logo menor será sua resistência, como no GIF abaixo, por exemplo. Entretanto, esse funcionamento vem com um custo. Por ter de identificar a condutividade do solo, este tipo de sensor possui terminais metálicos expostos que tendem a oxidar com o tempo. Essa oxidação não só pode influenciar na leitura do próprio sensor, como também pode ser desagradável para as plantas, pois a oxidação poderá alterar o pH do solo.

exemplo-funcionamento-sensor-resistivo — Exemplo de Funcionamento de um Sensor Resistivo
Fonte: Last Minute Engineers

Já os sensores de solo capacitivos leem a concentração de água no solo através da variação na sua zona dielétrica. Para entendermos melhor o funcionamento deste tipo de sensor, vamos nos lembrar do que um capacitor é formado. Os capacitores possuem dois terminais e entre esses terminais há um material dielétrico (como na imagem a seguir), que é responsável por armazenar energia elétrica em um campo elétrico.

composicao-capacitor — Composição de um Capacitor
Fonte: Learn Sparkfun

Para o sensor de umidade de solo, o solo úmido opera como o material dielétrico do sensor, que possui dois terminais que não são expostos. Para realizar uma leitura, o sensor cria um pequeno campo elétrico ao seu redor, como no exemplo da imagem abaixo, que utiliza um sensor touch capacitivo como exemplo.

exemplo-funcionamento-sensor-capacitivo — Exemplo de Funcionamento de Sensor Capacitivo
Fonte: Embedded

Com esse campo elétrico, o solo começa a carregar como um capacitor. Em seguida pode-se determinar a capacitância do ambiente em função do tempo de carga. Como essa capacitância está diretamente relacionada à quantidade de água, obtém-se facilmente que um solo mais úmido resulta em uma tensão menor ou um tempo de carga maior.

Primeiras Leituras do Sensor

Primeiramente iremos coletar uma média de leituras do sensor, para que possamos calibrá-lo corretamente no segundo projeto. Para isso, é recomendado realizar duas baterias de teste, uma com o solo completamente seco e uma com o solo com a concentração máxima de água desejada. Assim saberemos quais são os valores máximo e mínimo do sensor no vaso da planta. Para facilitar essa bateria de testes, é melhor realizar primeiro a coleta da média em solo seco, e então irrigá-lo para medir o solo úmido.

Circuito

Para coletar a média de leituras do sensor, monte o circuito a seguir.

Código

Com o circuito montado, carregue o exemplo a seguir para a sua placa.

/*******************************************************************************
* Sensor de Umidade de Solo Capacitivo - Coletor de Media de Leituras (v1.0)
* 
* Este codigo realiza um calculo de media de leitura de uma determinada 
* quantidade de amostras, para facilitar na calibracao futura do sensor. 
* O ideal e iniciar o teste com o sensor ja inserido na terra e em duas
* circunstancias distintas, com o solo seco e com o solo com a concentracao 
* maxima de agua desejada. Talvez seja melhor comecar os testes com o solo seco,
* para facilitar a obtencao dos valores.
* 
* Copyright 2020 RoboCore.
* Escrito por Giovanni de Castro (08/10/2020).
* 
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version (<https://www.gnu.org/licenses/>).
*******************************************************************************/

//Declaracao do pino conectado ao sensor
const int PINO_SENSOR = A0;

//Declaracao da variavel que armazena as leituras do sensor
int leitura_sensor = 0;

//Declaracao da variavel que armazena a quantidade de amostras que serao coletadas
const int NUMERO_AMOSTRAS = 100; 
//Altere a variavel acima com a quantidade de amostras que deseja coletar para o calculo da media

//Declaracao da variavel que armazena a soma das leituras
long somatoria = 0;

void setup() {

  Serial.begin(9600);
  Serial.println("                  ---*****---                  ");
  Serial.println("Sensor de Umidade de Solo Capacitivo - Primeiros Passos");
  Serial.println("Coletando media de leituras do sensor...");
  Serial.println("");

  //Configuracao do pino conectado ao sensor como uma entrada
  pinMode(PINO_SENSOR, INPUT);

  //Realiza a leitura do sensor de acordo com a variavel "NUMERO_AMOSTRAS"
  for(int i = 1; i <= NUMERO_AMOSTRAS; i++){
    leitura_sensor = analogRead(PINO_SENSOR); //Le o sensor
    somatoria = somatoria + leitura_sensor; //Soma a variavel "somatoria" a leitura atual do sensor com seu valor anterior
    float tensao = leitura_sensor*(5.0/1023); //Converte a leitura para tensao para referencia
    Serial.print("Amostra ");
    Serial.print(i);
    Serial.print("  |  ");
    Serial.print("Leitura: ");
    Serial.print(leitura_sensor);
    Serial.print("  |  ");
    Serial.print("Tensao: ");
    Serial.println(tensao);
    delay(1000);
  }

  //Calcula a media das leituras utilizando a variavel "somatoria" e a variavel "NUMERO_AMOSTRAS"
  int media = somatoria / NUMERO_AMOSTRAS;
  Serial.println("");
  Serial.print("Media obtida: ");
  Serial.println(media);

}

void loop() {
  //Nao ha nada para executar aqui
}

​x
 
/*******************************************************************************
* Sensor de Umidade de Solo Capacitivo - Coletor de Media de Leituras (v1.0)
* 
* Este codigo realiza um calculo de media de leitura de uma determinada 
* quantidade de amostras, para facilitar na calibracao futura do sensor. 
* O ideal e iniciar o teste com o sensor ja inserido na terra e em duas
* circunstancias distintas, com o solo seco e com o solo com a concentracao 
* maxima de agua desejada. Talvez seja melhor comecar os testes com o solo seco,
* para facilitar a obtencao dos valores.
* 
* Copyright 2020 RoboCore.
* Escrito por Giovanni de Castro (08/10/2020).
* 
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version (<https://www.gnu.org/licenses/>).
*******************************************************************************/
​
//Declaracao do pino conectado ao sensor
const int PINO_SENSOR = A0;
​
//Declaracao da variavel que armazena as leituras do sensor
int leitura_sensor = 0;
​
//Declaracao da variavel que armazena a quantidade de amostras que serao coletadas
const int NUMERO_AMOSTRAS = 100; 
//Altere a variavel acima com a quantidade de amostras que deseja coletar para o calculo da media
​
//Declaracao da variavel que armazena a soma das leituras
long somatoria = 0;
​
void setup() {
​
  Serial.begin(9600);
  Serial.println("                  ---*****---                  ");
  Serial.println("Sensor de Umidade de Solo Capacitivo - Primeiros Passos");
  Serial.println("Coletando media de leituras do sensor...");
  Serial.println("");
​
  //Configuracao do pino conectado ao sensor como uma entrada
  pinMode(PINO_SENSOR, INPUT);
​
  //Realiza a leitura do sensor de acordo com a variavel "NUMERO_AMOSTRAS"
  for(int i = 1; i <= NUMERO_AMOSTRAS; i++){
    leitura_sensor = analogRead(PINO_SENSOR); //Le o sensor
    somatoria = somatoria + leitura_sensor; //Soma a variavel "somatoria" a leitura atual do sensor com seu valor anterior
    float tensao = leitura_sensor*(5.0/1023); //Converte a leitura para tensao para referencia
    Serial.print("Amostra ");
    Serial.print(i);
    Serial.print("  |  ");
    Serial.print("Leitura: ");
    Serial.print(leitura_sensor);
    Serial.print("  |  ");
    Serial.print("Tensao: ");
    Serial.println(tensao);
    delay(1000);
  }
​
  //Calcula a media das leituras utilizando a variavel "somatoria" e a variavel "NUMERO_AMOSTRAS"
  int media = somatoria / NUMERO_AMOSTRAS;
  Serial.println("");
  Serial.print("Media obtida: ");
  Serial.println(media);
​
}
​
void loop() {
  //Nao ha nada para executar aqui
}

Entendendo o Código

O código inicia com a declaração das variáveis PINO_SENSOR e leitura_sensor, que são responsáveis por armazenar o pino em que o sensor está conectado e a leitura do sensor, respectivamente. A variável NUMERO_AMOSTRAS, por sua vez, armazena a quantidade de amostras de leitura do sensor que iremos coletar para calcular a média. Para finalizar as declarações globais do código, temos a variável somatoria, que é responsável por receber os valores das leituras do sensor somados para o cálculo da média.

//Declaracao do pino conectado ao sensor
const int PINO_SENSOR = A0;

//Declaracao da variavel que armazena as leituras do sensor
int leitura_sensor = 0;

//Declaracao da variavel que armazena a quantidade de amostras que serao coletadas
const int NUMERO_AMOSTRAS = 100; 
//Altere a variavel acima com a quantidade de amostras que deseja coletar para o calculo da media

//Declaracao da variavel que armazena a soma das leituras
long somatoria = 0;

xxxxxxxxxx
 
//Declaracao do pino conectado ao sensor
const int PINO_SENSOR = A0;
​
//Declaracao da variavel que armazena as leituras do sensor
int leitura_sensor = 0;
​
//Declaracao da variavel que armazena a quantidade de amostras que serao coletadas
const int NUMERO_AMOSTRAS = 100; 
//Altere a variavel acima com a quantidade de amostras que deseja coletar para o calculo da media
​
//Declaracao da variavel que armazena a soma das leituras
long somatoria = 0;

A rotina de configuração do código é onde coletamos a média de leituras do sensor, e começamos inicializando o monitor serial com a velocidade de 9600 bps para que possamos visualizar as leituras e a média coletada. Em seguida, configuramos o pino conectado ao sensor como uma entrada do sistema e entramos no laço for(int i = 1; i <= NUMERO_AMOSTRAS; i++), que irá executar a lógica dentro dele enquanto a variável auxiliar i for menor que o valor configurado na variável NUMERO_AMOSTRAS.

Dentro do laço "for", a leitura analógica do pino conectado ao sensor é atribuída à variável leitura_sensor. Feito isso, a variável somatoria possui seu valor anterior somado à leitura do sensor armazenada na variável leitura_sensor. Para finalizar a lógica deste laço, apenas convertemos o valor lido pelo sensor para um valor entre 0 e 5 V para que possamos ter como referência a tensão fornecida pelo sensor e entendermos um pouco melhor o seu funcionamento.

Serial.begin(9600);
Serial.println("                  ---*****---                  ");
Serial.println("Sensor de Umidade de Solo Capacitivo - Primeiros Passos");
Serial.println("Coletando media de leituras do sensor...");
Serial.println("");

//Configuracao do pino conectado ao sensor como uma entrada
pinMode(PINO_SENSOR, INPUT);

//Realiza a leitura do sensor de acordo com a variavel "NUMERO_AMOSTRAS"
for(int i = 1; i <= NUMERO_AMOSTRAS; i++){
  leitura_sensor = analogRead(PINO_SENSOR); //Le o sensor
  somatoria = somatoria + leitura_sensor; //Soma a variavel "somatoria" a leitura atual do sensor com seu valor anterior
  float tensao = leitura_sensor*(5.0/1023); //Converte a leitura para tensao para referencia
  Serial.print("Amostra ");
  Serial.print(i);
  Serial.print("  |  ");
  Serial.print("Leitura: ");
  Serial.print(leitura_sensor);
  Serial.print("  |  ");
  Serial.print("Tensao: ");
  Serial.println(tensao);
  delay(1000);
}

xxxxxxxxxx
 
Serial.begin(9600);
Serial.println("                  ---*****---                  ");
Serial.println("Sensor de Umidade de Solo Capacitivo - Primeiros Passos");
Serial.println("Coletando media de leituras do sensor...");
Serial.println("");
​
//Configuracao do pino conectado ao sensor como uma entrada
pinMode(PINO_SENSOR, INPUT);
​
//Realiza a leitura do sensor de acordo com a variavel "NUMERO_AMOSTRAS"
for(int i = 1; i <= NUMERO_AMOSTRAS; i++){
  leitura_sensor = analogRead(PINO_SENSOR); //Le o sensor
  somatoria = somatoria + leitura_sensor; //Soma a variavel "somatoria" a leitura atual do sensor com seu valor anterior
  float tensao = leitura_sensor*(5.0/1023); //Converte a leitura para tensao para referencia
  Serial.print("Amostra ");
  Serial.print(i);
  Serial.print("  |  ");
  Serial.print("Leitura: ");
  Serial.print(leitura_sensor);
  Serial.print("  |  ");
  Serial.print("Tensao: ");
  Serial.println(tensao);
  delay(1000);
}

Assim que o laço "for" é finalizado, calculamos a média das leituras feitas, declarando a variável media, e já a atribuindo ao valor da variável somatoria dividido pelo valor da variável NUMERO AMOSTRAS.

//Calcula a media das leituras utilizando a variavel "somatoria" e a variavel "NUMERO_AMOSTRAS"
int media = somatoria / NUMERO_AMOSTRAS;
Serial.println("");
Serial.print("Media obtida: ");
Serial.println(media);

xxxxxxxxxx
 
//Calcula a media das leituras utilizando a variavel "somatoria" e a variavel "NUMERO_AMOSTRAS"
int media = somatoria / NUMERO_AMOSTRAS;
Serial.println("");
Serial.print("Media obtida: ");
Serial.println(media);

O Que Deve Acontecer

Após carregar o código para a placa, abra o monitor serial em 9600 bps e aguarde alguns instantes para que as amostras sejam coletadas, e a média calculada. Vale lembrar que deve-se iniciar o código com o sensor já inserido no solo.

Para a bateria em solo seco, você deve obter um valor muito próximo ao nível alto do sensor, como na imagem à esquerda a seguir. Para a bateria em solo úmido, você deve obter um valor próximo ao nível baixo do sensor, como na imagem à direita a seguir.

resultado-solo-seco — Resultado Obtido em Solo Seco

resultado-solo-umido — Resultado Obtido em Solo Seco

É interessante observar com esses resultados que com o solo úmido a tensão lida no sensor é menor do que a tensão lida no solo seco, e isso se deve ao fato que a capacitância do solo úmido é maior que a capacitância com o solo seco, o que prova o que vimos anteriormente.

Vale lembrar que os resultados que você vai obter nas baterias de teste com o seu sensor podem e devem ser diferentes dos valores obtidos acima, pois as condições de teste irão mudar.

Projeto Monitoramento de Umidade

Para este projeto iremos utilizar o LCD com interface I2C para nos alertar quando a umidade do solo estiver abaixo do valor desejado para a planta.

Circuito

Para este projeto, monte o circuito a seguir.

Código

Com o circuito montado, carregue o código a seguir para a sua placa. As variáveis VALOR_MINIMO e VALOR_MAXIMO foram declaradas inicialmente com os valores que obtivemos em testes internos, portanto altere-as de acordo com os valores que você obteve em seus testes. Além disso, a variável CONCENTRACAO_MINIMA foi declarada com um valor padrão de 30% de concentração de água, mas você pode alterá-la para o valor que desejar e que seja melhor para a sua planta.

/*******************************************************************************
* Sensor de Umidade de Solo Capacitivo - Monitoramento de Umidade de Solo (v1.0)
* 
* Este codigo coleta a leitura do sensor, e a mapeia entre 0 e 100 % utilizando
* as medias maxima e minima coletadas no codigo anterior. Essa leitura mapeada e
* entao exibida no LCD, e e entao, caso a leitura seja menor que a concentracao 
* minima desejada, o LCD irá nos alertar que e necessario irrigar o solo.
* 
* Copyright 2020 RoboCore.
* Escrito por Giovanni de Castro (08/10/2020).
* 
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version (<https://www.gnu.org/licenses/>).
*******************************************************************************/

//Inclusao das bibliotecas
#include <Wire.h> 
#include <LiquidCrystal_I2C.h>

//Criacao do objeto "lcd" com o endereco I2C, e o numero de linhas e colunas
LiquidCrystal_I2C lcd(0x20, 16, 2); 
//Altere o endereco I2C acima de acordo com o que foi configurado no DIP switch do seu modulo

//Declaracao do pino conectado ao sensor
const int PINO_SENSOR = A0;

//Declaracao da variavel que armazena as leituras do sensor
int leitura_sensor = 0;

//Declaracao das variaveis que armazenam os valores de calibracao
const int VALOR_MAXIMO = 634; //Valor com solo seco
const int VALOR_MINIMO = 304; //Valor com solo umido
//Altere o valor das variaveis acima de acordo com as medias obtidas atraves do codigo do projeto anterior

//Declaracao da variavel que armazena a concentracao minima desejada
const int CONCENTRACAO_MINIMA = 30;
//Altere a variavel acima com o valor ideal para a sua planta

void setup() {

  //Inicia o display LCD com o backlight aceso, e exibindo o nome do projeto
  lcd.begin();
  lcd.backlight();
  lcd.print("Monitoramento de");
  lcd.setCursor(0,1);
  lcd.print("Umidade de Solo.");
  delay(5000);
  lcd.clear();

  //Define o pino conectado ao sensor como uma entrada do sistema
  pinMode(PINO_SENSOR, INPUT);
  
}

void loop() {

  //Realiza a leitura do sensor, a mapeia entre 0 e 100 % e exibe o valor no LCD
  leitura_sensor = analogRead(PINO_SENSOR);
  leitura_sensor = map(leitura_sensor, VALOR_MINIMO, VALOR_MAXIMO, 100, 0);
  lcd.print("Umidade =  ");
  lcd.print(leitura_sensor);
  lcd.print(" %");

  //Verifica se a leitura esta abaixo da concetracao minima desejada
  if(leitura_sensor < 30){ //Se sim, informamos pelo LCD que precisa irrigar
    lcd.setCursor(0,1);
    lcd.print("Precisa Irrigar!");
    lcd.noBacklight();
    delay(500);
    lcd.backlight();
    delay(500);
  } else { //Caso contrario, apenas esperamos 5 segundos para a proxima leitura
    delay(5000);
  }

  lcd.clear(); //Limpa o LCD para atualizacao

}

xxxxxxxxxx
 
/*******************************************************************************
* Sensor de Umidade de Solo Capacitivo - Monitoramento de Umidade de Solo (v1.0)
* 
* Este codigo coleta a leitura do sensor, e a mapeia entre 0 e 100 % utilizando
* as medias maxima e minima coletadas no codigo anterior. Essa leitura mapeada e
* entao exibida no LCD, e e entao, caso a leitura seja menor que a concentracao 
* minima desejada, o LCD irá nos alertar que e necessario irrigar o solo.
* 
* Copyright 2020 RoboCore.
* Escrito por Giovanni de Castro (08/10/2020).
* 
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version (<https://www.gnu.org/licenses/>).
*******************************************************************************/
​
//Inclusao das bibliotecas
#include <Wire.h> 
#include <LiquidCrystal_I2C.h>
​
//Criacao do objeto "lcd" com o endereco I2C, e o numero de linhas e colunas
LiquidCrystal_I2C lcd(0x20, 16, 2); 
//Altere o endereco I2C acima de acordo com o que foi configurado no DIP switch do seu modulo
​
//Declaracao do pino conectado ao sensor
const int PINO_SENSOR = A0;
​
//Declaracao da variavel que armazena as leituras do sensor
int leitura_sensor = 0;
​
//Declaracao das variaveis que armazenam os valores de calibracao
const int VALOR_MAXIMO = 634; //Valor com solo seco
const int VALOR_MINIMO = 304; //Valor com solo umido
//Altere o valor das variaveis acima de acordo com as medias obtidas atraves do codigo do projeto anterior
​
//Declaracao da variavel que armazena a concentracao minima desejada
const int CONCENTRACAO_MINIMA = 30;
//Altere a variavel acima com o valor ideal para a sua planta
​
void setup() {
​
  //Inicia o display LCD com o backlight aceso, e exibindo o nome do projeto
  lcd.begin();
  lcd.backlight();
  lcd.print("Monitoramento de");
  lcd.setCursor(0,1);
  lcd.print("Umidade de Solo.");
  delay(5000);
  lcd.clear();
​
  //Define o pino conectado ao sensor como uma entrada do sistema
  pinMode(PINO_SENSOR, INPUT);
  
}
​
void loop() {
​
  //Realiza a leitura do sensor, a mapeia entre 0 e 100 % e exibe o valor no LCD
  leitura_sensor = analogRead(PINO_SENSOR);
  leitura_sensor = map(leitura_sensor, VALOR_MINIMO, VALOR_MAXIMO, 100, 0);
  lcd.print("Umidade =  ");
  lcd.print(leitura_sensor);
  lcd.print(" %");
​
  //Verifica se a leitura esta abaixo da concetracao minima desejada
  if(leitura_sensor < 30){ //Se sim, informamos pelo LCD que precisa irrigar
    lcd.setCursor(0,1);
    lcd.print("Precisa Irrigar!");
    lcd.noBacklight();
    delay(500);
    lcd.backlight();
    delay(500);
  } else { //Caso contrario, apenas esperamos 5 segundos para a proxima leitura
    delay(5000);
  }
​
  lcd.clear(); //Limpa o LCD para atualizacao
​
}

Entendendo o Código

Nas configurações globais deste código, começamos incluindo as bibliotecas "Wire" e "LiquidCrystal_I2C" que nos ajudarão a controlar o display LCD com interface I2C, e então criamos o objeto lcd pela biblioteca "LiquidCrystal_I2C", com o endereço 0x27 (lembre-se que o endereço I2C do módulo irá variar de acordo com a configuração do DIP switch e de seu lote, portanto altere esse valor se precisar) e o número de colunas e linhas do display (16 x 2). Em seguida, criamos as variáveis PINO_SENSOR e leitura_sensor, que armazenam o pino que está conectado ao sensor e a leitura obtida no sensor, respectivamente. Por fim, temos a declaração das variáveis VALOR_MAXIMO e VALOR_MINIMO, que armazenam as médias máxima e mínima obtidas no código anterior. Além disso, também declaramos a variável CONCENTRACAO_MINIMA, que recebe o valor mínimo de concentração de água no solo desejado, e a princípio mantemos esse valor como 30, pois ele tende a ser um valor bom para maioria das plantas, mas altere-o de acordo com o que é ideal para a sua planta e para o seu ambiente.

//Inclusao das bibliotecas
#include <Wire.h> 
#include <LiquidCrystal_I2C.h>

//Criacao do objeto "lcd" com o endereco I2C, e o numero de linhas e colunas
LiquidCrystal_I2C lcd(0x27, 16, 2);

//Declaracao do pino conectado ao sensor
const int PINO_SENSOR = A0;

//Declaracao da variavel que armazena as leituras do sensor
int leitura_sensor = 0;

//Declaracao das variaveis que armazenam os valores de calibracao
const int VALOR_MAXIMO = 634; //Valor com solo seco
const int VALOR_MINIMO = 314; //Valor com solo umido
//Altere o valor das variaveis acima de acordo com as medias obtidas atraves do codigo do projeto anterior

//Declaracao da variavel que armazena a concentracao minima desejada
const int CONCENTRACAO_MINIMA = 30;
//Altere a variavel acima com o valor ideal para a sua planta

xxxxxxxxxx
 
//Inclusao das bibliotecas
#include <Wire.h> 
#include <LiquidCrystal_I2C.h>
​
//Criacao do objeto "lcd" com o endereco I2C, e o numero de linhas e colunas
LiquidCrystal_I2C lcd(0x27, 16, 2);
​
//Declaracao do pino conectado ao sensor
const int PINO_SENSOR = A0;
​
//Declaracao da variavel que armazena as leituras do sensor
int leitura_sensor = 0;
​
//Declaracao das variaveis que armazenam os valores de calibracao
const int VALOR_MAXIMO = 634; //Valor com solo seco
const int VALOR_MINIMO = 314; //Valor com solo umido
//Altere o valor das variaveis acima de acordo com as medias obtidas atraves do codigo do projeto anterior
​
//Declaracao da variavel que armazena a concentracao minima desejada
const int CONCENTRACAO_MINIMA = 30;
//Altere a variavel acima com o valor ideal para a sua planta

Na rotina de configurações do código, iniciamos o display LCD através do comando lcd.begin(), e então exibimos o cabeçalho do código nele. Em seguida, apenas configuramos o pino conectado ao sensor como uma entrada do sistema, graças ao comando pinMode(PINO_SENSOR, INPUT).

//Inicia o display LCD com o backlight aceso, e exibindo o nome do projeto
lcd.begin();
lcd.backlight();
lcd.print("Monitoramento de");
lcd.setCursor(0,1);
lcd.print("Umidade de Solo.");
delay(5000);
lcd.clear();

//Define o pino conectado ao sensor como uma entrada do sistema
pinMode(PINO_SENSOR, INPUT);

xxxxxxxxxx
 
//Inicia o display LCD com o backlight aceso, e exibindo o nome do projeto
lcd.begin();
lcd.backlight();
lcd.print("Monitoramento de");
lcd.setCursor(0,1);
lcd.print("Umidade de Solo.");
delay(5000);
lcd.clear();
​
//Define o pino conectado ao sensor como uma entrada do sistema
pinMode(PINO_SENSOR, INPUT);

A repetição do código consiste na atribuição da leitura analógica do pino conectado ao sensor à variável leitura_sensor utilizando o comando leitura_sensor = analogRead(PINO_SENSOR), e então mapeamos essa leitura entre 0 e 100 % usando o comando leitura_sensor = map(leitura_sensor, VALOR_MINIMO, VALOR_MAXIMO, 100, 0), de acordo com os valores configurados nas variáveis VALOR_MINIMO e VALOR_MAXIMO. Feito isso, exibimos o valor no display LCD, e então o verificamos através da condição if(leitura_sensor < CONCENTRACAO_MINIMA) se a leitura mapeada do sensor está abaixo do valor configurado na variável CONCENTRACAO_MINIMA. Se essa condição for verdadeira, nós enviamos um alerta no display LCD e piscamos o seu backlight para chamar atenção. Porém, se a condição for falsa, apenas aguardamos 5 segundos para executar a repetição novamente. Por fim, limpamos o display LCD através da função lcd.clear().

//Realiza a leitura do sensor, a mapeia entre 0 e 100 % e exibe o valor no LCD
leitura_sensor = analogRead(PINO_SENSOR);
leitura_sensor = map(leitura_sensor, VALOR_MINIMO, VALOR_MAXIMO, 100, 0);
lcd.print("Umidade =  ");
lcd.print(leitura_sensor);
lcd.print(" %");

//Verifica se a leitura esta abaixo da concetracao minima desejada
if(leitura_sensor < 30){ //Se sim, informamos pelo LCD que precisa irrigar
  lcd.setCursor(0,1);
  lcd.print("Precisa Irrigar!");
  lcd.noBacklight();
  delay(500);
  lcd.backlight();
  delay(500);
} else { //Caso contrario, apenas esperamos 5 segundos para a proxima leitura
  delay(5000);
}

lcd.clear(); //Limpa o LCD para atualizacao

xxxxxxxxxx
 
//Realiza a leitura do sensor, a mapeia entre 0 e 100 % e exibe o valor no LCD
leitura_sensor = analogRead(PINO_SENSOR);
leitura_sensor = map(leitura_sensor, VALOR_MINIMO, VALOR_MAXIMO, 100, 0);
lcd.print("Umidade =  ");
lcd.print(leitura_sensor);
lcd.print(" %");
​
//Verifica se a leitura esta abaixo da concetracao minima desejada
if(leitura_sensor < 30){ //Se sim, informamos pelo LCD que precisa irrigar
  lcd.setCursor(0,1);
  lcd.print("Precisa Irrigar!");
  lcd.noBacklight();
  delay(500);
  lcd.backlight();
  delay(500);
} else { //Caso contrario, apenas esperamos 5 segundos para a proxima leitura
  delay(5000);
}
​
lcd.clear(); //Limpa o LCD para atualizacao

O Que Deve Acontecer

Após carregar o código para a placa, insira o sensor no solo e aproveite o monitoramento. Quando o solo secar, o display ficará piscando e informando que é necessário irrigar a planta, como no GIF a seguir.

Resultado Final

No GIF acima utilizamos um copo d'água e aceleramos um pouco as leituras do sensor para facilitar a demonstração do comportamento do projeto, porém, em solo, esse aviso só deve ser apresentado após alguns dias depois da primeira irrigação.

Indo Além

Projetos mais sofisticados de controle de umidade de solo utilizam uma bomba peristáltica para irrigar o solo automaticamente quando ele estiver seco. Em nosso tutorial de projeto irrigador automático, ensinamos como criar um controle simples de umidade de solo, para não precisarmos nem regar as plantas, apenas abastecer o tanque de armazenamento.

Conclusão

Neste tutorial aprendemos como utilizar o sensor de solo capacitivo e como calibrá-lo de acordo com as leituras em solo seco e úmido para criar uma lógica de controle. Além disso, pudemos observar na prática o conceito sobre sensores capacitivos de solo e como sua tensão varia de acordo com a concentração de água.

Comentários

Para fazer comentários é necessário estar logado. Efetuar login.

Você ainda nao é cadastrado? Cadastre-se agora!

rudolfoprada
date

Enviado 2024-07-11 21:13:12

Olá. Tento fazer a leitura nos sensores (5 sensores) e eles sempre dão o mesmo resultado, independente do sensor ou se ele está na água. Inclusive tentei com outros arduino (Nano ou uno e esp32) e o resultado é sempre o mesmo pra qualquer sensor ou umidade (tensão perto de 0.85)

carlos.oliveira
date

Enviado 2024-07-12 08:03:27
rudolfoprada

Olá! Verifique se o circuito montado está conforme mostrado no tutorial. Se estiver correto e o problema persistir, peço que envie um e-mail para suporte@robocore.net juntamente com uma foto do circuito e um vídeo onde exibe as leituras do sensor. Desta forma, podemos compreender melhor o problema e lhe auxiliar da melhor forma possível. Vale dizer que o sensor não é diretamente compatível com placas ESP32, já que opera em 5 V enquanto as placas ESP32 operam em 3,3 V.

delton1

Enviado 2024-08-11 21:07:16
rudolfoprada

Tb tive problemas do tipo, será que é problema em algum lote desse sensor? pq aqui só notei oscilação ao apertar o sensor com os dedos ou pressionar a terra contra o sensor, acho que até danifiquei minha minha placa ao testar a conexão dos cabos.

carlos.oliveira
date

Enviado 2024-08-12 09:03:17
rudolfoprada

Olá! Recebemos o seu e-mail e daremos continuidade ao atendimento através daquele canal de comunicação.

diogofonrag
date

Enviado 2024-08-17 12:38:35
rudolfoprada

Olá, bom dia estou com o mesmo problema.

rudolfoprada
date

Enviado 2024-08-18 16:33:26
rudolfoprada

Foi pedido para mandar 5 sensores (valor menor de $50,00) para "testes", mas já sei a resposta. Não vou perder o meu tempo (e nem o valor do envio), obviamente já "fucei" eles (inclusive fiz 2 deles funcionarem, pois achei o problema que era na fabricação) e sei que vão alegar "mal uso". Acabei pedindo mais 2 e adivinha?? Sim, os 2 não funcionaram. Fui em outra loja (física em minha cidade) e acabei pegando com eles e esses funcionaram.
Não vou pedir reembolso ou troca, mas peço que pelo menos testem os sensores antes de enviar aos cliente.

Francois

Enviado 2024-08-19 19:03:42
rudolfoprada

@diogofonrag, por gentileza envie um e-mail para suporte@robocore.net com algumas fotos dos sensores adquiridos.

@rudolfoprada, sentimos muito pela má experiência que você teve com os sensores. O retorno dos produtos é um procedimento padrão e importante, pois, dependendo do resultado da análise, isso pode impactar em diversos processos internos. De toda forma, estamos analisando o estoque atual por possíveis irregularidades para evitar que isso ocorra novamente.

ndemcee
date

Enviado 2024-04-19 18:24:05

Olá, tudo bem? Gostaria de saber se com o sensor capacitivo eu consigo fazer a leitura de outros materiais, como por exemplo, de grãos para controle de armazenagem?

carlos.oliveira
date

Enviado 2024-04-22 09:13:48
ndemcee

Olá! Infelizmente nunca usamos o sensor nessas condições, portanto não temos informações se o mesmo é capaz de realizar a leitura de outros materiais.

ivan.lins
date

Enviado 2023-10-23 02:49:16

Olá, gostaria de um desse mais completo, para 4 ou 5 vasos, e consigo colocar em uma tomada inteligente pra usar no app ?
se tiver como montar um kit assim, vou querer um!
Obrigado desde já.

luan.ferreira
date

Enviado 2023-10-23 08:05:55
ivan.lins

Olá! Agradecemos a sua sugestão! Neste caso, você pode replicar a lógica usada neste tutorial para adicionar mais sensores. Vale dizer que a placa pode ser alimentada com uma fonte de alimentação externa (de 7 a 12V DC).

XandCapcom
date

Enviado 2023-03-11 15:04:54

Olá, parabéns pelo artigo. Saberia me ajudar com um codigo, que por meio desse sensor de umidade, consegue reconhecer que está sendo regada a planta. Algo tipo, calcular que subiu rapido a umidade, para alertar sobre um vazamento, ou sinalizar que a planta está sendo regada. Penso no codigo analizando que subiu de 40% para 50% umidade, dentro de um periodo curto. Obrigado

luan.ferreira
date

Enviado 2023-03-13 08:44:48
XandCapcom

Agradecemos o seu feedback sobre o nosso tutorial! Infelizmente não temos um código e/ou tutorial para o projeto mencionado. No entanto, você pode usar esse tutorial como base para a criação do seu código, inclusive você também pode usar como referência o tutorial “Irrigador Automático com Arduino” ( https://www.robocore.net/tutoriais/irrigador-automatico-arduino ).

lucas.pacheco1
date

Enviado 2023-03-01 18:37:16

ola poderia me dizer como solucionar esse problema .
C:\Users\pcser\OneDrive\Documentos\Arduino\BotTelegramEspelho_V1_temperatura_OK (1)\BotTelegramEspelho_V1_temperatura_OK (1).ino:20:10: fatal error: LiquidCrystal_I2C.h: No such file or directory
 #include <LiquidCrystal_I2C.h>
          ^~~~~~~~~~~~~~~~~~~~~
compilation terminated.

exit status 1

Compilation error: LiquidCrystal_I2C.h: No such file or directory

luan.ferreira
date

Enviado 2023-03-02 11:45:22
lucas.pacheco1

Esse erro está relacionado a falta da biblioteca LiquidCrystal_I2C.h, que é necessária para o funcionamento do código. Para baixar e instalar essa biblioteca, você pode seguir o tutorial "Módulo I2C - Primeiros Passos" ( https://www.robocore.net/tutoriais/primeiros-passos-com-modulo-i2c ).

acag

Enviado 2023-02-14 22:34:37

Olá. Vocês vendem os kits para Portugal? 
E é possível ter mangueiras mais compridas e terminais de fios mais compridos.
Obrigado

luan.ferreira
date

Enviado 2023-02-15 13:04:32
acag

Olá! Nós fazemos envios para todo o mundo, inclusive temos uma parceria com a FedEx, e por isso temos ótimas taxas de envio. Em relação a mangueira, o tamanho que acompanha o Kit Irrigador Automático ( https://www.robocore.net/kits/kit-irrigador-automatico ) é fixo ( 1 metro ), porém é possível adquirir mais unidades dessa mangueira ( https://www.robocore.net/item-mecanico/mangueira-de-silicone-1-metro ) separadamente, e interligá-las para ter o tamanho desejado.

dunirvana
date

Enviado 2023-01-07 12:17:15

Bom dia! Quantos sensores consigo conectar em uma mesma placa? Pergunto pois gostaria de realizar essa verificação em mais de um vazo.

luan.ferreira
date

Enviado 2023-01-09 09:01:12
dunirvana

Neste caso, a quantidade de sensores que podem ser conectados, irá depender da quantidade de portas analógicas disponíveis na placa que será utilizada. No caso da placa utilizada neste tutorial (e placas similares a ela), é possível conectar até 5 sensores nas portas disponíveis nas barras de pinos (sem o uso do LCD nas portas A4 e A5), pois essa é a quantidade de portas analógicas disponíveis neste modelo de placa Uno.

dunirvana

Enviado 2023-01-09 11:11:04
dunirvana

Bom dia luan.ferreira! Muito obrigado pela resposta, como não pretendo usar o LCD então eu teria a minha disposição cinco sensores, perfeito, agora caso eu opte por usar o "IoT DevKit - LoRaWAN" (link https://www.robocore.net/lorawan/iot-devkit-lorawan) eu conseguiria realizar esse mesmo trabalho (leitura da umidade do solo)? Só para ficar claro, minha intenção é, no lugar de mostrar no display as informações disparar mensagens na rede.

luan.ferreira
date

Enviado 2023-01-09 13:20:22
dunirvana

Infelizmente o módulo em questão não é diretamente compatível com o DevKit, pois a placa de controle do DevKit é um ESP32, que trabalha com uma tensão de 3V3, enquanto o sensor opera em 5V. Sendo assim, se deseja usar esse sensor com o DevKit, será necessário a utilização de um circuito para converter a tensão analógica para os limites do ESP32 (0 a 3,3 V), já que o sensor varia de 0 a 5 V. Infelizmente não temos nenhum circuito e/ou conversor para recomendar para essa aplicação. 

De toda forma, vale dizer que o DevKit tem apenas duas portas analógicas (VN e VP).

dunirvana

Enviado 2023-01-09 15:54:33
dunirvana

Boa tarde luan.ferreira! Mais uma vez obrigado pela resposta, entendido sobre as diferenças entre as placas, você saberia me indicar um kit ou mesmo "n" componentes que me permitisse criar o que desejo, medir a umidade de até cinco sensores e realizar comunicação via rede?

luan.ferreira
date

Enviado 2023-01-10 12:29:02
dunirvana

Como o sensor opera em 5V, e para facilitar a conexão dele com a placa, recomendamos que seja usada uma placa diretamente compatível, como a BlackBoard UNO ( https://www.robocore.net/placa-robocore/arduino-blackboard ), a BlackBoard Mega ( https://www.robocore.net/placa-arduino/blackboard-mega ) e similares.

luan.ferreira
date

Enviado 2023-01-10 12:30:30
dunirvana

Se optar por usar um desses modelos, você pode usar uma placa externa, como um ESP8266 (no caso de WiFi) ( https://www.robocore.net/wifi/modulo-wifi-esp8266 ), um "Shield Ethernet W5500" ( https://www.robocore.net/shields-arduino/arduino-shield-ethernet-w5500 ) ou um "Shield LoRaWAN Helix Antenna" ( https://www.robocore.net/shields-arduino/shield-para-arduino-lorawan-helix-antenna) (para o uso da comunicação LoRaWAN) para fazer o envio de dados para a rede da sua preferência.

dunirvana

Enviado 2023-01-10 15:16:48
dunirvana

Boa tarde luan.ferreira! Cara muito obrigado pela ajuda novamente, acredito que agora sou capaz de começar com essas informações.

luan.ferreira
date

Enviado 2023-01-10 15:46:01
dunirvana

Disponha. Qualquer dúvida ou problema, entre em contato.

kurten
date

Enviado 2021-03-08 15:26:37

troqui todos os fios novamente e funcionou !
OBRIGADO PELA PRONTA RESPOSTAS

kurten
date

Enviado 2021-03-06 18:53:16

ja montei 2 vezes com pecas iguais mas pecas novas e nao funciona ! nao aparece nada no display, embora ele ligue

Giovanni5

Enviado 2021-03-08 08:35:45
kurten

Talvez o display esteja sem ajuste de seu contraste, portanto tente girar o eixo do trimpot do módulo I2C, e veja se a mensagem passa a ser exibida. Caso o ajuste de contraste não solucione o problema, verifique a conexão dos pinos SDA e SCL do módulo no circuito, pois eles podem estar invertidos. Além disso, verifique a seleção do endereço I2C no "DIP Switch" do módulo (https://www.robocore.net/tutoriais/primeiros-passos-com-modulo-i2c), se você adquiriu o módulo recentemente, o endereço I2C será diferente do configurado no código (0x20).

kurten

Enviado 2021-03-08 14:46:14
kurten

ja fiz isso tudo e nao funciona......a tela do display ate acende, mas nao tem nada escrito a nao ser um monte de retangolos na primeira linha ....ja chequei os fios, inverti para ver se funcionava e nada....teria mais alguma coisa que eu possa fazer ? pois quero esse circuito para uso pessoal numa planta onde realmente a agua é fundamental.....

Leitura da Umidade do Solo

Introdução

Lista de Materiais

Lista completa de produtos

BlackBoard UNO R3

Sensor de Umidade de Solo Capacitivo

LCD 16x2 Com Interface I2C

Mini Protoboard 170 Pontos - Preta

Jumpers Macho-Macho x40 Unidades

Jumpers Macho-Fêmea x40 Unidades

Sensor Capacitivo Vs. Resistivo

Primeiras Leituras do Sensor

Circuito

Código

Entendendo o Código

O Que Deve Acontecer

Projeto Monitoramento de Umidade

Circuito

Código

Entendendo o Código

O Que Deve Acontecer

Indo Além

Conclusão