ESP32 Soil Moisture Sensor Guide: Complete DIY Tutorial

Improper soil moisture management is a leading cause of houseplant decline, contributing to up to 80% of plant deaths. As a new media artist, I am currently working on an interactive art installation titled The Importance of Life, which explores the critical importance of water to sustaining life on Earth. In developing this project, I created a modular soil moisture sensor system using the ESP32 microcontroller.

This guide outlines the process I used to design a smart, WiFi-enabled soil monitoring module for my installation. While it serves as a vital component of my artwork, this system is also practical for general use, offering a scalable solution for anyone interested in plant care or IoT-based soil monitoring.

With over 10+ years of experience programming microcontrollers, I bring a deep understanding of designing and implementing automation solutions for plant monitoring systems. In 2014, I was Greece’s nominee at the 26th EU Contest for Young Scientists with my research on the “Design and Implementation of an Automated Ultrasonic System for Remote Monitoring and Recording of Plant Growth Dynamics“.

Why Monitor Soil Moisture?

Maintaining proper soil moisture levels is critical for plant health and growth. Overwatering can lead to root rot and nutrient loss, while underwatering stresses plants and hinders growth. A soil moisture sensor provides precise, real-time feedback to help you maintain optimal conditions for your plants. By taking the guesswork out of watering, these sensors not only promote healthier plants but also improve water efficiency and, for crops, can significantly enhance yield.

What You’ll Need

To create your soil monitoring system, you’ll need the following components:

1. ESP32 microcontroller: The central processing unit for the project, responsible for data handling and WiFi-enabled connectivity (I’m using the LilyGo T-Display S3 for this guide).
2. Capacitive soil moisture sensor: Ideal for accurate readings and resistant to interference from fertilizers and chemicals.
3. SquareLine Studio: A tool for designing user interfaces if you plan to integrate visual data displays (optional but I’ll show you how).
4. Connecting wires and a breadboard: Essential for prototyping and connecting the components.
5. Power supply: To ensure a stable and consistent power source for the system.

Project Benefits

Leveraging the ESP32 microcontroller for soil moisture sensing offers several key advantages:

• Cost-effectiveness: The ESP32 is affordable and widely available, making it an excellent choice for both beginners and experienced developers.
• Remote monitoring: Use features like ESP32 WiFi setup to monitor your garden’s soil moisture levels from a smartphone or computer.
• Expandable functionality: The ESP32 is highly versatile, allowing integration with other sensors for advanced systems like automated irrigation or greenhouse climate control.

By following this guide, you’ll develop a robust, modular system for real-time plant monitoring. Beyond soil moisture, this setup can serve as a foundation for future projects like smart garden automation, moisture level alerts, and more.

Understanding ESP32 and Soil Moisture Sensors

ESP32: A Gardener’s Powerful Ally

The ESP32 microcontroller is a versatile tool for creating tech-driven gardening solutions. Equipped with Wi-Fi and Bluetooth capabilities, it enables real-time monitoring and control of your systems from virtually anywhere. With its GPIO pins and support for interfaces like I2C, SPI, and UART, the ESP32 is well-suited for integrating with various IoT plant monitoring components. Whether you’re tracking soil moisture while working from home or designing an automated irrigation system, the ESP32 provides the reliability and flexibility to bring your ideas to life.

Choosing the Right Soil Moisture Sensor: Capacitive vs. Resistive

Selecting the right soil moisture sensor is key to accurate and long-lasting results. Let’s look at the two main options:

1. Capacitive Soil Moisture Sensors: These sensors measure changes in capacitance due to soil moisture. They are more durable, resist corrosion, and perform reliably even in soil with fertilizers, making them ideal for long-term use.
2. Resistive Soil Moisture Sensors: These operate by measuring resistance between two electrodes. While they are cost-effective, they are prone to rusting and can be affected by high salinity in the soil, limiting their accuracy and lifespan.

Why the ESP32 is Perfect for Soil Monitoring

The ESP32 stands out as a smart choice for soil monitoring systems for several reasons:

• Remote Monitoring: The built-in Wi-Fi allows you to track soil moisture through an ESP32 web server or an MQTT broker from anywhere.
• Data Logging: Store moisture levels on an SD card or in the cloud to analyze patterns and optimize watering schedules.
• Integration Potential: Compatible with smart garden automation setups and IoT platforms, the ESP32 enables advanced features like moisture level alerts and automated irrigation systems.

Essential Gear for Your Soil Monitoring System

Ready to build your system? Here’s what you’ll need:

To dive deeper, explore our expert tips on sensor calibration, ESP32 irrigation wiring, and soil sensor placement. With a clear understanding of the ESP32 and its role in soil moisture sensing, you’re well on your way to developing an eco-friendly and efficient smart garden system. From moisture threshold alerts to automated irrigation systems, the possibilities are endless. 🌱

Hardware Setup and Wiring: Building Your ESP32 Soil Moisture Sensor

Setting up your ESP32 soil moisture sensor system is straightforward if you follow the steps carefully. Here’s how to get everything connected and running smoothly.

For more on the LilyGo T-Display S3, see my ESP32 greenhouse ventilation system.

Step-by-Step Wiring Guide

Connect your components as follows:

Setting up your ESP32 soil moisture sensor system requires using an Analog to Digital Converter (ADC) Pin to read the sensor’s output. Keep in mind that the available ADC pins vary depending on the ESP32 board model you are using. It’s important to consult the pinout diagram for your specific board.

For example, if you’re using the LilyGo T-Display S3, here’s the recommended configuration:

If you’re using a different ESP32 board, you must identify the ADC-capable GPIO pins from the board’s documentation or pinout diagram. Look for pins marked as ADCx, where “x” indicates the channel number.

Quick Wiring Tip:

• Power Source: Ensure the soil moisture sensor is powered through the 3.3V pin of the ESP32 to avoid damage or inaccurate readings.
• Connections: Use short, secure jumper wires to minimize noise interference in your readings.

Keeping It Dry: Waterproofing Tips

When working with soil moisture sensors and electronics in damp environments, waterproofing is essential to ensure durability and safety. Proper waterproofing protects your components from damage caused by moisture, extending the lifespan of your system.

Recommended Waterproofing Materials:

Tips for Placing Your Sensor Just Right

Proper placement of your soil moisture sensor is critical for accurate and reliable data. Follow these guidelines to optimize your system’s performance:

For optimal results, calibrate your sensor before placement to adjust for soil type and conditions. Refer to my guide on ESP32 moisture sensor calibration for detailed instructions.

With these tips, you’re well on your way to setting up a reliable and effective soil moisture monitoring system. Once your sensors are placed, test the setup and fine-tune as needed. Enhance your system further by integrating additional sensors like the ESP32 DHT22 for temperature and humidity tracking.

Programming the ESP32

Setting Up the Arduino IDE for ESP32

Before diving into code, ensure your Arduino IDE is set up to recognize the ESP32 board. Follow these steps:

1. Download and install the Arduino IDE from the official website.
2. Open Arduino IDE, then go to File > Preferences.
3. In the Additional Board Manager URLs field, add:
   https://dl.espressif.com/dl/package_esp32_index.json
4. Navigate to Tools > Board > Boards Manager, search for “ESP32,” and click Install.

To configure the Arduino IDE for the LilyGo T-Display S3 (used in this guide), follow these steps:

1. Download and install the Arduino IDE from the official website.
2. Open Arduino IDE, then go to File > Preferences.
3. In the Additional Board Manager URLs field, add:
   https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
4. Navigate to Tools > Board > Boards Manager, search for “ESP32,” and click Install.
5. After installation, go to Tools > Board > esp32 and Select “ESP32S3 Dev Module”.
6. Navigate to Tools and adjust the following settings:
   USB CDC On Boot: Enabled
   CPU Frequency: 240MHz (WiFi)
   Flash Size: 16MB (128Mb)
   PSRAM: OPI PSRAM
   Upload Speed: 921600
   USB Mode: CDC and JTAG
   Partition Scheme: 16M Flash (3M APP/9.9MB FATFS)
7. Download the necessary libraries from the LilyGo T-Display S3 GitHub repository.
8. Extract and place them into your Arduino libraries folder, typically located at: C:\Users\YourName\Documents\Arduino\libraries
9. Restart the Arduino IDE to recognize the new libraries.

By following these steps, your Arduino IDE will be configured to work seamlessly with the LilyGo T-Display S3, enabling you to develop and upload sketches effectively.

Installing Required Libraries for Soil Moisture Sensor System

To communicate with your ESP32 and soil moisture sensor, you’ll need to install the necessary libraries:

1. Open Arduino IDE.
2. Go to Sketch > Include Library > Manage Libraries.
3. Search for and install the following: WiFi, WebServer, Adafruit Sensor

Basic Code Structure Explanation

Here’s a starter example to get your ESP32 and soil moisture sensor up and running:

#include <WiFi.h>
#include <WebServer.h>
#include <TFT_eSPI.h> // Include the library for the TFT display

// WiFi credentials
const char* ssid = "YourWiFiSSID"; // Replace with your WiFi network name
const char* password = "YourWiFiPassword"; // Replace with your WiFi password

const int dryValue = 4095; // Replace with your calibrated dry soil reading
const int wetValue = 0;    // Replace with your calibrated wet soil reading

WebServer server(80); // Web server instance

// Define the GPIO pin for the sensor
const int sensorPin = 1; // ADC pin on the ESP32

// Initialize the TFT display
TFT_eSPI tft = TFT_eSPI();

void setup() {
  Serial.begin(115200); // Start the serial monitor for debugging

  // Turn on display power
  pinMode(15, OUTPUT);
  digitalWrite(15, HIGH);
  delay(500); // Small delay to ensure power is stabilized

  // Initialize the display
  tft.init();
  tft.setRotation(3);
  tft.fillScreen(TFT_BLACK);
  tft.setTextColor(TFT_WHITE, TFT_BLACK);
  tft.setTextSize(2);

  // Connect to WiFi
  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.println("Connecting to WiFi...");
  }

  Serial.println("Connected to WiFi");

  // Display WiFi status on the screen
  tft.fillScreen(TFT_BLACK);
  tft.setCursor(10, 10);
  tft.print("WiFi Connected!");
  tft.setCursor(10, 40);
  tft.print("IP: ");
  tft.print(WiFi.localIP());

  server.on("/", handleRoot); // Define a route for the web server
  server.begin();
}

void loop() {
  server.handleClient(); // Handle incoming HTTP requests

  // Read and display the sensor value
  int sensorValue = analogRead(sensorPin); // Read analog value from sensor
  int moisturePercentage = map(sensorValue, dryValue, wetValue, 0, 100); // Convert to percentage

  // Display the sensor value on the screen
  tft.fillRect(0, 70, 240, 30, TFT_BLACK); // Clear the previous value
  tft.setCursor(10, 70);
  tft.print("Moisture: ");
  tft.print(moisturePercentage);
  tft.print("%");

  delay(1000); // Update the screen every second
}

void handleRoot() {
  int sensorValue = analogRead(sensorPin); // Read analog value from sensor
  int moisturePercentage = map(sensorValue, 4095, 0, 0, 100); // Convert to percentage
  String message = "Soil Moisture: " + String(moisturePercentage) + "%";
  server.send(200, "text/plain", message); // Send the result via web server
}

This code displays both the WiFi connection status and the real-time soil moisture percentage on the LilyGO T-Display S3 screen. If you’re using a different ESP32 board, you can remove the TFT display functionality or customize it as needed. The full tutorial and code are available on my GitHub repository!

Calibration Process for Accurate Readings

To ensure your soil moisture sensor provides precise measurements, calibrate it to account for variations in soil type and environmental factors. Follow these steps:

1. Insert the sensor into completely dry soil and record the analog reading displayed in your serial monitor; this value will be your dryValue.
2. Submerge the sensor in water-saturated soil and record the analog reading; this value will be your wetValue.

Replace the following values in the example code to incorporate your calibrated sensor readings:

const int dryValue = 4095; // Replace with your calibrated dry soil reading
const int wetValue = 0;    // Replace with your calibrated wet soil reading

This ensures that the moisture percentage displayed on the screen and sent via the web server is based on your specific calibration values, providing accurate readings for your setup.

By incorporating these calibration steps, your sensor will deliver accurate, actionable data, allowing you to manage your plants’ watering needs with confidence.

WiFi and Cloud Integration for ESP32

Imagine your garden talking back to you, whether you’re relaxing in a hammock or on the go. By connecting your ESP32 to WiFi, running a web server, and logging data to the cloud, you can monitor and control your garden like a pro.

Connecting ESP32 to WiFi Network

Get your ESP32 online to start broadcasting soil moisture stats. Use the following code snippet to connect it to your WiFi:

#include <WiFi.h>

const char* ssid = "your_SSID"; // Replace with your WiFi network name
const char* password = "your_PASSWORD"; // Replace with your WiFi password

void setup() {
  Serial.begin(115200);
  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.println("Connecting to WiFi...");
  }
  Serial.println("Connected to WiFi");
}

void loop() {
}

Replace your_SSID and your_PASSWORD with your WiFi credentials and test the connection by monitoring the serial output for “Connected to WiFi”.

For more advanced options, visit my ESP32 Web Server guide.

Data Logging Options (SD Card vs. Cloud Platforms)

Track moisture trends over time by logging data. Choose between an SD card or a cloud platform:

Popular Cloud Platforms:

1. ThingSpeak: For simple data visualization and analysis.
2. Blynk: Offers real-time data and app-based controls.
3. Google Sheets: Log and graph data with spreadsheet tools.

Check out my ESP32 MySQL database setup guide to log data to a cloud server.

Real-time Monitoring Setup

Keep an eye on your garden in real-time by logging data to platforms like ThingsBoard:

#include <WiFi.h>
#include <HTTPClient.h>
#include <TFT_eSPI.h> // Include the TFT library for LilyGO T-Display

// WiFi credentials
const char* ssid = "your_SSID"; // Replace with your WiFi SSID
const char* password = "your_PASSWORD"; // Replace with your WiFi password

// ThingsBoard configuration
const char* tbServer = "http://your_thingsboard_server/api/v1/your_access_token/telemetry"; // Replace with your ThingsBoard server and access token

// TFT display setup
TFT_eSPI tft = TFT_eSPI();

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

  // Initialize the TFT display
  tft.init();
  tft.setRotation(3);
  tft.fillScreen(TFT_BLACK);
  tft.setTextColor(TFT_WHITE, TFT_BLACK);
  tft.setTextSize(2);

  // Display "Connecting to WiFi..." message
  tft.setCursor(10, 10);
  tft.print("Connecting to WiFi...");

  // Connect to WiFi
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.println("Connecting to WiFi...");
  }

  // Display "Connected to WiFi" message
  Serial.println("Connected to WiFi");
  tft.fillScreen(TFT_BLACK);
  tft.setCursor(10, 10);
  tft.print("WiFi Connected!");
  tft.setCursor(10, 40);
  tft.print("IP: ");
  tft.print(WiFi.localIP());
}

void loop() {
  if (WiFi.status() == WL_CONNECTED) {
    HTTPClient http;

    // Prepare telemetry payload
    String jsonPayload = "{\"moisture\":45}"; // Replace 45 with your actual moisture value

    // Make HTTP POST request to ThingsBoard
    http.begin(tbServer);
    http.addHeader("Content-Type", "application/json"); // Set the content type
    int httpResponseCode = http.POST(jsonPayload);

    // Handle HTTP response
    tft.fillRect(0, 70, 240, 30, TFT_BLACK); // Clear previous message
    tft.setCursor(10, 70);

    if (httpResponseCode > 0) {
      Serial.println("Data sent to ThingsBoard");
      tft.print("Data sent to ThingsBoard");
    } else {
      Serial.println("Failed to send data");
      tft.print("Failed to send data");
    }

    http.end();
  } else {
    tft.fillRect(0, 70, 240, 30, TFT_BLACK); // Clear previous message
    tft.setCursor(10, 70);
    tft.print("WiFi Disconnected!");
  }

  delay(15000); // Send telemetry data every 15 seconds
}

This will send the moisture value to ThingsBoard, where you can create dashboards and visualize the telemetry data. Adjust the payload to include other sensor readings as needed!

Building a Complete Modular Monitoring System: Integrating Art and Technology

In this section, I will walk you through how I developed a modular monitoring system for my interactive art installation, The Importance of Life. The system integrates the LilyGo T-Display S3, ESP-NOW protocol, and a master unit to monitor soil moisture levels while ensuring seamless communication between modules and a centralized server.

This modular approach not only simplifies environmental monitoring but also serves as the technological backbone of the installation, enabling real-time data visualization and automated responses.

Step 1: Designing the LilyGo T-Display User Interface

The LilyGo T-Display S3 is the heart of each monitoring module, equipped with a TFT screen for local data visualization. Using Squareline Studio, I crafted a user interface tailored to display real-time soil moisture data.

Creating the UI in Squareline Studio:

1. Choose Create then Arduino with TFT_eSPI: Resolution: 320×170,
   Color Depth: 16-bit, LVGL Version: 8.3.11, Theme: Dark
2. Design Elements: Soil moisture percentage prominently displayed. Connection status indicator for ESP-NOW communication.
   User-friendly layout with responsive color coding.
3. Exporting the Project: Squareline Studio generates a template project and UI files. These files integrate seamlessly with the Arduino environment for further customization.

Step 2: Adjusting the Template and Adding Core Functionality

Using the exported template, I added core functionality to the project. The LilyGo T-Display S3 reads soil moisture data from a capacitive sensor, displays it locally, and sends it to a master unit using the ESP-NOW protocol.

Key Adjustments in the Code:

• The soil sensor measures moisture levels as raw analog values, which are mapped to a percentage range (0–100%).
• Each module sends its data packet to the master unit, which aggregates data from multiple modules.

Step 3: Leveraging ESP-NOW for Wireless Communication

ESP-NOW is a low-power, peer-to-peer wireless protocol developed by Espressif Systems. It enables fast and efficient communication between ESP32 devices without requiring WiFi infrastructure.

How it Works:

1. Devices communicate using their MAC addresses.
2. Data packets are sent and received directly, reducing latency and power consumption.
3. Ideal for modular systems where multiple sensors need to send data to a central unit.

Each module in the system operates as a slave device, transmitting its data to a master unit. The master unit collects and aggregates the data from all connected modules and forwards it to a Node.js server using WebSockets for centralized processing and storage.

The system leverages the ESP-NOW protocol, which offers several key advantages:

• It is energy-efficient, enabling low-power operation that extends battery life
• it is scalable, allowing multiple peer-to-peer connections that are ideal for modular setups;
• it operates independently of WiFi infrastructure, ensuring reliable communication even in remote or isolated environments.

Step 4: Centralized Data Management with a Master Unit

The master unit serves as the central hub for all environmental data collected by the modules, performing critical tasks to ensure seamless operation. It aggregates data by receiving soil moisture, temperature, and humidity readings from multiple modules, processes the information, and formats it for transmission. Through WebSocket communication, the master unit transmits the data to a Node.js server, where it is stored in a MySQL database for further analysis.

Additionally, it manages environmental control by analyzing the collected data to adjust the plant’s microenvironment, such as activating watering systems or regulating humidity levels, ensuring optimal conditions for the plant’s health.

Step 5: Integration with The Importance of Life

The modular monitoring system is integral to the real-time functionality and artistic expression of my installation, The Importance of Life. It connects to the broader concept by powering responsive art, where soil moisture data directly influences the generative visuals displayed on the left screen, creating dynamic patterns that mirror the plant’s current state.

Additionally, historical data aggregated by the master unit is visualized on the right screen as “generational growth,” illustrating the plant’s environmental journey and its reliance on external conditions. To deepen audience engagement, live soil moisture readings are displayed on the TFT screen embedded in the installation, providing viewers with a direct and meaningful connection to the plant’s health and its dependence on water.

Through careful integration of hardware, software, and artistic intent, this modular system not only ensures precise environmental monitoring but also amplifies the installation’s message of interconnectedness and ecological stewardship.

Troubleshooting and Maintenance

Maintaining a reliable ESP32 soil moisture monitoring system involves addressing common issues, calibrating the sensor for accuracy, and following a consistent maintenance routine. Here’s a comprehensive guide based on my experience:

Common issues and solutions

Sensor calibration tips

Calibrating the sensor ensures accurate soil moisture readings and improves decision-making for plant care. Follow these steps to fine-tune your sensor:

1. Immerse the Sensor: Submerge the sensor in water to establish the “wet” baseline. Record the analog value displayed during this state.
2. Dry the Sensor: Let the sensor dry completely in the air to identify the “dry” baseline. Record the value for calibration.
3. Use a Reference Medium: Test the sensor in various soil samples with known moisture levels to refine its accuracy. Compare these readings to the expected values and adjust the calibration accordingly.

By addressing these common challenges, calibrating regularly, and maintaining the sensor with care, your soil monitoring system will remain efficient and dependable. Explore more advanced techniques in my detailed calibration guide to further enhance performance.

Advanced Features and Applications

Enhance your ESP32 soil moisture sensor setup with advanced features that automate plant care, integrate weather data, and even leverage cutting-edge machine learning. By implementing these tricks, you can create a smart, self-sustaining gardening system that ensures your plants thrive with minimal intervention.

Weather Data Integration

Integrating weather data into your ESP32 system empowers you to make informed watering decisions, reducing waste and improving plant health. Combine real-time weather APIs with local sensor readings, such as temperature and humidity from a DHT22 sensor, to track environmental conditions with precision.

Automated Irrigation Control

Take the guesswork out of watering by setting up an automated irrigation system. Pair your ESP32 with a relay module and solenoid valve to control water flow based on soil moisture readings.

Using soil moisture thresholds and weather data, your ESP32 can manage water delivery precisely, minimizing waste and keeping your plants hydrated. For wiring and setup guidance, check out my ESP32 irrigation wiring diagram.

Data Visualization Techniques

Transform raw data into actionable insights with data visualization tools. By sending your ESP32’s sensor data to a web interface or dashboard, you can monitor trends over time and make informed decisions.

Machine Learning Possibilities

Integrate machine learning to elevate your system from reactive to predictive. By analyzing historical data, your ESP32 can anticipate watering needs and optimize irrigation schedules.

For example, using time series analysis, your system can predict future soil moisture levels based on past patterns, ensuring proactive care. Explore these possibilities in my ESP32 time series analysis guide.

Scaling to Larger Systems

Expand your setup to cover larger gardens or multiple zones by networking multiple ESP32 devices. Each device monitors a specific area, while a central hub (or a Master Unit) collects and processes data from all units.

This scalable architecture is ideal for managing expansive green spaces or interconnected ecosystems, with centralized control ensuring efficiency and consistency. My ESP32 climate control kits provide the tools to build such systems.

Subscribe

Join Steve’s Newsletter & connect with a community of art enthousiasts, new media artists & collectors exploring the intersection of art and technology.

Join Konnekt, Steve’s exploration of human behavior, where artistic research intersects with technology and AI, digital media, and new media art. Read how technology-driven creative processes offer insights into our perceptions of self and society.

Subscribe

By checking this box, you confirm that you have read and are agreeing to our terms of service.

Conclusion

Creating your own ESP32 soil moisture sensor system is a gateway to smarter, more efficient gardening and agricultural practices. With the insights and techniques shared in this guide, you’re now prepared to develop a reliable monitoring system that conserves water, saves time, and ensures the health of your plants.

Start with the basics—calibrate your sensors, establish stable connections, and build a foundational setup. As your confidence grows, expand your system with advanced features like automation, data visualization, and even predictive analytics.

For those who want to skip the technical setup and jump straight into smart gardening, I’ve got you covered with my ready-made soil moisture monitoring module. Encased in a durable, 3D-printed housing, it’s pre-calibrated and ready to use right out of the box. Whether you’re a hobbyist or a professional, this plug-and-play solution saves you time and ensures reliable performance.

Frequently Asked Questions (FAQ)