fbpx
22 de maio de 2022

Do bit Ao Byte

Embarcados, Linux e programação

Irrigação com Arduino ou ESP32?

Irrigação com Arduino

Olha essa história sobre irrigação com Arduino, que acabou sendo ESP32.

Havia marcado viagem no final de semana anterior. Sem nenhum tipo de receio, o dia vinha chegando e a tão esperada viagem chegara. Porém, somente no dito dia minha esposa disse:

— E a horta?

De fato eu havia me esquecido que já há mais de um mês venho dedicando tempo a um trabalho manual, totalmente desligado de tecnologia, para distrair a mente. Com isso, obviamente nunca havia pensado em automatizar a irrigação, mas eis que a tecnologia me deu um tapa com luva de pelica. Eu teria que fazer algo, já que não podia contar com um jardineiro.

Projeto de última hora, de fato. Não dava pra planejar nada e então foquei em um único objetivo: Manter a terra molhada o suficiente para que nada morresse. Iniciei então a compra de aspersores de irrigação no Mercado Livre, engates rápidos e mangueira. Comprei material diferente e em maior quantidade, porque aquela era a única chance que eu teria de fazer a irrigação antes de viajar.

Alguns componentes eu já tinha, como microcontrolador, módulo relé e válvula solenoide, para abrir a água. Desconsiderando condições climáticas (sol, chuva, calor, umidade etc), defini duas regas por dia; uma ao amanhecer e uma à noite. Porém, como controlar o tempo? Não queria incluir RTC nem nada que fosse me tomar tempo. Então optei por utilizar um ESP32 (já que fazer a irrigação com Arduino implicaria em mais hardware), um servidor NTP buscando hora na Internet e pronto! Os artigos que escrevo são referências para mim mesmo, quando preciso. Eu já havia escrito um artigo sobre o NTP com ESP32, então copiei o código necessário dele. Usei o GPIO 22 do ESP32 e um módulo relé com lógica invertida, aterrando no GPIO, invés de o GPIO alimentar o relé. Com isso, 3v3 não seria um problema para manter o relé acionado com carga.

Era fim de tarde quando lembrei que teria que fazer o projeto no início da noite, antes de viajar. Estaria escuro e lembrei da iluminação que fiz para o jardim, que ainda estava sendo ligado manualmente todos os dias no início da noite. Bem, não queria que houvesse um indício de que não estaria em casa, por isso resolvi comprar sensores de luminosidade prontos, com acoplamento à prova d’água. Não era hora de provar-se maker, eu precisava de uma solução rápida! Fiz então a instalação elétrica da iluminação do jardim e da luz do corredor, que também costumo ligar à noite para não haver pontos escuros no quintal.

Chegara a noite e outra coisa que eu já tinha instalado era um conjunto de luzes carregadas por energia solar. Os detalhes você vê no vídeo, mas enfim, eu tinha tudo para parecer que estava em casa e após a instalação dos aspersores, pude enfim testar o código básica que salvaria minha pele enquanto eu viajava. Usando VS Code com PlatformIO, escrevi o seguinte código:

#include <Arduino.h>
#include <WiFi.h>

#include "time.h"

const char *ntpServer        = "pool.ntp.org";
const long gmtOffset_sec     = 0;
const int daylightOffset_sec = -3600 * 3;

const char *ssid             = "minha_rede";
const char *passwd           = "minha_senha";


bool already_wet             = false;
void printLocalTime() {
  struct tm timeinfo;
  
  if (!getLocalTime(&timeinfo)) {
     Serial.println("Failed to obtain time");
    return;
  }
  Serial.println(timeinfo.tm_hour);
  if ((timeinfo.tm_hour-3 == 8 || timeinfo.tm_hour-3 == 20) && !already_wet){
          for (uint8_t i=0;i<3;i++){
              digitalWrite(22,LOW);
              vTaskDelay(pdMS_TO_TICKS(30000));
              digitalWrite(22,HIGH);
              vTaskDelay(pdMS_TO_TICKS(30000));
              
          }         
          already_wet = true;
  }
  else if (timeinfo.tm_hour-3 == 9 || timeinfo.tm_hour-3 == 21){
      already_wet = false;
  }
      
}

void setup() {
    Serial.begin(9600);
  configTime(gmtOffset_sec, daylightOffset_sec, ntpServer);
  pinMode(22, OUTPUT);
  digitalWrite(22,HIGH);
  WiFi.begin(ssid, passwd);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
  }
}

void loop() {
    printLocalTime();
    delay(1000);
}

Repare as condicionais subtraindo 3 horas. Eu tinha pressa, não queria saber a razão de +3, sendo que eu já havia tratado o GMT no início do código. Usei a função do artigo supracitado sem alterar nome; não era hora de embelezar código. Por fim, defini uma rega de 3 ciclos de 30 segundos. Era água o suficiente? Bem, “muita água” com certeza não era, pois testei e achei bom. Poderia ser pouca, mas eu não tinha mais um dia para avaliar. Também, 3 ciclos de 30 segundos teve o propósito de não forçar tempo demais a válvula solenoide. Coloquei a rega às 8:00 e às 20:00. No código há um ponto crucial para falha, que é ignorar o fluxo caso não seja possível pegar a hora. O que eu deveria ter feito nesse caso era garantir o reinicio da MCU para reiniciar o fluxo e refazer a conexão, mas nem isso eu queria pensar, confiei na sorte e deu tudo certo.

De volta ao lar, retirei a automação, já que meu propósito com a horta é distrair a mente. Mas mantive a estrutura, agora sendo ligada pelo smartphone de forma manual, simplesmente se conectando ao ESP32, sem botões ou qualquer outra interação. Ao desconectar do modo AP do ESP32, a irrigação pára na hora. Ok, está um pouco tecnológico, mas é como se eu estivesse abrindo a torneira manualmente, não afetará meu propósito inicial. O código para esse segundo estágio ficou assim:

#include <Arduino.h>
#include <WiFi.h>

const char* ssid     = "Garden";
const char* password = "djamessuhanko";

uint8_t water = 0;
bool on       = false;

void setup() {
  Serial.begin(9600);
  pinMode(22, OUTPUT);
  digitalWrite(22,HIGH);
  
  WiFi.softAP(ssid, password);

  IPAddress IP = WiFi.softAPIP();
  Serial.print("AP IP address: ");
  Serial.println(IP);
}

void loop(){
      water = WiFi.softAPgetStationNum();
      if (water == 1 && on == false){
        digitalWrite(22, LOW);
        on = true;
      }
      else if (water == 0){
        on = false;
        digitalWrite(22,HIGH);
      }
      vTaskDelay(pdMS_TO_TICKS(1000));
}

Repare que mais uma vez eu não quis implementar nada de especial. Apenas garanti que quando WiFi.softAPgetStationNum() for igual a 1, alguém está conectado, então inicia a rega.

E aí temos a moral da história:

Você não precisa fazer nada genial para ter prazer em ser maker; basta fazer algo funcional que supra uma necessidade real e a satisfação estará garantida!

Vídeo da irrigação com Arduino ESP32

Enfim, fazer esse projeto de irrigação com Arduino envolve a complexidade da interface, que com ESP32 foi resolvido de forma quase automática. Então, se tem receio de sair do Arduino, não se preocupe, o ESP32 funciona na IDE do Arduino e vai lhe oferecer recursos que no final pouparão seu tempo!

O vídeo com esse projeto de irrigação de última hora deve sair em um ou dois dias; não tenho falhado com os vídeos. Nele, já aproveito pra falar da iluminação e mostrar se vale ou não a pena ter essas lâmpadas LED com baterias carregadas por energia solar ou se são melhores essas lâmpadas padrão de jardim ou outra coisa.

Não é inscrito no canal DobitaobyteBrasil ainda? Ow, please! Inscreva-se!!!