جریان آب → روتور توربینی → چرخش → سنسور اثر هال → پالس خروجی
   ↓           ↓             ↓           ↓            ↓
ورودی     پره‌های     تبدیل انرژی   تشخیص مغناطیسی  سیگنال
         توربین       مکانیکی به    تغییرات میدان    دیجیتال
                     چرخشی           مغناطیسی

// تعریف پایه‌های سنسور YF-S201
#define FLOW_SENSOR_PIN 2    // پین سیگنال (با وقفه)
#define FLOW_VCC_PIN     8    // پین کنترل تغذیه (اختیاری)

// متغیرهای جهانی
volatile unsigned long pulseCount = 0;
unsigned long lastTime = 0;
float flowRate = 0.0;        // لیتر بر دقیقه
float totalVolume = 0.0;     // لیتر
const float pulsesPerLiter = 450.0; // 450 پالس/لیتر

void setupWaterFlowSensor() {
    Serial.begin(9600);
    
    // تنظیم پین‌ها
    pinMode(FLOW_SENSOR_PIN, INPUT_PULLUP);
    pinMode(FLOW_VCC_PIN, OUTPUT);
    
    // فعال کردن سنسور
    digitalWrite(FLOW_VCC_PIN, HIGH);
    
    // تنظیم وقفه برای شمارش پالس‌ها
    attachInterrupt(digitalPinToInterrupt(FLOW_SENSOR_PIN), pulseCounter, RISING);
    
    Serial.println("سنسور جریان آب YF-S201 راه‌اندازی شد");
    Serial.println("===================================");
}

// تابع وقفه برای شمارش پالس‌ها
void pulseCounter() {
    pulseCount++;
}

void loop() {
    // محاسبه جریان هر 1 ثانیه
    if (millis() - lastTime >= 1000) {
        // غیرفعال کردن وقفه برای محاسبات
        detachInterrupt(digitalPinToInterrupt(FLOW_SENSOR_PIN));
        
        // محاسبه جریان (لیتر بر دقیقه)
        flowRate = ((pulseCount * 60.0) / pulsesPerLiter);
        
        // محاسبه حجم کل (لیتر)
        totalVolume += flowRate / 60.0; // تبدیل به لیتر
        
        // نمایش اطلاعات
        displayFlowInfo();
        
        // ریست شمارنده و زمان
        pulseCount = 0;
        lastTime = millis();
        
        // فعال کردن مجدد وقفه
        attachInterrupt(digitalPinToInterrupt(FLOW_SENSOR_PIN), pulseCounter, RISING);
    }
}

void displayFlowInfo() {
    Serial.print("جریان: ");
    Serial.print(flowRate, 2);
    Serial.print(" L/min | حجم کل: ");
    Serial.print(totalVolume, 2);
    Serial.println(" L");
    
    // هشدار جریان زیاد
    if (flowRate > 25.0) {
        Serial.println("⚠️ هشدار: جریان نزدیک به حداکثر!");
    }
    
    // تشخیص نشتی
    static float lastFlowRate = 0.0;
    if (lastFlowRate == 0.0 && flowRate > 0.1) {
        Serial.println("🚰 جریان آب تشخیص داده شد");
    }
    lastFlowRate = flowRate;
}

class WaterFlowSensor {
private:
    int sensorPin;
    int powerPin;
    volatile unsigned long pulseCount;
    unsigned long lastMeasurement;
    float flowRate;
    float totalVolume;
    float calibrationFactor;
    
public:
    WaterFlowSensor(int pin, int power = -1, float calFactor = 450.0) {
        sensorPin = pin;
        powerPin = power;
        calibrationFactor = calFactor;
        pulseCount = 0;
        flowRate = 0.0;
        totalVolume = 0.0;
        lastMeasurement = 0;
        
        pinMode(sensorPin, INPUT_PULLUP);
        if (powerPin != -1) {
            pinMode(powerPin, OUTPUT);
            digitalWrite(powerPin, HIGH);
        }
        
        // راه‌اندازی وقفه
        startMeasurement();
    }
    
    void startMeasurement() {
        attachInterrupt(digitalPinToInterrupt(sensorPin), isrWrapper, RISING);
    }
    
    void stopMeasurement() {
        detachInterrupt(digitalPinToInterrupt(sensorPin));
    }
    
    static void isrWrapper() {
        // تابع ایستای برای وقفه
        // Note: نیاز به پیاده‌سازی با متغیرهای استاتیک
    }
    
    void update() {
        unsigned long currentTime = millis();
        unsigned long elapsedTime = currentTime - lastMeasurement;
        
        if (elapsedTime >= 1000) { // هر 1 ثانیه
            stopMeasurement();
            
            // محاسبه جریان (لیتر بر دقیقه)
            flowRate = ((pulseCount * 60000.0) / calibrationFactor) / elapsedTime;
            
            // محاسبه حجم کل (لیتر)
            totalVolume += (flowRate * elapsedTime) / 60000.0;
            
            // ریست برای دوره بعدی
            pulseCount = 0;
            lastMeasurement = currentTime;
            
            startMeasurement();
        }
    }
    
    float getFlowRate() {
        return flowRate;
    }
    
    float getTotalVolume() {
        return totalVolume;
    }
    
    float getFlowSpeed() {
        // محاسبه سرعت آب در لوله (متر بر ثانیه)
        float pipeDiameter = 0.0125; // متر (0.5 اینچ)
        float crossSection = PI * pow(pipeDiameter / 2, 2);
        float flowM3PerSec = flowRate / 60000.0; // تبدیل به m³/s
        return flowM3PerSec / crossSection;
    }
    
    void resetTotalVolume() {
        totalVolume = 0.0;
    }
    
    void calibrate(float knownVolume) {
        // کالیبراسیون با حجم مشخص
        float measuredVolume = getTotalVolume();
        calibrationFactor = (pulseCount * knownVolume) / measuredVolume;
        
        Serial.print("کالیبراسیون انجام شد. ضریب جدید: ");
        Serial.print(calibrationFactor, 1);
        Serial.println(" پالس/لیتر");
    }
    
    bool isFlowDetected(float threshold = 0.5) {
        return flowRate > threshold;
    }
    
    void printStatus() {
        Serial.println("=== وضعیت سنسور جریان آب ===");
        Serial.print("جریان: ");
        Serial.print(flowRate, 2);
        Serial.print(" L/min | سرعت: ");
        Serial.print(getFlowSpeed(), 3);
        Serial.print(" m/s | حجم کل: ");
        Serial.print(totalVolume, 2);
        Serial.println(" L");
        
        // وضعیت سلامت
        if (flowRate > 30.0) {
            Serial.println("⚠️ جریان بیش از حد مجاز");
        }
        
        if (flowRate < 1.0 && flowRate > 0.1) {
            Serial.println("⚠️ جریان بسیار کم");
        }
    }
};

class SmartIrrigationSystem {
private:
    WaterFlowSensor flowSensor;
    float dailyLimit; // لیتر
    float waterUsedToday;
    unsigned long lastReset;
    
public:
    SmartIrrigationSystem(int pin, float dailyLimit = 100.0) 
        : flowSensor(pin), dailyLimit(dailyLimit) {
        waterUsedToday = 0.0;
        lastReset = millis();
    }
    
    void update() {
        flowSensor.update();
        waterUsedToday = flowSensor.getTotalVolume();
        
        // بررسی محدودیت روزانه
        if (waterUsedToday >= dailyLimit) {
            Serial.println("⚠️ محدودیت آبیاری روزانه رسیده است");
            stopIrrigation();
        }
        
        // ریست روزانه
        if (millis() - lastReset > 86400000) { // 24 ساعت
            waterUsedToday = 0.0;
            flowSensor.resetTotalVolume();
            lastReset = millis();
            Serial.println("📅 مصرف روزانه ریست شد");
        }
    }
    
    void startIrrigation(float targetVolume) {
        Serial.print("آبیاری شروع شد | هدف: ");
        Serial.print(targetVolume);
        Serial.println(" لیتر");
        
        flowSensor.resetTotalVolume();
        
        while (flowSensor.getTotalVolume() < targetVolume) {
            flowSensor.update();
            delay(100);
            
            // نمایش پیشرفت
            float progress = (flowSensor.getTotalVolume() / targetVolume) * 100;
            Serial.print("پیشرفت: ");
            Serial.print(progress, 1);
            Serial.println("%");
        }
        
        Serial.println("✅ آبیاری کامل شد");
    }
    
    void stopIrrigation() {
        // منطق قطع آبیاری
        Serial.println("آبیاری متوقف شد");
    }
    
    float getDailyUsage() {
        return waterUsedToday;
    }
    
    float getRemainingQuota() {
        return dailyLimit - waterUsedToday;
    }
};

class HomeWaterMonitor {
private:
    WaterFlowSensor flowSensor;
    float monthlyUsage[30]; // مصرف روزانه
    int currentDay;
    float monthlyLimit;
    
public:
    HomeWaterMonitor(int pin, float limit = 3000.0) 
        : flowSensor(pin), monthlyLimit(limit) {
        currentDay = 0;
        for (int i = 0; i < 30; i++) {
            monthlyUsage[i] = 0.0;
        }
    }
    
    void updateDaily() {
        flowSensor.update();
        monthlyUsage[currentDay] = flowSensor.getTotalVolume();
        
        // نمایش آمار
        Serial.print("روز ");
        Serial.print(currentDay + 1);
        Serial.print(": مصرف ");
        Serial.print(monthlyUsage[currentDay], 1);
        Serial.println(" لیتر");
        
        // محاسبه مصرف ماهانه
        float monthlyTotal = calculateMonthlyTotal();
        Serial.print("مصرف ماهانه: ");
        Serial.print(monthlyTotal, 1);
        Serial.print(" / ");
        Serial.print(monthlyLimit);
        Serial.println(" لیتر");
        
        // هشدار
        if (monthlyTotal > monthlyLimit * 0.8) {
            Serial.println("⚠️ مصرف ماهانه نزدیک به سقف مجاز");
        }
        
        // ریست روزانه
        flowSensor.resetTotalVolume();
        currentDay = (currentDay + 1) % 30;
    }
    
    float calculateMonthlyTotal() {
        float total = 0.0;
        for (int i = 0; i < 30; i++) {
            total += monthlyUsage[i];
        }
        return total;
    }
    
    float getAverageDailyUsage() {
        return calculateMonthlyTotal() / 30.0;
    }
    
    void generateReport() {
        Serial.println("📊 گزارش مصرف آب ماهانه");
        Serial.println("=========================");
        
        for (int i = 0; i < 30; i++) {
            Serial.print("روز ");
            Serial.print(i + 1);
            Serial.print(": ");
            Serial.print(monthlyUsage[i], 1);
            Serial.println(" لیتر");
        }
        
        Serial.print("میانگین روزانه: ");
        Serial.print(getAverageDailyUsage(), 1);
        Serial.println(" لیتر");
        
        Serial.print("کل ماه: ");
        Serial.print(calculateMonthlyTotal(), 1);
        Serial.println(" لیتر");
    }
};

class LeakDetectionSystem {
private:
    WaterFlowSensor flowSensor;
    float leakThreshold; // L/min
    unsigned long leakStartTime;
    bool leakDetected;
    
public:
    LeakDetectionSystem(int pin, float threshold = 0.2) 
        : flowSensor(pin), leakThreshold(threshold) {
        leakDetected = false;
        leakStartTime = 0;
    }
    
    void monitor() {
        flowSensor.update();
        float currentFlow = flowSensor.getFlowRate();
        
        // تشخیص جریان پایین مداوم (نشتی)
        if (currentFlow > 0.05 && currentFlow < leakThreshold) {
            if (!leakDetected) {
                leakDetected = true;
                leakStartTime = millis();
                Serial.println("⚠️ نشتی احتمالی تشخیص داده شد");
            } else {
                unsigned long leakDuration = millis() - leakStartTime;
                
                if (leakDuration > 300000) { // 5 دقیقه
                    Serial.println("🚨 نشتی تأیید شد! اقدام فوری لازم است");
                    triggerAlarm();
                    sendAlert();
                }
            }
        } else {
            leakDetected = false;
        }
        
        // تشخیص جریان غیرعادی (ترکیدگی لوله)
        if (currentFlow > 10.0) {
            Serial.println("🚨 جریان غیرعادی بالا! احتمال ترکیدگی لوله");
            emergencyShutoff();
        }
    }
    
    void triggerAlarm() {
        // فعال کردن آژیر
        // روشن کردن چراغ
        // ارسال پیام
        Serial.println("آژیر نشتی فعال شد");
    }
    
    void sendAlert() {
        // ارسال SMS یا اعلان
        Serial.println("اعلان نشتی ارسال شد");
    }
    
    void emergencyShutoff() {
        // قطع شیر اصلی برقی
        Serial.println("شیر اصلی آب قطع شد");
    }
};

void calibrationProcedure() {
    Serial.println("=== کالیبراسیون سنسور جریان آب ===");
    
    // 1. تست بدون جریان
    Serial.println("مرحله 1: تست بدون جریان");
    testZeroFlow();
    
    // 2. تست با حجم مشخص
    Serial.println("مرحله 2: کالیبراسیون با حجم مشخص");
    calibrateWithKnownVolume();
    
    // 3. تست دقت در دبی‌های مختلف
    Serial.println("مرحله 3: تست دقت");
    testAccuracyAtDifferentFlows();
    
    Serial.println("کالیبراسیون کامل شد");
}

void calibrateWithKnownVolume() {
    Serial.println("مخزن 10 لیتری را پر کرده و تخلیه کنید...");
    delay(30000); // زمان برای تخلیه
    
    float measuredVolume = flowSensor.getTotalVolume();
    float errorPercent = abs(10.0 - measuredVolume) / 10.0 * 100;
    
    Serial.print("حجم اندازه‌گیری شده: ");
    Serial.print(measuredVolume, 2);
    Serial.println(" لیتر");
    Serial.print("خطا: ");
    Serial.print(errorPercent, 1);
    Serial.println("%");
    
    if (errorPercent > 10.0) {
        Serial.println("⚠️ نیاز به کالیبراسیون دقیق‌تر");
    }
}

// 1. محاسبه دبی (لیتر بر دقیقه)
float calculateFlowRate(unsigned long pulseCount, unsigned long intervalMs) {
    return (pulseCount * 60000.0) / (pulsesPerLiter * intervalMs);
}

// 2. محاسبه حجم کل (لیتر)
float calculateTotalVolume(float flowRate, unsigned long intervalMs) {
    return (flowRate * intervalMs) / 60000.0;
}

// 3. محاسبه سرعت آب (متر بر ثانیه)
float calculateWaterSpeed(float flowRate, float pipeDiameter) {
    float area = PI * pow(pipeDiameter / 2, 2); // m²
    float flowM3PerMin = flowRate / 1000.0; // m³/min
    return (flowM3PerMin / 60.0) / area; // m/s
}

// 4. تبدیل واحدها
float litersToGallons(float liters) {
    return liters * 0.264172;
}

float LminToGPM(float lmin) {
    return lmin * 0.264172;
}

void safetyChecks() {
    // بررسی دمای آب
    if (waterTemperature > 60.0) {
        Serial.println("🚨 دمای آب بیش از حد مجاز");
        return;
    }
    
    // بررسی فشار
    if (waterPressure > 2.0) {
        Serial.println("🚨 فشار آب بیش از حد مجاز");
        return;
    }
    
    // بررسی وجود هوا در لوله
    if (flowSensor.getFlowRate() < 0.5 && waterPressure > 0.5) {
        Serial.println("⚠️ احتمال وجود هوا در سیستم");
    }
}

void diagnosticTest() {
    Serial.println("=== تست تشخیصی سنسور جریان ===");
    
    // تست تغذیه
    Serial.print("ولتاژ تغذیه: ");
    Serial.println(checkPowerSupply() ? "✅ OK" : "❌ مشکل");
    
    // تست سیگنال
    Serial.print("خروجی سیگنال: ");
    Serial.println(checkSignalOutput() ? "✅ OK" : "❌ مشکل");
    
    // تست مکانیکی
    Serial.print("آزادی چرخش روتور: ");
    Serial.println(checkRotorRotation() ? "✅ OK" : "❌ مشکل");
    
    // تست آب‌بندی
    Serial.print("آب‌بندی: ");
    Serial.println(checkSealing() ? "✅ OK" : "❌ نشتی");
    
    Serial.println("================================");
}

class WaterPurificationSystem {
private:
    WaterFlowSensor inputFlow, outputFlow;
    float filterEfficiency;
    
public:
    void monitorFilterPerformance() {
        float input = inputFlow.getFlowRate();
        float output = outputFlow.getFlowRate();
        
        if (input > 0) {
            filterEfficiency = (output / input) * 100;
            
            if (filterEfficiency < 85.0) {
                Serial.println("⚠️ کارایی فیلتر کاهش یافته - نیاز به تعویض");
            }
        }
    }
};

class HeatingSystemMonitor {
private:
    WaterFlowSensor flowSensor;
    float temperatureIn, temperatureOut;
    
public:
    float calculateHeatTransfer() {
        float flowRate = flowSensor.getFlowRate(); // L/min
        float deltaT = temperatureOut - temperatureIn;
        
        // Q = m * c * ΔT
        // m = flowRate (kg/min) ≈ flowRate (L/min)
        // c = 4.186 kJ/kg·°C (ظرفیت گرمایی آب)
        float heatPower = flowRate * 4.186 * deltaT; // kJ/min
        
        return heatPower * 16.67; // تبدیل به وات
    }
};

class PrecisionAgriculture {
private:
    WaterFlowSensor flowSensor;
    float soilMoisture;
    
public:
    void smartIrrigation() {
        float requiredWater = calculateWaterRequirement(soilMoisture);
        
        Serial.print("آب مورد نیاز: ");
        Serial.print(requiredWater);
        Serial.println(" لیتر");
        
        flowSensor.resetTotalVolume();
        
        while (flowSensor.getTotalVolume() < requiredWater) {
            flowSensor.update();
            delay(100);
        }
        
        Serial.println("✅ آبیاری بهینه انجام شد");
    }
};

void powerSavingMode() {
    // حالت کم‌مصرف برای سیستم‌های باتری‌دار
    digitalWrite(FLOW_VCC_PIN, LOW); // خاموش کردن سنسور
    
    // بیدار شدن هر 10 دقیقه برای نمونه‌برداری
    sleep(600000); // خواب عمیق 10 دقیقه
    
    digitalWrite(FLOW_VCC_PIN, HIGH);
    delay(1000); // زمان برای پایدار شدن
    
    // نمونه‌برداری سریع
    takeFlowSample();
    
    digitalWrite(FLOW_VCC_PIN, LOW);
}