Por qué vale la pena armar este monitor

¿Te pasa que tus plantas se secan en una semana ocupada y recién te das cuenta cuando las hojas ya están caídas? Este proyecto resuelve ese olvido con un sistema simple, barato y autónomo: un sensor capacitivo enterrado en la maceta, un Arduino UNO leyendo el dato analógico y una pantalla OLED que muestra una carita feliz, neutra o triste según el estado del suelo.

Al terminar vas a tener un monitor que cabe en la palma de la mano, funciona con batería y te avisa cuándo regar sin necesidad de wifi ni una app. Toda la lógica vive en menos de 100 líneas de código y los componentes los consigues en cualquier tienda de electrónica en Chile.

Caritas feliz, neutra y triste en la pantalla OLED según humedad del suelo

Cómo funciona el sensor capacitivo

A diferencia de los sensores resistivos viejos (los de dos puntas metálicas que se oxidan en pocas semanas), el sensor capacitivo v1.2 mide la constante dieléctrica del suelo. El agua tiene una dieléctrica de alrededor de 80; el suelo seco, entre 3 y 8. Cuando aumenta la humedad, la capacitancia del circuito interno cambia y el módulo entrega un voltaje analógico proporcional en su pin AOUT.

Esto te da dos ventajas concretas: no hay electrólisis entre las puntas (la sonda dura años en lugar de meses) y la lectura es más estable porque no depende de los iones disueltos en el agua de riego. Esa es la razón por la que recomendamos el capacitivo aunque cueste un poco más que el resistivo clásico de dos puntas.

Materiales

Componentes del proyecto antes de ensamblar

  • Sensor capacitivo de humedad de suelo v1.2 (sonda con salida analógica)
  • Arduino UNO R3 (cualquier clon compatible funciona)
  • Display OLED I2C 0.96" con driver SSD1306 (128×64 px)
  • Cable USB-A a USB-B para programar el Arduino
  • Jumpers macho hembra (mínimo 7 unidades)
  • Batería 9V y soporte para batería 9V (opcionales, para uso portátil)

Nota práctica: una batería 9V dura aproximadamente un día en esta configuración. Para uso permanente, prefiere alimentar el Arduino desde un cargador de pared 9V/12V por el jack DC o directamente desde el puerto USB del computador.

Conexiones (hardware)

Sensor capacitivo, Arduino y OLED ensamblados

Componente Pin del componente Pin Arduino UNO
Sensor capacitivo VCC 5V
Sensor capacitivo GND GND
Sensor capacitivo AOUT A0
OLED SSD1306 VCC 3.3V o 5V (revisa tu módulo)
OLED SSD1306 GND GND
OLED SSD1306 SDA A4
OLED SSD1306 SCL A5

La mayoría de los OLED I2C 0.96" del mercado chileno son tolerantes a 3.3V-5V, pero revisa la serigrafía del módulo antes de alimentarlo. Si el módulo solo soporta 3.3V y lo conectas a 5V, lo quemas.

Calibración: paso obligatorio antes de mostrar datos

Cada tierra es distinta y la resolución del ADC del Arduino UNO es de 10 bits (0 a 1023). Antes de mostrar valores en la pantalla, calibra el sensor con tu sustrato real siguiendo estos pasos:

  1. Sube el sketch al Arduino y abre el Monitor Serial a 115200 baudios.
  2. Anota el valor crudo con la sonda completamente seca, al aire. Ese es tu dryValue (típicamente cerca de 1023).
  3. Sumerge la parte sensible de la sonda en un vaso con agua hasta la línea blanca. Anota ese valor: es tu wetValue (típicamente entre 350 y 450).
  4. Reemplaza ambos números en las constantes del código y vuelve a cargar el sketch.

Lecturas crudas del sensor seco vs sumergido en agua

Código completo

Pega este sketch en el IDE de Arduino. Instala la librería Wire (viene incluida) y la librería OLED del fabricante de tu display. Si tu OLED es un SSD1306 genérico (lo más común en Chile), reemplaza la línea QwiicMicroOLED myOLED; por el equivalente de Adafruit_SSD1306 o U8g2. la lógica de las caras es la misma, solo cambia la API de dibujo de líneas.

C++ 
#include <Wire.h>
#include <SparkFun_Qwiic_OLED.h>
#include <res/qw_fnt_5x7.h>

QwiicMicroOLED myOLED;

#define COMMAND_GET_VALUE   0x05
const uint8_t qwiicAddress = 0x28;
uint16_t ADC_VALUE = 0;


const int dryValue = 1023;
const int wetValue = 400;

void setup() {
    Serial.begin(115200);
    Wire.begin();

    while (myOLED.begin() == false) {
        Serial.println("OLED not connected, check wiring!");
        delay(1000);
    }

    testForConnectivity();
}

void loop() {
    int moistureValue = getMoisture();
    displayMoisture(moistureValue);
    delay(1000);
}

int getMoisture() {
    get_value();
    return map(ADC_VALUE, dryValue, wetValue, 0, 100);
}

void get_value() {
    Wire.beginTransmission(qwiicAddress);
    Wire.write(COMMAND_GET_VALUE);
    Wire.endTransmission();

    Wire.requestFrom((uint8_t)qwiicAddress, (uint8_t)2);

    if (Wire.available() >= 2) {
        uint8_t ADC_VALUE_L = Wire.read();
        uint8_t ADC_VALUE_H = Wire.read();
        ADC_VALUE = (ADC_VALUE_H << 8) | ADC_VALUE_L;
    }
}

void displayMoisture(int moistureValue) {
    myOLED.erase();

    if (moistureValue < 30) {
        // Happy Face when well-watered
        myOLED.line(20, 0, 30, 0);   // Left eye
        myOLED.line(40, 0, 50, 0);   // Right eye

        // Smile: \__/
        myOLED.line(20, 20, 30, 10);   // Left smile
        myOLED.line(30, 10, 40, 10);   // Bottom of smile
        myOLED.line(40, 10, 50, 20);   // Right smile
    } else if (moistureValue >= 50 && moistureValue < 70) {
        // Neutral Face
        myOLED.line(20, 0, 30, 0);   // Left eye
        myOLED.line(40, 0, 50, 0);   // Right eye
        myOLED.line(20, 20, 50, 20);   // Neutral line
    } else {
        // Sad Face when dry
        myOLED.line(20, 0, 30, 0);   // Left eye
        myOLED.line(40, 0, 50, 0);   // Right eye

        // Sad mouth: /--\
        myOLED.line(20, 10, 30, 20);   // Left sad
        myOLED.line(30, 20, 40, 20);   // Bottom of sad
        myOLED.line(40, 20, 50, 10);   // Right sad
    }

    myOLED.display();

    Serial.print("Moisture: ");
    Serial.print(moistureValue);
    Serial.println("%");
}

Los umbrales de las caritas (< 30 feliz, 50-70 neutra, >= 70 triste) están pensados para una planta de bajo mantenimiento estilo árbol de jade o suculenta. Si tu planta es exigente (helechos, albahaca, perejil), baja los umbrales: feliz < 40, neutra 40-55, triste >= 55.

Variantes y mejoras

Tres ideas concretas para llevar el proyecto al siguiente nivel:

  1. Notificación al celular vía ESP32: reemplaza el Arduino UNO por un ESP32 y reenvía las mediciones por MQTT o un webhook de Telegram. Así te avisa cuando la planta entra en zona "triste" sin necesidad de tener la OLED encendida 24/7.
  2. Riego automático: agrega un mini relé de 5V y una bomba sumergible de 3-6V conectada a un balde de agua. Cuando moistureValue >= 70, activa el relé por 3 segundos. Importante: incluye un timeout mínimo entre riegos (por ejemplo, una vez cada 6 horas como máximo) para evitar sobre riego.
  3. Historial con microSD: conecta un módulo lector microSD por SPI y registra millis(),moistureValue en un CSV cada minuto. Después abres el archivo en LibreOffice Calc y graficas la curva de secado de tu maceta, útil para descubrir cuánto demora realmente en secarse cada planta.

Personalización para Chile

El tutorial original usa el ecosistema Qwiic de SparkFun (conectores I2C propietarios). En MechatronicStore encuentras equivalentes funcionales que se conectan con jumpers estándar:

  • Arduino UNO R3. reemplaza al SparkFun RedBoard Qwiic; mismo microcontrolador ATmega328P, mismo IDE de Arduino, el código compila igual.
  • Sensor capacitivo de humedad de suelo v1.2. reemplaza al sensor Qwiic de SparkFun; usa salida analógica directa al pin A0, no requiere librería propietaria.
  • Display OLED I2C 0.96" SSD1306. reemplaza al SparkFun Micro OLED Qwiic; usa los pines SDA/SCL del Arduino (A4/A5).
  • Soporte para batería 9V + batería alcalina 9V. para el modo portátil.

Donde el tutorial original muestra cables Qwiic, en la versión chilena se reemplazan por jumpers macho hembra estándar de 20 cm conectados a los headers del Arduino.

Recursos

Versión chilena con componentes en stock local en MechatronicStore.