public:
    void designPowerTraces() {
        // محاسبه عرض مسیر برای 10A
        float current = 10.0; // آمپر
        float thickness = 0.07; // mm (2 اونس)
        float temperatureRise = 20.0; // درجه سانتیگراد
        
        // فرمول IPC-2221
        float traceWidth = (current / (k * pow(temperatureRise, 0.44))) 
                           * pow(thickness, 0.725);
        // تقریباً 3mm برای 10A
    }
    
    void designTerminalPads() {
        // طراحی Pad برای ترمینال
        float holeDiameter = 3.2; // mm
        float padDiameter = 6.0; // mm
        int holeCount = 4; // تعداد سوراخ برای استحکام
    }
};

public:
    struct RelaySpecs {
        float coilVoltage;    // ولتاژ کوئل
        float coilResistance; // مقاومت کوئل
        float coilPower;      // توان کوئل
    };
    
    float calculateCoilCurrent(RelaySpecs specs) {
        // I = V / R
        return specs.coilVoltage / specs.coilResistance;
    }
    
    float calculateRequiredTransistorGain(float coilCurrent, 
                                          float microcontrollerCurrent) {
        // β_min = I_coil / I_micro
        return coilCurrent / microcontrollerCurrent;
    }
    
    bool checkTransistorCompatibility(float coilCurrent, 
                                      float transistorIcMax) {
        return coilCurrent < transistorIcMax;
    }
};

// مثال:
RelaySpecs specs = {5.0, 70.0, 0.4}; // 5V, 70Ω, 0.4W
CoilCalculator calc;
float coilCurrent = calc.calculateCoilCurrent(specs); // 71.4mA

public:
    struct CoilCharacteristics {
        float inductance;     // اندوکتانس کوئل
        float current;        // جریان کوئل
        float resistance;     // مقاومت کوئل
    };
    
    float calculateBackEMF(CoilCharacteristics coil, float turnOffTime) {
        // V = L * di/dt
        return coil.inductance * (coil.current / turnOffTime);
    }
    
    string selectDiode(float backEMF, float coilCurrent) {
        if(backEMF < 100 && coilCurrent < 100) {
            return "1N4148"; // سیگنال
        } else if(backEMF < 400 && coilCurrent < 1000) {
            return "1N4007"; // همه‌کاره
        } else {
            return "UF4007"; // سریع
        }
    }
    
    float calculatePowerDissipation(float forwardVoltage, 
                                    float current, 
                                    float dutyCycle) {
        return forwardVoltage * current * dutyCycle;
    }
};

private:
    int relayPin;
    bool state;
    
public:
    void setup(int pin) {
        relayPin = pin;
        pinMode(relayPin, OUTPUT);
        turnOff(); // حالت ایمن
    }
    
    void turnOn() {
        digitalWrite(relayPin, LOW); // فعال‌سازی
        state = true;
        logEvent("Light ON");
    }
    
    void turnOff() {
        digitalWrite(relayPin, HIGH); // غیرفعال
        state = false;
        logEvent("Light OFF");
    }
    
    void toggle() {
        if(state) turnOff();
        else turnOn();
    }
    
    void timedOperation(int duration) {
        turnOn();
        delay(duration * 1000);
        turnOff();
    }
};

private:
    struct MotorSpecs {
        float voltage;
        float current;
        float power;
        string type; // AC/DC
    };
    
    MotorSpecs motor;
    int relayPin;
    
public:
    void controlMotor(bool direction, int speedPercent) {
        // کنترل موتور DC
        if(motor.type == "DC") {
            controlDCMotor(direction, speedPercent);
        } else {
            controlACMotor(speedPercent);
        }
    }
    
    void softStart(int rampTime) {
        // راه‌اندازی نرم موتور
        for(int i = 0; i <= 100; i += 10) {
            controlMotor(true, i);
            delay(rampTime * 10);
        }
    }
    
    void emergencyStop() {
        digitalWrite(relayPin, HIGH);
        logEmergency("Motor STOPPED");
    }
};

private:
    int emergencyRelayPin;
    bool emergencyState;
    
public:
    void setup(int pin) {
        emergencyRelayPin = pin;
        pinMode(emergencyRelayPin, OUTPUT);
        enableSafetyMode(); // حالت ایمن
    }
    
    void enableSafetyMode() {
        // قطع همه بارها
        digitalWrite(emergencyRelayPin, HIGH);
        emergencyState = true;
    }
    
    void disableSafetyMode() {
        digitalWrite(emergencyRelayPin, LOW);
        emergencyState = false;
    }
    
    void checkSafetySensors() {
        // مانیتورینگ سنسورهای ایمنی
        if(readSmokeSensor() > THRESHOLD) {
            enableSafetyMode();
            triggerAlarm();
        }
        
        if(readTemperature() > MAX_TEMP) {
            enableSafetyMode();
            activateCooling();
        }
    }
};

private:
    int relayPin;
    int pwmFrequency;
    int pwmDutyCycle;
    
public:
    void setup(int pin, int frequency) {
        relayPin = pin;
        pwmFrequency = frequency;
        pinMode(relayPin, OUTPUT);
    }
    
    void setDutyCycle(int duty) {
        pwmDutyCycle = constrain(duty, 0, 100);
        
        // کنترل رله با PWM
        int onTime = (1000000 / pwmFrequency) * (pwmDutyCycle / 100.0);
        int offTime = (1000000 / pwmFrequency) - onTime;
        
        // اجرای PWM
        digitalWrite(relayPin, LOW);
        delayMicroseconds(onTime);
        digitalWrite(relayPin, HIGH);
        delayMicroseconds(offTime);
    }
    
    void softStart(int targetDuty, int rampTime) {
        for(int i = 0; i <= targetDuty; i++) {
            setDutyCycle(i);
            delay(rampTime);
        }
    }
};

private:
    struct Schedule {
        int hour;
        int minute;
        bool action; // true=ON, false=OFF
    };
    
    Schedule dailySchedule[10];
    int scheduleCount;
    
public:
    void addSchedule(int h, int m, bool act) {
        if(scheduleCount < 10) {
            dailySchedule[scheduleCount] = {h, m, act};
            scheduleCount++;
        }
    }
    
    void checkAndExecute() {
        int currentHour = hour();
        int currentMinute = minute();
        
        for(int i = 0; i < scheduleCount; i++) {
            if(dailySchedule[i].hour == currentHour &&
               dailySchedule[i].minute == currentMinute) {
                executeAction(dailySchedule[i].action);
            }
        }
    }
    
    void executeAction(bool action) {
        if(action) {
            digitalWrite(relayPin, LOW); // روشن
        } else {
            digitalWrite(relayPin, HIGH); // خاموش
        }
    }
};

private:
    int relayPin;
    RF24 radio;
    
public:
    void setup(int pin, uint8_t address) {
        relayPin = pin;
        pinMode(relayPin, OUTPUT);
        
        // تنظیمات رادیو
        radio.begin();
        radio.openReadingPipe(1, address);
        radio.startListening();
    }
    
    void checkCommands() {
        if(radio.available()) {
            char command;
            radio.read(&command, sizeof(command));
            
            switch(command) {
                case '1': // روشن
                    digitalWrite(relayPin, LOW);
                    sendAck("ON");
                    break;
                    
                case '0': // خاموش
                    digitalWrite(relayPin, HIGH);
                    sendAck("OFF");
                    break;
                    
                case 'T': // حالت چشمک‌زن
                    blinkMode(500);
                    break;
            }
        }
    }
    
    void sendAck(String status) {
        radio.stopListening();
        radio.write(status.c_str(), status.length());
        radio.startListening();
    }
};

private:
    const float OVERCURRENT_THRESHOLD = 12.0; // A
    const float OVERTEMP_THRESHOLD = 85.0;   // °C
    
public:
    void addCurrentProtection() {
        // استفاده از فیوز قابل بازنشانی
        addResettableFuse(10); // 10A
        addCurrentSensor();
    }
    
    void addVoltageProtection() {
        // محافظت در برابر ولتاژ بالا
        addMOV(275); // 275V MOV
        addTVSdiode(400); // 400V TVS
    }
    
    void addArcSuppression() {
        // سرکوب جرقه در کنتاکت‌ها
        addRCsnubber(100, 0.1); // 100Ω, 0.1μF
        addVaristor();
    }
    
    void monitorRelayHealth() {
        // مانیتورینگ سلامت رله
        float contactResistance = measureContactResistance();
        float operateTime = measureOperateTime();
        float releaseTime = measureReleaseTime();
        
        if(contactResistance > 0.1) { // اهم
            logWarning("Relay contact wear detected");
        }
    }
};

public:
    void implementOptoisolation() {
        // استفاده از اپتوکوپلر برای جداسازی کامل
        addOptocoupler("PC817", 5000); // 5000V isolation
        
        // مدار ایزوله شده:
        // میکروکنترلر ← اپتوکوپلر ← درایور ← رله
    }
    
    void designIsolatedPowerSupply() {
        // منبع تغذیه جداگانه برای بخش قدرت
        addIsolatedDCConverter(5, 5, 1000); // 5V to 5V, 1000V isolation
        
        // ترانسفورماتور ایزوله یا کنورتر flyback
    }
    
    float measureIsolationResistance() {
        // اندازه‌گیری مقاومت عایقی
        applyTestVoltage(500); // 500V DC
        float leakageCurrent = measureLeakage();
        return 500 / leakageCurrent; // مقاومت عایقی
    }
};

public:
    void runComprehensiveTest() {
        Serial.println("=== Relay Comprehensive Test ===");
        
        // ۱. تست عملکرد پایه
        testBasicOperation();
        
        // ۲. تست زمان‌ها
        testTimingCharacteristics();
        
        // ۳. تست جریان
        testCurrentConsumption();
        
        // ۴. تست حرارتی
        testThermalPerformance();
        
        // ۵. تست عمر
        testLifeCycle();
    }
    
    void testBasicOperation() {
        Serial.println("Basic Operation Test:");
        
        // تست روشن/خاموش
        for(int i = 0; i < 10; i++) {
            digitalWrite(relayPin, LOW);
            delay(100);
            bool onState = checkRelayState();
            
            digitalWrite(relayPin, HIGH);
            delay(100);
            bool offState = checkRelayState();
            
            Serial.print("Cycle "); Serial.print(i);
            Serial.print(": ON="); Serial.print(onState);
            Serial.print(", OFF="); Serial.println(offState);
        }
    }
    
    void testTimingCharacteristics() {
        Serial.println("Timing Test:");
        
        // اندازه‌گیری زمان عملکرد
        unsigned long startTime = micros();
        digitalWrite(relayPin, LOW);
        while(!checkRelayState()) { }
        unsigned long operateTime = micros() - startTime;
        
        startTime = micros();
        digitalWrite(relayPin, HIGH);
        while(checkRelayState()) { }
        unsigned long releaseTime = micros() - startTime;
        
        Serial.print("Operate Time: "); Serial.print(operateTime); Serial.println(" μs");
        Serial.print("Release Time: "); Serial.print(releaseTime); Serial.println(" μs");
    }
    
    void testCurrentConsumption() {
        Serial.println("Current Consumption Test:");
        
        // اندازه‌گیری جریان کوئل
        float voltage = 5.0;
        float shuntResistance = 1.0; // اهم
        
        digitalWrite(relayPin, LOW);
        delay(50); // زمان تثبیت
        
        float voltageDrop = analogRead(A0) * (5.0 / 1023.0);
        float coilCurrent = voltageDrop / shuntResistance;
        
        Serial.print("Coil Current: "); Serial.print(coilCurrent); Serial.println(" A");
        Serial.print("Coil Power: "); Serial.print(coilCurrent * voltage); Serial.println(" W");
    }
};

۱. بررسی تغذیه ۵V (LED روشن است؟)
۲. بررسی اتصال GND
۳. بررسی سیگنال IN (مقاومت pull-up/down)
۴. تست ترانزیستور درایور
۵. تست دیود flyback

مشکل: رله به صورت تصادفی قطع/وصل می‌شود
۱. بررسی نویز روی خط IN
۲. اضافه کردن خازن 0.1μF موازی با IN و GND
۳. بررسی پایداری منبع تغذیه
۴. استفاده از Schmitt trigger برای سیگنال

مشکل: جرقه در کنتاکت‌ها
۱. اضافه کردن مدار snubber
۲. استفاده از MOV برای بارهای القایی
۳. کاهش جریان بار
۴. استفاده از رله با جریان بالاتر

مشکل: گرمای بیش از حد
۱. بررسی جریان بار (از ۱۰A بیشتر نشود)
۲. بهبود تهویه و خنک‌کاری
۳. استفاده از هیت‌سینگ برای ترمینال‌ها
۴. کاهش فرکانس سوئیچینگ