💧 Data-Driven Irrigation Decisions - Smart Water Management

📊 Why Data-Driven Irrigation Matters

🎯 The Complete Irrigation Decision Matrix

🌧️ Rain Forecast Integration

🌡️ Temperature Adjustments

📈 Crop-Specific Moisture Thresholds

💻 Arduino Code: Smart Irrigation Decision Engine

/*
 * Smart Irrigation Decision Engine
 * Combines soil moisture, temperature, and rain forecast
 * 
 * Features:
 * - Automatic irrigation based on 5+ data points
 * - Rain forecast integration (saves water)
 * - Temperature compensation
 * - Crop-specific thresholds
 */

#include 

// ========== PIN DEFINITIONS ==========
#define SOIL_PIN 32        // Soil moisture sensor
#define RELAY_PIN 5        // Water pump relay
#define DHT_PIN 4          // DHT22 temperature/humidity

// ========== CALIBRATION VALUES (CALIBRATE THESE!) ==========
const int DRY_VALUE = 3800;
const int WET_VALUE = 1500;

// ========== CROP CONFIGURATION ==========
struct CropConfig {
    const char* name;
    int optimalMin;
    int optimalMax;
    int waterThreshold;    // Water when below this
    int criticalPoint;     // Emergency below this
};

CropConfig crops[] = {
    {"Tomatoes", 45, 70, 40, 25},
    {"Peppers", 45, 70, 40, 25},
    {"Corn", 40, 65, 35, 20},
    {"Lettuce", 50, 80, 45, 30},
    {"Default", 40, 70, 35, 20}
};

int currentCrop = 0; // Index of selected crop

// ========== WEATHER FORECAST ==========
float rainForecastMM = 0;    // mm of rain expected in 24h
bool heatWaveWarning = false;

// ========== IRRIGATION SETTINGS ==========
const int BASE_WATER_DURATION = 600;  // 10 minutes base
const int MAX_WATER_DURATION = 1200;  // 20 minutes max
const int MIN_WATER_DURATION = 180;    // 3 minutes min

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

// Calculate optimal water duration based on multiple factors
int calculateWaterDuration(int moisture, float temperature, float rainMM) {
    CropConfig crop = crops[currentCrop];
    int duration = 0;
    
    // Factor 1: Soil moisture deficit
    if (moisture < crop.criticalPoint) {
        duration = MAX_WATER_DURATION;
    } else if (moisture < crop.waterThreshold) {
        int deficit = crop.waterThreshold - moisture;
        duration = BASE_WATER_DURATION + (deficit * 10);
        duration = constrain(duration, MIN_WATER_DURATION, MAX_WATER_DURATION);
    }
    
    // Factor 2: Temperature adjustment
    if (temperature > 35) {
        duration = duration * 1.4;  // 40% increase for heat wave
    } else if (temperature > 32) {
        duration = duration * 1.2;  // 20% increase for heat
    } else if (temperature < 15) {
        duration = duration * 0.6;  // 40% reduction for cold
    }
    
    // Factor 3: Rain forecast adjustment
    if (rainMM > 15) {
        duration = 0;  // Skip completely if heavy rain
    } else if (rainMM > 8) {
        duration = duration * 0.5;  // 50% reduction if moderate rain
    } else if (rainMM > 3) {
        duration = duration * 0.7;  // 30% reduction if light rain
    }
    
    return constrain(duration, 0, MAX_WATER_DURATION);
}

// Get decision message
String getDecisionMessage(int moisture, float rainMM, float temperature) {
    CropConfig crop = crops[currentCrop];
    
    if (moisture < crop.criticalPoint) {
        return "🚨 CRITICAL: Soil extremely dry! Emergency irrigation required!";
    }
    if (moisture < crop.waterThreshold) {
        if (rainMM > 15) {
            return "⏸️ Soil dry but heavy rain expected - skipping irrigation, relying on rain";
        } else if (rainMM > 8) {
            return "💧 Soil dry - irrigating at 50% due to forecast rain";
        } else {
            return "💧 Soil below threshold - starting irrigation";
        }
    }
    if (moisture >= crop.optimalMin && moisture <= crop.optimalMax) {
        return "✅ Optimal soil moisture - no action needed";
    }
    if (moisture > crop.optimalMax) {
        return "⚠️ Soil too wet - stop irrigation, check drainage";
    }
    return "📊 Monitoring - conditions normal";
}

// Display complete irrigation report
void displayIrrigationReport(int moisture, int duration, float temp, float rainMM) {
    CropConfig crop = crops[currentCrop];
    
    Serial.println("╔══════════════════════════════════════════════════════════════╗");
    Serial.println("║              💧 IRRIGATION DECISION REPORT                    ║");
    Serial.println("╚══════════════════════════════════════════════════════════════╝");
    Serial.println("");
    
    Serial.println("📊 CURRENT CONDITIONS:");
    Serial.printf("   🌱 Crop: %s\n", crop.name);
    Serial.printf("   💧 Soil Moisture: %d%%\n", moisture);
    Serial.printf("   🌡️ Temperature: %.1f°C\n", temp);
    Serial.printf("   🌧️ Rain Forecast (24h): %.1f mm\n", rainMM);
    Serial.println("");
    
    Serial.println("📋 CROP THRESHOLDS:");
    Serial.printf("   🟢 Optimal range: %d-%d%%\n", crop.optimalMin, crop.optimalMax);
    Serial.printf("   🟡 Water below: %d%%\n", crop.waterThreshold);
    Serial.printf("   🔴 Critical below: %d%%\n", crop.criticalPoint);
    Serial.println("");
    
    Serial.println("🎯 DECISION:");
    Serial.printf("   %s\n", getDecisionMessage(moisture, rainMM, temp).c_str());
    
    if (duration > 0) {
        Serial.printf("   💧 Watering duration: %d seconds (%d minutes)\n", duration, duration/60);
    }
    Serial.println("");
    Serial.println("══════════════════════════════════════════════════════════════════\n");
}

void setup() {
    Serial.begin(115200);
    pinMode(RELAY_PIN, OUTPUT);
    digitalWrite(RELAY_PIN, HIGH);  // Pump OFF initially
    
    Serial.println("========================================");
    Serial.println("💧 SMART IRRIGATION DECISION ENGINE v2.0");
    Serial.println("   Data-driven watering decisions");
    Serial.println("========================================\n");
}

void loop() {
    // Read sensors
    int moisture = readSoilMoisture();
    
    // In real implementation, get temperature from DHT22
    float temperature = 26.5;  // Replace with actual sensor reading
    float rainForecast = 0;    // Replace with API call to weather service
    
    // Calculate water duration
    int waterDuration = calculateWaterDuration(moisture, temperature, rainForecast);
    
    // Generate report
    displayIrrigationReport(moisture, waterDuration, temperature, rainForecast);
    
    // Execute irrigation if needed
    if (waterDuration > 0) {
        Serial.printf("💧 Activating pump for %d seconds...\n", waterDuration);
        digitalWrite(RELAY_PIN, LOW);   // Pump ON
        delay(waterDuration * 1000);
        digitalWrite(RELAY_PIN, HIGH);  // Pump OFF
        Serial.println("✅ Irrigation complete\n");
    }
    
    // Wait before next check (default: 1 hour = 3,600,000 ms)
    delay(3600000);
}
    

📱 API Integration for Real-Time Weather Data

/*
 * Fetch real-time weather forecast from OpenWeatherMap API
 * Integrate with your irrigation decision engine
 */

#include 
#include 
#include 

const char* ssid = "YOUR_WIFI";
const char* password = "YOUR_PASSWORD";
const char* apiKey = "YOUR_OPENWEATHER_API_KEY";
const char* city = "Nairobi,KE";

struct WeatherForecast {
    float temp;
    float humidity;
    float rainMM;      // mm of rain expected
    int windSpeed;     // km/h
    String condition;
};

WeatherForecast getWeatherForecast() {
    WeatherForecast forecast = {0, 0, 0, 0, "clear"};
    
    if (WiFi.status() == WL_CONNECTED) {
        HTTPClient http;
        String url = "http://api.openweathermap.org/data/2.5/weather?q=" + String(city) + "&appid=" + apiKey + "&units=metric";
        http.begin(url);
        int httpCode = http.GET();
        
        if (httpCode == 200) {
            String payload = http.getString();
            DynamicJsonDocument doc(2048);
            deserializeJson(doc, payload);
            
            forecast.temp = doc["main"]["temp"];
            forecast.humidity = doc["main"]["humidity"];
            
            // Check for rain
            if (doc.containsKey("rain")) {
                forecast.rainMM = doc["rain"]["1h"].as();
            }
            
            // Get weather condition
            const char* condition = doc["weather"][0]["main"];
            forecast.condition = String(condition);
        }
        http.end();
    }
    
    return forecast;
}
    

┌─────────────────────────────────────────────────────────────────────────┐
│                    DAILY IRRIGATION DECISION FLOW                       │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│  1. Read soil moisture sensor                                           │
│         ↓                                                               │
│  2. Check rain forecast (24h)                                           │
│         ↓                                                               │
│  3. Check current temperature                                           │
│         ↓                                                               │
│  4. Apply decision matrix:                                              │
│                                                                         │
│     Moisture < 20%?  ──YES──→ EMERGENCY WATER (15-20 min)              │
│          ↓ NO                                                           │
│     Moisture < threshold? ──YES──→ Check rain forecast                 │
│          ↓ NO                           ↓                               │
│     Moisture optimal? ──YES──→ No action needed!                        │
│                              Rain > 10mm? ──YES──→ Skip irrigation      │
│                                   ↓ NO                                  │
│                              → Water (10-15 min)                        │
│                                                                         │
│  5. Adjust for temperature (hot = more water, cold = less)              │
│  6. Execute irrigation if needed                                        │
│  7. Log decision for future analysis                                    │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘