Proyecto 27 – Sensor de Humedad de Suelo

En este proyecto utilizaremos un sensor de humedad de suelo HW-080 o higrómetro con nuestro Arduino para detectar la humedad en un terreno. Este sensor es muy similar en su funcionamiento al sensor de lluvia utilizado en nuestro proyecto anterior

Sensor de humedad en suelo

Módulo comparador LM393 y sensor de humedad de suelo

El higrómetro de suelo es un sensor que mide la humedad por medio de la variación de la conductividad del suelo en el que se encuentra enterrado. Existen varios modelos higrómetros de tierra, pero aquí vamos a utilizar cualquiera de estos 3 modelos: HW-080, YL-69 o FC-28, que básicamente son el mismo sensor, hay que tener muy presente los pines del módulo comparador ya que pueden ser diferentes al del ejemplo. Son frecuentemente utilizados en sistemas de riego.

En nuestro caso vamos a utilizar el HW-080, este módulo se compone de dos partes:

  • La primera es un módulo de medición estándar con un comparador LM393, que nos permite obtener una lectura análoga o digital y se puede regular la sensibilidad del umbral, ya que tiene potenciómetro en el circuito.
  • La segunda parte es un PCB que básicamente es una resistencia variable cuyo valor varia según la humedad en la que se encuentra enterrada.

¿Cómo funciona el higrómetro?

El funcionamiento del sensor es bastante simple, la placa del sensor posee dos electrodos resistivos, los cuales miden la resistencia y de esto dependerá la humedad del suelo. Entonces en un suelo muy húmedo tendríamos un corto circuito entre los dos terminales es decir una resistencia muy baja o 0 resistencia y en el caso de un suelo muy seco la resistencia vendría siendo muy alta. En conclusión el sensor tiene dos sondas y medimos la resistencia entre ellas, entre menor sea la resistencia mayor la humedad.

Entre más humedad encuentre sobre las dos sondas del sensor la resistencia es menor, es decir la resistencia es inversamente proporcional a la humedad.

Componentes

  • Arduino UNO o placa compatible
  • Sensor de humedad en tierra HW-080 o FC-28
  • Cables o Jumpers
Diagrama de conexiones del sensor de humedad de suelo
Diagrama de conexiones del sensor de humedad de suelo

En este proyecto las conexiones son bastante simples, lo primero que debemos hacer es revisar es en el módulo comparador los pines de conexión, en un lado están los dos conectores que van a conectarse al sensor y por el otro lado encontraremos 4 pines (AO, DO, GND, VCC), los cuales son la alimentación del módulo (VCC, GND), un pin de salida digital (DO) y uno de salida análoga (AO).

Una vez identificados los pines del módulo comparador procedemos a conectar los dos pines de captura de datos a la tarjeta del sensor, luego conectamos el GND al GND del arduino, el VCC a los 5V del Arduino y por último conectamos el pin AO del módulo a el pin A0 del Arduino.

Código

#define sensor A0 
int valor = 0;

void setup()
{
    Serial.begin(9600);
}
void loop()
{
    int valor = map(analogRead(sensor), 0, 1023, 100, 0);
    //se hace un mapeo de la lectura del sensor a porcentual
    Serial.print("Humedad: ");
    Serial.print(valor);
    Serial.println("%");
    delay(100);
}

Explicación del código

Comenzaremos a revisar el código, primero vamos hacer la declaración de la variable.

#define sensor A0 
int valor = 0;

Declaramos primero una constante con define, pinSensor a la cual le asignaremos A0, el cual es el pin del Arduino al cual irá conectado nuestro sensor, luego vemos declarada otra variable de tipo entera valor que le asignaremos 0 para inicializarla.

Función setup()

Serial.begin(9600);

Como hemos visto anteriormente en otros proyectos en el setup ponemos todo lo que debe ser inicializado o ejecutado una sola vez, el el caso de este proyecto lo único que vemos es la inicialización de la comunicación serial a una velocidad el 9600 baudios, por medio de la cual veremos la información de la tecla que hemos presionado a través del monitor serial.

Función loop()

int valor = map(analogRead(sensor), 0, 1023, 100, 0);
//se hace un mapeo de la lectura del sensor a porcentual
Serial.print("Humedad: ");
Serial.print(valor);
Serial.println("%");
delay(100);

Comenzaremos revisando el contenido de nuestra función loop, para esto vamos a irlo desglosando un poco, para que sea mas fácil de entender.

int valor = map(analogRead(sensor), 0, 1023, 100, 0);

Aquí podemos ver que se declara una variable de tipo entero llamada valor, vamos a hacer una pausa aquí para analizar lo que le estamos asignando a la variable valor. Vemos una función que no habíamos trabajado aún, la función map, la cual toma un valor lo mapea de un rango a otro rango, en nuestro caso mapea los valores capturados por el puerto A0 que vienen de nuestro sensor de 0-1023 a un nuevo rango que sería 100-0, donde el valor 0 de nuestro sensor equivale a 100 y el 1024 del sensor equivale a 0. No olvidemos que si el sensor registra un valor 0 equivale al 100% de humedad y si el valor es de 1023 está completamente seco.

Entonces podemos resumir que en esta línea se declara la variable entera valor, a la cual le asignamos la captura del valor del sensor mapeado de 0-1023 a 100-0.

Serial.print("Humedad: ");
Serial.print(valor);
Serial.println("%");
delay(100);

Las líneas que siguen ya son muy fáciles de comprender, ya las hemos visto en casi todos nuestros proyectos. La primera línea nos imprime en el monitor serial el texto «Humedad: «, la siguiente línea nos muestra el valor de nuestra variable valor y luego nos imprime el signo % y una nueva línea, finalmente hay una pausa de 100 milisegundos entre lectura y lectura.

Salida serial sensor de humedad en suelo
Salida por monitor serial del sensor

Resumen

En resumen al conectar nuestro Arduino a la computadora e iniciamos el monitor serial, comenzaremos registrar el porcentaje de humedad que tiene el suelo donde tenemos nuestro higrómetro enterrado.

NOTA:  El  análisis de los valores del sensor en el código no es una referencia real del porcentaje de humedad del suelo, por lo que hay que tener presente que  este código es para fines educativos, no para aplicaciones que  necesiten precisión.

35 comentarios en «Proyecto 27 – Sensor de Humedad de Suelo»

    • Hola Ivan.

      El procedimiento es mus simple, conectas los tres sensores a la los 5V y a la tierra (GND), luego conectas el pin A0 de uno de los sensores al A0 del arduino, el otro puerto A0 del otro sensor al pin A1 del arduino y el último sensor al A2 del arduino.

      El código podría ser el siguiente:


      #define sensor1 A0
      #define sensor2 A1
      #define sensor3 A2

      int valor1 = 0;
      int valor2 = 0;
      int valor3 = 0;

      void setup()
      {
      Serial.begin(9600);
      }
      void loop()
      {
      //hago las 3 lecturas
      int valor1 = map(analogRead(sensor1), 0, 1023, 100, 0);
      int valor2 = map(analogRead(sensor2), 0, 1023, 100, 0);
      int valor3 = map(analogRead(sensor3), 0, 1023, 100, 0);
      //imprimo los 3 valores
      Serial.print("Humedad sensor 1: ");
      Serial.print(valor1);
      Serial.println("%");
      Serial.print("Humedad sensor 2: ");
      Serial.print(valor2);
      Serial.println("%");
      Serial.print("Humedad sensor 3: ");
      Serial.print(valor3);
      Serial.println("%");
      delay(1000);
      }

      La parte de la salida por monitor seria puedes organizarla con tabulaciones para que salga todo en una línea y poner un delay más corto.

      Espero te haya servido de ayuda. No dudes en consultarme si tienes una duda.

      Responder
    • Hola Pablo, discúlpame por la demora, estaba de viaje.

      Cuéntame que tipo de pantalla LCD quieres usar 2004 o 1602 y el tipo de conexión, ya sea 4 bits, 8 bits o con módulo I2C?
      Quedo pendiente para ayudarte con tu proyecto.

      Responder
        • Hola Diana, no hay problema con gusto te ayudaré. Cómo vas a conectar el 1602, en 8 bits, en 4 bits https://acortes.co/proyecto-29-lcd-1602/, o con módulo I2C https://acortes.co/proyecto-30-lcd-1602-modulo-i2c/?
          Personalmente prefiero utilizar un módulo I2C para conectar estas pantallas LCD, ya que solo usas dos pines para los datos y dos para energía.
          Cuéntame que método pretendes utilizar y te ayudo con el código y el diagrama de conexiones.

          Responder
          • Hola Diana, finalizando el día te envío el código y el diagrama de conexiones.

          • Hola Diana, he utilizado el LCD1602 con el módulo I2C, que es más simple para conectarlo al Arduino, las conexiones son las mismas de los dos proyectos, https://acortes.co/proyecto-30-lcd-1602-modulo-i2c/ y https://acortes.co/proyecto-27-sensor-de-humedad-de-suelo/ , sin embargo te enviaré al correo el diagrama del proyecto.

            El código:


            #include
            #include

            #define sensor A0

            //puede ser 0x3F o en otros casos 0x27
            LiquidCrystal_I2C lcd(0x27, 16, 2); //Establece la direccion del LCD 0x27 de 16 caracteres y 2 lineas
            int valor = 0;

            void setup()
            {
            lcd.init();
            lcd.backlight();
            }

            void loop()
            {
            int valor = map(analogRead(sensor), 0, 1023, 100, 0);
            //se hace un mapeo de la lectura del sensor a porcentual
            lcd.clear();
            lcd.setCursor(4,0);
            lcd.print("Humedad: ");
            lcd.setCursor(5,1);
            lcd.print(valor);
            lcd.setCursor(8,1);
            lcd.print("%");
            lcd.print(" "); // ponemos este espacio en blanco ya que estas pantallas tienen problemas al usar caracteres
            // diferentes a las letras normales y ponen otro caracter raro, intenta poner una ñ o °
            delay(200); //tiempo de refresco de los datos en milisegundos
            }

            No se por qué los #include no aparecen en el comentario, son los mismos que en el proyecto del la pantalla LCD con I2C https://acortes.co/proyecto-30-lcd-1602-modulo-i2c/
            #include «Wire.h»
            #include «LiquidCrystal_I2C.h»
            Este es el código básico para ver los datos en el LCD1602, ya te lo envié de todos modos al correo electrónico.

  1. Hola Andrés que tal?, estoy haciendo un trabajo para la facultad y necesitaría agregar un parlante con un modulo de reproducción de mp3 para que cuando el sensor de humedad detecte cierta humedad se dispare una música.
    La cosa es que recien estoy comenzando con lo del arduino y tengo miedo de cagarla con el tema de las resistencias y el voltaje.
    Si estuve investigando acerca de los parlantes y creo que necesito uno de 3 voltios, y un modulo dfplayer mini, lo que no me queda muy claro es el tema de los cables para la conexión y si necesito resistencias. Luego en el código pensaba poner simplemente un if con los valores del sensor de humedad y que al llegar a tales valores dispare la música.
    En cuanto a como conectarlo, me preguntaba si conectaba todo directamente al Arduino o utilizo el protoboard para el sonido únicamente y las conexiones del sensor las hago como muestra el video, o pongo tanto el sensor de humedad como el parlante con la sm card en el protoboard.
    Muchas gracias espero tu respuesta.

    Responder
    • Hola Mari, disculpa la tardanza, el Arduino tiene muy poca potencia de salida para controlar un parlante de un vatiaje muy alto, personalmente he utilizado parlantes de 0.5 vatios y 8 ohmios conectados directamente al Arduino y como prototipo suena bastante bien, pero si quieres un mejor volumen (para controlar parlantes de más vatios) te recomiendo usar un módulo amplificador como el PAM8403 que es de 3 Vatios, es económico, muy fácil de utilizar y conectar a tu proyecto.
      Por ejemplo en esta publicación, le puse a esta artesanía audio con un Arduino mini pro y el módulo PAM8403.
      https://www.instagram.com/p/ChoMQLfDUXK/

      Responder
    • Hola Jean Carlos, supongo a que te refieres a capturar los tres datos para controlarlos en otro lenguaje utilizando VS code, para esto debes tener en cuenta que el Arduino cuando lo instalas crea un puerto serial, por lo que debes desarrollar un programa que sea capaz de leer los datos que se envían por el serial en el que se encuentra el Arduino.

      Responder
  2. hola tengo una duda para esp32 y poniendo para mostrar los valores de humedad y pa imprimir un mensaje que muestre en una lcd 20×4 i2c es el mismo, estoy usando un menu tmb

    Responder
    • Hola Sebastián, Cuando uses el ESP32 debes tener en cuenta que la distribución de los pines entre este y el Arduino son diferentes, puedes utilizar cualquiera de los puertos ADC para hacer una medición análoga, y lo lo vas a realizar con «analogRead(GPIO);», donde GPIO es el pin que deseas leer, pero lo más importante que debes tener en cuenta es que los valores de medida en el ESP32 van de 0-4095 (en el Arduino son 0-1023).
      Para usar la pantalla LCD debes tener presente que los pines I2C son el GPIO22 para el SCL y el GPIO21 para el SDA.

      Responder
  3. Hola, tengo la misma duda, si tengo esas características ya en el codio y le quiero agregar por ejemplo un sensor dht22, como sería el código?, cambiaría algo en el yl69? Es que no me lee el yl69 si hago la conexión con otros sensores en el mismo codigo

    Responder
    • Hola Frida, no hay ningún problema en conectar simultáneamente un DHT22, solo debes tener en cuenta que el DHT22 lo conectas en un puerto digital, en este ejemplo puedes ver el uso del mismo. Puedes mezclar los dos códigos, te recomiendo que leas los dos sensores de forma seguida y luego apliques las reglas de conversión y/o la impresión por monitor serial.

      Responder
      • Ya lo hice, conecte tres sensores y los subí a la plataforma de thinspeak, el único sensor que no me da los datos bien es el YL69. El sensor YL69 si funciona cuando no lo subo al thingspeak, pero al momento de subirlo al thinspeak, no me marca los valores y los demás sensores si.

        Responder
        • Hola Frida, nunca he trabajado con la plataforma de Thinkspeak, pero si gustas me puedes compartir el código y te ayudo a encontrar el error.

          Responder
          • Claro, si porfavor
            #include «DHT.h»
            #include «Adafruit_BMP085.h»
            #include «Wire.h»
            #include «ThingSpeak.h»
            #include «WiFi.h»

            //DEFINIR PINES PARA SENSORES
            #define pin1 4 //Pin del DHTA.
            #define sensor 15 // Sensor Suelo
            #define pin2 21 //Datos BMP
            #define pin 22 //Datos MBP

            //DECLACRACION DE VARIABLES PARA SENSORES
            float t1;//dtha
            float h1;//dtha
            //Variables BMP180
            Adafruit_BMP085 bmp; //senosr barometrico
            float presion; //bmp180 presion
            float altitud; //bmp180 altitud

            //Variables YL69
            const int YL69Pin =15;
            //Declaracion de tipo de sensor con respecto al pin
            DHT dht1(pin1, DHT22); //crear objeto DHTA

            const char* ssid = «»; // Declaración variable internet nombre fijo
            const char* password = «»; // Contraseña constante WiFi fijo

            unsigned long channelID = 2037128; // Canal del ThingSpeak fijo
            const char* WriteAPIKey = «KHJ45CRCHM5C55TB»; // APIKey del ThingSpeak fijo

            WiFiClient Client; //Crear un objeto

            ////////////////////////////////////SETUP///////////////////////////////////////
            void setup() {
            Serial.begin(9600);
            Serial.println(«Test de sensores:»); //testeo sensores

            dht1.begin(); // Empiece la comunicación con el sensor DHTA
            bmp.begin(); // Empiece la comunicación con el sensor BMP180
            delay (2000);

            WiFi.begin (ssid,password); // Comunicación de variables

            while (WiFi.status () != WL_CONNECTED) {
            delay(1000); // Tiempo de espera
            Serial.print(«.»); // Escribir para la conexión de espera
            }
            Serial.println(«WiFi Conectado!»); // Se escribe la conexión establecida

            ThingSpeak.begin(Client);
            delay(5000);
            }

            void loop() { //void para dth
            delay(2000);
            leerdht1();//dtha

            delay(2000);
            leerbmp180();//bmp180

            delay(2000);
            leeryl69();

            ThingSpeak.writeFields(channelID, WriteAPIKey); // Variables fijas
            Serial.println(«Datos enviados a ThingSpeak!»);
            delay(14000);
            }
            ////////////////////////////LECTURA DTH A///////////////////////////////////////////////////
            void leerdht1() {

            float t1 = dht1.readTemperature(); //variable Temperatura
            float h1 = dht1.readHumidity(); //variable Humedad
            //Testeo DTHA
            while (isnan(t1) || isnan(h1)){
            Serial.println(«Lectura fallida en el sensor DHT1A, repitiendo lectura…»);
            delay(2000);
            t1 = dht1.readTemperature();
            h1 = dht1.readHumidity();
            }
            //imprimir lecturas en serial
            Serial.println(«////////////DTHA/////////////»);
            Serial.print(«Temperatura DHTA: «);
            Serial.print(t1);
            Serial.println(» ºC.»);

            Serial.print(«Humedad DHTA: «);
            Serial.print(h1);
            Serial.println(» %.»);

            Serial.println(«———————–«);

            ThingSpeak.setField (1, t1);
            ThingSpeak.setField (2, h1);
            }

            /////////////////////////////BMP180///////////////////////////////////////////////
            void leerbmp180(){
            Serial.println(«//////////////BMP180////////////////»);
            Serial.print(«Pressure = «);
            presion = bmp.readPressure();
            Serial.print(presion);
            Serial.println(» Pa»);
            Serial.print(«Altitude = «);
            altitud =bmp.readAltitude();
            Serial.print(altitud);
            Serial.println(» meters»);
            Serial.println(«———————–«);

            ThingSpeak.setField (3, presion);
            ThingSpeak.setField (4, altitud);
            }

            void leeryl69(){
            Serial.println(«//////////////YL69////////////////»);
            int const readYL69value = analogRead(YL69Pin);
            // map inversely to 0..10%
            int const convertedPercentage = map(readYL69value, 4095, 1200, 0, 100);
            Serial.print(«Moisture (YL-69): «);
            Serial.print(convertedPercentage);
            Serial.print(«%\n»);

            delay(2000);

            Serial.println(«———————–«);

            ThingSpeak.setField (5, convertedPercentage);
            }

          • Hola Frida, que pena contigo que no he tenido tiempo de revisar tu código a fondo, he estado muy ocupado en la oficina. Ya pudiste lograr que funcionara o aún necesitas de mi colaboración?

  4. Hola. Me podrían ayudar para que aparezca en °C
    Ya me aparece la humedad pero quiero saber la temperatura, pero me pidieron °C

    Responder
    • Hola Itzel, el sensor de este proyecto sólo mide la humedad en la tierra, si deseas la temperatura podrías utilizar un termistor, en especial uno que sea resistente al agua como el del proyecto 17 proyecto 17. Utilizando estos dos sensores podrías medir la humedad y la temperatura dentro de la tierra, pero si lo que quieres es medir la temperatura y la humedad del aire podrías utilizar el DHT11 o el DHT22 que también están en el proyecto 23 y el en proyecto 24

      Responder
  5. Hola que tal ?
    No me abre la pestaña de compilación, hice todo tal cual.
    No arroja ningún error y cuando termina de cargar, abro «Serial Monitor» y abre una pestaña al lado de output y no sucede nada.
    Atento a sus comentarios y gracias de antemano

    Responder
    • Hola Daniel. Si has subido el código al Arduino y en la salida te ha salido que fue exitoso, debes revisar el monitor de serie que tenga la misma velocidad de transmisión que la que tiene el código, que en el caso del ejemplo es 9600, en la línea del setup, "Serial.begin(9600);".

      Responder
    • Hola Bren, si tomas el sensor sólo, si usar el comparador y lo pruebas con el multímetro en resistencia, te debe dar una resistencia muy alta, a medida que se humedece la resistencia debe bajar hasta 0, esta sería una forma muy simple de testear el sensor. Espero te sirva de ayuda, cualquier duda o consulta no dudes en contactarme.

      Responder
  6. Buena noche, disculpe quisiera saber si podria ayudarme, lo que pasa es que quisiera que en la pantalla lcd me muestre los datos de los 6 sensores uno por uno, de antemano espero su respuesta

    Responder
    • Hola Jose.
      Es muy sencillo una vez que tienes los 6 sensores conectados en los 6 pines análogos del Arduino, solo debes agregar en el código la inicialización de los 6 y la inicialización de las 6 variables:

      #define sensor A0
      #define sensor1 A1
      #define sensor2 A2
      .
      .
      #define sensor5 A5

      int valor = 0;
      int valor1 = 0;
      .
      .
      int valor5=0;

      De igual forma debemos leer los 6 sensores:

      valor = map(analogRead(sensor), 0, 1023, 100, 0);
      valor1 = map(analogRead(sensor1), 0, 1023, 100, 0);
      .
      .
      valor6 = map(analogRead(sensor6), 0, 1023, 100, 0);

      Y para terminar los vamos a visualizar cada uno de los valores con un intervalo de un segundo entre cada uno:

      Serial.print("Humedad S0: ");
      Serial.print(valor);
      Serial.println("%");
      delay(1000);
      Serial.print("Humedad S1: ");
      Serial.print(valor1);
      Serial.println("%");
      delay(1000);
      .
      .
      Serial.print("Humedad S5: ");
      Serial.print(valor5);
      Serial.println("%");
      delay(1000);

      Esto sería todo para este fi, aunque la lectura y la visualización en pantalla se pueden optimizar con ciclos for y se ahorra unas líneas de código, pero sería el mismo resultado.

      Espero te sea de ayuda y disculpa la demora.

      Responder
    • Hola Daniela!

      Para utilizar este sensor de humedad no tienes que utilizar ninguna librería, con el IDE de Arduino y el código que hay en el proyecto es suficiente para que te funcione.

      Si tienes alguna duda o problema con la implementación del proyecto no dudes en contactarme de nuevo.

      Responder
  7. Hola, me podria ayudar tengo que realizar un código para arduino uno, utilizando el sensor de humedad y una pantalla LCD para que me de los resultados. Me serviría mucho su ayuda
    Gracias

    Responder
    • Hola Jessy.

      En el momento estoy bastante ocupado en la oficina y no podría colaborarte rápidamente, pero el Proyecto 30 te enseña a utilizar el LCD1602 y el Proyecto 31 es ya un proyecto con otro sensor diferente pero mostrando en el LCD 1602.

      Si no tienes afán te recomiendo revisar esos proyectos y verás que es muy simple. Si tienes alguna duda con los proyecto me puedes contactar y te aclaro las dudas.

      Responder

Deja un comentario

Este sitio está protegido por reCAPTCHA y se aplican la política de privacidad y los términos de servicio de Google.