Skip to main content

Primeros Pasos con el Sensor de Humedad del Suelo XIAO


Consíguelo Ahora 🖱️

Introducción​

El Sensor de Humedad del Suelo XIAO es un monitor ambiental compacto y de bajo consumo alimentado por el XIAO ESP32-C6. Funcionando con una sola batería AA, ofrece operación de larga duración y actualizaciones en tiempo real de las condiciones del suelo. Cuenta con Detección Adaptativa de Humedad del Suelo Pre-Calibrada para un monitoreo preciso del suelo. Además, permite intervalos de monitoreo dinámicos y lecturas instantáneas para datos precisos y responsivos. Totalmente compatible con Home Assistant, es ideal para jardinería inteligente y agricultura de precisión: eficiente, confiable y diseñado para el cuidado sostenible de plantas.

Características​

1.Monitoreo de Humedad del Suelo de Tres Niveles

  • 🌿 Normal: La humedad del suelo es óptima, no se necesita riego.
  • 🌤 Casi Seco: La humedad está disminuyendo, prepárate para regar pronto.
  • 🌵 Seco: Críticamente bajo, riega inmediatamente.

Umbrales predeterminados:

  • 60% → Transición de Verde a Amarillo.
  • 20% → Transición de Amarillo a Rojo.

2.Plug-and-Play con Home Assistant
Precargado con ESPHome: funciona inmediatamente con Home Assistant, permitiéndote monitorear y automatizar directamente desde tu panel de control de hogar inteligente.

3.Monitoreo Adaptativo y Lectura Instantánea

  • Ajusta automáticamente los intervalos de verificación (8h → 1h → 15min) dependiendo del nivel de humedad.
  • Presiona el botón una vez para obtener una lectura instantánea de humedad en cualquier momento.

4.Calibración Simple (Opcional)
Presiona rápidamente el botón tres veces para recalibrar para tu suelo específico: lectura seca + lectura húmeda → el sistema se ajusta automáticamente.

  • Triple presión corta → Entrar al modo de calibración:
    • LED rojo parpadea → Dentro de 10 segundos, inserta el sensor en suelo completamente seco.
    • Espera hasta que el LED rojo deje de parpadear, luego espera 3 segundos.
    • LED verde parpadea → Dentro de 10 segundos, inserta el sensor en suelo completamente húmedo.
    • Espera hasta que el LED verde deje de parpadear, luego espera 3 segundos.
    • Resultado de calibración:
      • Dos parpadeos verdes rápidos → Éxito.
      • Dos parpadeos rojos rápidos → Fallo (probablemente debido a lecturas seca/húmeda intercambiadas).

Nota: Durante la calibración, las lecturas iniciales pueden ser inestables si el sensor no se inserta rápidamente. El sistema tomará múltiples muestras, aplicará filtrado y promediará las lecturas para una calibración confiable.

Descripción del Hardware​

Primeros Pasos​

Esta sección te guiará a través de la configuración de tu Sensor de Humedad del Suelo XIAO por primera vez.

Materiales Requeridos​

Antes de que comience el contenido del tutorial de este artículo, es posible que necesites tener el siguiente hardware listo.

Sensor de Humedad del Suelo XIAOHome Assistant Green
Consíguelo Ahora 🖱️
Consíguelo Ahora 🖱️

Home Assistant Green es la forma más fácil y centrada en la privacidad de automatizar tu hogar. Ofrece una configuración sin esfuerzo y te permite controlar todos los dispositivos inteligentes con un solo sistema, donde todos los datos se almacenan localmente por defecto. Esta placa se beneficia del próspero ecosistema de Home Assistant y será mejorada cada mes por código abierto.

Recomendamos usar Home Assistant Green como el host de Home Assistant para este tutorial, o puedes usar cualquier host de Home Assistant con un Supervisor.

instalar Home Assistant

También hemos escrito cómo instalar Home Assistant para algunos productos de Seeed Studio, por favor consúltalos.

Si no estás usando un producto de Seeed Studio, también puedes verificar y aprender cómo instalar Home Assistant para otros productos en el sitio web oficial de Home Assistant.

Paso 1. Instalar ESPHome​

Si ya has instalado ESPHome, puedes omitir este paso.

Ve a Configuración -> Complementos -> TIENDA DE COMPLEMENTOS

Busca ESPHome y haz clic en él. Haz clic en INSTALAR e INICIAR.

tip

Si no puedes encontrar ESPHome en la tienda de complementos, asegúrate de estar usando una instalación de Home Assistant que soporte complementos (como Home Assistant OS o instalaciones supervisadas). Para otros tipos de instalación (como Home Assistant Container), es posible que necesites ejecutar el Constructor de Dispositivos ESPHome independientemente usando Docker. Consulta la documentación oficial de ESPHome para más detalles.

Y luego, ESPHome Builder aparecerá en la barra lateral.

Paso 2: Preparando el Sensor de Humedad del Suelo​

Por defecto, tu dispositivo (XIAO ESP32C6) viene pre-flasheado con firmware para el Sensor de Humedad del Suelo XIAO. Sin embargo, si necesitas modificar o actualizar el firmware predeterminado, un archivo de configuración YAML de fábrica está disponible en la sección de Recursos a continuación. Puedes personalizar la lógica según sea necesario y flashearlo a través de Home Assistant.

tip

Para asegurar lecturas precisas, simplemente realiza una calibración rápida del sensor antes del uso.

Paso 3: Configuración de Red​

  1. Habilitar Punto de Acceso:

    • Al encender por primera vez, el módulo creará una red Wi-Fi (SSID: Xiao-Soil-Moisture-Monitor).

  2. Acceder a la Configuración:

    • Conéctate a la red usando un teléfono o PC.
    • Abre un navegador y navega a http://192.168.4.1.
    • Ingresa el SSID y la contraseña de tu red Wi-Fi doméstica.
  1. Integración con Home Assistant:
    • Una vez conectado a la red doméstica, el módulo será descubrible en Home Assistant bajo Configuración -> Dispositivos y Servicios.

De esta manera, puedes conectar el módulo a tu red de Home Assistant y permitir que Home Assistant lo descubra.

Paso 4: Agregar el dispositivo del módulo​

  1. Descubrimiento Automático:

    • Asegúrate de que ESPHome esté instalado en Home Assistant.
    • Navega a Configuración -> Dispositivos y Servicios -> Integraciones y busca el dispositivo.

  2. Configuración Manual:

    • Si no se descubre automáticamente, agrega manualmente el dispositivo especificando su dirección IP.

Después de agregar el dispositivo, verás una nueva tarjeta de sensor llamada Solid_sensor en la página de Resumen de Home Assistant, mostrando tanto la medición de la batería como el estado actual de humedad del suelo.

Ahora que tu sensor de suelo está funcionando, ¡adelante y diviértete monitoreando tus plantas!

Uso Avanzado​

Puedes modificar la lógica del firmware original y flashear tu versión personalizada del sensor de suelo directamente a través de Home Assistant.

Paso 1. Instalar ESPHome​

Consulta la guía de instalación en el Paso 1 anterior.

Paso 2. Agregar un nuevo dispositivo​

Ve a ESPHome y haz clic en NUEVO DISPOSITIVO.

Dale al dispositivo un nombre que te guste y haz clic en SIGUIENTE.

Después de crear un nuevo dispositivo, haz clic en EDITAR.

Paso 3. Instalar firmware​

Aquí está el firmware de fábrica：

Descargar la Biblioteca

Aquí tienes una configuración YAML de ESPHome lista para usar con Home Assistant:

Haz clic aquí para previsualizar el código completo
esphome:
  name: soil-moisture-monitor
  friendly_name: XIAO Soil Moisture Monitor
  platformio_options:
    platform: https://github.com/mnowak32/platform-espressif32.git#boards/seeed_xiao_esp32c6
  on_boot: 
    then:
      # - output.turn_off: gpio_3_output
      - output.turn_on: gpio_14_output
      - light.turn_on:
          id: pwm_led
          brightness: 68%  # Set 68% duty cycle
      - if:
          condition:
            lambda: 'return id(wifi_net_status) == 0;'
          then:
            - logger.log: "The device has not been set to the network"
            - deep_sleep.prevent: deep_sleep_control
          else:
            - logger.log: "The device has been networked"
      - delay: 1s
      - script.execute: check_moisture_once

esp32:
  board: seeed_xiao_esp32c6
  variant: ESP32C6
  flash_size: 4MB    
  framework:
    type: esp-idf
    version: "5.2.1"
    platform_version: 6.6.0
    sdkconfig_options:
      CONFIG_ESPTOOLPY_FLASHSIZE_4MB: y

# LED Yellow D10 18
# LED RED D9  20
# LED Green D8 19
# button D2  2

# Battery D0 0
# PWM out D3 21
# Soil sensor D1  1

output:
  - platform: gpio
    pin: GPIO18
    id: yellow_led_output

  - platform: gpio
    pin: GPIO19
    id: green_led_output

  - platform: gpio
    pin: GPIO20
    id: red_led_output

  - platform: ledc
    pin: GPIO21  
    id: pwm_output
    frequency: 200kHz  # Set the frequency to 200kHz

  - platform: gpio
    pin: GPIO14
    id: gpio_14_output

light:
  - platform: binary
    id: yellow_led
    output: yellow_led_output

  - platform: binary
    id: green_led
    output: green_led_output

  - platform: binary
    id: red_led
    output: red_led_output

  - platform: monochromatic
    output: pwm_output
    id: pwm_led
    name: "200kHz PWM"
    internal: true
    default_transition_length: 0s

script:
  - id: red_led_blink
    mode: restart
    then:
      - repeat:
          count: 10
          then:
            - light.turn_on: red_led
            - delay: 500ms
            - light.turn_off: red_led
            - delay: 500ms

  - id: green_led_blink
    mode: restart
    then:
      - repeat:
          count: 10
          then:
            - light.turn_on: green_led
            - delay: 500ms
            - light.turn_off: green_led
            - delay: 500ms

  - id: fast_blink_green
    then:
      - repeat:
          count: 5
          then:
            - light.turn_on: green_led
            - delay: 200ms
            - light.turn_off: green_led
            - delay: 200ms

  - id: fast_blink_red
    then:
      - repeat:
          count: 5
          then:
            - light.turn_on: red_led
            - delay: 200ms
            - light.turn_off: red_led
            - delay: 200ms

  - id: red_led_blink_3_times
    then:
      - repeat:
          count: 1
          then:
            - light.turn_on: red_led
            - delay: 1000ms
            - light.turn_off: red_led
            - delay: 100ms
  - id: yellow_led_blink_3_times
    then:
      - repeat:
          count: 1
          then:
            - light.turn_on: yellow_led
            - delay: 1000ms
            - light.turn_off: yellow_led
            - delay: 100ms

  - id: green_led_blink_3_times
    then:
      - repeat:
          count: 1
          then:
            - light.turn_on: green_led
            - delay: 1000ms
            - light.turn_off: green_led
            - delay: 100ms

  - id: do_calibration
    then:
      - deep_sleep.prevent: deep_sleep_control
      - logger.log: "Starting calibration"
      - script.execute: red_led_blink
      - delay: 10s
      - script.stop: red_led_blink
      - lambda: |-
          float sum = 0;
          for (int i = 0; i < 10; i++) {
            id(soil_sensor).update();
            sum += id(soil_sensor).state;
            delay(200);
          }
          id(dry_value) = sum / 10.0;
          ESP_LOGI("calibration", "Dry value: %f", id(dry_value));

      - delay: 3s

      - script.execute: green_led_blink
      - delay: 10s
      - script.stop: green_led_blink
      - lambda: |-
          float sum = 0;
          for (int i = 0; i < 10; i++) {
            id(soil_sensor).update();
            sum += id(soil_sensor).state;
            delay(200);
          }
          id(wet_value) = sum / 10.0;
          ESP_LOGI("calibration", "Wet value: %f", id(wet_value));

      - delay: 3s

      - lambda: |-
          if (id(dry_value) > id(wet_value)) {
            ESP_LOGI("calibration", "Calibration success");
            id(fast_blink_green).execute();
          } else {
            ESP_LOGW("calibration", "Calibration failed");
            id(fast_blink_red).execute();
          }

      - delay: 3s
      - script.execute: check_moisture_once
      - delay: 3s
      - deep_sleep.enter: deep_sleep_control

  - id: check_moisture_once
    then:
      - lambda: |-
          for(int i = 0; i < 10; i++){
            id(soil_sensor).update();
            delay(200);
          }
          float moisture = id(soil_sensor).state;
          ESP_LOGI("moisture_check", "Moisture reading: %f", moisture);
          float Diff = id(dry_value) - id(wet_value);
          ESP_LOGI("moisture_check", "Diff is: %f", Diff);
          ESP_LOGI("moisture_check", "ref_dry Diff is: %f",id(dry_value) - Diff * id(ref_dry));
          ESP_LOGI("moisture_check", "ref_wet Diff is: %f",id(dry_value) - Diff * id(ref_wet));
          if (moisture >= (id(dry_value) - Diff * id(ref_dry))) {  // The drier -> the higher the voltage
            id(red_led_blink_3_times).execute();
            id(deep_sleep_control).set_sleep_duration(900000);
          } else if(moisture >  (id(dry_value) - Diff * id(ref_wet)) && moisture < (id(dry_value) - Diff * id(ref_dry))){
            id(yellow_led_blink_3_times).execute();
            id(deep_sleep_control).set_sleep_duration(3600000);
          }else{
            // moisture >  (id(dry_value) - Diff * id(ref_wet))
            id(green_led_blink_3_times).execute();
            id(deep_sleep_control).set_sleep_duration(28800000);
          }

globals:
  - id: button_press_count
    type: int
    restore_value: no
    initial_value: '0'
  - id: dry_value
    type: float
    restore_value: yes
    initial_value: '2.75'
  - id: wet_value
    type: float
    restore_value: yes
    initial_value: '1.2'
  - id: wifi_net_status
    type: int
    restore_value: yes
    initial_value: "0"
  - id: ref_dry
    type: float
    restore_value: no
    initial_value: "0.23"
  - id: ref_wet
    type: float
    restore_value: no
    initial_value: "0.58"

binary_sensor:
  - platform: gpio
    pin:
      number: GPIO2
      mode: INPUT_PULLUP
      allow_other_uses: true
    id: my_button
    on_press:
      - lambda: |-
          id(button_press_count)++;
      - delay: 1s  # Delay 1 second to see if the button is pressed 3 times in a row
      - lambda: |-
          if (id(button_press_count) == 3) {
            id(button_press_count) = 0;
            id(do_calibration).execute();  // Trigger calibration process
          } else if (id(button_press_count) == 1) {
            id(button_press_count) = 0;
            id(check_moisture_once).execute();  // Perform an ADC decision
          } else {
            id(button_press_count) = 0;
          }

deep_sleep:
  id: deep_sleep_control
  run_duration: 120s  
  sleep_duration: 180min  
  wakeup_pin: 
    number: GPIO2 
    inverted: true
    allow_other_uses: true
    mode: INPUT_PULLUP


external_components:
  - source: github://pr#7942
    components: [ "adc" ]

  - source:
      type: git
      url: https://github.com/ackPeng/esphome.git
      ref: api
    components: [ api ]
    refresh: 0s

sensor:
  - platform: adc
    id: soil_sensor
    pin: GPIO1
    name: "Soil moisture measurement"
    update_interval: 4s
    internal: true
    attenuation: 12db


  - platform: adc
    pin: GPIO0
    name: "Battery measurement"
    attenuation: 12db
    filters:                     # When the battery drops below 1V, it is dead.
      - lambda: |-
          if (x < 1.0) {
            return 0.0;
          } else {
            return ((x - 1.0) / (1.5 - 1.0)) * 100.0;
          } 
    unit_of_measurement: "%"
    update_interval: 5s
    force_update: True

  - platform: wifi_signal
    name: "wifi singnal strength"
    update_interval: 10s

text_sensor:
  - platform: template
    name: "Soil Moisture Status"
    id: soil_status
    lambda: |-
      float value = id(soil_sensor).state;
      float Diff = id(dry_value) - id(wet_value);
      if (value >= (id(dry_value) - Diff * id(ref_dry))) {
        return {"Dry"};
      } else if (value > (id(dry_value) - Diff * id(ref_wet)) && value < (id(dry_value) - Diff * id(ref_dry))) {
        return {"Almost Dry"};
      } else {
        return {"Normal Moisture"};
      }
    update_interval: never  # 不让自动触发上报，我们自己控制

interval:
  - interval: 5s
    then:
      - text_sensor.template.publish:
          id: soil_status
          state: !lambda |-
            return "";
      - delay: 10ms
      - text_sensor.template.publish:
          id: soil_status
          state: !lambda |-
            float value = id(soil_sensor).state;
            float Diff = id(dry_value) - id(wet_value);
            if (value >= (id(dry_value) - Diff * id(ref_dry))) {
              id(deep_sleep_control).set_sleep_duration(900000);
              return "Dry";
            } else if (value > (id(dry_value) - Diff * id(ref_wet)) && value < (id(dry_value) - Diff * id(ref_dry))) {
              id(deep_sleep_control).set_sleep_duration(3600000);
              return "Almost Dry";
            } else {
              id(deep_sleep_control).set_sleep_duration(28800000);
              return "Normal Moisture";
            }  

# Enable logging
logger:

improv_serial:

# Enable Home Assistant API
api:
  # encryption:
    # key: "YVjz+1l5zHXeyXFVinhaJkqh8RnG0gUVjaWniPEzCj4="

ota:
  - platform: esphome
    password: "dcad8df988971d761bc72a30d7878a40"

wifi:
  # ssid: "my68k"
  # password: "1143590135"
  on_connect:
    then:
      - if:
          condition:
            lambda: 'return id(wifi_net_status) == 0;'
          then:
            - logger.log: "The device has not been configured yet, but now it is successfully configured"
            - globals.set:
                id: wifi_net_status
                value: '1'
            - delay: 5s
            - deep_sleep.allow: deep_sleep_control
          else:
            - logger.log: "The device has been networked"

  on_disconnect:
    then:
      - globals.set:
          id: wifi_net_status
          value: '0'
  # Enable fallback hotspot (captive portal) in case wifi connection fails
  ap:
    ssid: "Xiao-Soil-Moisture-Monitor"
    password: ""

captive_portal:
Aquí tienes una descripción general de las funciones clave y la lógica utilizada en la configuración YAML.

on_boot – Define lo que sucede cuando el dispositivo se inicia.

  • Parámetros de entrada: Ninguno.
  • Acción: Enciende GPIO 14, establece el brillo del LED PWM, verifica el estado del Wi-Fi y activa la primera verificación de humedad.

scripts (red_led_blink, green_led_blink, fast_blink_green, fast_blink_red, etc.) – Patrones de parpadeo de LED predefinidos.

  • Parámetros de entrada: Ninguno.
  • Acción: Hace parpadear los LEDs en varios patrones para indicar estado o pasos de calibración.

do_calibration – Ejecuta el proceso de calibración para suelo seco y húmedo.

  • Parámetros de entrada: Ninguno.
  • Acción: Hace parpadear el LED rojo, espera la lectura en seco; luego hace parpadear el LED verde, espera la lectura húmeda; almacena valores promedio y confirma éxito o fallo.

check_moisture_once – Lee y evalúa los niveles de humedad del suelo.

  • Parámetros de entrada: Ninguno.
  • Acción: Toma múltiples lecturas ADC, las promedia, las compara con umbrales calibrados, decide el estado de humedad, activa LED y configuraciones de sueño profundo en consecuencia.

binary_sensor (GPIO2) – Maneja la lógica de presión del botón físico.

  • Parámetros de entrada: Ninguno.
  • Acción: Cuenta las presiones del botón; una sola presión activa una verificación de humedad, triple presión activa la calibración.

globals – Almacena el estado del sistema y datos de calibración.

  • Variables:
    • button_press_count: Rastrea el conteo de presiones del botón.
    • dry_value, wet_value: Almacena valores ADC calibrados seco/húmedo.
    • wifi_net_status: Rastrea el estado de conexión Wi-Fi.
    • ref_dry, ref_wet: Factores de escala de referencia para cálculos de umbral.

deep_sleep – Gestiona los ciclos de sueño para ahorro de energía.

  • Parámetros de entrada: Ninguno.
  • Acción: Funciona durante 120 segundos, luego duerme hasta 180 minutos; se despierta con presión del botón o intervalo.

sensor (ADC) – Lee valores analógicos del sensor de suelo y batería.

  • Parámetros de entrada: Ninguno.
  • Acción: Mide la humedad del suelo y voltaje de la batería; la batería se escala para mostrar porcentaje.

text_sensor – Publica el estado de humedad del suelo legible para humanos.

  • Parámetros de entrada: Ninguno.
  • Acción: Muestra "Seco", "Casi Seco", o "Humedad Normal" en Home Assistant.

wifi + api + ota – Gestiona la conexión de red, integración con Home Assistant y actualizaciones de firmware por aire.

  • Parámetros de entrada: SSID y contraseña de Wi-Fi.
  • Acción: Conecta el dispositivo a la red, expone su API y habilita actualizaciones remotas.

Haz clic en INSTALL para instalar el código en el dispositivo y verás la siguiente imagen.

tip

Si tu Host de Home Assistant (Raspberry PI/Green/Yellow etc.) está lejos de ti, recomendamos usar este método. Puedes instalarlo con la computadora que tengas a mano.

Primero, necesitas hacer clic en Manual download para descargar el firmware compilado.

Abre este sitio web donde subiremos el firmware al panel ePaper.

Regresa a ESPHome para descargar el firmware.

Selecciona Factory format.

Usa un cable USB para conectar el panel ePaper a tu computadora y haz clic en CONNECT.

Selecciona usbmodemxxx(Windows es COMxxx) y haz clic en connect.

Haz clic en INSTALL y selecciona el firmware que acabas de descargar.

Tu firmware se flasheará en breve ～

Restablecer​

Si el firmware necesita ser reflasheado, puedes usar el siguiente enlace para restaurar el firmware predeterminado:
https://gadgets.seeed.cc/

Conecta tu dispositivo a tu computadora primero.
Luego, encuentra XIAO Soil Moisture Monitor en la página y haz clic en Connect para proceder con el reflasheo.

Recursos​

Soporte Técnico y Discusión del Producto​

¡Gracias por elegir nuestros productos! Estamos aquí para brindarte diferentes tipos de soporte para asegurar que tu experiencia con nuestros productos sea lo más fluida posible. Ofrecemos varios canales de comunicación para atender diferentes preferencias y necesidades.

Loading Comments...