A gestão eficiente da água é uma preocupação crescente em Portugal, especialmente com as alterações climáticas a intensificarem os períodos de seca. Para os entusiastas da jardinagem, horticultores amadores e até pequenos agricultores, otimizar a rega não só contribui para a sustentabilidade ambiental, como também promove a saúde das plantas e poupa recursos. A automação surge aqui como uma aliada poderosa, e a combinação do popular microcontrolador ESP32 com o acessível sensor de humidade do solo YL-69 oferece uma solução eficaz e de baixo custo para criar sistemas de rega inteligentes.

O Que é o Sensor de Humidade do Solo YL-69 (ou HL-69)?

O YL-69 (por vezes comercializado como HL-69) é um dos sensores de humidade do solo mais comuns e económicos no mercado de eletrónica DIY. É um sensor do tipo resistivo, o que significa que mede a humidade através da variação da resistência elétrica entre duas sondas inseridas no solo.

Componentes do Sensor YL-69:

Sonda (Probe): Consiste em duas hastes metálicas (geralmente niqueladas ou estanhadas) que são inseridas diretamente no solo. Quanto mais húmido o solo, menor a resistência elétrica entre as hastes, pois a água atua como condutor.
Módulo Eletrónico (LM393): A sonda liga-se a um pequeno módulo que contém um comparador de tensão LM393. Este módulo possui:Saída Analógica (A0): Fornece um valor de tensão proporcional à condutividade (e, por conseguinte, à humidade) do solo. Esta é a saída mais utilizada para obter uma leitura gradual da humidade.
Saída Digital (D0): Fornece um sinal HIGH ou LOW com base num limiar de humidade ajustável através de um potenciómetro (trimmer) presente no módulo. Quando a humidade ultrapassa o limiar definido, a saída D0 muda de estado.
Pinos de Alimentação (VCC e GND): Para fornecer energia ao módulo (tipicamente 3.3V ou 5V).
LEDs Indicadores: Geralmente um LED de alimentação e um LED que acende quando a saída digital é ativada.
Princípio de Funcionamento: Quando uma corrente elétrica passa entre as duas hastes da sonda através do solo, a resistência encontrada depende da quantidade de água presente.

Solo Seco: Alta resistência elétrica, resultando numa tensão mais alta na saída analógica (A0).
Solo Húmido: Baixa resistência elétrica (devido aos iões na água), resultando numa tensão mais baixa na saída analógica (A0).

Vantagens do YL-69:

Baixo Custo: É extremamente acessível, ideal para projetos com orçamento limitado.
Simplicidade de Uso: Fácil de ligar e obter leituras básicas.
Disponibilidade: Amplamente disponível em lojas de eletrónica online e físicas em Portugal.

Desvantagens do YL-69:

Corrosão: Sendo um sensor resistivo, as sondas estão sujeitas a corrosão eletrolítica ao longo do tempo, especialmente se estiverem constantemente alimentadas e em contacto com solo húmido e fertilizantes. Isto afeta a precisão e a vida útil do sensor.
Precisão Limitada: A leitura pode ser influenciada pela compactação do solo, salinidade e temperatura.
Necessidade de Calibração: É crucial calibrar o sensor para o tipo específico de solo e para as condições da sua planta, pois os valores brutos variam consideravelmente.

O ESP32: O Cérebro Perfeito para a Automação da Rega

O ESP32, desenvolvido pela Espressif Systems, é um microcontrolador poderoso e versátil que se tornou um favorito na comunidade maker. As suas características tornam-no ideal para sistemas de rega automáticos:

Conectividade Wi-Fi e Bluetooth: Permite ligar o sistema à internet para monitorização remota, controlo via app, integração com serviços de meteorologia, ou notificações.
Processador Dual-Core: Oferece capacidade de processamento suficiente para tarefas complexas.
Múltiplos Pinos ADC (Analog-to-Digital Converter): Essencial para ler a saída analógica do sensor YL-69.
Pinos GPIO (General Purpose Input/Output): Para controlar relés (que acionam bombas de água ou eletroválvulas), ler outros sensores, ou interagir com botões e LEDs.
Baixo Consumo de Energia (com modos de deep sleep): Importante para sistemas alimentados por bateria.
Programável com Arduino IDE: Facilita o desenvolvimento para quem já está familiarizado com o ecossistema Arduino.
Comunidade Ativa e Vasta Documentação: Suporte abundante online.
Custo Acessível: Embora mais caro que um Arduino Uno, o seu conjunto de funcionalidades justifica o preço.
Componentes Necessários para o Seu Sistema de Rega Automático com YL-69 e ESP32

Para construir o sistema básico, precisará dos seguintes componentes, facilmente encontráveis em Portugal:

Placa de Desenvolvimento ESP32: Existem várias versões (ESP32-WROOM-32, ESP32-DevKitC, etc.). Qualquer uma serve.
Sensor de Humidade do Solo YL-69: Com sonda e módulo.
Módulo Relé (1 Canal): Para controlar a bomba de água ou eletroválvula. Certifique-se que o relé suporta a tensão e corrente da sua bomba/eletroválvula. Um relé de 5V com controlo lógico de 3.3V (compatível com ESP32) é ideal.
Bomba de Água Submersível Pequena (DC): Se for regar vasos ou pequenos canteiros. Tipicamente 5V, 6V ou 12V. Ou uma Eletroválvula: Se for controlar um sistema de rega maior ligado à rede de água.
Fonte de Alimentação:Para o ESP32: Um carregador de telemóvel USB (5V) ou uma fonte de 3.3V/5V.
Para a Bomba/Eletroválvula: Uma fonte de alimentação separada com a tensão e corrente adequadas (e.g., 12V para uma bomba de 12V). Não alimente a bomba diretamente do ESP32.
Fios de Ligação (Jumpers): Macho-macho, macho-fêmea.
Mangueira Fina: Para a bomba de água.
Opcional (para melhorias):Display LCD ou OLED: Para mostrar o nível de humidade e estado do sistema.
Botões: Para controlo manual ou configuração.
Caixa para o Projeto: Para proteger os componentes.
Resistências (Pull-up/Pull-down, se necessário).
Ligação dos Componentes: YL-69, Relé e ESP32

Atenção: Desligue sempre a alimentação antes de fazer ou alterar ligações.

1. Ligar o Sensor YL-69 ao ESP32:

VCC (YL-69) -> 3V3 (ESP32) ou VIN (ESP32) se o módulo YL-69 suportar 5V e o ESP32 estiver a ser alimentado por USB. Recomenda-se 3.3V para maior consistência com os níveis lógicos do ESP32.
GND (YL-69) -> GND (ESP32)
A0 (YL-69 Saída Analógica) -> Um pino ADC do ESP32 (e.g., GPIO34, GPIO35, GPIO32, etc. Verifique o pinout da sua placa ESP32, pois alguns ADCs são dedicados ao Wi-Fi). Vamos usar o GPIO34 como exemplo.
D0 (YL-69 Saída Digital) -> (Opcional) Um pino digital do ESP32 (e.g., GPIO25). Usaremos principalmente a saída analógica para maior granularidade.

2. Ligar o Módulo Relé ao ESP32 e à Bomba/Eletroválvula:

O módulo relé tem geralmente três pinos de controlo (VCC, GND, IN) e três terminais de comutação (COM, NO - Normally Open, NC - Normally Closed).

VCC (Relé) -> VIN (ESP32) (se o relé for de 5V e o ESP32 alimentado por USB) ou a uma fonte de 5V externa. Alguns relés funcionam com 3.3V no VCC.
GND (Relé) -> GND (ESP32)
IN (Relé Sinal) -> Um pino digital do ESP32 (e.g., GPIO26).
Ligação da Bomba/Eletroválvula (Carga) ao Relé: A bomba/eletroválvula será alimentada por uma fonte externa. O relé atua como um interruptor.

Terminal COM (Relé) -> Um dos fios da bomba/eletroválvula.
Terminal NO (Relé) -> O polo positivo (+) da fonte de alimentação externa da bomba/eletroválvula.
O outro fio da bomba/eletroválvula -> O polo negativo (-) da fonte de alimentação externa da bomba/eletroválvula.

Esquema Simplificado:

ESP32 YL-69
3V3 ----------------------- VCC
GND ----------------------- GND
GPIO34 (ADC1_CH6) --------- A0

ESP32 Módulo Relé
VIN (ou 5V externo) ------- VCC
GND ----------------------- GND
GPIO26 -------------------- IN

Módulo Relé Bomba/Eletroválvula & Fonte Externa
COM ----------------------- Fio 1 da Bomba
NO ----------------------- (+) da Fonte Externa da Bomba
Fio 2 da Bomba -> (-) da Fonte Externa da Bomba

Programação do ESP32 com Arduino IDE

Certifique-se que tem o Arduino IDE instalado e configurado para o ESP32. (Ferramentas -> Placa -> Gestor de Placas -> procurar "esp32" e instalar).

Código Base (Exemplo):

C++ 
// Definição dos Pinos
const int pinoSensorHumidadeA0 = 34; // Pino ADC para a saída analógica do YL-69
const int pinoRele = 26; // Pino digital para controlar o relé

// Limiares de Humidade (Estes valores precisam de ser CALIBRADOS!)
// Valores mais baixos do ADC geralmente indicam mais humidade.
// Valores mais altos do ADC geralmente indicam solo seco.
// A escala do ADC do ESP32 é de 0-4095 para 0-3.3V (por defeito).
int limiarSoloSeco = 3000; // Exemplo: Acima deste valor, o solo está muito seco
int limiarSoloHumido = 1500; // Exemplo: Abaixo deste valor, o solo está suficientemente húmido

// Variáveis de controlo
unsigned long tempoUltimaRega = 0;
const unsigned long intervaloMinimoEntreRegas = 30 * 60 * 1000; // Ex: 30 minutos em milissegundos
const unsigned long duracaoRega = 10 * 1000; // Ex: 10 segundos em milissegundos
bool aRegar = false;
unsigned long inicioRegaAtual = 0;

void setup() {
Serial.begin(115200);
pinMode(pinoRele, OUTPUT);
digitalWrite(pinoRele, LOW); // Garantir que o relé começa desligado (LOW pode ligar alguns relés, HIGH para outros. Teste!)
// Para muitos módulos relé, LOW ativa o relé. Se for o caso, comece com HIGH.

Serial.println("Sistema de Rega Automático Iniciado");
Serial.println("Calibre os limiares de humidade para o seu solo!");
}

void loop() {
// Ler o valor do sensor de humidade
// Para mitigar a corrosão, idealmente ligaria o VCC do sensor apenas durante a leitura.
// Isto requer um pino digital extra para controlar a alimentação do sensor YL-69.
// Para este exemplo simples, assumimos que está sempre ligado.
int valorHumidadeADC = analogRead(pinoSensorHumidadeA0);
Serial.print("Valor ADC Humidade: ");
Serial.println(valorHumidadeADC);

// Lógica de Rega
if (aRegar) {
// Se estiver a regar, verificar se o tempo de rega terminou
if (millis() - inicioRegaAtual >= duracaoRega) {
pararRega();
tempoUltimaRega = millis(); // Registar quando a rega terminou
}
} else {
// Se não estiver a regar, verificar se é necessário regar
if (valorHumidadeADC > limiarSoloSeco) {
// Solo está seco, verificar se já passou tempo suficiente desde a última rega
if (millis() - tempoUltimaRega >= intervaloMinimoEntreRegas) {
iniciarRega();
} else {
Serial.println("Solo seco, mas a aguardar intervalo mínimo entre regas.");
}
} else if (valorHumidadeADC < limiarSoloHumido) {
Serial.println("Solo suficientemente húmido.");
// Poderia adicionar lógica para parar uma rega em curso se atingir este nível,
// mas com `duracaoRega` curta, pode não ser necessário.
} else {
Serial.println("Humidade do solo em nível aceitável.");
}
}

delay(2000); // Esperar 2 segundos entre leituras (ajuste conforme necessário)
}

void iniciarRega() {
Serial.println("A iniciar rega...");
digitalWrite(pinoRele, HIGH); // Ou LOW, dependendo da lógica do seu relé
aRegar = true;
inicioRegaAtual = millis();
}

void pararRega() {
Serial.println("A parar rega.");
digitalWrite(pinoRele, LOW); // Ou HIGH, dependendo da lógica do seu relé
aRegar = false;
}

Explicação do Código:

pinoSensorHumidadeA0, pinoRele: Definem os pinos do ESP32 utilizados.
limiarSoloSeco, limiarSoloHumido: CRUCIAL! Estes valores determinam quando a rega começa e quando o solo é considerado húmido. Precisam de ser calibrados experimentalmente.
tempoUltimaRega, intervaloMinimoEntreRegas: Evitam regas demasiado frequentes.
duracaoRega: Define por quanto tempo a bomba fica ligada.
setup(): Inicializa a comunicação serial e configura os pinos.
loop():Lê o valor analógico do sensor.
Verifica se está no estado aRegar. Se sim, e se duracaoRega passou, para de regar.
Se não está a regar, verifica se valorHumidadeADC é maior que limiarSoloSeco. Se sim, e se intervaloMinimoEntreRegas passou, inicia a rega.
iniciarRega(), pararRega(): Funções para controlar o relé. Importante: Alguns módulos relé são ativados com um sinal LOW e outros com HIGH. Teste o seu! Se o relé acende quando digitalWrite(pinoRele, LOW) é usado, então o estado "desligado" é HIGH e o "ligado" é LOW. Ajuste o código (digitalWrite) accordingly.

A Calibração do Sensor YL-69: Um Passo Essencial

Os valores lidos pelo YL-69 variam drasticamente com o tipo de solo, compactação, salinidade e até mesmo entre sensores idênticos. Por isso, a calibração é fundamental.

Método de Calibração em Dois Pontos:

Ponto Seco:

Coloque a sonda YL-69 no seu tipo de solo completamente seco (ou o mais seco possível, pode secar uma amostra ao ar).
Carregue um código simples no ESP32 que apenas leia o valor do pinoSensorHumidadeA0 e o imprima no Monitor Serial.
Anote o valor ADC lido. Este será o seu valorADC_SoloSeco_Bruto. Por exemplo, pode ser 3800.

Ponto Saturado:

Retire a sonda, adicione água ao solo até ficar completamente saturado (mas sem estar submerso em água livre, apenas muito húmido). Deixe estabilizar um pouco.
Insira novamente a sonda no solo saturado.
Anote o valor ADC lido. Este será o seu valorADC_SoloHumido_Bruto. Por exemplo, pode ser 1200.
Utilizar os Valores Calibrados: Agora, pode usar estes valores para definir os seus limiarSoloSeco e limiarSoloHumido no código principal.

limiarSoloSeco pode ser um pouco abaixo do seu valorADC_SoloSeco_Bruto (e.g., 3000 se o seco foi 3800).
limiarSoloHumido pode ser um pouco acima do seu valorADC_SoloHumido_Bruto (e.g., 1500 se o saturado foi 1200).
Mapear para Percentagem (Opcional, para melhor visualização): Pode usar a função map() para converter os valores ADC para uma escala de percentagem (0% para seco, 100% para húmido):

C++ 
// Dentro do loop, após ler valorHumidadeADC:
// Lembre-se que valores ADC mais altos = mais seco, valores ADC mais baixos = mais húmido
// Por isso, invertemos os limites no map() para que 0% = seco, 100% = húmido.
long humidadePercentagem = map(valorHumidadeADC, valorADC_SoloSeco_Bruto, valorADC_SoloHumido_Bruto, 0, 100);

// Limitar a percentagem entre 0 e 100
humidadePercentagem = constrain(humidadePercentagem, 0, 100);

Serial.print("Humidade Estimada (%): ");
Serial.println(humidadePercentagem);

Com isto, pode definir os seus limiares em termos de percentagem, o que pode ser mais intuitivo.

Melhorando o Seu Sistema de Rega Automático

O sistema básico é funcional, mas pode ser significativamente melhorado:

Mitigação da Corrosão da Sonda YL-69:

Alimentar a Sonda Apenas Durante a Leitura: Use um pino digital do ESP32 para ligar/desligar o VCC do sensor YL-69 (através de um transistor, se necessário, para não sobrecarregar o pino do ESP32, embora para o YL-69 um pino direto possa ser suficiente). Ligue o VCC, espere alguns milissegundos, faça a leitura, e desligue o VCC. Isto reduz drasticamente o tempo de eletrólise.
Alternativa: Usar sensores de humidade capacitivos. Estes não expõem os elétrodos diretamente ao solo, medindo a variação da capacitância causada pela água. São mais caros, mas muito mais duráveis e menos suscetíveis a variações de salinidade.

Conectividade Wi-Fi (Potencial do ESP32):

Publicar Dados Online: Enviar leituras de humidade para plataformas IoT como ThingSpeak, Blynk, MQTT brokers.
Controlo Remoto: Ativar/desativar a rega através de uma app (Blynk é ótimo para isto) ou interface web.
Alertas e Notificações: Enviar emails ou notificações push quando a humidade estiver criticamente baixa ou a rega for ativada.
Integração com API de Meteorologia: Evitar regar se houver previsão de chuva para as próximas horas (requer acesso à internet e parsing de dados de APIs como OpenWeatherMap).
Múltiplos Sensores: Para jardins maiores com diferentes necessidades hídricas, use vários sensores YL-69 (ou outros) ligados a diferentes pinos ADC do ESP32, controlando relés individuais para cada zona de rega.
Interface de Utilizador Local:

Adicionar um display LCD I2C ou OLED para mostrar o nível de humidade, o estado da rega e outras informações.
Incluir botões para acionar uma rega manual, ajustar limiares ou colocar o sistema em modo de espera.
Alimentação Solar: Para locais remotos, combine o ESP32 com um painel solar, um controlador de carga e uma bateria recarregável. Utilize os modos de deep sleep do ESP32 para conservar energia, acordando apenas periodicamente para fazer leituras e regar se necessário.

Lógica de Rega Mais Inteligente:

Implementar PID controller para uma rega mais precisa (mais avançado).
Considerar a evapotranspiração (ET) para calcular as necessidades de água.
Resolução de Problemas Comuns (Troubleshooting)
Leituras Erráticas ou Sempre no Máximo/Mínimo:Verifique as ligações (VCC, GND, A0).
Certifique-se que o pino ADC correto está a ser usado no código.
A sonda pode estar corroída ou danificada.
O solo pode estar excessivamente seco/húmido, fora da faixa de operação útil do sensor.
Interferência elétrica – tente usar cabos mais curtos ou blindados.
Relé Não Ativa ou Não Desativa:Verifique as ligações do relé (VCC, GND, IN).
Confirme se o relé é compatível com o nível lógico de 3.3V do ESP32.
Teste a lógica do relé: é ativado por HIGH ou LOW? Ajuste digitalWrite() no código.
Verifique se a fonte de alimentação da bomba/eletroválvula está correta e ligada.
O relé pode estar danificado.
Corrosão Rápida da Sonda:Implemente a técnica de alimentar a sonda apenas durante a leitura.
Evite solos excessivamente salinos ou com muitos fertilizantes químicos perto da sonda.
Considere um sensor capacitivo.
ESP32 Reinicia Constantemente:Pode ser um problema de alimentação. Certifique-se que a fonte de alimentação do ESP32 é estável e fornece corrente suficiente.
Evite alimentar componentes de alta corrente (como relés ou bombas) diretamente dos pinos do ESP32.

Vantagens e Aplicações em Portugal

Um sistema de rega automático baseado em ESP32 e YL-69 é particularmente relevante para o contexto português:

Poupança de Água: Numa altura de crescente escassez hídrica, regar apenas quando necessário é crucial.
Jardinagem e Hortas Urbanas: Ideal para varandas, pequenos jardins e hortas em casa, garantindo que as plantas recebem a quantidade certa de água, mesmo durante ausências.
Pequenas Estufas e Viveiros: Permite um controlo mais preciso da humidade do substrato.
Educação e Projetos DIY: Uma excelente forma de aprender sobre eletrónica, programação e automação com aplicações práticas.
Adaptação às Condições Locais: Com a calibração adequada, o sistema pode ser ajustado aos diferentes tipos de solo e microclimas encontrados em Portugal.
Conclusão: A Rega Inteligente ao Seu Alcance
Construir um sistema de rega automático com o sensor de humidade do solo YL-69 e o microcontrolador ESP32 é um projeto gratificante e extremamente útil, especialmente no contexto da gestão de água em Portugal. Embora o sensor YL-69 tenha as suas limitações, principalmente a corrosão, o seu baixo custo e simplicidade tornam-no um excelente ponto de partida. Com a calibração correta e algumas melhorias, como a alimentação intermitente da sonda ou a eventual migração para sensores capacitivos, é possível criar um sistema robusto e eficiente.

O poder do ESP32 abre um leque de possibilidades para expandir o projeto, desde a simples automação local até sistemas complexos controlados pela internet e integrados com dados meteorológicos. Ao investir tempo neste tipo de projeto, não só estará a otimizar o cuidado das suas plantas e a poupar água, mas também a adquirir competências valiosas no crescente campo da automação e da Internet das Coisas (IoT).

Experimente, adapte o código às suas necessidades, e desfrute dos benefícios de uma rega mais inteligente e sustentável no seu jardim ou horta em Portugal! Partilhe as suas experiências e modificações nos comentários.