En este tutorial medimos la humedad del suelo con un sensor de humedad del suelo.
Como hay dos tipos diferentes de sensores, describimos la funcionalidad de cada uno en el primer capítulo.
Después de aprender a conectar el sensor a tu placa microcontroladora Arduino, ESP8266 o ESP32, creamos un script básico para Arduino.
Sensor de humedad del suelo
En la última parte de este tutorial te muestro un ejemplo práctico con los microcontroladores Arduino, ESP8266 o ESP32. En este ejemplo he medido la humedad del suelo de una planta de orquídea durante 2 semanas.
¿Cómo funciona el sensor de humedad del suelo?
Como se describe en la introducción, existen dos tipos diferentes de sensores de humedad del suelo. Por lo tanto, el primer paso en este tutorial es describir la funcionalidad de cada uno y también asegurarse de que está comprando el sensor correcto, si aún no tiene un sensor de humedad del suelo.
Las siguientes dos imágenes muestran una foto de cada sensor.
Sensor capacitivo de humedad del suelo
- Larga vida útil y sin corrosión.
- Solo funciona con voltaje de funcionamiento de 5 V
Sensor de humedad del suelo resistivo
- Funciona con voltaje de funcionamiento de 3,3 V y 5 V
- Solo funciona durante varios días debido a la corrosión.
Sensor capacitivo de humedad del suelo
El sensor capacitivo de humedad del suelo no mide directamente la humedad, sino que mide los cambios en la capacitancia causados por los cambios en el contraste dieléctrico entre el agua y el suelo. Los suelos secos tienen una permitividad relativa entre 2 y 6 y el agua tiene un valor de alrededor de 80.
La principal ventaja del sensor capacitivo es que no hay exposición directa de los electrodos metálicos. Por tanto, no hay electrólisis que dañe el sensor por corrosión.
El voltaje de funcionamiento del sensor capacitivo de humedad del suelo es de 5 V en mi experiencia. En algunas hojas de datos encontrará la declaración de que el sensor también funciona para microcontroladores de 3.3V, pero en el subcapítulo Influencia de la fuente de alimentación en el valor del sensor analógico, verá que tengo valores de sensores no válidos.
Si desea comprar un sensor de humedad del suelo, asegúrese de comprar uno capacitivo.
Sensor de humedad del suelo resistivo
El sensor resistivo de humedad del suelo consta de 2 sondas que se insertan en el suelo. Dependiendo de la dirección de la corriente, una sonda funcionará como cátodo y la otra como ánodo. En general, qué sonda es el ánodo o el cátodo no importa para la funcionalidad del sensor, ya que el sensor solo mide la resistencia y, por lo tanto, es independiente de la dirección de la corriente.
El circuito eléctrico está cerrado en el suelo que funciona como una resistencia al flujo de corriente. Esta resistencia se mide y depende de la cantidad de agua en el suelo porque el agua es un conductor natural de la electricidad. Cuanto menor sea la resistencia medida, mayor será la cantidad de agua en el suelo.
La corriente que fluye a través del ánodo del sensor resistivo de humedad del suelo, que está en contacto con el agua, es un entorno perfecto para la electrólisis y, por lo tanto, para la galvanoplastia. Esta electrólisis daña el sensor y hace que el sensor sea inexacto. La fuerza de la electrólisis depende de la frecuencia y la cantidad de corriente que pasa a través de los electrodos.
Cableado entre el sensor de humedad del suelo y el microcontrolador
Las siguientes imágenes muestran el cableado entre el sensor de humedad del suelo y el microcontrolador Arduino más utilizado, ESP32 y ESP8266. Si le falta su microcontrolador favorito, avíseme en la sección de comentarios y también agregaré el cableado para su placa de microcontrolador.
Cableado entre el sensor capacitivo de humedad del suelo y Arduino
Las siguientes imágenes muestran el cableado entre el sensor capacitivo de humedad del suelo y diferentes placas Arduino. Usamos una fuente de alimentación de 5V para el sensor y leemos los valores del sensor analógico con el pin A0 de la placa Arduino.
- Arduino Nano
- Arduino Pro Mini
- Arduino Uno
- Arduino Mega
Arduino Nano
Para obtener más información sobre Arduino Nano, visite el tutorial de Arduino Nano.
Arduino Pro Mini
Arduino Uno
Para obtener más información sobre Arduino Uno, visite el tutorial de Arduino Uno.
Arduino Mega
Para obtener más información sobre Arduino Mega, visite el tutorial de Arduino Mega.
Cableado entre el sensor capacitivo de humedad del suelo y el ESP8266
Para el cableado entre el sensor capacitivo de humedad del suelo y el ESP8266, podemos usar el pin de 5V de la placa ESP8266 o el pin de 3.3V del microcontrolador, ya que el sensor puede trabajar con ambos voltajes. El ESP8266 lee el valor del sensor de suelo en el pin analógico A0. La siguiente imagen muestra el cableado entre el sensor capacitivo de humedad del suelo y el ESP8266 NodeMCU, así como el ESP8266 WeMos D1 Mini.
- ESP8266 NodeMCU
- ESP8266 WeMos D1 Mini
ESP8266 NodeMCU
ESP8266 WeMos D1 Mini
Cableado entre el sensor capacitivo de humedad del suelo y el ESP32
La siguiente imagen muestra el cableado entre el sensor capacitivo de humedad del suelo y el ESP32 ESP-WROOM-32. Para la fuente de alimentación del sensor, podemos usar el pin de salida de 5V o 3.3V de la placa ESP32. El valor del sensor analógico se puede leer con cualquier pin digital del ESP32 que esté conectado internamente con un convertidor analógico a digital.
Si no está seguro de qué pines de la placa ESP32 pueden leer los valores de los sensores analógicos, le recomiendo que descargue mi libro electrónico gratuito de hoja de datos del microcontrolador con pinouts detallados de varias placas Arduino, ESP8266 y ESP32.
ESP32 ESP-WROOM-32
Influencia de la fuente de alimentación en el valor del sensor analógico
El sensor de humedad del suelo capacitivo y resistivo funciona con voltajes de suministro entre 3,3 V y 5 V. Por lo tanto, puede usar el microcontrolador Arduino (voltaje de funcionamiento 5 V) y ESP (voltaje de funcionamiento 3, 3 V) para medir la humedad del suelo.
Pero debe tener en cuenta que el valor del sensor analógico depende de la tensión de funcionamiento. La siguiente tabla muestra el valor del sensor analógico para todas las diferentes combinaciones de voltaje de funcionamiento, humedad y tipo de sensor de humedad del suelo.
| Tensión de funcionamiento | 3,3V | 5V | ||
|---|---|---|---|---|
| Seco/Húmedo | Seco | Húmedo | Seco | Húmedo |
| Sensor capacitivo de humedad del suelo | 2…8 | 14…21 | 821…824 | 490…549 |
| Sensor de humedad del suelo resistivo | 1024 | 483…505 | 1023 | 344…358 |
En teoría, puede usar cualquiera de estas combinaciones, pero debe calibrar su sensor antes de declarar su suelo húmedo o seco.
Para el sensor capacitivo de humedad del suelo, también puede ver en la tabla que la diferencia en el valor del sensor para una tensión de funcionamiento de 3,3 V es muy pequeña. Por lo tanto, su rango de medición es muy cercano y recomiendo usar un voltaje de operación de 5V para el sensor capacitivo.
Código Arduino para leer el valor analógico del sensor de humedad del suelo
El siguiente script de Arduino lee el valor del sensor analógico del sensor de humedad del suelo. El script está preparado para placas de microcontroladores Arduino, EPS8266 y ESP32. Solo tiene que comentar las partes que no necesita según mis comentarios en el guión.
#define SensorPin A0 // used for Arduino and ESP8266
//#define SensorPin 4 // used for ESP32
void setup() {
Serial.begin(9600);
}
void loop() {
float sensorValue = analogRead(SensorPin);
Serial.println(sensorValue);
delay(30000);
}
Dentro En la primera parte del script definimos el pin analógico que conecta el microcontrolador al sensor de humedad del suelo. Para Arduino y ESP8266 usamos el pin A0. Dado que cada pin de E / S digital del ESP32, que no se utiliza para una interfaz de comunicación, puede ser una entrada analógica, tenemos que elegir un pin como entrada analógica. En mi caso estoy usando el pin 4.
Si no está seguro de qué pines de la placa ESP32 se pueden usar como entradas analógicas, le recomiendo que descargue el libro de lectura de la hoja de datos del microcontrolador donde encontrará los pines detallados de varias placas de microcontroladores, incluido el ESP32.
En la función de configuración, establecemos la velocidad en baudios en 9600 que debe coincidir con la velocidad en baudios del monitor en serie del IDE de Arduino.
La función de bucle comienza leyendo el valor del sensor analógico del pin analógico que configuramos al inicio del script. El valor del sensor se almacena en una variable de tipo float. Ahora imprimimos el valor del sensor en el monitor en serie y esperamos 30 segundos para iniciar la función de bucle nuevamente.
La siguiente imagen muestra los valores del sensor en la serie de salida.
Cómo aumentar la vida útil del sensor de humedad del suelo resistivo
Como se describe en el capítulo de características de este tutorial, la electrólisis del sensor resistivo de humedad del suelo es causada por el flujo de corriente a través del ánodo. Para evitar el flujo de corriente al sensor, utilizamos un circuito MOSFET de canal N para desconectar el sensor de la fuente de alimentación. También leemos el valor del sensor solo una vez por hora.
Como no queremos esperar una hora por un nuevo valor de sensor, usamos un retraso de 30 segundos en el siguiente ejemplo. Entonces, todo lo que tiene que hacer es cambiar la fecha límite de su proyecto.
La siguiente imagen muestra el circuito MOSFET de canal N con el sensor de humedad del suelo para las diferentes placas de microcontroladores.
#define SensorPin A0
void setup() {
Serial.begin(9600);
pinMode(4, OUTPUT);
}
void loop() {
digitalWrite(4, HIGH);
delay(1000);
float sensorValue = analogRead(SensorPin);
Serial.println(sensorValue);
delay(1000);
digitalWrite(4, LOW);
delay(28000);
}
Al comienzo del script de Arduino, configuramos el pin analógico del microcontrolador. Para las placas Arduino y ESP8266 usamos el pin A0 y para ESP32 configuramos el pin 4 como entrada analógica.
En la función de configuración, establecemos la velocidad en baudios en 9600, que debe coincidir con la velocidad en baudios del Arduino IDE para ver los valores del sensor que queremos imprimir en la conexión en serie entre el microcontrolador y la PC.
También configuramos el pin de salida digital que está conectado a la puerta del MOSFET para encender y apagar el sensor. Para las placas Arduino, utilizamos el pin digital 4, el pin D4 de ESP8266 y el pin 0 de ESP32 como pin de salida digital. Solo tienes que comentar las líneas del microcontrolador que no necesitas.
En la función de bucle, leemos el valor del sensor de humedad cada 30 segundos. Por lo tanto, usamos el pin digital para activar el flujo de corriente a la puerta del MOSFET. Esto cierra el circuito del sensor de humedad del suelo y leemos el valor del sensor analógico después de un breve retraso de 1 segundo. Después de que el valor del sensor se imprime en el monitor en serie, esperamos 1 segundo y apagamos el flujo de corriente a través del sensor tirando de la puerta del MOSFET LOW.
Debido a que queremos leer el valor del sensor cada 30 segundos en este ejemplo y ya tenemos dos retrasos de 1 segundo en el script de Arduino, esperamos 28 segundos para que finalice el código del programa.
Ejemplo de MQTT para monitorización a largo plazo
En el siguiente ejemplo, quiero observar la humedad del suelo de una planta durante mucho tiempo y ver el cambio en la humedad como un gráfico de líneas. Por lo tanto, estoy construyendo un sistema MQTT que incluye los siguientes componentes:
- NodeMCU para leer los valores del sensor de humedad del suelo analógico y enviarlos cada hora a través de MQTT a un agente de MQTT
- Raspberry Pi como un corredor de MQTT que registra los valores de humedad en una base de datos de Influx y visualiza la humedad del suelo del avión a través de Grafana.
La siguiente tabla le brinda una descripción general de todos los componentes y partes que utilicé para todo este tutorial. Para el ejemplo de MQTT, solo necesita un microcontrolador ESP8266 o ESP32 y una sola Raspberry Pi. Recibo comisiones por las compras realizadas a través de los enlaces de esta tabla.
| Arduino Nano | Amazon | AliExpress |
| Arduino Pro Mini | Amazon | AliExpress |
| Arduino Uno | Amazon | AliExpress |
| Arduino Mega | Amazon | AliExpress |
| ESP32 ESP-WROOM-32 | Amazon | AliExpress |
| ESP8266 NodeMCU | Amazon | AliExpress |
| ESP8266 WeMos D1 Mini | Amazon | AliExpress |
| Kit Raspberry Pi 4 modelo B | Amazon | AliExpress |
| Raspberry Pi 4 Modelo B | Amazon | AliExpress |
| Kit Raspberry Pi 3 B + | Amazon | AliExpress |
| Raspberry Pi 3 B+ Motherboard | Amazon | AliExpress |
| Sensor de humedad del suelo | Amazon | AliExpress |
Este ejemplo se relaciona fuertemente con dos artículos que escribí el mes pasado. Por lo tanto, aceleraré este ejemplo porque encontrará un tutorial paso a paso en los dos artículos siguientes:
- Comunicación entre microcontrolador y Raspberry Pi WiFi MQTT
- Visualice datos MQTT con InfluxDB y Grafana
Primero construimos la parte del NodeMCU para enviar los valores de los sensores al corredor MQTT. La siguiente imagen muestra el cableado del NodeMCU.
El código del programa es casi exactamente el mismo que usé para enviar la temperatura y la humedad al corredor de MQTT. Solo cambié el asunto MQTT, MQTT clientID y leí los valores de humedad para enviarlos a través de MQTT al mismo corredor existente. El código principal está dentro de la función de configuración, ya que estoy usando la función de sueño profundo del NodeMCU para reducir la electrólisis en el sensor de humedad del suelo.
Asegúrese de agregar el retraso antes de entrar en sueño profundo. Tuve algunos problemas, que el NodeMCU se apaga aunque el mensaje MQTT no se envió por completo.
#include "ESP8266WiFi.h" // Enables the ESP8266 to connect to the local network (via WiFi)
#include "PubSubClient.h" // Allows us to connect to, and publish to the MQTT broker
#define SensorPin A0
// WiFi
const char* ssid = "KabelBox-0174";
const char* wifi_password = "943476385562******";
// MQTT
// Make sure to update this for your own MQTT Broker!
const char* mqtt_server = "192.168.0.8";
const char* plant_topic = "plant";
const char* mqtt_username = "cdavid";
const char* mqtt_password = "cdavid";
// The client id identifies the ESP8266 device. Think of it a bit like a hostname (Or just a name, like Greg).
const char* clientID = "client_plant_test";
// Initialise the WiFi and MQTT Client objects
WiFiClient wifiClient;
PubSubClient client(mqtt_server, 1883, wifiClient); // 1883 is the listener port for the Broker
void connect_MQTT(){
Serial.print("Connecting to ");
Serial.println(ssid);
// Connect to the WiFi
WiFi.begin(ssid, wifi_password);
// Wait until the connection has been confirmed before continuing
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
// Debugging - Output the IP Address of the ESP8266
Serial.println("WiFi connected");
Serial.print("IP address: ");
Serial.println(WiFi.localIP());
// Connect to MQTT Broker
// client.connect returns a boolean value to let us know if the connection was successful.
// If the connection is failing, make sure you are using the correct MQTT Username and Password (Setup Earlier in the Instructable)
if (client.connect(clientID, mqtt_username, mqtt_password)) {
Serial.println("Connected to MQTT Broker!");
}
else {
Serial.println("Connection to MQTT Broker failed...");
}
}
void setup() {
Serial.begin(9600);
connect_MQTT();
Serial.setTimeout(2000);
float sensorValue = analogRead(SensorPin);
Serial.println(sensorValue);
// PUBLISH to the MQTT Broker
if (client.publish(plant_topic, String(sensorValue).c_str())) {
Serial.println("Moisture sent!");
Serial.println(plant_topic);
}
// Again, client.publish will return a boolean value depending on whether it succeded or not.
// If the message failed to send, we will try again, as the connection may have broken.
else {
Serial.println("Moisture failed to send. Reconnecting to MQTT Broker and trying again");
client.connect(clientID, mqtt_username, mqtt_password);
delay(10); // This delay ensures that client.publish doesn't clash with the client.connect call
client.publish(plant_topic, String(sensorValue).c_str());
}
delay(1000);
ESP.deepSleep(0.2*60e6);
}
void loop() {
}
Ahora, NodeMCU envía la humedad actual del suelo cada hora al corredor de MQTT. La siguiente tarea es escribir un script puente que lea la carga útil de MQTT y lo escriba en la base de datos de Influx. Para esta tarea, puede encontrar una guía paso a paso en el artículo Visualizar datos MQTT con InfluxDB y Grafana.
Creé una nueva base de datos de Influx llamada «sol_moisture» y un nuevo usuario de Influx «mqtt_moisture» con la contraseña «mqtt_moisture». También he otorgado todos los derechos para esta nueva base de datos al nuevo usuario.
import re
from typing import NamedTuple
import paho.mqtt.client as mqtt
from influxdb import InfluxDBClient
INFLUXDB_ADDRESS = '192.168.0.8'
INFLUXDB_USER = 'mqtt_moisture'
INFLUXDB_PASSWORD = 'mqtt_moisture'
INFLUXDB_DATABASE = 'soil_moisture'
MQTT_ADDRESS = '192.168.0.8'
MQTT_USER = 'cdavid'
MQTT_PASSWORD = 'cdavid'
MQTT_TOPIC = 'plant'
MQTT_CLIENT_ID = 'MQTTInfluxDBBridge_moisture'
influxdb_client = InfluxDBClient(INFLUXDB_ADDRESS, 8086, INFLUXDB_USER, INFLUXDB_PASSWORD, None)
def on_connect(client, userdata, flags, rc):
""" The callback for when the client receives a CONNACK response from the server."""
print('Connected with result code ' + str(rc))
client.subscribe(MQTT_TOPIC)
def on_message(client, userdata, msg):
"""The callback for when a PUBLISH message is received from the server."""
print(msg.topic + ' ' + str(msg.payload))
sensor_data = float(msg.payload)
if sensor_data is not None:
_send_sensor_data_to_influxdb(sensor_data)
def _send_sensor_data_to_influxdb(sensor_data):
json_body = [
{
'measurement': 'soil_moisture',
'tags': {
'location': 'livingroom'
},
'fields': {
'value': sensor_data
}
}
]
influxdb_client.write_points(json_body)
def _init_influxdb_database():
databases = influxdb_client.get_list_database()
if len(list(filter(lambda x: x['name'] == INFLUXDB_DATABASE, databases))) == 0:
influxdb_client.create_database(INFLUXDB_DATABASE)
influxdb_client.switch_database(INFLUXDB_DATABASE)
def main():
_init_influxdb_database()
mqtt_client = mqtt.Client(MQTT_CLIENT_ID)
mqtt_client.username_pw_set(MQTT_USER, MQTT_PASSWORD)
mqtt_client.on_connect = on_connect
mqtt_client.on_message = on_message
mqtt_client.connect(MQTT_ADDRESS, 1883)
mqtt_client.loop_forever()
if __name__ == '__main__':
print('MQTT to InfluxDB bridge Moisture')
main()
Ahora los valores de los sensores se almacenan en la base de datos de Influx para que podamos crear un tablero en Grafana. En Grafana, puede crear una nueva fuente de datos. Utilice la base de datos de Influx y el nombre de usuario y la contraseña que definió anteriormente.
Ahora puede crear un nuevo tablero y ver la humedad del suelo de sus plantas en casa. La siguiente imagen es la que recopilé datos durante varios días. Puede ver claramente cómo los valores del sensor alcanzan 980 a lo largo de los días. Entre el 12.01. y 13.01 la planta recibió agua y los valores del sensor caen a alrededor de 750. Los días siguientes los valores del sensor aumentan nuevamente y ahora sé exactamente cuándo mi planta necesita agua.
Conclusión
Espero que con este tutorial ahora tenga una buena comprensión del sensor de humedad del suelo. Traté de mantener la teoría del sensor lo más breve posible porque la funcionalidad del sensor no es muy compleja de entender. Así que traté de enfocarme en un buen ejemplo de trabajo usando MQTT, InfluxDB y Grafana para construir un buen sistema de monitoreo para sus plantas en casa.
Espero que este artículo te complacerá. Si tiene alguna pregunta sobre el sensor de humedad o el ejemplo de MQTT, utilice la sección de comentarios a continuación para hacer sus preguntas. Les respondo lo antes posible.
