Putting It All Together - Smart Farm Management

🎯 Smart Farm Management Dashboard - Complete IoT Decision Support System

🌾 What You'll Learn in This Lesson:

📊 Combine ALL sensor data into actionable daily decisions
🌡️ Calculate Growing Degree Days (GDD) for harvest prediction
💧 Create automated irrigation rules based on soil moisture + weather
📈 Track NPK nutrient trends for fertilizer optimization
🚨 Set up alert systems for critical farm conditions
📱 Build a real-time dashboard visible from anywhere

📋 Why You Need a Smart Farm Management Dashboard

Traditional Farming	Smart Dashboard Farming
❌ Guess when to water	✅ Real-time soil moisture data
❌ Fertilize on calendar schedule	✅ Apply nutrients when crops need them
❌ Estimate harvest dates	✅ Predict harvest within 2-3 days using GDD
❌ Discover problems too late	✅ Instant alerts for anomalies
❌ Walk fields daily for inspection	✅ Monitor 100+ acres from your phone

💡 ROI of Smart Farm Dashboard:

Farmers using integrated dashboards report:

💰 20-35% reduction in water costs
💰 15-25% reduction in fertilizer costs
📈 20-40% increase in crop yields
⏰ 10+ hours/week saved on manual monitoring
🌍 50% reduction in environmental runoff

🌡️ Growing Degree Days (GDD) - Predict Your Harvest

📊 What is GDD? Growing Degree Days measure heat accumulation over time. Plants develop based on temperature, not calendar days. GDD helps you predict exactly when crops will flower, fruit, and be ready for harvest!

/*
 * Growing Degree Days (GDD) Calculator
 * Predict harvest dates based on temperature accumulation
 * 
 * Formula: GDD = ((Tmax + Tmin) / 2) - Tbase
 * Where Tbase is minimum temperature for crop growth
 */

#include <Arduino.h>
#include <DHT.h>

#define DHTPIN 4
#define DHTTYPE DHT22

DHT dht(DHTPIN, DHTTYPE);

// Crop-specific base temperatures (Tbase)
const float TBASE_TOMATO = 10.0;      // Tomatoes need 10°C minimum
const float TBASE_CORN = 10.0;         // Corn needs 10°C minimum  
const float TBASE_WHEAT = 0.0;         // Wheat can grow at 0°C
const float TBASE_POTATO = 7.0;        // Potatoes need 7°C minimum

// GDD requirements for common crops (until harvest)
const float GDD_TOMATO = 1300.0;       // 1300 GDD to harvest
const float GDD_CORN = 1400.0;         // 1400 GDD to harvest
const float GDD_WHEAT = 1800.0;        // 1800 GDD to harvest
const float GDD_POTATO = 1200.0;       // 1200 GDD to harvest

float totalGDD = 0;
float dailyMaxTemp = -100;
float dailyMinTemp = 100;
int readingsToday = 0;

void setup() {
    Serial.begin(115200);
    dht.begin();
    
    Serial.println("═══════════════════════════════════════════");
    Serial.println("🌡️ GDD (Growing Degree Days) Calculator");
    Serial.println("   Predict your harvest dates!");
    Serial.println("═══════════════════════════════════════════");
    Serial.println();
    
    Serial.println("📊 CROP GDD REQUIREMENTS:");
    Serial.printf("   🍅 Tomatoes: %.0f GDD (approx 70-80 days)\n", GDD_TOMATO);
    Serial.printf("   🌽 Corn: %.0f GDD (approx 80-90 days)\n", GDD_CORN);
    Serial.printf("   🌾 Wheat: %.0f GDD (approx 100-120 days)\n", GDD_WHEAT);
    Serial.printf("   🥔 Potatoes: %.0f GDD (approx 60-80 days)\n\n", GDD_POTATO);
}

float calculateDailyGDD(float tmax, float tmin, float tbase) {
    float dailyGDD = ((tmax + tmin) / 2.0) - tbase;
    if (dailyGDD < 0) dailyGDD = 0; // No negative GDD
    return dailyGDD;
}

void loop() {
    // Read temperature every hour
    float temp = dht.readTemperature();
    
    if (!isnan(temp)) {
        // Track daily min and max
        if (temp > dailyMaxTemp) dailyMaxTemp = temp;
        if (temp < dailyMinTemp) dailyMinTemp = temp;
        readingsToday++;
        
        // At midnight (after 24 readings, reset)
        if (readingsToday >= 24) {
            float dailyGDD = calculateDailyGDD(dailyMaxTemp, dailyMinTemp, TBASE_TOMATO);
            totalGDD += dailyGDD;
            
            Serial.println("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
            Serial.printf("📅 Daily Max: %.1f°C | Min: %.1f°C\n", dailyMaxTemp, dailyMinTemp);
            Serial.printf("🌡️ Daily GDD: %.1f\n", dailyGDD);
            Serial.printf("📊 Total GDD Accumulated: %.1f\n", totalGDD);
            
            // Harvest predictions
            float progressTomato = (totalGDD / GDD_TOMATO) * 100;
            float progressCorn = (totalGDD / GDD_CORN) * 100;
            
            Serial.println("\n📈 HARVEST PREDICTIONS:");
            if (progressTomato < 100) {
                float daysRemaining = ((GDD_TOMATO - totalGDD) / 10.0); // Rough estimate
                Serial.printf("   🍅 Tomatoes: %.0f%% complete | ~%.0f days to harvest\n", progressTomato, daysRemaining);
            } else {
                Serial.println("   🍅 Tomatoes: ✅ READY FOR HARVEST!");
            }
            
            if (progressCorn < 100) {
                float daysRemaining = ((GDD_CORN - totalGDD) / 12.0);
                Serial.printf("   🌽 Corn: %.0f%% complete | ~%.0f days to harvest\n", progressCorn, daysRemaining);
            } else {
                Serial.println("   🌽 Corn: ✅ READY FOR HARVEST!");
            }
            
            Serial.println("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");
            
            // Reset for new day
            dailyMaxTemp = -100;
            dailyMinTemp = 100;
            readingsToday = 0;
        }
    }
    
    delay(3600000); // Read every hour (3,600,000 ms)
}

📊 GDD Success Story - Moroccan Tomato Farm:

A commercial tomato grower used GDD tracking to optimize harvest planning:

🌡️ Before: Harvested based on calendar - often too early or too late
📊 After: Tracked GDD daily from planting to harvest
📈 Result: Harvest timing accuracy improved by 85%
💰 Profit: Captured premium prices by harvesting at peak ripeness

💧 Smart Irrigation Rules Engine

/*
 * Smart Irrigation Decision Engine
 * Combines soil moisture + weather forecast + crop type
 * Waters ONLY when necessary - no water waste!
 */

struct IrrigationDecision {
    bool shouldWater;
    int durationSeconds;
    String reason;
};

class SmartIrrigation {
private:
    int soilMoisture;
    float temperature;
    float humidity;
    bool rainForecast;
    String cropType;
    
    // Crop-specific moisture thresholds
    int getMoistureThreshold() {
        if (cropType == "tomato") return 40;
        if (cropType == "corn") return 35;
        if (cropType == "lettuce") return 45;
        if (cropType == "pepper") return 40;
        return 35; // Default
    }
    
public:
    SmartIrrigation(int moisture, float temp, float hum, bool rain, String crop) {
        soilMoisture = moisture;
        temperature = temp;
        humidity = hum;
        rainForecast = rain;
        cropType = crop;
    }
    
    IrrigationDecision makeDecision() {
        IrrigationDecision decision;
        int threshold = getMoistureThreshold();
        
        // Rule 1: Don't water if rain is coming
        if (rainForecast) {
            decision.shouldWater = false;
            decision.reason = "🌧️ Rain forecast - skipping irrigation";
            decision.durationSeconds = 0;
            return decision;
        }
        
        // Rule 2: Emergency watering (critically dry)
        if (soilMoisture < 15) {
            decision.shouldWater = true;
            decision.durationSeconds = 600; // 10 minutes emergency
            decision.reason = "🚨 CRITICAL! Soil extremely dry - emergency watering";
            return decision;
        }
        
        // Rule 3: Normal watering based on threshold
        if (soilMoisture < threshold) {
            // Calculate duration based on how dry it is
            int drynessFactor = threshold - soilMoisture;
            int baseDuration = 300; // 5 minutes base
            decision.durationSeconds = baseDuration + (drynessFactor * 10);
            decision.durationSeconds = min(decision.durationSeconds, 900); // Max 15 minutes
            decision.shouldWater = true;
            decision.reason = "💧 Soil below threshold - scheduled irrigation";
            return decision;
        }
        
        // Rule 4: Heat wave adjustment
        if (temperature > 35 && soilMoisture < 50) {
            decision.shouldWater = true;
            decision.durationSeconds = 180; // 3 minutes cooling
            decision.reason = "🔥 Heat wave detected - cooling irrigation";
            return decision;
        }
        
        // Rule 5: No watering needed
        decision.shouldWater = false;
        decision.reason = "✅ Soil moisture adequate - no action needed";
        decision.durationSeconds = 0;
        return decision;
    }
};

// Usage example
void setup() {
    // In your main loop, create decision engine
    SmartIrrigation engine(38, 28.5, 65, false, "tomato");
    IrrigationDecision decision = engine.makeDecision();
    
    if (decision.shouldWater) {
        Serial.println(decision.reason);
        Serial.printf("💧 Watering for %d seconds\n", decision.durationSeconds);
        // digitalWrite(RELAY_PIN, LOW); // Turn pump ON
        // delay(decision.durationSeconds * 1000);
        // digitalWrite(RELAY_PIN, HIGH); // Turn pump OFF
    } else {
        Serial.println(decision.reason);
    }
}

📈 NPK Nutrient Trend Analysis

/*
 * NPK Soil Nutrient Tracker
 * Track Nitrogen (N), Phosphorus (P), Potassium (K) trends
 * Know exactly when to fertilize - no guessing!
 */

struct NutrientReading {
    float nitrogen;    // mg/kg (ppm)
    float phosphorus;  // mg/kg (ppm)
    float potassium;   // mg/kg (ppm)
    unsigned long timestamp;
};

class NPKTracker {
private:
    NutrientReading readings[100];
    int readingCount = 0;
    
    // Optimal ranges for tomatoes (mg/kg)
    const float N_OPTIMAL_MIN = 40;
    const float N_OPTIMAL_MAX = 80;
    const float P_OPTIMAL_MIN = 20;
    const float P_OPTIMAL_MAX = 50;
    const float K_OPTIMAL_MIN = 150;
    const float K_OPTIMAL_MAX = 300;
    
public:
    void addReading(float n, float p, float k) {
        if (readingCount < 100) {
            readings[readingCount].nitrogen = n;
            readings[readingCount].phosphorus = p;
            readings[readingCount].potassium = k;
            readings[readingCount].timestamp = millis();
            readingCount++;
        }
    }
    
    void analyzeTrends() {
        if (readingCount < 2) {
            Serial.println("📊 Need more data for trend analysis");
            return;
        }
        
        // Get last 5 readings for trend
        int startIdx = max(0, readingCount - 5);
        int samples = readingCount - startIdx;
        
        float nAvg=0, pAvg=0, kAvg=0;
        for (int i = startIdx; i < readingCount; i++) {
            nAvg += readings[i].nitrogen;
            pAvg += readings[i].phosphorus;
            kAvg += readings[i].potassium;
        }
        nAvg /= samples;
        pAvg /= samples;
        kAvg /= samples;
        
        Serial.println("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
        Serial.println("📊 NUTRIENT STATUS REPORT:");
        Serial.printf("   🌿 Nitrogen (N): %.1f ppm ", nAvg);
        if (nAvg < N_OPTIMAL_MIN) Serial.println("⬇️ DEFICIENT - Apply nitrogen fertilizer");
        else if (nAvg > N_OPTIMAL_MAX) Serial.println("⬆️ EXCESS - Reduce nitrogen application");
        else Serial.println("✅ Optimal");
        
        Serial.printf("   🔥 Phosphorus (P): %.1f ppm ", pAvg);
        if (pAvg < P_OPTIMAL_MIN) Serial.println("⬇️ DEFICIENT - Apply phosphorus (bone meal)");
        else if (pAvg > P_OPTIMAL_MAX) Serial.println("⬆️ EXCESS - Reduce phosphorus");
        else Serial.println("✅ Optimal");
        
        Serial.printf("   🍌 Potassium (K): %.1f ppm ", kAvg);
        if (kAvg < K_OPTIMAL_MIN) Serial.println("⬇️ DEFICIENT - Apply potassium (potash)");
        else if (kAvg > K_OPTIMAL_MAX) Serial.println("⬆️ EXCESS - Reduce potassium");
        else Serial.println("✅ Optimal");
        
        Serial.println("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
        
        // Fertilizer recommendation
        if (nAvg < N_OPTIMAL_MIN || pAvg < P_OPTIMAL_MIN || kAvg < K_OPTIMAL_MIN) {
            Serial.println("📋 FERTILIZER RECOMMENDATION:");
            if (nAvg < N_OPTIMAL_MIN) Serial.println("   - Apply high-nitrogen fertilizer (e.g., blood meal, fish emulsion)");
            if (pAvg < P_OPTIMAL_MIN) Serial.println("   - Apply phosphorus-rich fertilizer (e.g., bone meal, rock phosphate)");
            if (kAvg < K_OPTIMAL_MIN) Serial.println("   - Apply potassium-rich fertilizer (e.g., greensand, wood ash)");
        }
    }
};

🚨 Smart Alert System

/*
 * Smart Farm Alert System
 * Get notified immediately when conditions require attention
 */

struct Alert {
    String type;
    String message;
    int severity; // 1=info, 2=warning, 3=critical
    unsigned long timestamp;
};

class AlertSystem {
private:
    Alert alerts[50];
    int alertCount = 0;
    
    void addAlert(String type, String message, int severity) {
        if (alertCount < 50) {
            alerts[alertCount].type = type;
            alerts[alertCount].message = message;
            alerts[alertCount].severity = severity;
            alerts[alertCount].timestamp = millis();
            alertCount++;
        }
    }
    
public:
    void checkConditions(int moisture, float temp, float humidity, int nitrogen, int phosphorus, int potassium) {
        // CRITICAL alerts (must act immediately)
        if (moisture < 15) {
            addAlert("WATER", "🚨 CRITICAL: Soil moisture below 15%! Irrigate immediately!", 3);
        }
        if (temp > 40) {
            addAlert("HEAT", "🚨 CRITICAL: Temperature exceeds 40°C! Risk of crop damage!", 3);
        }
        if (temp < 0) {
            addAlert("FROST", "🚨 CRITICAL: Frost detected! Protect crops immediately!", 3);
        }
        
        // WARNING alerts (act within 24 hours)
        if (moisture >= 15 && moisture < 30) {
            addAlert("WATER", "⚠️ WARNING: Low soil moisture. Plan irrigation within 24 hours.", 2);
        }
        if (temp > 35 && temp <= 40) {
            addAlert("HEAT", "⚠️ WARNING: High temperature. Increase ventilation.", 2);
        }
        if (humidity > 85) {
            addAlert("HUMIDITY", "⚠️ WARNING: High humidity. Mold risk increased.", 2);
        }
        if (nitrogen < 30) {
            addAlert("NUTRIENT", "⚠️ WARNING: Low nitrogen. Apply fertilizer within 3 days.", 2);
        }
        
        // INFO alerts (monitor only)
        if (moisture >= 30 && moisture < 40) {
            addAlert("WATER", "ℹ️ INFO: Soil moisture decreasing. Monitor closely.", 1);
        }
        if (temp > 30 && temp <= 35) {
            addAlert("HEAT", "ℹ️ INFO: Elevated temperature. Monitor crop stress.", 1);
        }
    }
    
    void displayAlerts() {
        if (alertCount == 0) {
            Serial.println("✅ No active alerts - All systems normal");
            return;
        }
        
        Serial.println("═══════════════════════════════════════════");
        Serial.println("🚨 ACTIVE ALERTS");
        Serial.println("═══════════════════════════════════════════");
        
        for (int i = 0; i < alertCount; i++) {
            String severityIcon = (alerts[i].severity == 3) ? "🔴 CRITICAL" : 
                                  (alerts[i].severity == 2) ? "🟡 WARNING" : "🔵 INFO";
            Serial.printf("%s: %s\n", severityIcon.c_str(), alerts[i].message.c_str());
        }
        Serial.println("═══════════════════════════════════════════");
    }
    
    void clearAlerts() {
        alertCount = 0;
        Serial.println("✅ All alerts cleared");
    }
};

📊 Complete Dashboard Decision Matrix

Data Source	What to Check	Action Threshold	Action to Take
💧 Soil Moisture	Current %	< 35%	Start irrigation
🌡️ Temperature	Current & forecast	> 35°C	Increase ventilation, shade cloth
💧 Humidity	Current %	> 85%	Run exhaust fans, reduce watering
🌿 Nitrogen (N)	mg/kg trend	< 40 ppm	Apply nitrogen fertilizer
🔥 Phosphorus (P)	mg/kg trend	< 20 ppm	Apply bone meal or rock phosphate
🍌 Potassium (K)	mg/kg trend	< 150 ppm	Apply potash or greensand
🌡️ Growing Degree Days	Total accumulated	≥ crop requirement	Begin harvest planning
🌧️ Rain Forecast	Next 24-48 hours	≥ 50% chance	Skip scheduled irrigation

📱 Complete Daily Dashboard Routine

/*
 * Complete Daily Farm Management Routine
 * Run this every morning to get your farm action plan
 */

void dailyFarmRoutine() {
    Serial.println("╔══════════════════════════════════════════════════════════════╗");
    Serial.println("║              🌾 DAILY FARM MANAGEMENT DASHBOARD              ║");
    Serial.println("║                         Good Morning, Farmer!                ║");
    Serial.println("╚══════════════════════════════════════════════════════════════╝");
    
    // STEP 1: Check Soil Moisture
    Serial.println("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    Serial.println("💧 STEP 1: SOIL MOISTURE STATUS");
    Serial.println("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    int moisture = readSoilMoisture();
    Serial.printf("   Current soil moisture: %d%%\n", moisture);
    
    if (moisture < 20) {
        Serial.println("   🔴 ACTION: IMMEDIATE IRRIGATION REQUIRED!");
        Serial.println("   → Water for 15-20 minutes immediately");
    } else if (moisture < 35) {
        Serial.println("   🟡 ACTION: Plan irrigation today");
        Serial.println("   → Schedule watering within 24 hours");
    } else if (moisture >= 45 && moisture <= 70) {
        Serial.println("   ✅ OPTIMAL: No action needed");
    } else if (moisture > 85) {
        Serial.println("   ⚠️ ACTION: Soil too wet!");
        Serial.println("   → Stop irrigation, increase drainage");
    }
    
    // STEP 2: Check Weather Forecast
    Serial.println("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    Serial.println("🌤️ STEP 2: WEATHER FORECAST");
    Serial.println("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    bool rainForecast = checkRainForecast(); // API call
    float forecastTemp = getForecastTemp();
    
    if (rainForecast) {
        Serial.println("   🌧️ Rain forecast in next 24 hours");
        Serial.println("   ✅ ACTION: Cancel scheduled irrigation");
    } else {
        Serial.println("   ☀️ No rain forecast");
        Serial.println("   ✅ ACTION: Proceed with irrigation schedule");
    }
    
    if (forecastTemp > 35) {
        Serial.println("   🔥 Heat wave expected!");
        Serial.println("   ✅ ACTION: Apply mulch, increase ventilation");
    }
    
    // STEP 3: Review Nutrient Trends
    Serial.println("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    Serial.println("📊 STEP 3: NPK NUTRIENT TRENDS");
    Serial.println("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    analyzeNutrientTrends();
    
    // STEP 4: Monitor GDD Progress
    Serial.println("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    Serial.println("🌡️ STEP 4: GROWING DEGREE DAYS (GDD)");
    Serial.println("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    float gdd = getTotalGDD();
    float gddTomato = 1300;
    float progress = (gdd / gddTomato) * 100;
    
    Serial.printf("   Total GDD accumulated: %.0f\n", gdd);
    Serial.printf("   Progress to harvest: %.0f%%\n", progress);
    
    if (progress >= 100) {
        Serial.println("   ✅ Tomatoes are READY FOR HARVEST!");
    } else {
        float daysRemaining = (gddTomato - gdd) / 12.0;
        Serial.printf("   📅 Estimated days to harvest: %.0f\n", daysRemaining);
    }
    
    // STEP 5: Review Active Alerts
    Serial.println("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    Serial.println("🚨 STEP 5: ACTIVE ALERTS");
    Serial.println("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    displayActiveAlerts();
    
    // FINAL SUMMARY
    Serial.println("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    Serial.println("📋 TODAY'S FARM ACTION SUMMARY");
    Serial.println("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    Serial.println("\n   ✅ Morning (6-8 AM):  Check sensors, water if needed");
    Serial.println("   ✅ Mid-Day (12 PM):   Monitor temperature, ventilate if hot");
    Serial.println("   ✅ Evening (6 PM):    Review daily data, plan for tomorrow");
    Serial.println("\n💡 Tip: Connect this dashboard to a mobile app for remote monitoring!");
}

💡 Pro Tips for Dashboard Success:

📱 Mobile Access: Connect your dashboard to OceanRemote for smartphone monitoring
📧 Email Alerts: Configure critical alerts to send email or SMS notifications
📊 Historical Data: Save readings to SD card or cloud for season-over-season comparison
🤖 Automation: Connect relays to automate pumps, fans, and heaters based on rules
📈 Yield Tracking: Record harvest weights to correlate with GDD and nutrient data

🎉 Congratulations!

You now have a complete IoT data analytics system for your farm!

✅ Smart irrigation based on soil moisture + weather forecast
✅ GDD tracking to predict harvest dates within days
✅ NPK trend analysis for precise fertilizer application
✅ Multi-level alert system for critical conditions (water, heat, frost, nutrients)
✅ Daily dashboard combining ALL data into actionable decisions

🌾 Remember: Data alone doesn't grow crops - action does! Use your dashboard daily to make informed decisions and watch your yields improve season after season.

"Measure what matters, act on what you measure."

📚 Quick Reference - Daily 5-Step Routine:

┌─────────────────────────────────────────────────────────────────┐
│  🌅 MORNING FARM CHECKLIST (15 minutes)                         │
├─────────────────────────────────────────────────────────────────┤
│  □ 1. Check soil moisture → Water if < 35%                     │
│  □ 2. Check weather forecast → Adjust if rain expected         │
│  □ 3. Review NPK trends → Apply fertilizer if needed           │
│  □ 4. Monitor GDD → Plan harvest timing                        │
│  □ 5. Review alerts → Investigate anomalies                    │
├─────────────────────────────────────────────────────────────────┤
│  📊 Remember: 15 minutes of data review saves HOURS of         │
│  guesswork and prevents costly crop failures!                   │
└─────────────────────────────────────────────────────────────────┘

💡 Key Takeaways:

Apply these concepts directly to your farm or project.
Take notes on important details for the quiz.
Use the button below to track your progress.

← Previous Lesson 📝 Take Quiz →