Calibración de Sensores de Humedad del Suelo para ESP32: Protocolo de Ingeniería Brutal

Determinación del Rango de Operación del Sensor y Limitaciones del ADC del ESP32

La fiabilidad de un sistema de riego automatizado basado en ESP32 reside directamente en la precisión de sus datos de humedad del suelo. Un sensor no calibrado puede generar errores de hasta el 40%, resultando en riego excesivo o insuficiente, comprometiendo la viabilidad del cultivo. La lectura directa del conversor analógico-digital (ADC) de un sensor de humedad (e.g., FC-28 o YL-69 resistivo, o módulos capacitivos) es un valor relativo y sin unidades, altamente dependiente del tipo de sensor, el voltaje de alimentación y las características específicas del ESP32.

Especificaciones Críticas del ADC del ESP32

El ESP32 integra dos ADC SAR (Successive Approximation Register) de 12 bits, con un rango de lectura de 0 a 4095. Sin embargo, su linealidad es variable, especialmente en los extremos del rango, y la tensión de entrada máxima sin atenuación es de 1.1V. Para leer voltajes superiores (hasta 3.3V o más), es indispensable configurar la atenuación del ADC. Ignorar este paso lleva a lecturas truncadas o saturadas. Los pines ADC específicos (GPIO 32-39) son más estables; se recomienda evitar los pines ADC 0, 2, 4, 12, 13, 14, 15 por su posible uso por el Wi-Fi o como salida de arranque.

Para la mayoría de los sensores de humedad del suelo alimentados a 3.3V o 5V (con divisor de voltaje para 3.3V de salida), la atenuación de 11dB es la configuración más adecuada, permitiendo un rango de entrada de hasta ~3.3V y mapeando la señal de salida del sensor a la resolución completa de 0-4095 del ADC. Esto es crítico para evitar la saturación si el sensor devuelve un valor cercano a VCC.

Comparativa de Sensores de Humedad: Capacitivos vs. Resistivos

La elección del sensor impacta directamente en la durabilidad y la consistencia de las lecturas, lo que a su vez afecta la estrategia de calibración y el TCO (Total Cost of Ownership).

Conclusión preliminar: Para aplicaciones de monitoreo a largo plazo y datos fiables, los sensores capacitivos son superiores, justificando su mayor costo inicial mediante una menor necesidad de reemplazo y mayor estabilidad de lectura en el tiempo. Son la elección recomendada para entornos agrícolas o de jardinería profesional.

⚠️ ADVERTENCIA TÉCNICA: Los sensores resistivos degradan rápidamente en entornos húmedos debido a la electrólisis y corrosión de los electrodos. Su uso sin un sistema de encendido/apagado intermitente resultará en fallas prematuras y lecturas erráticas en semanas, no meses. La conductividad del agua afecta directamente su lectura.

Protocolo de Calibración Multi-Punto para Máxima Precisión

La calibración es el proceso de mapear las lecturas crudas del ADC a valores significativos, típicamente un porcentaje de humedad relativa o un valor gravimétrico. Un protocolo de dos puntos (seco/húmedo) es el mínimo indispensable, pero la calibración multi-punto ofrece una linealización más precisa en el rango operativo real del suelo, compensando la no-linealidad inherente de muchos sensores y del propio ADC del ESP32.

Procedimiento de Calibración 'Dry' (Aire)

La lectura en aire (o suelo absolutamente seco) establece el punto de máxima resistencia/mínima capacitancia, que corresponde al valor más alto de ADC (suelo seco -> menor conductividad/capacitancia -> mayor voltaje de salida en la mayoría de los diseños de sensores). Este es el minMoisture o dryValue. Idealmente, se debe usar suelo horneado a 105°C hasta peso constante para un 'dry' absoluto.

Pasos:

1. Asegure el sensor completamente limpio y seco al aire, sin contacto con ninguna superficie conductora o humedad residual. Evite tocar las puntas del sensor.
2. Alimente el ESP32 y el sensor. Realice un mínimo de 100 lecturas con un intervalo de 100ms.
3. Calcule el promedio de estas lecturas para obtener el dryValue.

cpp #include <analogRead_ESP32.h>

const int SENSOR_PIN = 34; // Pin ADC_CHANNEL_6 (GPIO34) para ESP32, es solo de entrada. const int NUM_READINGS = 100;

void setup() { Serial.begin(115200); analogReadResolution(12); analogSetAttenuation(ADC_11db); // Rango completo de 0-3.9V para la mayoría de los sensores de 3.3V // analogSetPinAttenuation(SENSOR_PIN, ADC_11db); // Especifica la atenuación para el pin si es necesario delay(2000); Serial.println("Preparado para calibración en aire (DRY). Mantenga el sensor seco."); }

void loop() { static long drySum = 0; static int count = 0;

if (count < NUM_READINGS) { int sensorValue = analogRead(SENSOR_PIN); drySum += sensorValue; Serial.print("Lectura DRY: "); Serial.println(sensorValue); count++; delay(100); } else if (count == NUM_READINGS) { int dryValue = drySum / NUM_READINGS; Serial.print("\n--- VALOR DRY CALIBRADO: "); Serial.print(dryValue); Serial.println(" ---"); Serial.println("Proceda a calibración en agua (WET). Reinicie el ESP32 con el sensor en agua."); count++; // Evita recalcular } delay(1000); }

Procedimiento de Calibración 'Wet' (Agua)

La lectura en agua (submersión total) establece el punto de mínima resistencia/máxima capacitancia, que corresponde al valor más bajo de ADC (suelo saturado -> mayor conductividad/capacitancia -> menor voltaje de salida). Este es el maxMoisture o wetValue.

Pasos:

1. Sumerja el sensor completamente en agua destilada o del grifo limpia. Evite agua salada o altamente mineralizada, ya que podría alterar la conductividad y, por ende, las lecturas.
2. Realice un mínimo de 100 lecturas con un intervalo de 100ms.
3. Calcule el promedio de estas lecturas para obtener el wetValue.

cpp // Reemplazar la sección loop() del código anterior después de obtener dryValue. // Reiniciar ESP32 o cargar nuevo código con el sensor sumergido.

void loop() { static long wetSum = 0; static int count = 0;

if (count < NUM_READINGS) { int sensorValue = analogRead(SENSOR_PIN); wetSum += sensorValue; Serial.print("Lectura WET: "); Serial.println(sensorValue); count++; delay(100); } else if (count == NUM_READINGS) { int wetValue = wetSum / NUM_READINGS; Serial.print("\n--- VALOR WET CALIBRADO: "); Serial.print(wetValue); Serial.println(" ---"); Serial.println("Calibración básica completada. Utilice estos valores en su código."); count++; // Evita recalcular } delay(1000); }

⚠️ ADVERTENCIA TÉCNICA: Asegúrese de que dryValue > wetValue. Si wetValue es mayor que dryValue, la lógica de su sensor o su diseño de circuito es inversa (mayor humedad = mayor ADC), o hay un error de conexión. Adapte la función de mapeo en consecuencia.

Creación de Curvas de Calibración Avanzadas (Multi-Punto)

Para entornos que requieren mayor precisión, especialmente en tipos de suelo heterogéneos, el método de dos puntos es insuficiente. La calibración multi-punto implica el uso de muestras de suelo con porcentajes de humedad conocidos (p. ej., 0%, 25%, 50%, 75%, 100% de humedad gravimétrica). Esto puede lograrse pesando suelo seco, añadiendo una cantidad específica de agua y calculando el porcentaje gravimétrico. Con múltiples puntos, se puede aplicar interpolación lineal por segmentos o un ajuste polinomial (usando herramientas como NumPy en Python, Octave o Gnuplot) para crear una función de mapeo más precisa f(raw_adc) -> humedad_porcentaje.

Ejemplo de mapeo lineal (simplificado):

cpp float mapSensorToPercent(int rawValue, int dryValue, int wetValue) { // Asegurarse que el rango wetValue a dryValue es válido if (dryValue == wetValue) return 0.0; // Evitar división por cero

// Mapea el valor crudo entre wetValue (100%) y dryValue (0%). // Se asume que un valor de ADC más alto es más seco y un valor más bajo es más húmedo. float percent = (float)(rawValue - wetValue) / (dryValue - wetValue) * 100.0; return constrain(100.0 - percent, 0.0, 100.0); // Invierte para que 0% sea seco y 100% sea mojado }

Implementación de Lectura y Calibración Continua en ESP32

Una vez obtenidos dryValue y wetValue, el firmware del ESP32 debe aplicar esta calibración para proporcionar datos significativos. Es esencial realizar múltiples lecturas y promediarlas para mitigar el ruido del ADC y las variaciones ambientales, que pueden ser significativas en entornos externos.

cpp // Valores obtenidos de la calibración real para su sensor específico. const int CAL_DRY_VALUE = 3950; // Ejemplo: lectura en aire const int CAL_WET_VALUE = 1750; // Ejemplo: lectura en agua const int SENSOR_PIN = 34; // Asegúrese de usar un pin ADC adecuado y estable.

void setup() { Serial.begin(115200); analogReadResolution(12); analogSetAttenuation(ADC_11db); }

void loop() { // Realizar múltiples lecturas para promediar y reducir ruido long sumOfReadings = 0; for (int i = 0; i < 20; i++) { // Aumentar número de muestras para mayor estabilidad sumOfReadings += analogRead(SENSOR_PIN); delay(5); // Pequeño retardo entre lecturas para permitir estabilización del ADC } int rawMoisture = sumOfReadings / 20;

// Mapear el valor crudo a un porcentaje de humedad float moisturePercent = mapSensorToPercent(rawMoisture, CAL_DRY_VALUE, CAL_WET_VALUE);

Serial.print("Lectura Raw ADC: "); Serial.print(rawMoisture); Serial.print(" | Humedad (%): "); Serial.print(moisturePercent, 1); // 1 decimal de precisión Serial.println("%");

delay(10000); // Leer cada 10 segundos }

// Función de mapeo definida anteriormente (copiar aquí si está en un solo archivo) float mapSensorToPercent(int rawValue, int dryValue, int wetValue) { if (dryValue == wetValue) return 0.0; float percent = (float)(rawValue - wetValue) / (dryValue - wetValue) * 100.0; return constrain(100.0 - percent, 0.0, 100.0); }

💡 INGENIERO TIP: Para optimizar la duración de la batería y la vida útil del sensor (especialmente resistivos), encienda el sensor solo antes de la lectura, espere unos milisegundos para la estabilización y luego apáguelo. Esto reduce drásticamente el consumo de energía y la corrosión. Utilice un divisor de voltaje si la salida del sensor es >3.3V o un chip lógico de 5V.

Gestión de Energía y Durabilidad del Sensor en Implementaciones con ESP32

Para sistemas alimentados por batería (relevante para el silo smartfrugal y solarstack), el consumo de energía del sensor es un factor crítico. Los sensores de humedad consumen energía constantemente si están conectados a VCC y GND de forma permanente. La solución es integrar un MOSFET de canal N o un transistor BJT para controlar el VCC del sensor, permitiendo que el ESP32 lo encienda y apague bajo demanda. Un MOSFET como el 2N7000 o IRLZ44N es ideal para este propósito, activado por un GPIO del ESP32.

Ciclo de Trabajo para Ahorro Energético

cpp const int SENSOR_POWER_PIN = 14; // Pin GPIO (ej. GPIO14) para controlar el VCC del sensor const int SENSOR_DATA_PIN = 34; // Pin ADC para la lectura (ej. GPIO34) const int CAL_DRY_VALUE = 3950; const int CAL_WET_VALUE = 1750;

void setup() { Serial.begin(115200); pinMode(SENSOR_POWER_PIN, OUTPUT); digitalWrite(SENSOR_POWER_PIN, LOW); // Asegurarse de que el sensor está apagado inicialmente analogReadResolution(12); analogSetAttenuation(ADC_11db); }

void loop() { // Encender el sensor a través del MOSFET digitalWrite(SENSOR_POWER_PIN, HIGH); delay(100); // Esperar que el sensor se estabilice (ajustar según el sensor)

long sumOfReadings = 0; for (int i = 0; i < 20; i++) { sumOfReadings += analogRead(SENSOR_DATA_PIN); delay(5); // Pequeño retardo entre lecturas } int rawMoisture = sumOfReadings / 20;

// Apagar el sensor digitalWrite(SENSOR_POWER_PIN, LOW);

float moisturePercent = mapSensorToPercent(rawMoisture, CAL_DRY_VALUE, CAL_WET_VALUE);

Serial.print("Lectura Raw ADC (Pulsed): "); Serial.print(rawMoisture); Serial.print(" | Humedad (%): "); Serial.print(moisturePercent, 1); Serial.println("%");

delay(300000); // Leer cada 5 minutos (para aplicaciones de bajo consumo en campo) }

// Función de mapeo definida anteriormente (copiar aquí si está en un solo archivo) float mapSensorToPercent(int rawValue, int dryValue, int wetValue) { if (dryValue == wetValue) return 0.0; float percent = (float)(rawValue - wetValue) / (dryValue - wetValue) * 100.0; return constrain(100.0 - percent, 0.0, 100.0); }

Este enfoque no solo preserva la batería en deployments remotos, sino que también extiende significativamente la vida útil de los sensores capacitivos y, crucialmente, de los resistivos, al minimizar el tiempo de exposición a corrientes eléctricas en el suelo. Para solarstack, esto se traduce en menores requisitos para el panel solar y la batería.

VERDICTO DEL LABORATORIO

La implementación de monitoreo de humedad del suelo con ESP32 sin una calibración robusta es una negligencia ingenieril que conduce a datos erróneos y decisiones de riego ineficientes. El protocolo de calibración multi-punto es esencial para la precisión, y la configuración correcta del ADC del ESP32 (especialmente la atenuación de 11dB en los pines adecuados) es mandatoria para obtener el rango completo de la señal. La superioridad de los sensores capacitivos en durabilidad y estabilidad justifica plenamente su inversión inicial para sistemas a largo plazo. Además, la gestión energética mediante el control de encendido/apagado del sensor no es una opción, sino una característica crítica para la longevidad del hardware y la eficiencia de la batería en cualquier despliegue real, especialmente en entornos de exterior y alimentados de forma autónoma. Se recomienda encarecidamente la implementación de un circuito de conmutación de energía para todos los sensores de humedad en sistemas autónomos, sin excepción, para maximizar la vida útil del sensor y la autonomía del sistema.

RECURSOS RELACIONADOS

• Eficiencia Energética en IoT (smartfrugal): "Optimización de Consumo en Nodos ESP32 para Despliegues de Bajo Presupuesto"
• Sistemas de Alimentación Autónoma (solarstack): "Diseño y Gestión de Fuentes de Alimentación Solar para Sensores Remotos"
• Automatización de Cultivos (kitchenbot): "Control de Nutrientes y Riego Automatizado en Sistemas Hidropónicos de Interior con ESP32"