Chisme 193 del Lince: sensor humedad Arduino y NodeMCU

En la cueva del Lince de la Noche, en pleno Sierra Bermeja, hay una planta. Una sola. Y está mustia.

—No lo entiendo —dice el Lince, o Víctor Vílchez cuando nadie mira—. La riego cada día. Dos litros. ¡Dos!

La Gata Montesa mira la tierra, mira la planta y mira el charco que hay en el suelo.

—Quizá no tiene sed. Quizá se está ahogando.

El Lince saca su sensor de humedad, lo conecta a la NodeMCU y lee 13 en seco y 613 en agua. Todo perfecto. Al día siguiente lo prueba en el Arduino Mega de clase y lee… 9 y 405.

—¡El sensor está roto! —grita.

—No —suspira la Gata—. El Arduino compara con 5 V y la NodeMCU con 3,3 V. Por eso hay que calibrar.

Introducción: sensor humedad Arduino paso a paso

En este chisme montamos un sensor humedad Arduino que avisa cuando la planta tiene sed. Funciona igual con un Arduino Mega o UNO y con una NodeMCU ESP8266.

Es el Chisme 193, para Bachillerato. Medimos la humedad del suelo, calibramos el sensor con dos valores (en seco y en agua) y lo relacionamos con las ODS 6 y 15.

Para no equivocarte de pin, tienes un simulador de conexiones con las tres placas: te dice dónde va cada cable y por qué.

Por qué este chisme

Regar «por costumbre» malgasta agua y, a veces, daña la planta. Medir antes de regar es una decisión con datos.

Y hay una lección escondida: el mismo sensor da números distintos en placas distintas. Sin calibrar, un número no significa nada.

Cómo funciona

El sensor tiene dos puntas metálicas. La tierra mojada conduce mejor que la seca, y el módulo convierte ese cambio en una tensión por su pin AO (salida analógica).

La placa mide esa tensión con analogRead(A0) y devuelve un número entre 0 y 1023. Pero ese número depende de la tensión de referencia: la NodeMCU compara con 3,3 V y el Arduino con 5 V.

Con el mismo voltaje, el Arduino da un número más bajo: por eso en la NodeMCU salen 13 y 613 y en el Arduino unos 9 y 405 (valores aproximados).

Qué necesitamos

• Un Arduino Mega (el habitual en clase) o UNO, o una NodeMCU ESP8266.
• El módulo sensor de humedad del suelo.
• Tres cables de conexión.
• Un cable USB (micro-USB en la NodeMCU).
• Un vaso con agua y, si puedes, una maceta con tierra.
• El IDE de Arduino.

Montaje: los tres pines

El sensor tiene tres pines que hay que conectar. Alimenta a 3,3 V y no a 5 V: así el sensor se comporta igual en las dos placas.

Sensor	Arduino (Mega o UNO)	NodeMCU
VCC	3,3 V	3V
GND	GND	G
AO	A0	A0

Si tu módulo tiene un cuarto pin (DO), no lo uses.

Programa 1: leer el sensor

Abre el IDE de Arduino, elige tu placa y el puerto, y sube este programa. Abre el monitor serie a 115200.

// Lee el sensor de humedad del suelo y lo muestra por el monitor serie

void setup() {
  Serial.begin(115200);   // monitor serie a 115200
}

void loop() {
  int valor = analogRead(A0);   // lee el sensor (0 a 1023)
  Serial.println(valor);        // muestra el número
  delay(1000);                  // espera 1 segundo
}

Pon el sensor al aire y luego en agua. ¿El número sube o baja al mojar?

Programa 2: calibración, cada grupo mide lo suyo

Cada grupo anota su valor en seco (al aire) y en agua. Esos dos números son la calibración de su sensor y su placa.

El programa 2 es el programa final de abajo con valores provisionales: VALOR_SECO = 13 y VALOR_MOJADO = 600. En el Arduino, mientras no pongas los tuyos, el porcentaje saldrá mal. Esa es la razón de calibrar.

Programa 3: el código final

Es el mismo programa con tus dos valores (en la NodeMCU del profesor, 13 y 613). Convierte el número en un porcentaje con map() y enciende el LED cuando la planta tiene sed.

// ODS 6 y 15: planta que avisa cuando tiene sed
// NodeMCU ESP8266 - sensor de humedad del suelo en A0

const int PIN_SENSOR = A0;      // única entrada analógica (0-1023)

// CALIBRACIÓN (valor BAJO en seco, ALTO en mojado)
int VALOR_SECO   = 13;          // sensor al aire
int VALOR_MOJADO = 613;         // puntas en agua

int UMBRAL_SED   = 30;          // por debajo de este % la planta tiene sed

// Media de 10 lecturas para quitar ruido
int leerSensor() {
  long suma = 0;
  for (int i = 0; i < 10; i++) {
    suma += analogRead(PIN_SENSOR);
    delay(10);
  }
  return suma / 10;
}

void setup() {
  Serial.begin(115200);
  pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, HIGH);      // HIGH = apagado
  Serial.println();
  Serial.println("Sensor de humedad del suelo listo");
}

void loop() {
  int valor = leerSensor();

  int humedad = map(valor, VALOR_SECO, VALOR_MOJADO, 0, 100);
  humedad = constrain(humedad, 0, 100);

  Serial.print("Valor A0: ");
  Serial.print(valor);
  Serial.print("  |  Humedad: ");
  Serial.print(humedad);
  Serial.print(" %  |  ");

  if (humedad < UMBRAL_SED) {
    Serial.println("TENGO SED, riégame");
    digitalWrite(LED_BUILTIN, LOW);     // LOW = enciende
  } else {
    Serial.println("Estoy bien");
    digitalWrite(LED_BUILTIN, HIGH);    // HIGH = apaga
  }

  delay(1000);
}

Qué cambia de la NodeMCU al Arduino

• Los números salen más bajos en el Arduino, porque lee con referencia de 5 V. Por eso calibrar es necesario, no un adorno.
• El LED integrado va al revés. En el Arduino (pin 13) HIGH enciende y LOW apaga. En la NodeMCU es al contrario.

Así que, en el Arduino, el programa final cambia en tres líneas del LED. Los tres sitios donde hay que intercambiar HIGH y LOW son estos:

  digitalWrite(LED_BUILTIN, LOW);       // en setup(): LOW = apagado
  ...
    digitalWrite(LED_BUILTIN, HIGH);    // en loop(), con sed: HIGH = enciende
  ...
    digitalWrite(LED_BUILTIN, LOW);     // en loop(), sin sed: LOW = apaga

Cómo probarlo

1. Sube el programa final y abre el monitor serie a 115200.
2. Con el sensor al aire, el porcentaje debe estar cerca del 0 %.
3. Con las puntas en agua, cerca del 100 %.
4. Prueba con tierra seca y tierra húmeda: ¿cuándo se enciende el LED?

Moja solo las puntas, nunca la parte con los componentes, y no dejes el sensor dentro del agua todo el día.

Qué estamos midiendo realmente

El sensor no mide «litros» ni «porcentaje de agua». Mide cómo conduce la electricidad el suelo, y la placa lo traduce a un número. El porcentaje lo inventamos nosotros con la calibración.

map(valor, VALOR_SECO, VALOR_MOJADO, 0, 100) asume que entre «seco» y «mojado» la relación es una recta. Es una aproximación: el sensor real no es perfectamente lineal.

La media de 10 lecturas reduce el ruido. Recuerda: medir no significa medir bien. Dos sensores iguales pueden dar números distintos, y por eso cada grupo calibra el suyo.

El sensor humedad Arduino y las ODS

El programa empieza con «ODS 6 y 15». Los Objetivos de Desarrollo Sostenible que toca este chisme:

• ODS 6, Agua limpia y saneamiento: la planta avisa cuando tiene sed, y se riega solo lo necesario.
• ODS 15, Vida de ecosistemas terrestres: suelos y plantas sanos, la base de huertos y bosques como los de Sierra Bermeja.
• ODS 2, Hambre cero: cultivar con datos, con menos agua.
• ODS 13, Acción por el clima: ante la sequía, medir ayuda a adaptarnos.

Para el aula

• ¿Por qué el mismo sensor da números distintos en el Arduino y en la NodeMCU?
• ¿Qué error puede tener la medida? Repite diez lecturas y calcula cuánto varían.
• Dos grupos calibran distinto: ¿cuál tiene razón? ¿Cómo lo sabrías?
• ¿Qué UMBRAL_SED elegirías para una lechuga y cuál para un cactus?
• ¿Qué pasa con el porcentaje si pones VALOR_MOJADO mal?

Retos

• Reto 1: monta el sensor y que salga un número por el monitor serie.
• Reto 2: calibra tu sensor con tu placa y cambia VALOR_SECO y VALOR_MOJADO.
• Reto 3: cambia el UMBRAL_SED y mira cuándo se enciende el LED.
• Reto 4: añade un zumbador o un LED externo que avise de que hay que regar.
• Reto 5: guarda los valores durante un día y represéntalos en una gráfica.
• Reto 6: investiga: ¿cuánta agua ahorra una planta con riego por sensor frente a un riego fijo?

Qué hemos aprendido

• Un sensor analógico da un número que hay que calibrar con dos puntos.
• El mismo sensor da números distintos según la placa, por la tensión de referencia.
• Medir con datos ayuda a regar solo lo necesario: ODS 6 y 15.

Escena final

El Lince calibró su sensor en las dos placas. Ahora la planta avisa cuando tiene sed, y la Gata ya no tiene que mirar el charco.

—Se lo dije —murmuró la Gata—. No estaba rota. Solo había que calibrarla.

Para seguir investigando

• Chisme 182: servidor web ESP8266, un LED desde el móvil
• Chisme 147: termómetro con micro:bit y LM35
• Referencia de analogRead() de Arduino
• Objetivos de Desarrollo Sostenible, en Wikipedia

Este chisme es un prototipo educativo, no un instrumento agrícola ni científico certificado.