💧 Soil Moisture Sensor - Complete Guide for Smart Irrigation

📊 Why Soil Moisture Monitoring Matters for Your Farm

🔌 Complete Wiring Diagram

═══════════════════════════════════════════════════════════════════
           CAPACITIVE SOIL MOISTURE SENSOR WIRING
═══════════════════════════════════════════════════════════════════

                    Capacitive Sensor          ESP32/ESP8266
                    ════════════════          ════════════
                    
                    VCC (Red)        ───►     3.3V or 5V
                    GND (Black)      ───►     GND
                    AO (Analog Out)  ───►     GPIO32 (ESP32)
                                           or A0 (ESP8266)*
                    
*ESP8266 WARNING: A0 only accepts 0-1.0V!
Use voltage divider if using 3.3V sensor:
    3.3V ──┬── 10kΩ ──┬── A0 (ESP8266)
           │          │
           └── 20kΩ ──┴── GND
This divides 3.3V to 1.0V for ESP8266!

═══════════════════════════════════════════════════════════════════
              RESISTIVE SENSOR (NOT RECOMMENDED)
═══════════════════════════════════════════════════════════════════

                    VCC ───► 3.3V (NOT 5V! It heats the soil!)
                    GND ───► GND
                    AO  ───► GPIO32

⚠️ Resistive sensors use DC current through soil - this causes:
   - Electrode corrosion within 2-4 weeks
   - Electrolysis that changes soil chemistry  
   - Salt buildup affecting readings
   - AVOID AT ALL COSTS!
    

📚 Calibration Guide (Most Important Step!)

💻 Production-Ready Arduino Code

/*
 * Professional Soil Moisture Monitor
 * Works with ESP32, ESP8266, Arduino
 * 
 * Features:
 * - Moving average filter for stable readings
 * - Automatic calibration mode
 * - Agricultural recommendations
 * - Deep sleep support for battery operation
 */

#include 

// ========== CONFIGURATION ==========
#ifdef ESP32
    #define SOIL_PIN 32          // GPIO32 for ESP32
#elif defined(ESP8266)
    #define SOIL_PIN A0          // A0 for ESP8266 (needs voltage divider)
#else
    #define SOIL_PIN A0          // Default for Arduino
#endif

// ========== CALIBRATION VALUES (REPLACE WITH YOURS!) ==========
const int DRY_VALUE = 3800;      // Reading in dry air (calibrate this!)
const int WET_VALUE = 1500;      // Reading in water (calibrate this!)

// Agricultural thresholds
const int VERY_DRY = 20;         // Below 20% - Critical! Water immediately
const int DRY_THRESHOLD = 35;     // Below 35% - Needs watering
const int OPTIMAL_MIN = 45;       // Ideal range: 45-70%
const int OPTIMAL_MAX = 70;       
const int WET_THRESHOLD = 85;     // Above 85% - Too wet, risk of root rot

// Filter settings for stable readings
const int SAMPLE_COUNT = 10;      // Number of samples to average
const int SAMPLE_DELAY_MS = 100;  // Delay between samples (ms)

// ========== GLOBAL VARIABLES ==========
int samples[SAMPLE_COUNT];
int sampleIndex = 0;
long sampleSum = 0;

void setup() {
    Serial.begin(115200);
    pinMode(SOIL_PIN, INPUT);
    
    Serial.println("═══════════════════════════════════════════");
    Serial.println("💧 PROFESSIONAL SOIL MOISTURE MONITOR v2.0");
    Serial.println("   Precision Agriculture System");
    Serial.println("═══════════════════════════════════════════");
    Serial.println();
    
    // Validate calibration
    if (DRY_VALUE == 3800 && WET_VALUE == 1500) {
        Serial.println("⚠️ WARNING: Using EXAMPLE calibration values!");
        Serial.println("   Please calibrate for YOUR sensor!");
        Serial.println("   Dry value: 3800 (example)");
        Serial.println("   Wet value: 1500 (example)");
        Serial.println();
    }
}

// Read sensor with moving average filter
int readSoilMoisture() {
    // Take multiple samples for stability
    long sum = 0;
    for (int i = 0; i < SAMPLE_COUNT; i++) {
        sum += analogRead(SOIL_PIN);
        delay(SAMPLE_DELAY_MS);
    }
    int raw = sum / SAMPLE_COUNT;
    
    // Convert to percentage
    int percentage = map(raw, DRY_VALUE, WET_VALUE, 0, 100);
    
    // Clamp to valid range
    if (percentage < 0) percentage = 0;
    if (percentage > 100) percentage = 100;
    
    // Return raw value and percentage
    return percentage;
}

// Get crop-specific recommendation
String getCropRecommendation(int moisture, const char* crop) {
    if (moisture < VERY_DRY) {
        return String(crop) + ": CRITICAL! Water immediately!";
    } else if (moisture < DRY_THRESHOLD) {
        return String(crop) + ": Dry - Water within 24 hours";
    } else if (moisture >= OPTIMAL_MIN && moisture <= OPTIMAL_MAX) {
        return String(crop) + ": ✅ Optimal moisture - No action needed";
    } else if (moisture > WET_THRESHOLD) {
        return String(crop) + ": ⚠️ Too wet! Risk of root rot - Stop watering!";
    } else {
        return String(crop) + ": Moisture adequate";
    }
}

void loop() {
    int moisture = readSoilMoisture();
    
    Serial.println("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    Serial.printf("💧 SOIL MOISTURE: %d%%\n", moisture);
    Serial.println("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    
    // Agricultural recommendations by crop type
    Serial.println("📋 CROP RECOMMENDATIONS:");
    Serial.println("  " + getCropRecommendation(moisture, "🍅 Tomatoes"));
    Serial.println("  " + getCropRecommendation(moisture, "🌶️ Peppers"));
    Serial.println("  " + getCropRecommendation(moisture, "🥒 Cucumbers"));
    Serial.println("  " + getCropRecommendation(moisture, "🥬 Lettuce"));
    Serial.println("  " + getCropRecommendation(moisture, "🌽 Corn"));
    
    // Actionable alerts
    Serial.println("\n🎯 RECOMMENDED ACTIONS:");
    if (moisture < DRY_THRESHOLD) {
        Serial.println("  ⏰ ACTION: Turn ON irrigation system");
        Serial.println("  💧 Water for 15-20 minutes");
    } else if (moisture > WET_THRESHOLD) {
        Serial.println("  ⏰ ACTION: Turn OFF irrigation system");
        Serial.println("  💨 Increase ventilation to dry soil");
    } else if (moisture >= OPTIMAL_MIN && moisture <= OPTIMAL_MAX) {
        Serial.println("  ✅ No action needed - Perfect conditions");
    }
    
    Serial.println("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");
    
    delay(60000); // Read every minute
}
    

💧 Automatic Irrigation System (With Relay)

/*
 * Automatic Irrigation System
 * Waters crops automatically when soil is dry
 * Saves water and ensures optimal plant health
 * 
 * Components:
 * - Soil moisture sensor
 * - 5V relay module
 * - Water pump (12V or 110-240V)
 */

#include 

#define SOIL_PIN 32
#define RELAY_PIN 5          // Controls water pump

// Calibration values (replace with yours!)
const int DRY_VALUE = 3800;
const int WET_VALUE = 1500;
const int WATER_THRESHOLD = 35;  // Water when below 35%
const int WATER_DURATION = 10000; // Water for 10 seconds
const int CHECK_INTERVAL = 300000; // Check every 5 minutes (300,000ms)

bool isWatering = false;
unsigned long wateringStartTime = 0;

void setup() {
    Serial.begin(115200);
    pinMode(RELAY_PIN, OUTPUT);
    digitalWrite(RELAY_PIN, HIGH);  // Relay OFF initially (active LOW)
    
    Serial.println("═══════════════════════════════════════════");
    Serial.println("💧 AUTOMATIC IRRIGATION SYSTEM v1.0");
    Serial.println("   Smart farming - Waters only when needed");
    Serial.println("═══════════════════════════════════════════");
    Serial.printf("💧 Water threshold: %d%%\n", WATER_THRESHOLD);
    Serial.printf("💧 Water duration: %d seconds\n", WATER_DURATION/1000);
    Serial.printf("⏰ Check interval: %d minutes\n\n", CHECK_INTERVAL/60000);
}

int readSoilMoisture() {
    int raw = analogRead(SOIL_PIN);
    int percentage = map(raw, DRY_VALUE, WET_VALUE, 0, 100);
    percentage = constrain(percentage, 0, 100);
    return percentage;
}

void startWatering() {
    isWatering = true;
    wateringStartTime = millis();
    digitalWrite(RELAY_PIN, LOW);  // Turn pump ON
    Serial.println("💧 WATERING STARTED");
    Serial.printf("   Duration: %d seconds\n", WATER_DURATION/1000);
}

void stopWatering() {
    isWatering = false;
    digitalWrite(RELAY_PIN, HIGH);  // Turn pump OFF
    Serial.println("💧 WATERING COMPLETED");
    Serial.println("   Waiting for next check cycle...\n");
}

void loop() {
    if (isWatering) {
        // Check if watering duration is complete
        if (millis() - wateringStartTime >= WATER_DURATION) {
            stopWatering();
        }
    } else {
        // Check soil moisture
        int moisture = readSoilMoisture();
        
        Serial.printf("💧 Soil moisture: %d%%\n", moisture);
        
        if (moisture < WATER_THRESHOLD) {
            Serial.println("⚠️ Soil too dry! Starting irrigation...");
            startWatering();
        } else if (moisture < 50) {
            Serial.println("💡 Soil moisture adequate - No watering needed");
        } else if (moisture > 80) {
            Serial.println("⚠️ Soil too wet! Check drainage");
        } else {
            Serial.println("✅ Optimal soil moisture - Crop thriving");
        }
        
        delay(CHECK_INTERVAL);
    }
}
    

📖 MicroPython Version (Raspberry Pi Pico W)

# Soil Moisture Sensor for Raspberry Pi Pico W
# With cloud integration and automatic irrigation

from machine import Pin, ADC
import time
import network
import urequests

# ========== SENSOR CONFIGURATION ==========
moisture_sensor = ADC(Pin(26))  # GP26 = ADC0
relay = Pin(15, Pin.OUT)        # Controls pump
relay.value(1)                   # Start with pump OFF

# Calibration values (CALIBRATE THESE!)
DRY_VALUE = 60000      # Sensor in dry air
WET_VALUE = 20000      # Sensor in water
WATER_THRESHOLD = 35   # Water below 35%

# ========== WiFi Configuration ==========
SSID = "YOUR_WIFI"
PASSWORD = "YOUR_PASSWORD"

def connect_wifi():
    wlan = network.WLAN(network.STA_IF)
    wlan.active(True)
    wlan.connect(SSID, PASSWORD)
    
    print("📡 Connecting to WiFi", end="")
    while not wlan.isconnected():
        print(".", end="")
        time.sleep(0.5)
    print("\n✅ WiFi connected!")
    print(f"📡 IP: {wlan.ifconfig()[0]}\n")

def read_moisture():
    """Read soil moisture and return percentage"""
    raw = moisture_sensor.read_u16()
    
    # Convert to percentage (0-100%)
    percent = 100 - ((raw - WET_VALUE) * 100 / (DRY_VALUE - WET_VALUE))
    percent = max(0, min(100, percent))
    
    return raw, percent

def water_pump():
    """Turn on water pump for 10 seconds"""
    print("💧 WATERING STARTED")
    relay.value(0)  # Turn pump ON (active LOW)
    time.sleep(10)   # Water for 10 seconds
    relay.value(1)  # Turn pump OFF
    print("💧 WATERING COMPLETED")

def send_to_cloud(moisture):
    """Send reading to OceanRemote platform"""
    try:
        token = "YOUR_DEVICE_TOKEN"
        url = "https://api.oceanremote.net/device/state"
        data = f"token={token}&soil_moisture={moisture}"
        
        response = urequests.post(url, data=data)
        response.close()
        print("✅ Data sent to OceanRemote")
    except Exception as e:
        print(f"❌ Cloud upload failed: {e}")

# ========== MAIN LOOP ==========
print("═" * 50)
print("💧 SMART IRRIGATION SYSTEM - Pico W")
print("   Automatic watering based on soil moisture")
print("═" * 50)

connect_wifi()

while True:
    raw, moisture = read_moisture()
    
    # Display readings
    print("─" * 50)
    print(f"📊 Raw ADC: {raw}")
    print(f"💧 Soil Moisture: {moisture:.1f}%")
    
    # Make decision
    if moisture < WATER_THRESHOLD:
        print("⚠️ SOIL TOO DRY!")
        water_pump()
        time.sleep(60)  # Wait after watering
    elif moisture < 50:
        print("💡 Soil moisture adequate")
    elif moisture > 80:
        print("⚠️ SOIL TOO WET! Check drainage")
    else:
        print("✅ Optimal soil moisture")
    
    # Send to cloud
    send_to_cloud(moisture)
    
    print("─" * 50)
    print(f"⏰ Next check in 5 minutes\n")
    time.sleep(300)  # Check every 5 minutes
    

☁️ Send Data to OceanRemote Cloud

/*
 * Soil Moisture Monitor with OceanRemote Cloud
 * Monitor soil conditions from anywhere!
 * Get alerts when crops need water
 */

#include 
#include 
#include 

#define SOIL_PIN 32

// WiFi Configuration
const char* ssid = "YOUR_WIFI";
const char* password = "YOUR_PASSWORD";

// OceanRemote Configuration
const char* token = "YOUR_DEVICE_TOKEN";
const char* apiEndpoint = "https://api.oceanremote.net/device/state";

// Calibration values
const int DRY_VALUE = 3800;
const int WET_VALUE = 1500;

WiFiClient client;

void setup() {
    Serial.begin(115200);
    
    // Connect to WiFi
    WiFi.begin(ssid, password);
    while (WiFi.status() != WL_CONNECTED) {
        delay(500);
        Serial.print(".");
    }
    Serial.println("\n✅ WiFi connected!");
    Serial.println("💧 Soil Moisture Cloud Monitor Ready\n");
}

int readSoilMoisture() {
    int raw = analogRead(SOIL_PIN);
    int moisture = map(raw, DRY_VALUE, WET_VALUE, 0, 100);
    moisture = constrain(moisture, 0, 100);
    return moisture;
}

void sendToCloud(int moisture) {
    if (WiFi.status() != WL_CONNECTED) {
        Serial.println("❌ WiFi disconnected!");
        return;
    }
    
    HTTPClient http;
    http.begin(apiEndpoint);
    http.addHeader("Content-Type", "application/x-www-form-urlencoded");
    
    String data = "token=" + String(token);
    data += "&soil_moisture=" + String(moisture);
    data += "&sensor=capacitive";
    
    int httpCode = http.POST(data);
    
    if (httpCode == 200) {
        Serial.println("✅ Data sent to OceanRemote dashboard");
    } else {
        Serial.printf("❌ Upload failed: HTTP %d\n", httpCode);
    }
    
    http.end();
}

void loop() {
    int moisture = readSoilMoisture();
    
    Serial.println("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    Serial.printf("💧 Soil Moisture: %d%%\n", moisture);
    
    // Send alert if too dry
    if (moisture < 35) {
        Serial.println("🚨 ALERT: Soil too dry! Water immediately!");
    }
    
    sendToCloud(moisture);
    Serial.println("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");
    
    delay(60000); // Send every minute
}
    

🌾 Optimal Soil Moisture by Crop Type

🔧 Troubleshooting Common Issues

% Range    | Status              | Action
═══════════|═════════════════════|═══════════════════════════════════
0-20%      | CRITICALLY DRY      | WATER IMMEDIATELY!
20-35%     | Dry                 | Water within 24 hours
35-45%     | Slightly Dry        | Monitor closely
45-70%     | ✅ OPTIMAL          | No action needed
70-85%     | Moist               | Reduce watering
85-100%    | ⚠️ Too Wet          | Risk of root rot - Stop watering!