Caso práctico: Monitor de humedad del suelo con ESP32

Objetivo y caso de uso

Qué construirás: Un monitor continuo de hidratación de plantas que mide la humedad del suelo utilizando un sensor capacitivo analógico, activando alertas visuales y sonoras locales cuando se requiere riego.

Por qué es importante / Casos de uso

Prototipado agrícola: Sirve como un nodo fundamental de recolección de datos para sistemas automatizados de riego en invernaderos, asegurando que las plantas reciban agua basándose en métricas objetivas en lugar de horarios.
Longevidad del hardware: Demuestra la ventaja práctica de la detección capacitiva sobre los sensores resistivos tradicionales, eliminando la rápida corrosión galvánica y la contaminación del suelo.
Prevención del estrés de las plantas: Reemplaza las conjeturas con mediciones dieléctricas del suelo empíricas y en tiempo real para prevenir tanto el exceso de riego (pudrición de la raíz) como la falta de agua.
Procesamiento de señales: Proporciona una aplicación tangible para mapear valores brutos y no lineales del convertidor analógico a digital (ADC) de 12-bit en métricas de humedad intuitivas del 0–100%.

Resultado esperado

Salida serie continua en tiempo real que muestra tanto los valores brutos del ADC de 12-bit (0–4095) como los porcentajes de humedad calculados (0–100%) a una tasa de sondeo de ~1Hz.
Alerta visual inmediata (iluminación del LED de estado) y señales sonoras activadas en milisegundos cuando el nivel de humedad cae por debajo del umbral definido.

Audiencia: Aficionados al IoT y desarrolladores de sistemas embebidos; Nivel: Principiante a Intermedio

Arquitectura/flujo: Sensor de humedad capacitivo del suelo → ADC del microcontrolador (lectura analógica de 12-bit) → Mapeo del porcentaje de humedad → Salida GPIO (LED/Zumbador) & Monitor Serie

Nota educativa de validación

Antes de publicar este caso, el contenido pasó la puerta automática de validación de Prometeo con estado PASS. Para este perfil ESP32 DevKitC, el proyecto se comprobó como proyecto PlatformIO: el validador extrajo platformio.ini y src/main.cpp, creó un proyecto temporal y ejecutó pio run contra platform = espressif32, board = esp32dev y framework = arduino. También revisó la estructura del artículo, que los comandos sean copiables con guiones ASCII, y que no aparezcan stacks no soportados como ESP-IDF directo o placas ESP32 no acotadas.

Evidencia de validación publicada

Resultado automático: PASS.
Estructura parseada: 3 apartados, 2 tablas y 2 bloques de código detectados antes de publicar.
Código comprobado: 1 PlatformIO config + 1 ESP32 source/pio run.
Catálogo soportado: el texto se contrastó contra los perfiles de dispositivo validables de Prometeo y los stacks no soportados bloquean la publicación.
Hallazgos del informe: sin hallazgos bloqueantes.

Esta validación confirma compatibilidad sintáctica y de herramientas para el código publicado, pero no sustituye la prueba física sobre tu placa ESP32 DevKitC exacta, tu cableado, alimentación y entorno WiFi local.

Nota educativa de seguridad

Este proyecto es un prototipo educativo, no un producto certificado. Antes de encender el montaje, verifique la distribución de pines de su revisión exacta de la placa ULX3S, mantenga las señales de E/S de la FPGA a 3.3 V, nunca conecte 5 V directamente a los pines de E/S, desconecte la alimentación antes de cambiar el cableado y use fuentes externas adecuadas para cargas, motores o servos, compartiendo la tierra solo cuando el cableado lo requiera.

Diagrama de bloques conceptual

Vista de alto nivel: qué entra, qué procesa cada bloque y qué sale del sistema.

Arquitectura funcional

Botones ULX3S

Sincronizador/antirrebote

Selector de modo

Generador periodo 20 ms

Comparador ancho de pulso

Salida PWM 50 Hz

Servo SG90

Flujo conceptual de control: entrada de botones, selección de modo, temporización PWM y movimiento del servo.

Ruta de validación

Verilog fuente

Verilator lint/testbench

Yosys síntesis

nextpnr-ecp5

ecppack bitstream

ULX3S programada

La validación automática comprueba sintaxis, simulación/lint y compatibilidad con la toolchain ULX3S/ECP5.

Requisitos previos

Para completar este tutorial con éxito, los estudiantes deben tener:
* Una comprensión básica de la diferencia entre señales analógicas (niveles de voltaje continuos) y señales digitales (estados binarios HIGH/LOW).
* PlatformIO IDE instalado (preferiblemente como extensión de Visual Studio Code) o el PlatformIO Core CLI.
* Familiaridad con técnicas básicas de protoboard, incluyendo el enrutamiento de rieles de alimentación y el uso de resistencias limitadoras de corriente para LEDs.
* Conocimientos básicos de programación en C/C++ (variables, lógica condicional if/else y funciones).

Materiales

Debe usar la siguiente configuración de hardware exacta para asegurarse de que el código y la distribución de pines proporcionados funcionen sin modificaciones:

ESP32 DevKitC + sensor de humedad del suelo capacitivo v1.2 + LED de estado + zumbador piezoeléctrico
1x resistencia de 330Ω (Código de colores: Naranja-Naranja-Marrón, utilizada para el LED de estado para prevenir sobrecorriente).
1x Protoboard estándar (se recomiendan 830 puntos de conexión).
Cables puente Dupont variados (Macho-Macho y Macho-Hembra dependiendo del conector específico de su sensor).
1x cable Micro-USB o USB-C (asegúrese de que sea un cable de sincronización de datos, no solo de carga).
Una taza de tierra seca y una taza de agua (para calibración y pruebas).

Configuración/Conexión

La conexión correcta del hardware es fundamental. El ESP32 funciona con niveles lógicos de 3.3V. El sensor de humedad del suelo capacitivo v1.2 incluye un regulador de voltaje integrado, pero la mejor práctica es alimentarlo desde el pin de 3.3V del ESP32 para asegurar que su salida analógica nunca exceda la clasificación de entrada ADC máxima del ESP32 (3.3V). Suministrar 5V al sensor podría dar como resultado señales analógicas que dañen permanentemente los pines GPIO del ESP32.

Usamos el GPIO 34 para la entrada analógica. El ESP32 tiene dos ADC internos. El ADC2 se comparte con la radio Wi-Fi y no se puede usar de manera confiable cuando el Wi-Fi está activo. El ADC1 (que incluye el GPIO 34) funciona de manera independiente del stack Wi-Fi, lo que lo convierte en la opción estándar para lecturas de sensores robustas.

Tabla de cableado

Componente	Pin / Terminal del componente	Pin del ESP32 DevKitC	Notas
Sensor capacitivo	VCC / V+	3V3	Alimentar con 3.3V para proteger el ADC del ESP32.
Sensor capacitivo	GND / G	GND	Referencia de tierra común.
Sensor capacitivo	AOUT / AU	GPIO 34	Conectado a ADC1_CH6.
LED de estado	Ánodo (Pata larga)	GPIO 25	Conectar a través de la resistencia de 330Ω.
LED de estado	Cátodo (Pata corta)	GND	Referencia de tierra común.
Zumbador piezoeléctrico	Positivo (+)	GPIO 26	Controlado a través del PWM por hardware del ESP32 (LEDC).
Zumbador piezoeléctrico	Negativo (-)	GND	Referencia de tierra común.

Nota de hardware: El zumbador piezoeléctrico puede ser activo o pasivo. El código proporcionado utiliza una señal de Modulación por Ancho de Pulso (PWM), que generará un tono específico en un zumbador pasivo, y también activará con éxito un zumbador activo al alternar su alimentación rápidamente.

Código validado

El proyecto utiliza PlatformIO. Deberá configurar su archivo de entorno y el archivo fuente de su aplicación principal.

platformio.ini

Cree o reemplace el contenido de su archivo platformio.ini con la siguiente configuración:

[env:esp32dev]
platform = espressif32
board = esp32dev
framework = arduino
monitor_speed = 115200

src/main.cpp

Copie el siguiente código C++ en su archivo src/main.cpp. Este código implementa la lectura analógica continua, realiza una interpolación lineal para calcular el porcentaje de humedad y maneja la lógica para las alertas de hardware.

Vista pública parcial del archivo validado. El código completo se muestra a miembros y en PDF/Print.

#include <Arduino.h>

// --------------------------------------------------------
// Hardware Pin Definitions
// --------------------------------------------------------
const int MOISTURE_PIN = 34; // ADC1 Channel 6
const int LED_PIN      = 25; // Digital Output for Status LED
const int BUZZER_PIN   = 26; // Digital Output for Piezo Buzzer

// --------------------------------------------------------
// PWM Configuration for Piezo Buzzer
// --------------------------------------------------------
const int PWM_FREQ       = 2000; // 2 kHz audio frequency
const int PWM_CHANNEL    = 0;    // ESP32 Hardware Timer Channel 0
const int PWM_RESOLUTION = 8;    // 8-bit resolution (0-255)

// --------------------------------------------------------
// Calibration Constants
// --------------------------------------------------------
// IMPORTANT: Capacitive sensors output a HIGHER voltage when dry 
// and a LOWER voltage when wet. These values represent the 12-bit 
// ADC readings (0-4095). You must calibrate these for your specific sensor.
const int DRY_VALUE = 3200;  // Expected ADC reading in completely dry air
const int WET_VALUE = 1400;  // Expected ADC reading submerged in water

// --------------------------------------------------------
// Application Logic Constants
// --------------------------------------------------------
const int ALARM_THRESHOLD_PERCENT = 30; // Trigger alert at or below 30% moisture

void setup() {
    // Initialize Serial Communication for debugging
    Serial.begin(115200);

    // Configure Digital Output Pins
    pinMode(LED_PIN, OUTPUT);
    digitalWrite(LED_PIN, LOW); // Ensure LED is off at boot

    // Configure LEDC PWM peripheral for the Buzzer
    // This allows us to generate a clean square wave for a passive piezo
    ledcSetup(PWM_CHANNEL, PWM_FREQ, PWM_RESOLUTION);
    ledcAttachPin(BUZZER_PIN, PWM_CHANNEL);
    ledcWrite(PWM_CHANNEL, 0); // Ensure buzzer is silent at boot

    Serial.println("=========================================");
    Serial.println(" ESP32 Soil Moisture Monitor Initialized ");
    Serial.println("=========================================");

    // Allow hardware to stabilize
    delay(1000); 
}
// ... continúa para miembros en el código completo validado ...


void loop() {
    // 1. Read the raw analog voltage from the sensor
    int rawAdcValue = analogRead(MOISTURE_PIN);

    // 2. Map the raw ADC value to a 0-100 percentage scale.
    // We invert the mapping parameters because DRY is high, WET is low.
    int moisturePercent = map(rawAdcValue, DRY_VALUE, WET_VALUE, 0, 100);

    // 3. Constrain the percentage to strictly 0-100.
    // This prevents negative numbers or values > 100% if the sensor 
    // reads slightly outside the hardcoded calibration range.
    moisturePercent = constrain(moisturePercent, 0, 100);

    // 4. Output telemetry to the Serial Monitor
    Serial.print("Raw ADC: ");
    Serial.print(rawAdcValue);
    Serial.print("\t | Moisture: ");
    Serial.print(moisturePercent);
    Serial.println("%");

    // 5. Evaluate the alert threshold
    if (moisturePercent <= ALARM_THRESHOLD_PERCENT) {
        // Condition: Soil is dangerously dry.
        // Action: Flash the LED and pulse the buzzer.

        digitalWrite(LED_PIN, HIGH);
        // Set PWM duty cycle to 50% (128 out of 255) to generate sound

🔒 Parte del código validado es premium. Con el pase de 7 días o la suscripción mensual podrás consultar el archivo completo validado.

🔓 Ver planes de acceso premium

#include <Arduino.h>

// --------------------------------------------------------
// Hardware Pin Definitions
// --------------------------------------------------------
const int MOISTURE_PIN = 34; // ADC1 Channel 6
const int LED_PIN      = 25; // Digital Output for Status LED
const int BUZZER_PIN   = 26; // Digital Output for Piezo Buzzer

// --------------------------------------------------------
// PWM Configuration for Piezo Buzzer
// --------------------------------------------------------
const int PWM_FREQ       = 2000; // 2 kHz audio frequency
const int PWM_CHANNEL    = 0;    // ESP32 Hardware Timer Channel 0
const int PWM_RESOLUTION = 8;    // 8-bit resolution (0-255)

// --------------------------------------------------------
// Calibration Constants
// --------------------------------------------------------
// IMPORTANT: Capacitive sensors output a HIGHER voltage when dry 
// and a LOWER voltage when wet. These values represent the 12-bit 
// ADC readings (0-4095). You must calibrate these for your specific sensor.
const int DRY_VALUE = 3200;  // Expected ADC reading in completely dry air
const int WET_VALUE = 1400;  // Expected ADC reading submerged in water

// --------------------------------------------------------
// Application Logic Constants
// --------------------------------------------------------
const int ALARM_THRESHOLD_PERCENT = 30; // Trigger alert at or below 30% moisture

void setup() {
    // Initialize Serial Communication for debugging
    Serial.begin(115200);

    // Configure Digital Output Pins
    pinMode(LED_PIN, OUTPUT);
    digitalWrite(LED_PIN, LOW); // Ensure LED is off at boot

    // Configure LEDC PWM peripheral for the Buzzer
    // This allows us to generate a clean square wave for a passive piezo
    ledcSetup(PWM_CHANNEL, PWM_FREQ, PWM_RESOLUTION);
    ledcAttachPin(BUZZER_PIN, PWM_CHANNEL);
    ledcWrite(PWM_CHANNEL, 0); // Ensure buzzer is silent at boot

    Serial.println("=========================================");
    Serial.println(" ESP32 Soil Moisture Monitor Initialized ");
    Serial.println("=========================================");

    // Allow hardware to stabilize
    delay(1000); 
}

void loop() {
    // 1. Read the raw analog voltage from the sensor
    int rawAdcValue = analogRead(MOISTURE_PIN);

    // 2. Map the raw ADC value to a 0-100 percentage scale.
    // We invert the mapping parameters because DRY is high, WET is low.
    int moisturePercent = map(rawAdcValue, DRY_VALUE, WET_VALUE, 0, 100);

    // 3. Constrain the percentage to strictly 0-100.
    // This prevents negative numbers or values > 100% if the sensor 
    // reads slightly outside the hardcoded calibration range.
    moisturePercent = constrain(moisturePercent, 0, 100);

    // 4. Output telemetry to the Serial Monitor
    Serial.print("Raw ADC: ");
    Serial.print(rawAdcValue);
    Serial.print("\t | Moisture: ");
    Serial.print(moisturePercent);
    Serial.println("%");

    // 5. Evaluate the alert threshold
    if (moisturePercent <= ALARM_THRESHOLD_PERCENT) {
        // Condition: Soil is dangerously dry.
        // Action: Flash the LED and pulse the buzzer.

        digitalWrite(LED_PIN, HIGH);
        // Set PWM duty cycle to 50% (128 out of 255) to generate sound
        ledcWrite(PWM_CHANNEL, 128); 
        delay(500); // Wait 500ms

        digitalWrite(LED_PIN, LOW);
        // Set PWM duty cycle to 0% to silence buzzer
        ledcWrite(PWM_CHANNEL, 0);   
        delay(500); // Wait 500ms

    } else {
        // Condition: Soil moisture is adequate.
        // Action: Keep alerts turned off and delay before next reading.

        digitalWrite(LED_PIN, LOW);
        ledcWrite(PWM_CHANNEL, 0);
        delay(1000); // Poll sensor once per second
    }
}

Comandos de compilación/flasheo/ejecución

Para compilar, subir y monitorear el código en su ESP32 DevKitC, use la CLI de PlatformIO. Abra su terminal en el directorio raíz de su proyecto (donde se encuentra platformio.ini) y ejecute los siguientes comandos.

Referencia de comandos

Acción	Comando	Propósito
Compilar	`pio run`	Compila el código fuente en C++ y enlaza el framework de Arduino.
Subir	`pio run --target upload`	Flashea el binario del firmware compilado en el ESP32.
Monitorear	`pio device monitor`	Abre el monitor serie para ver la salida de telemetría.

Flujo de ejecución

Conecte el ESP32 DevKitC a su computadora a través del cable USB. Asegúrese de que los controladores CP210x o CH34x estén instalados si su sistema operativo no reconoce el dispositivo automáticamente.
Ejecute pio run para verificar que no haya errores de sintaxis y que el entorno esté configurado correctamente.
Ejecute pio run --target upload para flashear el dispositivo. Si la terminal muestra «Connecting…» y se detiene, es posible que deba mantener presionado el botón «BOOT» en el ESP32 DevKitC hasta que comience el proceso de flasheo.
Ejecute pio device monitor para observar la salida serie. Debería ver inmediatamente el banner de inicialización seguido de lecturas continuas del ADC.

Caso práctico: Monitor de humedad del suelo con ESP32

Objetivo y caso de uso

Por qué es importante / Casos de uso

Resultado esperado

Nota educativa de validación

Evidencia de validación publicada

Nota educativa de seguridad

Diagrama de bloques conceptual

Arquitectura funcional

Ruta de validación

Requisitos previos

Materiales

Configuración/Conexión

Tabla de cableado

Código validado

platformio.ini

src/main.cpp

Comandos de compilación/flasheo/ejecución

Referencia de comandos

Flujo de ejecución

Validación paso a paso

Quiz rápido

Caso práctico: Monitor de humedad del suelo con ESP32

Objetivo y caso de uso

Por qué es importante / Casos de uso

Resultado esperado

Nota educativa de validación

Evidencia de validación publicada

Nota educativa de seguridad

Diagrama de bloques conceptual

Arquitectura funcional

Ruta de validación

Requisitos previos

Materiales

Configuración/Conexión

Tabla de cableado

Código validado

platformio.ini

src/main.cpp

Comandos de compilación/flasheo/ejecución

Referencia de comandos

Flujo de ejecución

Validación paso a paso

Quiz rápido

Entradas relacionadas