طرح کلی مدار:
منبع تغذیه (5-30V) → فیوز ←→ MOSFET ←→ بار
                       ↓           ↓
                    خازن‌های     درایور
                    فیلتر       گیت
                                 ↓
                          سیگنال PWM (3.3V/5V)

پیکربندی ترمینال:
┌─────────────────────┐
│  V+  ──┬──  Load+   │
│        │            │
│      فیوز 15A      │
│        │            │
│  GND ──┴──  Load-   │
└─────────────────────┘
    کنترل: Signal, GND

// کنترل ساده ماژول PWM 15A
#define PWM_PIN 9          // پین PWM (با قابلیت PWM آردوینو)
#define ENABLE_PIN 8       // پین فعال‌سازی (اختیاری)

void setupPWMController() {
  Serial.begin(115200);
  
  pinMode(PWM_PIN, OUTPUT);
  pinMode(ENABLE_PIN, OUTPUT);
  
  // تنظیم فرکانس PWM برای پین 9 و 10 آردوینو Uno
  // 31250Hz برای عملکرد بهتر موتورها
  TCCR1B = TCCR1B & 0b11111000 | 0x01;
  
  Serial.println("ماژول سوئیچ PWM 15A راه‌اندازی شد");
  Serial.println("فرکانس PWM: 31.25kHz");
}

void loop() {
  // کنترل سرعت موتور DC
  controlMotorSpeed();
  
  // کنترل روشنایی LED پرقدرت
  controlLEDBrightness();
  
  // کنترل المنت حرارتی
  controlHeater();
}

// مثال: کنترل سرعت موتور
void controlMotorSpeed() {
  for (int dutyCycle = 0; dutyCycle <= 255; dutyCycle += 5) {
    analogWrite(PWM_PIN, dutyCycle);
    Serial.print("چرخه کاری: ");
    Serial.print((dutyCycle * 100) / 255);
    Serial.println("%");
    delay(100);
  }
  
  for (int dutyCycle = 255; dutyCycle >= 0; dutyCycle -= 5) {
    analogWrite(PWM_PIN, dutyCycle);
    delay(100);
  }
}

class HighPowerPWMController {
private:
    int pwmPin;
    int enablePin;
    int frequency;
    int currentDuty;
    bool enabled;
    
public:
    HighPowerPWMController(int pin, int enPin = -1, int freq = 25000) {
        pwmPin = pin;
        enablePin = enPin;
        frequency = freq;
        currentDuty = 0;
        enabled = false;
        
        pinMode(pwmPin, OUTPUT);
        if (enablePin != -1) {
            pinMode(enablePin, OUTPUT);
            disable();  // ابتدا غیرفعال
        }
        
        setupPWMFrequency();
    }
    
    void setupPWMFrequency() {
        // تنظیم فرکانس PWM برای آردوینو
        if (pwmPin == 9 || pwmPin == 10) {
            // تایمر 1
            TCCR1B = TCCR1B & 0b11111000 | 0x01; // 31.25kHz
        } else if (pwmPin == 3 || pwmPin == 11) {
            // تایمر 2
            TCCR2B = TCCR2B & 0b11111000 | 0x01; // 31.25kHz
        }
        Serial.print("فرکانس PWM تنظیم شد: ");
        Serial.print(frequency);
        Serial.println("Hz");
    }
    
    void enable() {
        if (enablePin != -1) {
            digitalWrite(enablePin, HIGH);
            enabled = true;
            Serial.println("ماژول فعال شد");
        }
    }
    
    void disable() {
        if (enablePin != -1) {
            digitalWrite(enablePin, LOW);
            enabled = false;
            analogWrite(pwmPin, 0);
            Serial.println("ماژول غیرفعال شد");
        }
    }
    
    void setDutyCycle(int duty) {
        duty = constrain(duty, 0, 255);
        currentDuty = duty;
        
        if (enabled || enablePin == -1) {
            analogWrite(pwmPin, duty);
            
            // مانیتورینگ
            static unsigned long lastPrint = 0;
            if (millis() - lastPrint > 1000) {
                lastPrint = millis();
                Serial.print("Duty Cycle: ");
                Serial.print((duty * 100) / 255);
                Serial.println("%");
            }
        }
    }
    
    void setDutyPercent(float percent) {
        percent = constrain(percent, 0, 100);
        int duty = (percent * 255) / 100;
        setDutyCycle(duty);
    }
    
    void rampUp(int targetDuty, int durationMs) {
        int steps = abs(targetDuty - currentDuty);
        int stepTime = durationMs / steps;
        
        for (int i = currentDuty; i != targetDuty; i += (targetDuty > currentDuty ? 1 : -1)) {
            setDutyCycle(i);
            delay(stepTime);
        }
        setDutyCycle(targetDuty);
    }
    
    void softStart(int targetPercent, int rampTime = 2000) {
        enable();
        Serial.println("Soft Start آغاز شد");
        rampUp((targetPercent * 255) / 100, rampTime);
        Serial.println("Soft Start تکمیل شد");
    }
    
    void softStop(int rampTime = 1000) {
        Serial.println("Soft Stop آغاز شد");
        rampUp(0, rampTime);
        disable();
        Serial.println("Soft Stop تکمیل شد");
    }
    
    int getCurrentDuty() {
        return currentDuty;
    }
    
    float getCurrentPercent() {
        return (currentDuty * 100.0) / 255.0;
    }
    
    bool isEnabled() {
        return enabled;
    }
};

// استفاده از کلاس
HighPowerPWMController motorController(9, 8); // PWM پین 9، Enable پین 8

void setup() {
    Serial.begin(115200);
    motorController.softStart(50); // شروع نرم تا 50%
}

void loop() {
    // کنترل با پتانسیومتر
    int potValue = analogRead(A0);
    int dutyValue = map(potValue, 0, 1023, 0, 255);
    motorController.setDutyCycle(dutyValue);
    
    delay(50);
}

void motorSpeedControl() {
    HighPowerPWMController motor(9);
    
    // الگوی کنترل سرعت
    int speedPattern[] = {0, 25, 50, 75, 100, 75, 50, 25, 0};
    int patternSize = sizeof(speedPattern) / sizeof(speedPattern[0]);
    
    for (int i = 0; i < patternSize; i++) {
        motor.setDutyPercent(speedPattern[i]);
        Serial.print("سرعت موتور: ");
        Serial.print(speedPattern[i]);
        Serial.println("%");
        
        // مانیتور جریان
        float current = readCurrentSensor();
        Serial.print("جریان: ");
        Serial.print(current);
        Serial.println("A");
        
        // حفاظت از اضافه بار
        if (current > 10.0) { // آستانه 10A
            Serial.println("⚠️ اضافه بار! توقف موتور");
            motor.softStop();
            delay(5000);
            motor.softStart(speedPattern[i]);
        }
        
        delay(2000);
    }
}

class HighPowerLEDDriver {
private:
    HighPowerPWMController pwm;
    int maxCurrent;
    float currentLimit;
    
public:
    HighPowerLEDDriver(int pin, int maxA = 5) : pwm(pin), maxCurrent(maxA) {
        currentLimit = maxA * 0.8; // 80% حاشیه ایمنی
    }
    
    void setBrightness(float percent) {
        // منحنی غیرخطی برای درک بصری بهتر روشنایی
        float correctedPercent = pow(percent / 100.0, 2.2) * 100;
        pwm.setDutyPercent(correctedPercent);
        
        // مانیتورینگ
        float current = readLEDCurrent();
        if (current > currentLimit) {
            Serial.print("⚠️ جریان LED بالا: ");
            Serial.print(current);
            Serial.println("A - کاهش روشنایی");
            reduceBrightness();
        }
    }
    
    void fadeIn(int duration) {
        for (int i = 0; i <= 100; i++) {
            setBrightness(i);
            delay(duration / 100);
        }
    }
    
    void fadeOut(int duration) {
        for (int i = 100; i >= 0; i--) {
            setBrightness(i);
            delay(duration / 100);
        }
    }
    
    void strobe(int frequencyHz, int durationMs) {
        unsigned long startTime = millis();
        unsigned long halfPeriod = 1000 / (frequencyHz * 2);
        
        while (millis() - startTime < durationMs) {
            setBrightness(100);
            delay(halfPeriod);
            setBrightness(0);
            delay(halfPeriod);
        }
        setBrightness(0);
    }
};

class HeaterController {
private:
    HighPowerPWMController pwm;
    float targetTemp;
    float currentTemp;
    float kp, ki, kd; // ضرایب PID
    
public:
    HeaterController(int pin, float kp = 2.0, float ki = 0.5, float kd = 1.0) 
        : pwm(pin), kp(kp), ki(ki), kd(kd) {
        targetTemp = 25.0; // دمای اتاق پیش‌فرض
    }
    
    void setTemperature(float temp) {
        targetTemp = constrain(temp, 0.0, 200.0);
        Serial.print("دمای هدف تنظیم شد: ");
        Serial.print(targetTemp);
        Serial.println("°C");
    }
    
    void updatePID() {
        currentTemp = readTemperature();
        static float integral = 0;
        static float lastError = 0;
        
        float error = targetTemp - currentTemp;
        integral += error;
        float derivative = error - lastError;
        
        // محاسبه خروجی PID
        float output = (kp * error) + (ki * integral) + (kd * derivative);
        
        // تبدیل به duty cycle
        int duty = constrain(map(output, -100, 100, 0, 255), 0, 255);
        pwm.setDutyCycle(duty);
        
        lastError = error;
        
        // لاگ اطلاعات
        static unsigned long lastLog = 0;
        if (millis() - lastLog > 1000) {
            lastLog = millis();
            Serial.print("دما: ");
            Serial.print(currentTemp);
            Serial.print("°C | Duty: ");
            Serial.print((duty * 100) / 255);
            Serial.println("%");
        }
    }
    
    void safetyCheck() {
        if (currentTemp > targetTemp + 20.0) {
            Serial.println("🚨 دمای بیش از حد! خاموش کردن");
            pwm.setDutyPercent(0);
            triggerAlarm();
        }
        
        float current = readCurrent();
        if (current > 12.0) { // بیشتر از 12A
            Serial.println("🚨 جریان بیش از حد! خاموش کردن");
            pwm.setDutyPercent(0);
        }
    }
};

void safetyChecks() {
    // بررسی‌های اولیه قبل از راه‌اندازی
    Serial.println("=== بررسی ایمنی ماژول ===");
    
    // 1. بررسی اتصال کوتاه
    if (checkShortCircuit()) {
        Serial.println("❌ اتصال کوتاه تشخیص داده شد");
        return;
    }
    
    // 2. بررسی قطبیت
    if (!checkPolarity()) {
        Serial.println("❌ قطبیت اشتباه است");
        return;
    }
    
    // 3. بررسی دمای ماژول
    float temp = readModuleTemperature();
    if (temp > 60.0) {
        Serial.println("⚠️ دمای ماژول بالا است");
        Serial.print("دمای فعلی: ");
        Serial.print(temp);
        Serial.println("°C");
    }
    
    // 4. بررسی جریان اولیه
    float initialCurrent = readCurrent();
    if (initialCurrent > 1.0) { // بیشتر از 1A در حالت خاموش
        Serial.println("⚠️ جریان نشتی غیرعادی");
    }
    
    Serial.println("✅ تمام بررسی‌های ایمنی passed");
}

class PowerMonitor {
private:
    int currentPin;
    int voltagePin;
    int tempPin;
    
public:
    PowerMonitor(int currPin, int voltPin, int tempPin) 
        : currentPin(currPin), voltagePin(voltPin), tempPin(tempPin) {
        pinMode(currentPin, INPUT);
        pinMode(voltagePin, INPUT);
        pinMode(tempPin, INPUT);
    }
    
    float readCurrent() {
        // خواندن از سنسور جریان (ACS712 یا معادل)
        int raw = analogRead(currentPin);
        float voltage = (raw * 5.0) / 1023.0;
        float current = (voltage - 2.5) / 0.185; // برای ACS712 20A
        return abs(current);
    }
    
    float readVoltage() {
        int raw = analogRead(voltagePin);
        float voltage = (raw * 5.0) / 1023.0 * 6.6; // تقسیم ولتاژ 6.6:1
        return voltage;
    }
    
    float readTemperature() {
        int raw = analogRead(tempPin);
        float voltage = (raw * 5.0) / 1023.0;
        float temp = (voltage - 0.5) * 100; // برای LM35
        return temp;
    }
    
    void logStatus() {
        static unsigned long lastLog = 0;
        if (millis() - lastLog > 1000) {
            lastLog = millis();
            
            float current = readCurrent();
            float voltage = readVoltage();
            float temp = readTemperature();
            float power = current * voltage;
            
            Serial.println("=== وضعیت ماژول PWM ===");
            Serial.print("ولتاژ: ");
            Serial.print(voltage, 1);
            Serial.print("V | جریان: ");
            Serial.print(current, 2);
            Serial.print("A | توان: ");
            Serial.print(power, 1);
            Serial.print("W | دما: ");
            Serial.print(temp, 1);
            Serial.println("°C");
            
            // هشدارها
            if (current > 15.0) Serial.println("⚠️ جریان بیش از حد مجاز");
            if (temp > 75.0) Serial.println("⚠️ دمای بحرانی");
            if (voltage > 30.0) Serial.println("⚠️ ولتاژ بیش از حد");
        }
    }
};

void emergencyProcedures() {
    // اقدامات اضطراری
    Serial.println("🚨 اقدامات اضطراری فعال شد");
    
    // 1. قطع فوری خروجی
    digitalWrite(PWM_PIN, LOW);
    digitalWrite(ENABLE_PIN, LOW);
    
    // 2. ذخیره وضعیت
    saveErrorState();
    
    // 3. فعال کردن آلارم
    triggerEmergencyAlarm();
    
    // 4. خنک‌کاری اضطراری (اگر موجود باشد)
    activateCoolingSystem();
    
    // 5. گزارش خطا
    sendEmergencyReport();
}

void maintenanceRoutine() {
    Serial.println("=== برنامه نگهداری ماژول PWM ===");
    
    // 1. تمیزکاری
    cleanTerminals();
    
    // 2. بررسی اتصالات
    checkConnections();
    
    // 3. تست عملکرد
    performanceTest();
    
    // 4. کالیبراسیون سنسورها
    calibrateSensors();
    
    // 5. ثبت گزارش
    generateMaintenanceReport();
    
    Serial.println("نگهداری تکمیل شد");
}