Sistema de riego automático con sensores de humedad

#include <WiFi.h>
#include <PubSubClient.h>
#include <ArduinoJson.h>

// Pines del sistema
#define MOISTURE_SENSOR_PIN 34
#define RELAY_PIN 26
#define PUMP_ENABLE_PIN 27
#define FLOW_SENSOR_PIN 35

// Calibración del sensor (valores específicos por sensor)
const int AIR_VALUE = 3000;    // Valor en aire seco
const int WATER_VALUE = 1300;  // Valor en agua
const int MOISTURE_THRESHOLD = 30; // Porcentaje mínimo de humedad

// Variables del sistema
float moisturePercentage = 0;
bool pumpActive = false;
unsigned long lastReading = 0;
const unsigned long READING_INTERVAL = 30000; // 30 segundos

// Configuración WiFi y MQTT
const char* ssid = "TU_WIFI";
const char* password = "TU_PASSWORD";
const char* mqtt_server = "tu.broker.mqtt.com";

WiFiClient espClient;
PubSubClient client(espClient);

void setup() {
    Serial.begin(115200);
    
    // Configurar pines
    pinMode(MOISTURE_SENSOR_PIN, INPUT);
    pinMode(RELAY_PIN, OUTPUT);
    pinMode(PUMP_ENABLE_PIN, OUTPUT);
    pinMode(FLOW_SENSOR_PIN, INPUT_PULLUP);
    
    // Estado inicial: bomba apagada
    digitalWrite(RELAY_PIN, LOW);
    digitalWrite(PUMP_ENABLE_PIN, LOW);
    
    // Conectar WiFi
    setupWiFi();
    
    // Configurar MQTT
    client.setServer(mqtt_server, 1883);
    client.setCallback(mqttCallback);
    
    Serial.println("Sistema de riego iniciado");
}

void loop() {
    // Mantener conexión MQTT
    if (!client.connected()) {
        reconnectMQTT();
    }
    client.loop();
    
    // Lectura periódica del sensor
    if (millis() - lastReading >= READING_INTERVAL) {
        readMoistureSensor();
        controlIrrigation();
        sendData();
        lastReading = millis();
    }
    
    delay(100);
}

float readMoistureSensor() {
    // Tomar múltiples lecturas para estabilidad
    int totalReading = 0;
    const int numReadings = 10;
    
    for (int i = 0; i < numReadings; i++) {
        totalReading += analogRead(MOISTURE_SENSOR_PIN);
        delay(50);
    }
    
    int averageReading = totalReading / numReadings;
    
    // Convertir a porcentaje con calibración
    moisturePercentage = map(averageReading, AIR_VALUE, WATER_VALUE, 0, 100);
    moisturePercentage = constrain(moisturePercentage, 0, 100);
    
    Serial.printf("Lectura ADC: %d, Humedad: %.1f%%\n", 
                  averageReading, moisturePercentage);
    
    return moisturePercentage;
}

void controlIrrigation() {
    if (moisturePercentage < MOISTURE_THRESHOLD && !pumpActive) {
        startIrrigation();
    } else if (moisturePercentage > (MOISTURE_THRESHOLD + 10) && pumpActive) {
        stopIrrigation();
    }
}

void startIrrigation() {
    pumpActive = true;
    digitalWrite(RELAY_PIN, HIGH);
    digitalWrite(PUMP_ENABLE_PIN, HIGH);
    
    Serial.println("🌱 Iniciando riego automático");
    
    // Enviar notificación MQTT
    client.publish("irrigation/status", "STARTED");
}

void stopIrrigation() {
    pumpActive = false;
    digitalWrite(RELAY_PIN, LOW);
    digitalWrite(PUMP_ENABLE_PIN, LOW);
    
    Serial.println("🛑 Deteniendo riego - Humedad adecuada");
    
    // Enviar notificación MQTT
    client.publish("irrigation/status", "STOPPED");
}

// Sistema de riego multi-zona avanzado
#define NUM_ZONES 4
#define FLOW_SENSOR_INTERRUPT 0

struct IrrigationZone {
    int moistureSensorPin;
    int valveRelayPin;
    float moistureLevel;
    bool isActive;
    unsigned long startTime;
    unsigned long duration;
    String name;
};

IrrigationZone zones[NUM_ZONES] = {
    {34, 26, 0, false, 0, 600000, "Tomates"},      // 10 min
    {35, 27, 0, false, 0, 900000, "Lechugas"},     // 15 min
    {32, 28, 0, false, 0, 1200000, "Maíz"},        // 20 min
    {33, 29, 0, false, 0, 450000, "Hierbas"}       // 7.5 min
};

volatile unsigned int flowPulseCount = 0;
float flowRate = 0.0;
unsigned int flowMilliLitres = 0;
unsigned long totalMilliLitres = 0;

void setup() {
    // Configurar zonas
    for (int i = 0; i < NUM_ZONES; i++) {
        pinMode(zones[i].moistureSensorPin, INPUT);
        pinMode(zones[i].valveRelayPin, OUTPUT);
        digitalWrite(zones[i].valveRelayPin, LOW);
    }
    
    // Configurar sensor de flujo
    pinMode(FLOW_SENSOR_PIN, INPUT_PULLUP);
    attachInterrupt(FLOW_SENSOR_INTERRUPT, pulseCounter, FALLING);
}

void pulseCounter() {
    flowPulseCount++;
}

void updateFlowMeasurement() {
    // Cálculo cada segundo
    static unsigned long lastTime = 0;
    
    if (millis() - lastTime >= 1000) {
        detachInterrupt(FLOW_SENSOR_INTERRUPT);
        
        // Calcular flujo (L/min) - Calibración específica del sensor
        flowRate = ((1000.0 / (millis() - lastTime)) * flowPulseCount) / 7.5;
        flowMilliLitres = (flowRate / 60) * 1000;
        totalMilliLitres += flowMilliLitres;
        
        flowPulseCount = 0;
        lastTime = millis();
        
        attachInterrupt(FLOW_SENSOR_INTERRUPT, pulseCounter, FALLING);
    }
}

void manageMultiZoneIrrigation() {
    for (int i = 0; i < NUM_ZONES; i++) {
        // Leer humedad de cada zona
        zones[i].moistureLevel = readZoneMoisture(i);
        
        // Control de riego por zona
        if (zones[i].moistureLevel < MOISTURE_THRESHOLD && !zones[i].isActive) {
            startZoneIrrigation(i);
        }
        
        // Verificar duración máxima
        if (zones[i].isActive && 
            (millis() - zones[i].startTime) > zones[i].duration) {
            stopZoneIrrigation(i);
        }
    }
}

void startZoneIrrigation(int zone) {
    zones[zone].isActive = true;
    zones[zone].startTime = millis();
    digitalWrite(zones[zone].valveRelayPin, HIGH);
    
    Serial.printf("🌱 Iniciando riego en zona %s\n", zones[zone].name.c_str());
    
    // Crear mensaje JSON para MQTT
    DynamicJsonDocument doc(200);
    doc["zone"] = zones[zone].name;
    doc["action"] = "start";
    doc["moisture"] = zones[zone].moistureLevel;
    doc["timestamp"] = millis();
    
    String message;
    serializeJson(doc, message);
    client.publish("irrigation/zone_status", message.c_str());
}

// Sistema de diagnóstico y autodiagnóstico
class SystemDiagnostics {
private:
    struct DiagnosticTest {
        String testName;
        bool (*testFunction)();
        String errorMessage;
        String solution;
    };
    
    static DiagnosticTest tests[];
    static const int numTests = 8;
    
public:
    static void runFullDiagnostic() {
        Serial.println("\n🔍 Iniciando diagnóstico del sistema...");
        bool systemHealthy = true;
        
        for (int i = 0; i < numTests; i++) {
            Serial.printf("Ejecutando: %s... ", tests[i].testName.c_str());
            
            if (tests[i].testFunction()) {
                Serial.println("✅ PASS");
            } else {
                Serial.println("❌ FAIL");
                Serial.printf("   Error: %s\n", tests[i].errorMessage.c_str());
                Serial.printf("   Solución: %s\n", tests[i].solution.c_str());
                systemHealthy = false;
            }
        }
        
        if (systemHealthy) {
            Serial.println("\n✅ Sistema saludable - Todos los tests pasaron");
        } else {
            Serial.println("\n⚠️ Sistema requiere atención - Revisar errores");
        }
    }
    
    // Tests específicos
    static bool testWiFiConnection() {
        return WiFi.status() == WL_CONNECTED;
    }
    
    static bool testMQTTConnection() {
        return client.connected();
    }
    
    static bool testSensorsReading() {
        bool allSensorsOK = true;
        
        // Verificar sensores de humedad
        for (int i = 0; i < NUM_ZONES; i++) {
            int reading = analogRead(zones[i].moistureSensorPin);
            if (reading < 100 || reading > 4000) {
                allSensorsOK = false;
                break;
            }
        }
        
        // Verificar sensor DHT
        float temp = dht.readTemperature();
        float hum = dht.readHumidity();
        if (isnan(temp) || isnan(hum)) {
            allSensorsOK = false;
        }
        
        return allSensorsOK;
    }
    
    static bool testWaterLevel() {
        return waterLevel > 15; // Mínimo 15% de nivel
    }
    
    static bool testRelayFunction() {
        // Test rápido de todos los relés
        bool allRelaysOK = true;
        
        for (int i = 0; i < NUM_ZONES; i++) {
            digitalWrite(zones[i].relayPin, HIGH);
            delay(100);
            // Aquí podrías agregar verificación de feedback del relé
            digitalWrite(zones[i].relayPin, LOW);
        }
        
        return allRelaysOK;
    }
    
    static bool testPowerVoltage() {
        // Leer voltaje de alimentación a través del ADC
        int adcReading = analogRead(39); // Pin específico para voltaje
        float voltage = (adcReading / 4095.0) * 3.3 * 4; // Factor de división
        
        return (voltage > 11.0 && voltage < 14.5); // Rango aceptable para 12V
    }
    
    static bool testFlowSensor() {
        unsigned int initialCount = flowPulseCount;
        delay(5000); // Esperar 5 segundos
        
        return (flowPulseCount > initialCount) || (totalWaterUsed == 0);
    }
    
    static bool testMemoryUsage() {
        return ESP.getFreeHeap() > 50000; // Mínimo 50KB libre
    }
};

// Inicialización de tests
SystemDiagnostics::DiagnosticTest SystemDiagnostics::tests[] = {
    {"Conexión WiFi", testWiFiConnection, "WiFi desconectado", "Verificar SSID y contraseña"},
    {"Conexión MQTT", testMQTTConnection, "Broker MQTT inaccesible", "Verificar servidor y credenciales"},
    {"Lectura de Sensores", testSensorsReading, "Sensores con lecturas anómalas", "Verificar conexiones y calibración"},
    {"Nivel de Agua", testWaterLevel, "Nivel de agua crítico", "Rellenar tanque de agua"},
    {"Función de Relés", testRelayFunction, "Relé no responde", "Verificar conexiones y alimentación"},
    {"Voltaje de Alimentación", testPowerVoltage, "Voltaje fuera de rango", "Verificar fuente de poder"},
    {"Sensor de Flujo", testFlowSensor, "Sensor de flujo sin respuesta", "Verificar instalación del sensor"},
    {"Memoria Disponible", testMemoryUsage, "Memoria insuficiente", "Reiniciar sistema o revisar código"}
};

// Función de mantenimiento preventivo
void performPreventiveMaintenance() {
    static unsigned long lastMaintenance = 0;
    const unsigned long maintenanceInterval = 86400000; // 24 horas
    
    if (millis() - lastMaintenance >= maintenanceInterval) {
        Serial.println("🔧 Iniciando mantenimiento preventivo...");
        
        // Limpiar archivos temporales
        cleanupTempFiles();
        
        // Verificar y limpiar conexiones
        WiFi.disconnect();
        delay(1000);
        connectToWiFi();
        
        // Ejecutar diagnóstico completo
        SystemDiagnostics::runFullDiagnostic();
        
        // Reiniciar contadores
        resetSystemCounters();
        
        lastMaintenance = millis();
        Serial.println("✅ Mantenimiento preventivo completado");
    }
}

void cleanupTempFiles() {
    // Limpiar archivos de log antiguos
    File root = SPIFFS.open("/");
    File file = root.openNextFile();
    
    while (file) {
        String fileName = file.name();
        if (fileName.endsWith(".tmp") || fileName.startsWith("old_")) {
            SPIFFS.remove(fileName);
            Serial.printf("Eliminado: %s\n", fileName.c_str());
        }
        file = root.openNextFile();
    }
}

void resetSystemCounters() {
    totalWaterUsed = 0;
    flowPulseCount = 0;
    
    for (int i = 0; i < NUM_ZONES; i++) {
        zones[i].totalIrrigationTime = 0;
        zones[i].waterConsumption = 0;
    }
}