Diversos sistemas de agricultura necessitam de sensores para medir a umidade do solo. Nesse artigo, apresentaremos como criar um sistema de alarme de baixa umidade com Arduino e o sensor capacitivo de umidade. A seguir, apresentamos o circuito do projeto na Figura 1.
Por meio desse projeto, apresentaremos várias etapas que te permitirão aprender a utilizar o sensor de umidade capacitivo.
Portanto, por meio desse sistema, apresentaremos como realizar a configuração, calibração e monitoramento da umidade em tempo real.
A seguir, apresentaremos passo a passo como desenvolver este projeto.
Desenvolvimento do Alarme com Sensor de Umidade Capacitivo e Arduino
No sistema a seguir, apresentamos a estrutura do circuito na Figura 2.
Portanto, por meio do sistema apresentado na Figura 2, o usuário será avisado quando ocorrer alterações no valor de umidade. Desse modo, o usuário será alertado e deverá irrigar a planta para manter o solo em níveis adequados de umidade.
Na Figura 2, o LED será acionado quando ocorrer alterações na umidade. De forma ilustrativa, estamos utilizando um sensor de umidade resistivo.
A seguir, disponibilizamos toda a lista de componentes eletrônicos utilizados nesse projeto.
Lista de Componentes do Projeto
- Arduino Nano
- Sensor de Umidade Capacitivo
- Display LCD 16×2 c/ Backlight Azul
- Trimpot 5kR
- Resistor 10kR
- Botão de Toque 6 x 6 x 6 mm
- Kit de Jumpers Rígidos para Protoboard
Por fim, você pode adquirir todos os produtos em nossa loja Autocore Robótica e montar o seu projeto.
Lógica de Desenvolvimento do Projeto do Sensor de Umidade Capacitivo com Arduino
A princípio, apresentamos a estrutura completa do código e, a seguir, iniciaremos a discussão da lógica para o projeto.
<code>#include <LiquidCrystal.h> #include <EEPROM.h> #define sensor A0 #define botaoOK 11 #define BotaoInc 12 #define BotaoDec 9 bool LCDControl = 0, BaixaUmid = 0, AltaUmid = 0, ConfirmaAnterior = 0, Incremento = 0, IncrementoAnterior = 0; bool Decremento = 0, DecrementoAnterior = 0; byte UmidadePercent = 0, umidade = 0, ValorAnterior = 0, VerifCalib = 0, UmidadeAjuste = 0; byte MaxCalib = 0; signed char AlarmeUmidade = 0; int ValUmidade = 0, ValorAnalog = 0, UmidadeMap = 0; long int UmidadeCalib = 0, tempo_atual = 0, ultimo_tempo = 0, ultimo_tempo2 = 0; #define VALORCALIB 130 #define SINALCALIB 131 #define UMIDADEAJUSTADA 132 const int rs = 2, en = 3, d4 = 4, d5 = 5, d6 = 6, d7 = 7; LiquidCrystal lcd(rs, en, d4, d5, d6, d7); void CalibraSensor(); void UmidadeAlarme(); void setup() { Serial.begin(9600); lcd.begin(16,2); pinMode(sensor, INPUT); pinMode(13, OUTPUT); lcd.clear(); ValorAnterior = analogRead(sensor); VerifCalib = EEPROM.read(SINALCALIB); UmidadeAjuste = EEPROM.read(UMIDADEAJUSTADA); if(VerifCalib != 73) { CalibraSensor(); lcd.clear(); UmidadeAlarme(); EEPROM.write(SINALCALIB, 73); } MaxCalib = EEPROM.read(VALORCALIB); } bool control = 0; void loop() { tempo_atual = millis(); //Le o valor do pino A0 do sensor ValorAnalog = analogRead(sensor); byte AjustAnalog = map(ValorAnalog, 0, 1023, 0, 255); if(AjustAnalog >= MaxCalib) { AjustAnalog = MaxCalib; } UmidadePercent = map(AjustAnalog, 0, MaxCalib, 0, 100); delay(2000); lcd.clear(); lcd.setCursor(3,0); lcd.print("Umidade:"); lcd.setCursor(12,0); lcd.print(UmidadePercent); lcd.print("%"); if(UmidadePercent >= UmidadeAjuste) { digitalWrite(13, HIGH); lcd.setCursor(1,1); lcd.print("Baixa Umidade"); } if(UmidadePercent < UmidadeAjuste) { digitalWrite(13, LOW); lcd.setCursor(2,1); lcd.print("Alta Umidade"); } byte Parametrizar = digitalRead(BotaoDec); if(Parametrizar == 0) { ultimo_tempo = tempo_atual; } if(Parametrizar == 1 && (tempo_atual - ultimo_tempo > 4000)) { for(byte endereco = 130; endereco < 133; endereco++) { EEPROM.write(endereco, 0); } CalibraSensor(); EEPROM.write(SINALCALIB, 73); UmidadeAlarme(); UmidadeAjuste = EEPROM.read(UMIDADEAJUSTADA); MaxCalib = EEPROM.read(VALORCALIB); } byte ConfigUmidade = digitalRead(BotaoInc); if(ConfigUmidade == 0) { ultimo_tempo2 = tempo_atual; } if(ConfigUmidade == 1 && (tempo_atual - ultimo_tempo2 > 3000)) { UmidadeAlarme(); UmidadeAjuste = EEPROM.read(UMIDADEAJUSTADA); } } void CalibraSensor() { bool confirma = 0; byte cont = 0; lcd.clear(); lcd.setCursor(0,0); lcd.print("Insira o sensor"); lcd.setCursor(0,1); lcd.print("e confirme:"); do { confirma = digitalRead(botaoOK); }while(confirma == 0); do { long int ValAnalog = analogRead(A0); byte AjustAnalog = map(ValAnalog, 0, 1023, 0, 255); UmidadeCalib = AjustAnalog + UmidadeCalib; cont++; }while(cont < 10); lcd.clear(); lcd.setCursor(5,0); lcd.print("Fim da"); lcd.setCursor(3,1); lcd.print("Calibracao"); delay(15000); lcd.clear(); byte ValorCalibrado = UmidadeCalib/10; EEPROM.write(VALORCALIB, ValorCalibrado); } void UmidadeAlarme() { bool BotaoEnter = 0; byte ajuste = 0; byte ValorAnt = 0; lcd.clear(); lcd.setCursor(0,0); lcd.print("Ajustar Umidade:"); lcd.setCursor(7,1); lcd.print(ajuste); do { Incremento = digitalRead(BotaoInc); Decremento = digitalRead(BotaoDec); if(Incremento == 1 && IncrementoAnterior == 0) { AlarmeUmidade++; IncrementoAnterior = 1; } if(Incremento == 0 && IncrementoAnterior == 1) { IncrementoAnterior = 0; } if(Decremento == 1 && DecrementoAnterior == 0) { AlarmeUmidade--; DecrementoAnterior = 1; } if(Decremento == 0 && DecrementoAnterior == 1) { DecrementoAnterior = 0; } if(AlarmeUmidade > 100) { AlarmeUmidade = 100; } if(AlarmeUmidade < 0) { AlarmeUmidade = 0; } delay(100); if(AlarmeUmidade != ValorAnt) { lcd.clear(); lcd.setCursor(0,0); lcd.print("Ajustar Umidade:"); lcd.setCursor(7,1); lcd.print(AlarmeUmidade); ValorAnt = AlarmeUmidade; } BotaoEnter = digitalRead(botaoOK); }while(BotaoEnter != 1); EEPROM.write(UMIDADEAJUSTADA, AlarmeUmidade); return; }</code>
Inicialmente, uma função foi criada para forçar o usuário configurar os parâmetros na inicialização. Portanto, o dispositivo será ligado e o usuário deverá configurá-lo durante a primeira vez que for iniciado. É sempre importante realizar a limpeza(zerar) de toda a memória EEPROM, antes de gravar o código no sistema.
Dessa maneira, o sistema verificará se o valor da posição SINALCALIB na EEPROM é diferente de 73. Caso o valor seja diferente, o sistema chamará as funções CalibraSensor e UmidadeAlarme.
Em resumo, o valor 73 é utilizado para sinalizar que o sistema já foi calibrado. Portanto, como o valor será 0 na primeira execução, o sistema chamará as duas funções.
Desse modo, o sistema irá calibrar o sensor e, em seguida, configurar o nível para alarme de baixa umidade, conforme apresentado na condição abaixo.
Após a calibração e configuração da umidade, o sistema escreverá o valor 73 na posição SINALCALIB, para sinalizar que o sistema está com o sensor calibrado.
<code>if(VerifCalib != 73) { CalibraSensor(); lcd.clear(); UmidadeAlarme(); EEPROM.write(SINALCALIB, 73); }</code>
A seguir, serão apresentados os códigos implementados nas funções de CalibraSensor e UmidadeAlarme.
Funções CalibraSensor e UmidadeAlarme
A fim de criar um sistema de medição de umidade capaz de se ajustar às necessidades do usuário, foram desenvolvidas duas funções.
Primeiramente, vamos apresentar a implementação da função CalibraSensor.
Implementação da Função CalibraSensor
Por meio desta função, o usuário deverá espetar o sensor na terra seca e realizar o processo de calibração.
Em seguida, o usuário deverá confirmar e o sistema iniciará a calibração. Após isto, uma mensagem será apresentada, a fim de indicar a ocorrência do processo, conforme apresentada na Figura 3.
A seguir, o sistema irá realizar 10 medidas do sensor. Em seguida, calculará a média e utilizará este valor a fim de calibrar o sensor, conforme apresentado na porção de código abaixo.
<code> do { long int ValAnalog = analogRead(A0); byte AjustAnalog = map(ValAnalog, 0, 1023, 0, 255); UmidadeCalib = AjustAnalog + UmidadeCalib; cont++; }while(cont < 10);</code>
Por fim, apresentará a mensagem Fim de Calibração e salvará o valor calibrado na memória EEPROM do Arduino. A porção de código é apresentada abaixo.
<code>lcd.clear(); lcd.setCursor(5,0); lcd.print("Fim da"); lcd.setCursor(3,1); lcd.print("Calibracao"); delay(15000); lcd.clear(); byte ValorCalibrado = UmidadeCalib/10; EEPROM.write(VALORCALIB, ValorCalibrado);</code>
Finalmente, será chamada a função UmidadeAlarme, a fim de permitir ajustar o valor de umidade para alertar o usuário.
Implementação da Função UmidadeAlarme
Conforme apresentado, o sistema necessita ser parametrizado, para acionar o alerta, quando o valor de umidade ultrapassar um certo limite. Portanto, o usuário deve ajustar esse parâmetro por meio da função UmidadeAlarme.
A seguir, é apresentada a tela de ajuste de umidade na Figura 4. Desse modo, o usuário pode ajustar um valor entre 0% e 100%.
Esse processo é realizado através do código a seguir.
<code>void UmidadeAlarme() { bool BotaoEnter = 0; byte ajuste = 0; byte ValorAnt = 0; lcd.clear(); lcd.setCursor(0,0); lcd.print("Ajustar Umidade:"); lcd.setCursor(7,1); lcd.print(ajuste); do { Incremento = digitalRead(BotaoInc); Decremento = digitalRead(BotaoDec); if(Incremento == 1 && IncrementoAnterior == 0) { AlarmeUmidade++; IncrementoAnterior = 1; } if(Incremento == 0 && IncrementoAnterior == 1) { IncrementoAnterior = 0; } if(Decremento == 1 && DecrementoAnterior == 0) { AlarmeUmidade--; DecrementoAnterior = 1; } if(Decremento == 0 && DecrementoAnterior == 1) { DecrementoAnterior = 0; } if(AlarmeUmidade > 100) { AlarmeUmidade = 100; } if(AlarmeUmidade < 0) { AlarmeUmidade = 0; } delay(100); if(AlarmeUmidade != ValorAnt) { lcd.clear(); lcd.setCursor(0,0); lcd.print("Ajustar Umidade:"); lcd.setCursor(7,1); lcd.print(AlarmeUmidade); ValorAnt = AlarmeUmidade; } BotaoEnter = digitalRead(botaoOK); }while(BotaoEnter != 1); EEPROM.write(UMIDADEAJUSTADA, AlarmeUmidade); return; }</code>
Dessa forma, o usuário deverá utilizar os botões incremento e decremento, para configurar o valor da umidade no laço do while.
Além disso, o sistema atualizará a tela, apenas quando o valor da contagem é diferente do valor anterior, para evitar efeito indesejado na tela a cada ciclo de loop. Isto é apresentado na porção de código a seguir.
<code> if(AlarmeUmidade != ValorAnt) { lcd.clear(); lcd.setCursor(0,0); lcd.print("Ajustar Umidade:"); lcd.setCursor(7,1); lcd.print(AlarmeUmidade); ValorAnt = AlarmeUmidade; }</code>
Por fim, o sistema aguarda o usuário pressionar o botão Ok. Dessa forma, sairá do laço do while e salvará o valor de ajuste na memória EEPROM, conforme apresentado abaixo.
<code>EEPROM.write(UMIDADEAJUSTADA, AlarmeUmidade);</code>
Finalmente, após realizar a calibração e ajuste da umidade para o alarme, o sistema entrará na função loop.
Implementação da Lógica Principal – Função Loop
Primeiramente, o sistema captura o valor de tempo da função millis e salva na variável tempo_atual. Posteriormente, esse valor de tempo será usado para criar outras funções com os botões de incremento e decremento.
<code>tempo_atual = millis();</code>
Após isto, é realizada a leitura do sensor analógico e o valor é mapeado na escala de 0 a 255. Esse processo foi realizado, já que os valores de calibração foram ajustados para 8 bits, pois as posições da memória são de 8 bits.
Por fim, verifica-se o valor ajustado com o valor calibrado no sistema. Se o valor lido e ajustado for maior, atribui-se o próprio valor máximo à variável, conforme apresentado abaixo.
<code>//Le o valor do pino A0 do sensor ValorAnalog = analogRead(sensor); byte AjustAnalog = map(ValorAnalog, 0, 1023, 0, 255); if(AjustAnalog >= MaxCalib) { AjustAnalog = MaxCalib; }</code>
Esse processo força ao sistema apresentar o resultado de solo 100% seco, caso o valor de leitura seja maior que o de calibração.
Em seguida, o valor da umidade será apresentado na tela. Além disso, o sistema informará se a umidade está alta ou baixa, conforme apresentado na Figura 5.
Esse processo é representado pela porção de código a seguir.
<code> lcd.clear(); lcd.setCursor(3,0); lcd.print("Umidade:"); lcd.setCursor(12,0); lcd.print(UmidadePercent); lcd.print("%"); if(UmidadePercent >= UmidadeAjuste) { digitalWrite(13, HIGH); lcd.setCursor(1,1); lcd.print("Baixa Umidade"); } if(UmidadePercent < UmidadeAjuste) { digitalWrite(13, LOW); lcd.setCursor(2,1); lcd.print("Alta Umidade"); }</code>
Caso o valor de umidade seja baixo, ou seja, o valor se aproximar de 100% (terra seca), o sistema irá apresentar a mensagem Baixa Umidade e ligar um LED. Na Figura 6 é apresentado o resultado desse processo.
Além desse processo de apresentar o valor de umidade e seu estado, foram necessárias outras funcionalidades.
Implementação de novas funcionalidades de ajuste em tempo real da umidade e calibração
Entre essas funcionalidades, destacamos duas: reconfigurar a calibração e ajustar um novo nível de alarme de umidade para o sistema.
Essas funcionalidades são importantes, pois o usuário pode necessitar inserir o sensor em uma nova planta e, portanto, todo o sistema necessita de um novo ajuste.
Portanto, para realizar esse processo, utilizamos os próprios botões de incremento e decremento. Para realizar novas funcionalidades, utilizamos a função millis para isso.
Ou seja, ao pressionar o botão de decremento por mais de 4 segundos, o sistema inicia o processo de calibração e ajuste de umidade.
A seguir, apresentamos a porção de código, para realizar esse processo.
<code> bool Parametrizar = digitalRead(BotaoDec); if(Parametrizar == 0) { ultimo_tempo = tempo_atual; } if(Parametrizar == 1 && (tempo_atual - ultimo_tempo > 4000)) { for(byte endereco = 130; endereco < 133; endereco++) { EEPROM.write(endereco, 0); } CalibraSensor(); EEPROM.write(SINALCALIB, 73); UmidadeAlarme(); UmidadeAjuste = EEPROM.read(UMIDADEAJUSTADA); MaxCalib = EEPROM.read(VALORCALIB); }</code>
Primeiramente, é realizada a leitura do estado do botão decremento. Em seguida, verifica-se o teste a fim de determinar o seu estado. Caso seja 0, o valor da variável tempo_atual será atribuída à variável ultimo_tempo, para atualizar o último tempo retornado pela função millis.
Em seguida, temos a condição para verificar se o botão está acionado e se o botão está pressionado por mais de 4 segundos.
Botão com Multifunção para Ajuste e Calibração da Umidade
Portanto, quando o botão está pressionado, o valor da variável tempo_anterior não será mais atualizado. Logo, haverá um instante em que a diferença entre a variável tempo_atual e a variável ultimo_tempo será maior que 4000 ms.
Dessa forma, o sistema entrará na condição e limpará as posições da memória EEPROM. Além disso, chamará as funções CalibraSensor e UmidadeAlarme, a fim de iniciar o processo de calibração do sensor e ajuste de um novo valor de alarme para umidade.
Por fim, há a última condição e similar à anterior. Esta condição é utilizada para verificar se o botão de incremento está acionado por 3 segundos ou mais. Caso seja verdade, a função de ajuste do alarme de umidade será chamada.
Desse modo, ela permitirá ao usuário ajustar um novo nível de alarme durante a execução do código.
Portanto, por meio desse sistema você poderá utilizá-lo em qualquer projeto
Depois disso, o sistema retorna ao início do loop e inicia todo o processo de monitoramento do nível de umidade com o sensor de umidade capacitivo pelo arduino.
Conclusão
Por meio desse sensor, finalmente, é possível aplicá-lo em vários projetos que necessitam utilizar sensor de umidade. Além disso, destacamos o principal benefício desse sensor: sua alta resistência à corrosão.
Isto se deve à camada de proteção, que irá garantir uma vida útil maior ao sensor. Portanto, com um baixo custo do sensor é possível obter uma maior durabilidade do mesmo em processos de medição e monitoramento de umidade.
Portanto, com um baixo custo do sensor é possível obter uma maior durabilidade do mesmo em processos de medição e monitoramento de umidade.